blob: e88401ebb0fe22ff79be1c470dcd233538e25805 [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) {
Atneya3c61d882021-09-20 14:52:15 -0400165 mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{{size},
166 std::string("Track ID: ").append(std::to_string(mId))});
Glenn Kasten663c2242013-09-24 11:52:37 -0700167 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700168 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700169 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Atneya3c61d882021-09-20 14:52:15 -0400170 ALOGE("%s", client->allocator().dump().c_str());
Glenn Kasten663c2242013-09-24 11:52:37 -0700171 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800172 return;
173 }
174 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800175 mCblk = (audio_track_cblk_t *) malloc(size);
176 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700177 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800178 return;
179 }
Eric Laurent81784c32012-11-19 14:55:58 -0800180 }
181
182 // construct the shared structure in-place.
183 if (mCblk != NULL) {
184 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700185 switch (alloc) {
186 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700187 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
188 if (roHeap == 0 ||
189 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700190 (mBuffer = mBufferMemory->unsecurePointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700191 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
192 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700193 if (roHeap != 0) {
194 roHeap->dump("buffer");
195 }
196 mCblkMemory.clear();
197 mBufferMemory.clear();
198 return;
199 }
Eric Laurent81784c32012-11-19 14:55:58 -0800200 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700201 } break;
202 case ALLOC_PIPE:
203 mBufferMemory = thread->pipeMemory();
204 // mBuffer is the virtual address as seen from current process (mediaserver),
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700205 // and should normally be coming from mBufferMemory->unsecurePointer().
Glenn Kastenc263ca02014-06-04 20:31:46 -0700206 // However in this case the TrackBase does not reference the buffer directly.
207 // It should references the buffer via the pipe.
208 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
209 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700210 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700211 break;
212 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700213 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700214 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700215 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
216 memset(mBuffer, 0, bufferSize);
217 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700218 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800219#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700220 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800221#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700222 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700223 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700224 case ALLOC_LOCAL:
225 mBuffer = calloc(1, bufferSize);
226 break;
227 case ALLOC_NONE:
228 mBuffer = buffer;
229 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700230 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700231 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800232 }
Andy Hung8fe68032017-06-05 16:17:51 -0700233 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800234
Glenn Kasten46909e72013-02-26 09:20:22 -0800235#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700236 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800237#endif
Andy Hung959b5b82021-09-24 10:46:20 -0700238 // mState is mirrored for the client to read.
239 mState.setMirror(&mCblk->mState);
240 // ensure our state matches up until we consolidate the enumeration.
241 static_assert(CBLK_STATE_IDLE == IDLE);
242 static_assert(CBLK_STATE_PAUSING == PAUSING);
Eric Laurent81784c32012-11-19 14:55:58 -0800243 }
244}
245
Svet Ganov33761132021-05-13 22:51:08 +0000246// TODO b/182392769: use attribution source util
247static AttributionSourceState audioServerAttributionSource(pid_t pid) {
248 AttributionSourceState attributionSource{};
249 attributionSource.uid = AID_AUDIOSERVER;
250 attributionSource.pid = pid;
251 attributionSource.token = sp<BBinder>::make();
252 return attributionSource;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700253}
254
Eric Laurent83b88082014-06-20 18:31:16 -0700255status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
256{
257 status_t status;
258 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
259 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
260 } else {
261 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
262 }
263 return status;
264}
265
Eric Laurent81784c32012-11-19 14:55:58 -0800266AudioFlinger::ThreadBase::TrackBase::~TrackBase()
267{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800268 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700269 mServerProxy.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700270 releaseCblk();
Eric Laurent81784c32012-11-19 14:55:58 -0800271 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
272 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700273 // Client destructor must run with AudioFlinger client mutex locked
274 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800275 // If the client's reference count drops to zero, the associated destructor
276 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
277 // relying on the automatic clear() at end of scope.
278 mClient.clear();
279 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700280 // flush the binder command buffer
281 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800282}
283
284// AudioBufferProvider interface
285// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800286// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800287void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
288{
Glenn Kasten46909e72013-02-26 09:20:22 -0800289#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700290 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800291#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800292
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800293 ServerProxy::Buffer buf;
294 buf.mFrameCount = buffer->frameCount;
295 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800296 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800297 buffer->raw = NULL;
298 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800299}
300
Eric Laurent81784c32012-11-19 14:55:58 -0800301status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
302{
303 mSyncEvents.add(event);
304 return NO_ERROR;
305}
306
Kevin Rocard45986c72018-12-18 18:22:59 -0800307AudioFlinger::ThreadBase::PatchTrackBase::PatchTrackBase(sp<ClientProxy> proxy,
308 const ThreadBase& thread,
309 const Timeout& timeout)
310 : mProxy(proxy)
311{
312 if (timeout) {
313 setPeerTimeout(*timeout);
314 } else {
315 // Double buffer mixer
316 uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
317 thread.sampleRate();
318 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
319 }
320}
321
322void AudioFlinger::ThreadBase::PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
323 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
324 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
325}
326
327
Eric Laurent81784c32012-11-19 14:55:58 -0800328// ----------------------------------------------------------------------------
329// Playback
330// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700331#undef LOG_TAG
332#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800333
334AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
335 : BnAudioTrack(),
336 mTrack(track)
337{
Andy Hung225aef62022-12-06 16:33:20 -0800338 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -0800339}
340
341AudioFlinger::TrackHandle::~TrackHandle() {
342 // just stop the track on deletion, associated resources
343 // will be freed from the main thread once all pending buffers have
344 // been played. Unless it's not in the active track list, in which
345 // case we free everything now...
346 mTrack->destroy();
347}
348
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800349Status AudioFlinger::TrackHandle::getCblk(
350 std::optional<media::SharedFileRegion>* _aidl_return) {
351 *_aidl_return = legacy2aidl_NullableIMemory_SharedFileRegion(mTrack->getCblk()).value();
352 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800353}
354
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800355Status AudioFlinger::TrackHandle::start(int32_t* _aidl_return) {
356 *_aidl_return = mTrack->start();
357 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800358}
359
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800360Status AudioFlinger::TrackHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -0800361 mTrack->stop();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800362 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800363}
364
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800365Status AudioFlinger::TrackHandle::flush() {
Eric Laurent81784c32012-11-19 14:55:58 -0800366 mTrack->flush();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800367 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800368}
369
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800370Status AudioFlinger::TrackHandle::pause() {
Eric Laurent81784c32012-11-19 14:55:58 -0800371 mTrack->pause();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800372 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800373}
374
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800375Status AudioFlinger::TrackHandle::attachAuxEffect(int32_t effectId,
376 int32_t* _aidl_return) {
377 *_aidl_return = mTrack->attachAuxEffect(effectId);
378 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800379}
380
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800381Status AudioFlinger::TrackHandle::setParameters(const std::string& keyValuePairs,
382 int32_t* _aidl_return) {
383 *_aidl_return = mTrack->setParameters(String8(keyValuePairs.c_str()));
384 return Status::ok();
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700385}
386
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800387Status AudioFlinger::TrackHandle::selectPresentation(int32_t presentationId, int32_t programId,
388 int32_t* _aidl_return) {
389 *_aidl_return = mTrack->selectPresentation(presentationId, programId);
390 return Status::ok();
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800391}
392
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800393Status AudioFlinger::TrackHandle::getTimestamp(media::AudioTimestampInternal* timestamp,
394 int32_t* _aidl_return) {
395 AudioTimestamp legacy;
396 *_aidl_return = mTrack->getTimestamp(legacy);
397 if (*_aidl_return != OK) {
398 return Status::ok();
399 }
Andy Hung973638a2020-12-08 20:47:45 -0800400 *timestamp = legacy2aidl_AudioTimestamp_AudioTimestampInternal(legacy).value();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800401 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800402}
403
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800404Status AudioFlinger::TrackHandle::signal() {
405 mTrack->signal();
406 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800407}
408
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800409Status AudioFlinger::TrackHandle::applyVolumeShaper(
410 const media::VolumeShaperConfiguration& configuration,
411 const media::VolumeShaperOperation& operation,
412 int32_t* _aidl_return) {
413 sp<VolumeShaper::Configuration> conf = new VolumeShaper::Configuration();
414 *_aidl_return = conf->readFromParcelable(configuration);
415 if (*_aidl_return != OK) {
416 return Status::ok();
417 }
418
419 sp<VolumeShaper::Operation> op = new VolumeShaper::Operation();
420 *_aidl_return = op->readFromParcelable(operation);
421 if (*_aidl_return != OK) {
422 return Status::ok();
423 }
424
425 *_aidl_return = mTrack->applyVolumeShaper(conf, op);
426 return Status::ok();
Glenn Kasten53cec222013-08-29 09:01:02 -0700427}
428
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800429Status AudioFlinger::TrackHandle::getVolumeShaperState(
430 int32_t id,
431 std::optional<media::VolumeShaperState>* _aidl_return) {
432 sp<VolumeShaper::State> legacy = mTrack->getVolumeShaperState(id);
433 if (legacy == nullptr) {
434 _aidl_return->reset();
435 return Status::ok();
436 }
437 media::VolumeShaperState aidl;
438 legacy->writeToParcelable(&aidl);
439 *_aidl_return = aidl;
440 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800441}
442
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800443Status AudioFlinger::TrackHandle::getDualMonoMode(media::AudioDualMonoMode* _aidl_return)
444{
445 audio_dual_mono_mode_t mode = AUDIO_DUAL_MONO_MODE_OFF;
446 const status_t status = mTrack->getDualMonoMode(&mode)
447 ?: AudioValidator::validateDualMonoMode(mode);
448 if (status == OK) {
449 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
450 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(mode));
451 }
452 return binderStatusFromStatusT(status);
453}
454
455Status AudioFlinger::TrackHandle::setDualMonoMode(
456 media::AudioDualMonoMode mode)
457{
458 const auto localMonoMode = VALUE_OR_RETURN_BINDER_STATUS(
459 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(mode));
460 return binderStatusFromStatusT(AudioValidator::validateDualMonoMode(localMonoMode)
461 ?: mTrack->setDualMonoMode(localMonoMode));
462}
463
464Status AudioFlinger::TrackHandle::getAudioDescriptionMixLevel(float* _aidl_return)
465{
466 float leveldB = -std::numeric_limits<float>::infinity();
467 const status_t status = mTrack->getAudioDescriptionMixLevel(&leveldB)
468 ?: AudioValidator::validateAudioDescriptionMixLevel(leveldB);
469 if (status == OK) *_aidl_return = leveldB;
470 return binderStatusFromStatusT(status);
471}
472
473Status AudioFlinger::TrackHandle::setAudioDescriptionMixLevel(float leveldB)
474{
475 return binderStatusFromStatusT(AudioValidator::validateAudioDescriptionMixLevel(leveldB)
476 ?: mTrack->setAudioDescriptionMixLevel(leveldB));
477}
478
479Status AudioFlinger::TrackHandle::getPlaybackRateParameters(
480 media::AudioPlaybackRate* _aidl_return)
481{
482 audio_playback_rate_t localPlaybackRate{};
483 status_t status = mTrack->getPlaybackRateParameters(&localPlaybackRate)
484 ?: AudioValidator::validatePlaybackRate(localPlaybackRate);
485 if (status == NO_ERROR) {
486 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
487 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(localPlaybackRate));
488 }
489 return binderStatusFromStatusT(status);
490}
491
492Status AudioFlinger::TrackHandle::setPlaybackRateParameters(
493 const media::AudioPlaybackRate& playbackRate)
494{
495 const audio_playback_rate_t localPlaybackRate = VALUE_OR_RETURN_BINDER_STATUS(
496 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(playbackRate));
497 return binderStatusFromStatusT(AudioValidator::validatePlaybackRate(localPlaybackRate)
498 ?: mTrack->setPlaybackRateParameters(localPlaybackRate));
499}
500
Eric Laurent81784c32012-11-19 14:55:58 -0800501// ----------------------------------------------------------------------------
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800502// AppOp for audio playback
503// -------------------------------
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700504
505// static
506sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
507AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
Svet Ganov33761132021-05-13 22:51:08 +0000508 const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700509 audio_stream_type_t streamType)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800510{
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000511 Vector <String16> packages;
Svet Ganov33761132021-05-13 22:51:08 +0000512 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000513 getPackagesForUid(uid, packages);
Eric Laurent9066ad32019-05-20 14:40:10 -0700514 if (isServiceUid(uid)) {
Eric Laurent9066ad32019-05-20 14:40:10 -0700515 if (packages.isEmpty()) {
516 ALOGD("OpPlayAudio: not muting track:%d usage:%d for service UID %d",
517 id,
518 attr.usage,
519 uid);
520 return nullptr;
521 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800522 }
523 // stream type has been filtered by audio policy to indicate whether it can be muted
524 if (streamType == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Eric Laurent2dab0302019-05-08 18:15:55 -0700525 ALOGD("OpPlayAudio: not muting track:%d usage:%d ENFORCED_AUDIBLE", id, attr.usage);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700526 return nullptr;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800527 }
Eric Laurent2dab0302019-05-08 18:15:55 -0700528 if ((attr.flags & AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY)
529 == AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY) {
530 ALOGD("OpPlayAudio: not muting track:%d flags %#x have FLAG_BYPASS_INTERRUPTION_POLICY",
531 id, attr.flags);
532 return nullptr;
533 }
Eric Laurent9ff3e532022-11-10 16:04:44 +0100534 return new OpPlayAudioMonitor(attributionSource, attr.usage, id);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700535}
536
537AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
Svet Ganov33761132021-05-13 22:51:08 +0000538 const AttributionSourceState& attributionSource, audio_usage_t usage, int id)
539 : mHasOpPlayAudio(true), mAttributionSource(attributionSource), mUsage((int32_t) usage),
540 mId(id)
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700541{
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800542}
543
544AudioFlinger::PlaybackThread::OpPlayAudioMonitor::~OpPlayAudioMonitor()
545{
546 if (mOpCallback != 0) {
547 mAppOpsManager.stopWatchingMode(mOpCallback);
548 }
549 mOpCallback.clear();
550}
551
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700552void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
553{
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700554 checkPlayAudioForUsage();
Svet Ganov33761132021-05-13 22:51:08 +0000555 if (mAttributionSource.packageName.has_value()) {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700556 mOpCallback = new PlayAudioOpCallback(this);
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700557 mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
Svet Ganov33761132021-05-13 22:51:08 +0000558 VALUE_OR_FATAL(aidl2legacy_string_view_String16(
559 mAttributionSource.packageName.value_or("")))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700560 , mOpCallback);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700561 }
562}
563
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800564bool AudioFlinger::PlaybackThread::OpPlayAudioMonitor::hasOpPlayAudio() const {
565 return mHasOpPlayAudio.load();
566}
567
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700568// Note this method is never called (and never to be) for audio server / patch record track
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800569// - not called from constructor due to check on UID,
570// - not called from PlayAudioOpCallback because the callback is not installed in this case
571void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage()
572{
Svet Ganov33761132021-05-13 22:51:08 +0000573 if (!mAttributionSource.packageName.has_value()) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800574 mHasOpPlayAudio.store(false);
575 } else {
Svet Ganov33761132021-05-13 22:51:08 +0000576 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAttributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700577 String16 packageName = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000578 aidl2legacy_string_view_String16(mAttributionSource.packageName.value_or("")));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000579 bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700580 mUsage, uid, packageName) == AppOpsManager::MODE_ALLOWED;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800581 ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
582 mHasOpPlayAudio.store(hasIt);
583 }
584}
585
586AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::PlayAudioOpCallback(
587 const wp<OpPlayAudioMonitor>& monitor) : mMonitor(monitor)
588{ }
589
590void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::opChanged(int32_t op,
591 const String16& packageName) {
592 // we only have uid, so we need to check all package names anyway
593 UNUSED(packageName);
594 if (op != AppOpsManager::OP_PLAY_AUDIO) {
595 return;
596 }
597 sp<OpPlayAudioMonitor> monitor = mMonitor.promote();
598 if (monitor != NULL) {
599 monitor->checkPlayAudioForUsage();
600 }
601}
602
Eric Laurent9066ad32019-05-20 14:40:10 -0700603// static
604void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::getPackagesForUid(
605 uid_t uid, Vector<String16>& packages)
606{
607 PermissionController permissionController;
608 permissionController.getPackagesForUid(uid, packages);
609}
610
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800611// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700612#undef LOG_TAG
613#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800614
615// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
616AudioFlinger::PlaybackThread::Track::Track(
617 PlaybackThread *thread,
618 const sp<Client>& client,
619 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700620 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800621 uint32_t sampleRate,
622 audio_format_t format,
623 audio_channel_mask_t channelMask,
624 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700625 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700626 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800627 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800628 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700629 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000630 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -0700631 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800632 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100633 audio_port_handle_t portId,
jiabinf042b9b2021-05-07 23:46:28 +0000634 size_t frameCountToBeReady,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200635 float speed,
jiabinc658e452022-10-21 20:52:21 +0000636 bool isSpatialized,
637 bool isBitPerfect)
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),
jiabinc658e452022-10-21 20:52:21 +0000672 mIsSpatialized(isSpatialized),
673 mIsBitPerfect(isBitPerfect)
Eric Laurent81784c32012-11-19 14:55:58 -0800674{
Eric Laurent83b88082014-06-20 18:31:16 -0700675 // client == 0 implies sharedBuffer == 0
676 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
677
Andy Hung9d84af52018-09-12 18:03:44 -0700678 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700679 __func__, mId, sharedBuffer->unsecurePointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700680
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700681 if (mCblk == NULL) {
682 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800683 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700684
Svet Ganov33761132021-05-13 22:51:08 +0000685 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Andy Hung689e82c2019-08-21 17:53:17 -0700686 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
687 ALOGE("%s(%d): no more tracks available", __func__, mId);
688 releaseCblk(); // this makes the track invalid.
689 return;
690 }
691
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700692 if (sharedBuffer == 0) {
693 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700694 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700695 } else {
696 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
Kevin Rocard36862032019-10-10 10:52:19 +0100697 mFrameSize, sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700698 }
699 mServerProxy = mAudioTrackServerProxy;
Andy Hung3c7f47a2021-03-16 17:30:09 -0700700 mServerProxy->setStartThresholdInFrames(frameCountToBeReady); // update the Cblk value
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700701
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700702 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700703 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700704 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
705 // race with setSyncEvent(). However, if we call it, we cannot properly start
706 // static fast tracks (SoundPool) immediately after stopping.
707 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700708 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
709 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700710 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700711 // FIXME This is too eager. We allocate a fast track index before the
712 // fast track becomes active. Since fast tracks are a scarce resource,
713 // this means we are potentially denying other more important fast tracks from
714 // being created. It would be better to allocate the index dynamically.
715 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700716 thread->mFastTrackAvailMask &= ~(1 << i);
717 }
Andy Hung8946a282018-04-19 20:04:56 -0700718
Dean Wheatley7b036912020-06-18 16:22:11 +1000719 mServerLatencySupported = checkServerLatencySupported(format, flags);
Andy Hung8946a282018-04-19 20:04:56 -0700720#ifdef TEE_SINK
721 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800722 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700723#endif
jiabin57303cc2018-12-18 15:45:57 -0800724
jiabineb3bda02020-06-30 14:07:03 -0700725 if (thread->supportsHapticPlayback()) {
726 // If the track is attached to haptic playback thread, it is potentially to have
727 // HapticGenerator effect, which will generate haptic data, on the track. In that case,
728 // external vibration is always created for all tracks attached to haptic playback thread.
jiabin57303cc2018-12-18 15:45:57 -0800729 mAudioVibrationController = new AudioVibrationController(this);
Svet Ganov33761132021-05-13 22:51:08 +0000730 std::string packageName = attributionSource.packageName.has_value() ?
731 attributionSource.packageName.value() : "";
jiabin57303cc2018-12-18 15:45:57 -0800732 mExternalVibration = new os::ExternalVibration(
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700733 mUid, packageName, mAttr, mAudioVibrationController);
jiabin57303cc2018-12-18 15:45:57 -0800734 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800735
736 // Once this item is logged by the server, the client can add properties.
Andy Hunga629bd12020-06-05 16:03:53 -0700737 const char * const traits = sharedBuffer == 0 ? "" : "static";
Andy Hung5837c7f2021-02-25 10:48:24 -0800738 mTrackMetrics.logConstructor(creatorPid, uid, id(), traits, streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800739}
740
741AudioFlinger::PlaybackThread::Track::~Track()
742{
Andy Hung9d84af52018-09-12 18:03:44 -0700743 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700744
745 // The destructor would clear mSharedBuffer,
746 // but it will not push the decremented reference count,
747 // leaving the client's IMemory dangling indefinitely.
748 // This prevents that leak.
749 if (mSharedBuffer != 0) {
750 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700751 }
Eric Laurent81784c32012-11-19 14:55:58 -0800752}
753
Glenn Kasten03003332013-08-06 15:40:54 -0700754status_t AudioFlinger::PlaybackThread::Track::initCheck() const
755{
756 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700757 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700758 status = NO_MEMORY;
759 }
760 return status;
761}
762
Eric Laurent81784c32012-11-19 14:55:58 -0800763void AudioFlinger::PlaybackThread::Track::destroy()
764{
765 // NOTE: destroyTrack_l() can remove a strong reference to this Track
766 // by removing it from mTracks vector, so there is a risk that this Tracks's
767 // destructor is called. As the destructor needs to lock mLock,
768 // we must acquire a strong reference on this Track before locking mLock
769 // here so that the destructor is called only when exiting this function.
770 // On the other hand, as long as Track::destroy() is only called by
771 // TrackHandle destructor, the TrackHandle still holds a strong ref on
772 // this Track with its member mTrack.
773 sp<Track> keep(this);
774 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700775 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800776 sp<ThreadBase> thread = mThread.promote();
777 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800778 Mutex::Autolock _l(thread->mLock);
779 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700780 wasActive = playbackThread->destroyTrack_l(this);
781 }
782 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700783 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800784 }
785 }
Kevin Rocardc43ea142019-01-31 18:17:37 -0800786 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Eric Laurent81784c32012-11-19 14:55:58 -0800787}
788
Andy Hungf6ab58d2018-05-25 12:50:39 -0700789void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800790{
Eric Laurent973db022018-11-20 14:54:31 -0800791 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700792 " Format Chn mask SRate "
793 "ST Usg CT "
794 " G db L dB R dB VS dB "
795 " Server FrmCnt FrmRdy F Underruns Flushed"
796 "%s\n",
797 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800798}
799
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700800void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800801{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700802 char trackType;
803 switch (mType) {
804 case TYPE_DEFAULT:
805 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700806 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700807 trackType = 'S'; // static
808 } else {
809 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800810 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700811 break;
812 case TYPE_PATCH:
813 trackType = 'P';
814 break;
815 default:
816 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800817 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700818
819 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700820 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700821 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700822 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700823 }
824
Eric Laurent81784c32012-11-19 14:55:58 -0800825 char nowInUnderrun;
826 switch (mObservedUnderruns.mBitFields.mMostRecent) {
827 case UNDERRUN_FULL:
828 nowInUnderrun = ' ';
829 break;
830 case UNDERRUN_PARTIAL:
831 nowInUnderrun = '<';
832 break;
833 case UNDERRUN_EMPTY:
834 nowInUnderrun = '*';
835 break;
836 default:
837 nowInUnderrun = '?';
838 break;
839 }
Andy Hungda540db2017-04-20 14:06:17 -0700840
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700841 char fillingStatus;
842 switch (mFillingUpStatus) {
843 case FS_INVALID:
844 fillingStatus = 'I';
845 break;
846 case FS_FILLING:
847 fillingStatus = 'f';
848 break;
849 case FS_FILLED:
850 fillingStatus = 'F';
851 break;
852 case FS_ACTIVE:
853 fillingStatus = 'A';
854 break;
855 default:
856 fillingStatus = '?';
857 break;
858 }
859
860 // clip framesReadySafe to max representation in dump
861 const size_t framesReadySafe =
862 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
863
864 // obtain volumes
865 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
866 const std::pair<float /* volume */, bool /* active */> vsVolume =
867 mVolumeHandler->getLastVolume();
868
869 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
870 // as it may be reduced by the application.
871 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
872 // Check whether the buffer size has been modified by the app.
873 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
874 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
875 ? 'e' /* error */ : ' ' /* identical */;
876
Eric Laurent973db022018-11-20 14:54:31 -0800877 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700878 "%08X %08X %6u "
879 "%2u %3x %2x "
880 "%5.2g %5.2g %5.2g %5.2g%c "
881 "%08X %6zu%c %6zu %c %9u%c %7u",
Marco Nelissenb2208842014-02-07 14:00:50 -0800882 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700883 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700884 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -0800885 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -0800886 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700887 mCblk->mFlags,
888
Eric Laurent81784c32012-11-19 14:55:58 -0800889 mFormat,
890 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700891 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700892
893 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700894 mAttr.usage,
895 mAttr.content_type,
896
897 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700898 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
899 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700900 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
901 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700902
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700903 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700904 bufferSizeInFrames,
905 modifiedBufferChar,
906 framesReadySafe,
907 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700908 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800909 nowInUnderrun,
Andy Hungf6ab58d2018-05-25 12:50:39 -0700910 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700911 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700912
913 if (isServerLatencySupported()) {
914 double latencyMs;
915 bool fromTrack;
916 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
917 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
918 // or 'k' if estimated from kernel because track frames haven't been presented yet.
919 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700920 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700921 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700922 }
923 }
924 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800925}
926
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800927uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
928 return mAudioTrackServerProxy->getSampleRate();
929}
930
Eric Laurent81784c32012-11-19 14:55:58 -0800931// AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800932status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800933{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800934 ServerProxy::Buffer buf;
935 size_t desiredFrames = buffer->frameCount;
936 buf.mFrameCount = desiredFrames;
937 status_t status = mServerProxy->obtainBuffer(&buf);
938 buffer->frameCount = buf.mFrameCount;
939 buffer->raw = buf.mRaw;
Andy Hungfc629172020-06-22 10:06:23 -0700940 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused() && !isOffloaded()) {
Andy Hung9d84af52018-09-12 18:03:44 -0700941 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
Andy Hung959b5b82021-09-24 10:46:20 -0700942 __func__, mId, buf.mFrameCount, desiredFrames, (int)mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -0700943 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -0800944 } else {
945 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -0800946 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800947 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800948}
949
Kevin Rocard153f92d2018-12-18 18:33:28 -0800950void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
951{
952 interceptBuffer(*buffer);
953 TrackBase::releaseBuffer(buffer);
954}
955
956// TODO: compensate for time shift between HW modules.
957void AudioFlinger::PlaybackThread::Track::interceptBuffer(
Kevin Rocarda134b002019-02-07 18:05:31 -0800958 const AudioBufferProvider::Buffer& sourceBuffer) {
Kevin Rocard6057fa22019-02-08 14:08:07 -0800959 auto start = std::chrono::steady_clock::now();
Kevin Rocarda134b002019-02-07 18:05:31 -0800960 const size_t frameCount = sourceBuffer.frameCount;
Kevin Rocardd83b08a2019-02-27 15:05:54 -0800961 if (frameCount == 0) {
962 return; // No audio to intercept.
963 // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
964 // does not allow 0 frame size request contrary to getNextBuffer
965 }
966 for (auto& teePatch : mTeePatches) {
967 RecordThread::PatchRecord* patchRecord = teePatch.patchRecord.get();
Mikhail Naganov8296c252019-09-25 14:59:54 -0700968 const size_t framesWritten = patchRecord->writeFrames(
969 sourceBuffer.i8, frameCount, mFrameSize);
970 const size_t framesLeft = frameCount - framesWritten;
Kevin Rocarda134b002019-02-07 18:05:31 -0800971 ALOGW_IF(framesLeft != 0, "%s(%d) PatchRecord %d can not provide big enough "
972 "buffer %zu/%zu, dropping %zu frames", __func__, mId, patchRecord->mId,
973 framesWritten, frameCount, framesLeft);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800974 }
Kevin Rocard6057fa22019-02-08 14:08:07 -0800975 auto spent = ceil<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
976 using namespace std::chrono_literals;
977 // Average is ~20us per track, this should virtually never be logged (Logging takes >200us)
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100978 ALOGD_IF(spent > 500us, "%s: took %lldus to intercept %zu tracks", __func__,
Kevin Rocard6057fa22019-02-08 14:08:07 -0800979 spent.count(), mTeePatches.size());
Kevin Rocard153f92d2018-12-18 18:33:28 -0800980}
981
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700982// ExtendedAudioBufferProvider interface
983
Andy Hung27876c02014-09-09 18:07:55 -0700984// framesReady() may return an approximation of the number of frames if called
985// from a different thread than the one calling Proxy->obtainBuffer() and
986// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
987// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800988size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700989 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
990 // Static tracks return zero frames immediately upon stopping (for FastTracks).
991 // The remainder of the buffer is not drained.
992 return 0;
993 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800994 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800995}
996
Andy Hung818e7a32016-02-16 18:08:07 -0800997int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700998{
999 return mAudioTrackServerProxy->framesReleased();
1000}
1001
Andy Hung818e7a32016-02-16 18:08:07 -08001002void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -08001003{
1004 // This call comes from a FastTrack and should be kept lockless.
1005 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -08001006 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -08001007
Andy Hung818e7a32016-02-16 18:08:07 -08001008 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -07001009
1010 // Compute latency.
1011 // TODO: Consider whether the server latency may be passed in by FastMixer
1012 // as a constant for all active FastTracks.
1013 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
1014 mServerLatencyFromTrack.store(true);
1015 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -08001016}
1017
Eric Laurent81784c32012-11-19 14:55:58 -08001018// Don't call for fast tracks; the framesReady() could result in priority inversion
1019bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001020 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
1021 return true;
1022 }
1023
Eric Laurent16498512014-03-17 17:22:08 -07001024 if (isStopping()) {
1025 if (framesReady() > 0) {
1026 mFillingUpStatus = FS_FILLED;
1027 }
Eric Laurent81784c32012-11-19 14:55:58 -08001028 return true;
1029 }
1030
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001031 size_t bufferSizeInFrames = mServerProxy->getBufferSizeInFrames();
Andy Hung3c7f47a2021-03-16 17:30:09 -07001032 // Note: mServerProxy->getStartThresholdInFrames() is clamped.
1033 const size_t startThresholdInFrames = mServerProxy->getStartThresholdInFrames();
1034 const size_t framesToBeReady = std::clamp( // clamp again to validate client values.
1035 std::min(startThresholdInFrames, bufferSizeInFrames), size_t(1), mFrameCount);
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001036
1037 if (framesReady() >= framesToBeReady || (mCblk->mFlags & CBLK_FORCEREADY)) {
1038 ALOGV("%s(%d): consider track ready with %zu/%zu, target was %zu)",
1039 __func__, mId, framesReady(), bufferSizeInFrames, framesToBeReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001040 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001041 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001042 return true;
1043 }
1044 return false;
1045}
1046
Glenn Kasten0f11b512014-01-31 16:18:54 -08001047status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -08001048 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001049{
1050 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -07001051 ALOGV("%s(%d): calling pid %d session %d",
1052 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001053
1054 sp<ThreadBase> thread = mThread.promote();
1055 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001056 if (isOffloaded()) {
1057 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
1058 Mutex::Autolock _lth(thread->mLock);
1059 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001060 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
1061 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001062 invalidate();
1063 return PERMISSION_DENIED;
1064 }
1065 }
1066 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001067 track_state state = mState;
1068 // here the track could be either new, or restarted
1069 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -08001070
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001071 // initial state-stopping. next state-pausing.
1072 // What if resume is called ?
1073
Zhou Song1ed46a22020-08-17 15:36:56 +08001074 if (state == FLUSHED) {
1075 // avoid underrun glitches when starting after flush
1076 reset();
1077 }
1078
kuowei.li576f1362021-05-11 18:02:32 +08001079 // clear mPauseHwPending because of pause (and possibly flush) during underrun.
1080 mPauseHwPending = false;
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001081 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001082 if (mResumeToStopping) {
1083 // happened we need to resume to STOPPING_1
1084 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -07001085 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
1086 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001087 } else {
1088 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -07001089 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
1090 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001091 }
Eric Laurent81784c32012-11-19 14:55:58 -08001092 } else {
1093 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -07001094 ALOGV("%s(%d): ? => ACTIVE on thread %d",
1095 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001096 }
1097
yucliu6cfb5932022-07-20 17:40:39 -07001098 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1099
1100 // states to reset position info for pcm tracks
1101 if (audio_is_linear_pcm(mFormat)
Andy Hunge10393e2015-06-12 13:59:33 -07001102 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
1103 mFrameMap.reset();
yucliu6cfb5932022-07-20 17:40:39 -07001104
1105 if (!isFastTrack() && (isDirect() || isOffloaded())) {
1106 // Start point of track -> sink frame map. If the HAL returns a
1107 // frame position smaller than the first written frame in
1108 // updateTrackFrameInfo, the timestamp can be interpolated
1109 // instead of using a larger value.
1110 mFrameMap.push(mAudioTrackServerProxy->framesReleased(),
1111 playbackThread->framesWritten());
1112 }
Andy Hunge10393e2015-06-12 13:59:33 -07001113 }
Haynes Mathew George240934b2015-03-11 18:25:50 -07001114 if (isFastTrack()) {
1115 // refresh fast track underruns on start because that field is never cleared
1116 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
1117 // after stop.
1118 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
1119 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001120 status = playbackThread->addTrack_l(this);
jiabina84c3d32022-12-02 18:59:55 +00001121 if (status == INVALID_OPERATION || status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurent81784c32012-11-19 14:55:58 -08001122 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001123 // restore previous state if start was rejected by policy manager
jiabina84c3d32022-12-02 18:59:55 +00001124 if (status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001125 mState = state;
1126 }
1127 }
Andy Hung1d3556d2018-03-29 16:30:14 -07001128
Andy Hungb68f5eb2019-12-03 16:49:17 -08001129 // Audio timing metrics are computed a few mix cycles after starting.
1130 {
1131 mLogStartCountdown = LOG_START_COUNTDOWN;
1132 mLogStartTimeNs = systemTime();
1133 mLogStartFrames = mAudioTrackServerProxy->getTimestamp()
Andy Hung62921122020-05-18 10:47:31 -07001134 .mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1135 mLogLatencyMs = 0.;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001136 }
Andy Hunga81a4b42022-05-19 19:24:51 -07001137 mLogForceVolumeUpdate = true; // at least one volume logged for metrics when starting.
Andy Hungb68f5eb2019-12-03 16:49:17 -08001138
Andy Hung1d3556d2018-03-29 16:30:14 -07001139 if (status == NO_ERROR || status == ALREADY_EXISTS) {
1140 // for streaming tracks, remove the buffer read stop limit.
1141 mAudioTrackServerProxy->start();
1142 }
1143
Eric Laurentbfb1b832013-01-07 09:53:42 -08001144 // track was already in the active list, not a problem
1145 if (status == ALREADY_EXISTS) {
1146 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -07001147 } else {
1148 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
1149 // It is usually unsafe to access the server proxy from a binder thread.
1150 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
1151 // isn't looking at this track yet: we still hold the normal mixer thread lock,
1152 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -07001153 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -07001154 ServerProxy::Buffer buffer;
1155 buffer.mFrameCount = 1;
1156 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -08001157 }
1158 } else {
1159 status = BAD_VALUE;
1160 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001161 if (status == NO_ERROR) {
1162 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
Jean-Michel Trivi16395ca2022-12-11 22:10:11 +00001163
1164 // send format to AudioManager for playback activity monitoring
1165 sp<IAudioManager> audioManager = thread->mAudioFlinger->getOrCreateAudioManager();
1166 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1167 std::unique_ptr<os::PersistableBundle> bundle =
1168 std::make_unique<os::PersistableBundle>();
1169 bundle->putBoolean(String16(kExtraPlayerEventSpatializedKey),
1170 isSpatialized());
1171 bundle->putInt(String16(kExtraPlayerEventSampleRateKey), mSampleRate);
1172 bundle->putInt(String16(kExtraPlayerEventChannelMaskKey), mChannelMask);
1173 status_t result = audioManager->portEvent(mPortId,
1174 PLAYER_UPDATE_FORMAT, bundle);
1175 if (result != OK) {
1176 ALOGE("%s: unable to send playback format for port ID %d, status error %d",
1177 __func__, mPortId, result);
1178 }
1179 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001180 }
Eric Laurent81784c32012-11-19 14:55:58 -08001181 return status;
1182}
1183
1184void AudioFlinger::PlaybackThread::Track::stop()
1185{
Andy Hungc0691382018-09-12 18:01:57 -07001186 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001187 sp<ThreadBase> thread = mThread.promote();
1188 if (thread != 0) {
1189 Mutex::Autolock _l(thread->mLock);
1190 track_state state = mState;
1191 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
1192 // If the track is not active (PAUSED and buffers full), flush buffers
1193 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1194 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1195 reset();
1196 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -07001197 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001198 mState = STOPPED;
1199 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001200 // For fast tracks prepareTracks_l() will set state to STOPPING_2
1201 // presentation is complete
1202 // For an offloaded track this starts a drain and state will
1203 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -08001204 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -07001205 if (isOffloaded()) {
1206 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
1207 }
Eric Laurent81784c32012-11-19 14:55:58 -08001208 }
Eric Laurentb369caf2015-03-30 20:51:47 -07001209 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -07001210 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
1211 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001212 }
Eric Laurent81784c32012-11-19 14:55:58 -08001213 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001214 forEachTeePatchTrack([](auto patchTrack) { patchTrack->stop(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001215}
1216
1217void AudioFlinger::PlaybackThread::Track::pause()
1218{
Andy Hungc0691382018-09-12 18:01:57 -07001219 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001220 sp<ThreadBase> thread = mThread.promote();
1221 if (thread != 0) {
1222 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001223 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1224 switch (mState) {
1225 case STOPPING_1:
1226 case STOPPING_2:
1227 if (!isOffloaded()) {
1228 /* nothing to do if track is not offloaded */
1229 break;
1230 }
1231
1232 // Offloaded track was draining, we need to carry on draining when resumed
1233 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07001234 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001235 case ACTIVE:
1236 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -08001237 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -07001238 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
1239 __func__, mId, (int)mThreadIoHandle);
Kuowei Li23666472021-01-20 10:23:25 +08001240 if (isOffloadedOrDirect()) {
1241 mPauseHwPending = true;
1242 }
Eric Laurentede6c3b2013-09-19 14:37:46 -07001243 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001244 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001245
Eric Laurentbfb1b832013-01-07 09:53:42 -08001246 default:
1247 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001248 }
1249 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001250 // Pausing the TeePatch to avoid a glitch on underrun, at the cost of buffered audio loss.
1251 forEachTeePatchTrack([](auto patchTrack) { patchTrack->pause(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001252}
1253
1254void AudioFlinger::PlaybackThread::Track::flush()
1255{
Andy Hungc0691382018-09-12 18:01:57 -07001256 ALOGV("%s(%d)", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001257 sp<ThreadBase> thread = mThread.promote();
1258 if (thread != 0) {
1259 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001260 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001261
Phil Burk4bb650b2016-09-09 12:11:17 -07001262 // Flush the ring buffer now if the track is not active in the PlaybackThread.
1263 // Otherwise the flush would not be done until the track is resumed.
1264 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
1265 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1266 (void)mServerProxy->flushBufferIfNeeded();
1267 }
1268
Eric Laurentbfb1b832013-01-07 09:53:42 -08001269 if (isOffloaded()) {
1270 // If offloaded we allow flush during any state except terminated
1271 // and keep the track active to avoid problems if user is seeking
1272 // rapidly and underlying hardware has a significant delay handling
1273 // a pause
1274 if (isTerminated()) {
1275 return;
1276 }
1277
Andy Hung9d84af52018-09-12 18:03:44 -07001278 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001279 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001280
1281 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -07001282 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
1283 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001284 mState = ACTIVE;
1285 }
1286
Haynes Mathew George7844f672014-01-15 12:32:55 -08001287 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001288 mResumeToStopping = false;
1289 } else {
1290 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
1291 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
1292 return;
1293 }
1294 // No point remaining in PAUSED state after a flush => go to
1295 // FLUSHED state
1296 mState = FLUSHED;
1297 // do not reset the track if it is still in the process of being stopped or paused.
1298 // this will be done by prepareTracks_l() when the track is stopped.
1299 // prepareTracks_l() will see mState == FLUSHED, then
1300 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -08001301 if (isDirect()) {
1302 mFlushHwPending = true;
1303 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001304 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1305 reset();
1306 }
Eric Laurent81784c32012-11-19 14:55:58 -08001307 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001308 // Prevent flush being lost if the track is flushed and then resumed
1309 // before mixer thread can run. This is important when offloading
1310 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -07001311 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001312 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001313 // Flush the Tee to avoid on resume playing old data and glitching on the transition to new data
1314 forEachTeePatchTrack([](auto patchTrack) { patchTrack->flush(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001315}
1316
Haynes Mathew George7844f672014-01-15 12:32:55 -08001317// must be called with thread lock held
1318void AudioFlinger::PlaybackThread::Track::flushAck()
1319{
Eric Laurentd1f69b02014-12-15 14:33:13 -08001320 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -08001321 return;
1322
Phil Burk4bb650b2016-09-09 12:11:17 -07001323 // Clear the client ring buffer so that the app can prime the buffer while paused.
1324 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1325 mServerProxy->flushBufferIfNeeded();
1326
Haynes Mathew George7844f672014-01-15 12:32:55 -08001327 mFlushHwPending = false;
1328}
1329
Kuowei Li23666472021-01-20 10:23:25 +08001330void AudioFlinger::PlaybackThread::Track::pauseAck()
1331{
1332 mPauseHwPending = false;
1333}
1334
Eric Laurent81784c32012-11-19 14:55:58 -08001335void AudioFlinger::PlaybackThread::Track::reset()
1336{
1337 // Do not reset twice to avoid discarding data written just after a flush and before
1338 // the audioflinger thread detects the track is stopped.
1339 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001340 // Force underrun condition to avoid false underrun callback until first data is
1341 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001342 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001343 mFillingUpStatus = FS_FILLING;
1344 mResetDone = true;
1345 if (mState == FLUSHED) {
1346 mState = IDLE;
1347 }
1348 }
1349}
1350
Eric Laurentbfb1b832013-01-07 09:53:42 -08001351status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
1352{
1353 sp<ThreadBase> thread = mThread.promote();
1354 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001355 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001356 return FAILED_TRANSACTION;
1357 } else if ((thread->type() == ThreadBase::DIRECT) ||
1358 (thread->type() == ThreadBase::OFFLOAD)) {
1359 return thread->setParameters(keyValuePairs);
1360 } else {
1361 return PERMISSION_DENIED;
1362 }
1363}
1364
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001365status_t AudioFlinger::PlaybackThread::Track::selectPresentation(int presentationId,
1366 int programId) {
1367 sp<ThreadBase> thread = mThread.promote();
1368 if (thread == 0) {
1369 ALOGE("thread is dead");
1370 return FAILED_TRANSACTION;
1371 } else if ((thread->type() == ThreadBase::DIRECT) || (thread->type() == ThreadBase::OFFLOAD)) {
1372 DirectOutputThread *directOutputThread = static_cast<DirectOutputThread*>(thread.get());
1373 return directOutputThread->selectPresentation(presentationId, programId);
1374 }
1375 return INVALID_OPERATION;
1376}
1377
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001378VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
1379 const sp<VolumeShaper::Configuration>& configuration,
1380 const sp<VolumeShaper::Operation>& operation)
1381{
Andy Hung10cbff12017-02-21 17:30:14 -08001382 sp<VolumeShaper::Configuration> newConfiguration;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001383
Andy Hung10cbff12017-02-21 17:30:14 -08001384 if (isOffloadedOrDirect()) {
1385 const VolumeShaper::Configuration::OptionFlag optionFlag
1386 = configuration->getOptionFlags();
1387 if ((optionFlag & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001388 ALOGW("%s(%d): %s tracks do not support frame counted VolumeShaper,"
1389 " using clock time instead",
1390 __func__, mId,
1391 isOffloaded() ? "Offload" : "Direct");
Andy Hung10cbff12017-02-21 17:30:14 -08001392 newConfiguration = new VolumeShaper::Configuration(*configuration);
1393 newConfiguration->setOptionFlags(
1394 VolumeShaper::Configuration::OptionFlag(optionFlag
1395 | VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME));
1396 }
1397 }
1398
1399 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(
1400 (newConfiguration.get() != nullptr ? newConfiguration : configuration), operation);
1401
1402 if (isOffloadedOrDirect()) {
1403 // Signal thread to fetch new volume.
1404 sp<ThreadBase> thread = mThread.promote();
1405 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001406 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001407 thread->broadcast_l();
1408 }
1409 }
1410 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001411}
1412
1413sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1414{
1415 // Note: We don't check if Thread exists.
1416
1417 // mVolumeHandler is thread safe.
1418 return mVolumeHandler->getVolumeShaperState(id);
1419}
1420
Kevin Rocard12381092018-04-11 09:19:59 -07001421void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volume)
1422{
1423 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1424 mFinalVolume = volume;
1425 setMetadataHasChanged();
Andy Hunga81a4b42022-05-19 19:24:51 -07001426 mLogForceVolumeUpdate = true;
1427 }
1428 if (mLogForceVolumeUpdate) {
1429 mLogForceVolumeUpdate = false;
1430 mTrackMetrics.logVolume(mFinalVolume);
Kevin Rocard12381092018-04-11 09:19:59 -07001431 }
1432}
1433
1434void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1435{
Eric Laurent49e39282022-06-24 18:42:45 +02001436 // Do not forward metadata for PatchTrack with unspecified stream type
1437 if (mStreamType == AUDIO_STREAM_PATCH) {
1438 return;
1439 }
1440
Eric Laurent94579172020-11-20 18:41:04 +01001441 playback_track_metadata_v7_t metadata;
1442 metadata.base = {
Kevin Rocard12381092018-04-11 09:19:59 -07001443 .usage = mAttr.usage,
1444 .content_type = mAttr.content_type,
1445 .gain = mFinalVolume,
1446 };
Eric Laurentfdf99502021-11-26 19:05:02 +01001447
1448 // When attributes are undefined, derive default values from stream type.
1449 // See AudioAttributes.java, usageForStreamType() and Builder.setInternalLegacyStreamType()
1450 if (mAttr.usage == AUDIO_USAGE_UNKNOWN) {
1451 switch (mStreamType) {
1452 case AUDIO_STREAM_VOICE_CALL:
1453 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION;
1454 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1455 break;
1456 case AUDIO_STREAM_SYSTEM:
1457 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1458 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1459 break;
1460 case AUDIO_STREAM_RING:
1461 metadata.base.usage = AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1462 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1463 break;
1464 case AUDIO_STREAM_MUSIC:
1465 metadata.base.usage = AUDIO_USAGE_MEDIA;
1466 metadata.base.content_type = AUDIO_CONTENT_TYPE_MUSIC;
1467 break;
1468 case AUDIO_STREAM_ALARM:
1469 metadata.base.usage = AUDIO_USAGE_ALARM;
1470 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1471 break;
1472 case AUDIO_STREAM_NOTIFICATION:
1473 metadata.base.usage = AUDIO_USAGE_NOTIFICATION;
1474 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1475 break;
1476 case AUDIO_STREAM_DTMF:
1477 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1478 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1479 break;
1480 case AUDIO_STREAM_ACCESSIBILITY:
1481 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1482 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1483 break;
1484 case AUDIO_STREAM_ASSISTANT:
1485 metadata.base.usage = AUDIO_USAGE_ASSISTANT;
1486 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1487 break;
1488 case AUDIO_STREAM_REROUTING:
1489 metadata.base.usage = AUDIO_USAGE_VIRTUAL_SOURCE;
1490 // unknown content type
1491 break;
1492 case AUDIO_STREAM_CALL_ASSISTANT:
1493 metadata.base.usage = AUDIO_USAGE_CALL_ASSISTANT;
1494 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1495 break;
1496 default:
1497 break;
1498 }
1499 }
1500
Eric Laurent78b07302022-10-07 16:20:34 +02001501 metadata.channel_mask = mChannelMask;
Eric Laurent94579172020-11-20 18:41:04 +01001502 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
1503 *backInserter++ = metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07001504}
1505
Kevin Rocard153f92d2018-12-18 18:33:28 -08001506void AudioFlinger::PlaybackThread::Track::setTeePatches(TeePatches teePatches) {
Kevin Rocardc43ea142019-01-31 18:17:37 -08001507 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Kevin Rocard153f92d2018-12-18 18:33:28 -08001508 mTeePatches = std::move(teePatches);
jiabinf042b9b2021-05-07 23:46:28 +00001509 if (mState == TrackBase::ACTIVE || mState == TrackBase::RESUMING ||
1510 mState == TrackBase::STOPPING_1) {
1511 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1512 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001513}
1514
Vlad Popae8d99472022-06-30 16:02:48 +02001515// must be called with player thread lock held
1516void AudioFlinger::PlaybackThread::Track::processMuteEvent_l(const sp<
1517 IAudioManager>& audioManager, mute_state_t muteState)
1518{
1519 if (mMuteState == muteState) {
1520 // mute state did not change, do nothing
1521 return;
1522 }
1523
1524 status_t result = UNKNOWN_ERROR;
1525 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1526 if (mMuteEventExtras == nullptr) {
1527 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
1528 }
1529 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
1530 static_cast<int>(muteState));
1531
1532 result = audioManager->portEvent(mPortId,
1533 PLAYER_UPDATE_MUTED,
1534 mMuteEventExtras);
1535 }
1536
1537 if (result == OK) {
1538 mMuteState = muteState;
1539 } else {
1540 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
1541 __func__,
1542 id(),
1543 mPortId,
1544 result);
1545 }
1546}
1547
Glenn Kasten573d80a2013-08-26 09:36:23 -07001548status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
1549{
Andy Hung818e7a32016-02-16 18:08:07 -08001550 if (!isOffloaded() && !isDirect()) {
1551 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kastenfe346c72013-08-30 13:28:22 -07001552 }
Glenn Kasten573d80a2013-08-26 09:36:23 -07001553 sp<ThreadBase> thread = mThread.promote();
1554 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001555 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001556 }
Phil Burk6140c792015-03-19 14:30:21 -07001557
Glenn Kasten573d80a2013-08-26 09:36:23 -07001558 Mutex::Autolock _l(thread->mLock);
1559 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Andy Hung818e7a32016-02-16 18:08:07 -08001560 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001561}
1562
Eric Laurent81784c32012-11-19 14:55:58 -08001563status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
1564{
Eric Laurent81784c32012-11-19 14:55:58 -08001565 sp<ThreadBase> thread = mThread.promote();
Eric Laurent6c796322019-04-09 14:13:17 -07001566 if (thread == nullptr) {
1567 return DEAD_OBJECT;
1568 }
Eric Laurent81784c32012-11-19 14:55:58 -08001569
Eric Laurent6c796322019-04-09 14:13:17 -07001570 sp<PlaybackThread> dstThread = (PlaybackThread *)thread.get();
1571 sp<PlaybackThread> srcThread; // srcThread is initialized by call to moveAuxEffectToIo()
1572 sp<AudioFlinger> af = mClient->audioFlinger();
1573 status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001574
Eric Laurent6c796322019-04-09 14:13:17 -07001575 if (EffectId != 0 && status == NO_ERROR) {
1576 status = dstThread->attachAuxEffect(this, EffectId);
1577 if (status == NO_ERROR) {
1578 AudioSystem::moveEffectsToIo(std::vector<int>(EffectId), dstThread->id());
Eric Laurent81784c32012-11-19 14:55:58 -08001579 }
Eric Laurent6c796322019-04-09 14:13:17 -07001580 }
1581
1582 if (status != NO_ERROR && srcThread != nullptr) {
1583 af->moveAuxEffectToIo(EffectId, srcThread, &dstThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001584 }
1585 return status;
1586}
1587
1588void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1589{
1590 mAuxEffectId = EffectId;
1591 mAuxBuffer = buffer;
1592}
1593
Andy Hung59de4262021-06-14 10:53:54 -07001594// presentationComplete verified by frames, used by Mixed tracks.
Andy Hung818e7a32016-02-16 18:08:07 -08001595bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1596 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001597{
Andy Hung818e7a32016-02-16 18:08:07 -08001598 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1599 // This assists in proper timestamp computation as well as wakelock management.
1600
Eric Laurent81784c32012-11-19 14:55:58 -08001601 // a track is considered presented when the total number of frames written to audio HAL
1602 // corresponds to the number of frames written when presentationComplete() is called for the
1603 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001604 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1605 // to detect when all frames have been played. In this case framesWritten isn't
1606 // useful because it doesn't always reflect whether there is data in the h/w
1607 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001608 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1609 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001610 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001611 if (mPresentationCompleteFrames == 0) {
1612 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001613 ALOGV("%s(%d): set:"
Andy Hung9d84af52018-09-12 18:03:44 -07001614 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1615 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001616 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001617 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001618
Andy Hungc54b1ff2016-02-23 14:07:07 -08001619 bool complete;
Andy Hung59de4262021-06-14 10:53:54 -07001620 if (isFastTrack()) { // does not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001621 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001622 ALOGV("%s(%d): %s framesWritten:%lld mPresentationCompleteFrames:%lld",
1623 __func__, mId, (complete ? "complete" : "waiting"),
1624 (long long) framesWritten, (long long) mPresentationCompleteFrames);
Andy Hungc54b1ff2016-02-23 14:07:07 -08001625 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001626 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001627 && mAudioTrackServerProxy->isDrained();
1628 }
1629
1630 if (complete) {
Andy Hung59de4262021-06-14 10:53:54 -07001631 notifyPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08001632 return true;
1633 }
1634 return false;
1635}
1636
Andy Hung59de4262021-06-14 10:53:54 -07001637// presentationComplete checked by time, used by DirectTracks.
1638bool AudioFlinger::PlaybackThread::Track::presentationComplete(uint32_t latencyMs)
1639{
1640 // For Offloaded or Direct tracks.
1641
1642 // For a direct track, we incorporated time based testing for presentationComplete.
1643
1644 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1645 // to detect when all frames have been played. In this case latencyMs isn't
1646 // useful because it doesn't always reflect whether there is data in the h/w
1647 // buffers, particularly if a track has been paused and resumed during draining
1648
1649 constexpr float MIN_SPEED = 0.125f; // min speed scaling allowed for timely response.
1650 if (mPresentationCompleteTimeNs == 0) {
1651 mPresentationCompleteTimeNs = systemTime() + latencyMs * 1e6 / fmax(mSpeed, MIN_SPEED);
1652 ALOGV("%s(%d): set: latencyMs %u mPresentationCompleteTimeNs:%lld",
1653 __func__, mId, latencyMs, (long long) mPresentationCompleteTimeNs);
1654 }
1655
1656 bool complete;
1657 if (isOffloaded()) {
1658 complete = true;
1659 } else { // Direct
1660 complete = systemTime() >= mPresentationCompleteTimeNs;
1661 ALOGV("%s(%d): %s", __func__, mId, (complete ? "complete" : "waiting"));
1662 }
1663 if (complete) {
1664 notifyPresentationComplete();
1665 return true;
1666 }
1667 return false;
1668}
1669
1670void AudioFlinger::PlaybackThread::Track::notifyPresentationComplete()
1671{
1672 // This only triggers once. TODO: should we enforce this?
1673 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
1674 mAudioTrackServerProxy->setStreamEndDone();
1675}
1676
Eric Laurent81784c32012-11-19 14:55:58 -08001677void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1678{
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001679 for (size_t i = 0; i < mSyncEvents.size();) {
Eric Laurent81784c32012-11-19 14:55:58 -08001680 if (mSyncEvents[i]->type() == type) {
1681 mSyncEvents[i]->trigger();
1682 mSyncEvents.removeAt(i);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001683 } else {
1684 ++i;
Eric Laurent81784c32012-11-19 14:55:58 -08001685 }
1686 }
1687}
1688
1689// implement VolumeBufferProvider interface
1690
Glenn Kastenc56f3422014-03-21 17:53:17 -07001691gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001692{
1693 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1694 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001695 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1696 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1697 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001698 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001699 if (vl > GAIN_FLOAT_UNITY) {
1700 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001701 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001702 if (vr > GAIN_FLOAT_UNITY) {
1703 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001704 }
1705 // now apply the cached master volume and stream type volume;
1706 // this is trusted but lacks any synchronization or barrier so may be stale
1707 float v = mCachedVolume;
1708 vl *= v;
1709 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001710 // re-combine into packed minifloat
1711 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001712 // FIXME look at mute, pause, and stop flags
1713 return vlr;
1714}
1715
1716status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1717{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001718 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001719 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1720 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001721 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1722 __func__, mId,
Andy Hung959b5b82021-09-24 10:46:20 -07001723 (int)mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
Eric Laurent81784c32012-11-19 14:55:58 -08001724 event->cancel();
1725 return INVALID_OPERATION;
1726 }
1727 (void) TrackBase::setSyncEvent(event);
1728 return NO_ERROR;
1729}
1730
Glenn Kasten5736c352012-12-04 12:12:34 -08001731void AudioFlinger::PlaybackThread::Track::invalidate()
1732{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001733 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001734 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001735}
1736
1737void AudioFlinger::PlaybackThread::Track::disable()
1738{
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001739 // TODO(b/142394888): the filling status should also be reset to filling
Eric Laurent4d231dc2016-03-11 18:38:23 -08001740 signalClientFlag(CBLK_DISABLED);
1741}
1742
1743void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1744{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001745 // FIXME should use proxy, and needs work
1746 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001747 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001748 android_atomic_release_store(0x40000000, &cblk->mFutex);
1749 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001750 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001751}
1752
Eric Laurent59fe0102013-09-27 18:48:26 -07001753void AudioFlinger::PlaybackThread::Track::signal()
1754{
1755 sp<ThreadBase> thread = mThread.promote();
1756 if (thread != 0) {
1757 PlaybackThread *t = (PlaybackThread *)thread.get();
1758 Mutex::Autolock _l(t->mLock);
1759 t->broadcast_l();
1760 }
1761}
1762
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001763status_t AudioFlinger::PlaybackThread::Track::getDualMonoMode(audio_dual_mono_mode_t* mode)
1764{
1765 status_t status = INVALID_OPERATION;
1766 if (isOffloadedOrDirect()) {
1767 sp<ThreadBase> thread = mThread.promote();
1768 if (thread != nullptr) {
1769 PlaybackThread *t = (PlaybackThread *)thread.get();
1770 Mutex::Autolock _l(t->mLock);
1771 status = t->mOutput->stream->getDualMonoMode(mode);
1772 ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
1773 "%s: mode %d inconsistent", __func__, mDualMonoMode);
1774 }
1775 }
1776 return status;
1777}
1778
1779status_t AudioFlinger::PlaybackThread::Track::setDualMonoMode(audio_dual_mono_mode_t mode)
1780{
1781 status_t status = INVALID_OPERATION;
1782 if (isOffloadedOrDirect()) {
1783 sp<ThreadBase> thread = mThread.promote();
1784 if (thread != nullptr) {
1785 auto t = static_cast<PlaybackThread *>(thread.get());
1786 Mutex::Autolock lock(t->mLock);
1787 status = t->mOutput->stream->setDualMonoMode(mode);
1788 if (status == NO_ERROR) {
1789 mDualMonoMode = mode;
1790 }
1791 }
1792 }
1793 return status;
1794}
1795
1796status_t AudioFlinger::PlaybackThread::Track::getAudioDescriptionMixLevel(float* leveldB)
1797{
1798 status_t status = INVALID_OPERATION;
1799 if (isOffloadedOrDirect()) {
1800 sp<ThreadBase> thread = mThread.promote();
1801 if (thread != nullptr) {
1802 auto t = static_cast<PlaybackThread *>(thread.get());
1803 Mutex::Autolock lock(t->mLock);
1804 status = t->mOutput->stream->getAudioDescriptionMixLevel(leveldB);
1805 ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
1806 "%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
1807 }
1808 }
1809 return status;
1810}
1811
1812status_t AudioFlinger::PlaybackThread::Track::setAudioDescriptionMixLevel(float leveldB)
1813{
1814 status_t status = INVALID_OPERATION;
1815 if (isOffloadedOrDirect()) {
1816 sp<ThreadBase> thread = mThread.promote();
1817 if (thread != nullptr) {
1818 auto t = static_cast<PlaybackThread *>(thread.get());
1819 Mutex::Autolock lock(t->mLock);
1820 status = t->mOutput->stream->setAudioDescriptionMixLevel(leveldB);
1821 if (status == NO_ERROR) {
1822 mAudioDescriptionMixLevel = leveldB;
1823 }
1824 }
1825 }
1826 return status;
1827}
1828
1829status_t AudioFlinger::PlaybackThread::Track::getPlaybackRateParameters(
1830 audio_playback_rate_t* playbackRate)
1831{
1832 status_t status = INVALID_OPERATION;
1833 if (isOffloadedOrDirect()) {
1834 sp<ThreadBase> thread = mThread.promote();
1835 if (thread != nullptr) {
1836 auto t = static_cast<PlaybackThread *>(thread.get());
1837 Mutex::Autolock lock(t->mLock);
1838 status = t->mOutput->stream->getPlaybackRateParameters(playbackRate);
1839 ALOGD_IF((status == NO_ERROR) &&
1840 !isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
1841 "%s: playbackRate inconsistent", __func__);
1842 }
1843 }
1844 return status;
1845}
1846
1847status_t AudioFlinger::PlaybackThread::Track::setPlaybackRateParameters(
1848 const audio_playback_rate_t& playbackRate)
1849{
1850 status_t status = INVALID_OPERATION;
1851 if (isOffloadedOrDirect()) {
1852 sp<ThreadBase> thread = mThread.promote();
1853 if (thread != nullptr) {
1854 auto t = static_cast<PlaybackThread *>(thread.get());
1855 Mutex::Autolock lock(t->mLock);
1856 status = t->mOutput->stream->setPlaybackRateParameters(playbackRate);
1857 if (status == NO_ERROR) {
1858 mPlaybackRateParameters = playbackRate;
1859 }
1860 }
1861 }
1862 return status;
1863}
1864
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001865//To be called with thread lock held
1866bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1867
1868 if (mState == RESUMING)
1869 return true;
1870 /* Resume is pending if track was stopping before pause was called */
1871 if (mState == STOPPING_1 &&
1872 mResumeToStopping)
1873 return true;
1874
1875 return false;
1876}
1877
1878//To be called with thread lock held
1879void AudioFlinger::PlaybackThread::Track::resumeAck() {
1880
1881
1882 if (mState == RESUMING)
1883 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001884
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001885 // Other possibility of pending resume is stopping_1 state
1886 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001887 // drain being called.
1888 if (mState == STOPPING_1) {
1889 mResumeToStopping = false;
1890 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001891}
Andy Hunge10393e2015-06-12 13:59:33 -07001892
1893//To be called with thread lock held
1894void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001895 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001896 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07001897 // Make the kernel frametime available.
1898 const FrameTime ft{
1899 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
1900 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
1901 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
1902 mKernelFrameTime.store(ft);
1903 if (!audio_is_linear_pcm(mFormat)) {
1904 return;
1905 }
1906
Andy Hung818e7a32016-02-16 18:08:07 -08001907 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001908 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001909
1910 // adjust server times and set drained state.
1911 //
1912 // Our timestamps are only updated when the track is on the Thread active list.
1913 // We need to ensure that tracks are not removed before full drain.
1914 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001915 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001916 bool checked = false;
1917 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1918 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1919 // Lookup the track frame corresponding to the sink frame position.
1920 if (local.mTimeNs[i] > 0) {
1921 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1922 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001923 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001924 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001925 checked = true;
1926 }
1927 }
Andy Hunge10393e2015-06-12 13:59:33 -07001928 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001929
1930 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001931 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001932 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001933 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07001934
1935 // Compute latency info.
1936 const bool useTrackTimestamp = !drained;
1937 const double latencyMs = useTrackTimestamp
1938 ? local.getOutputServerLatencyMs(sampleRate())
1939 : timeStamp.getOutputServerLatencyMs(halSampleRate);
1940
1941 mServerLatencyFromTrack.store(useTrackTimestamp);
1942 mServerLatencyMs.store(latencyMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001943
Andy Hung62921122020-05-18 10:47:31 -07001944 if (mLogStartCountdown > 0
1945 && local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0
1946 && local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] > 0)
1947 {
1948 if (mLogStartCountdown > 1) {
1949 --mLogStartCountdown;
1950 } else if (latencyMs < mLogLatencyMs) { // wait for latency to stabilize (dip)
1951 mLogStartCountdown = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001952 // startup is the difference in times for the current timestamp and our start
1953 double startUpMs =
Andy Hung62921122020-05-18 10:47:31 -07001954 (local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartTimeNs) * 1e-6;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001955 // adjust for frames played.
Andy Hung62921122020-05-18 10:47:31 -07001956 startUpMs -= (local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartFrames)
1957 * 1e3 / mSampleRate;
1958 ALOGV("%s: latencyMs:%lf startUpMs:%lf"
1959 " localTime:%lld startTime:%lld"
1960 " localPosition:%lld startPosition:%lld",
1961 __func__, latencyMs, startUpMs,
1962 (long long)local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001963 (long long)mLogStartTimeNs,
Andy Hung62921122020-05-18 10:47:31 -07001964 (long long)local.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001965 (long long)mLogStartFrames);
Andy Hungc2b11cb2020-04-22 09:04:01 -07001966 mTrackMetrics.logLatencyAndStartup(latencyMs, startUpMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001967 }
Andy Hung62921122020-05-18 10:47:31 -07001968 mLogLatencyMs = latencyMs;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001969 }
Andy Hunge10393e2015-06-12 13:59:33 -07001970}
1971
SPeak Shenc19aa9e2022-11-11 00:28:50 +08001972bool AudioFlinger::PlaybackThread::Track::AudioVibrationController::setMute(bool muted) {
jiabin57303cc2018-12-18 15:45:57 -08001973 sp<ThreadBase> thread = mTrack->mThread.promote();
1974 if (thread != 0) {
1975 // Lock for updating mHapticPlaybackEnabled.
1976 Mutex::Autolock _l(thread->mLock);
1977 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1978 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1979 && playbackThread->mHapticChannelCount > 0) {
SPeak Shenc19aa9e2022-11-11 00:28:50 +08001980 ALOGD("%s, haptic playback was %s for track %d",
1981 __func__, muted ? "muted" : "unmuted", mTrack->id());
1982 mTrack->setHapticPlaybackEnabled(!muted);
1983 return true;
jiabin57303cc2018-12-18 15:45:57 -08001984 }
1985 }
SPeak Shenc19aa9e2022-11-11 00:28:50 +08001986 return false;
1987}
1988
1989binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::mute(
1990 /*out*/ bool *ret) {
1991 *ret = setMute(true);
jiabin57303cc2018-12-18 15:45:57 -08001992 return binder::Status::ok();
1993}
1994
1995binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::unmute(
1996 /*out*/ bool *ret) {
SPeak Shenc19aa9e2022-11-11 00:28:50 +08001997 *ret = setMute(false);
jiabin57303cc2018-12-18 15:45:57 -08001998 return binder::Status::ok();
1999}
2000
Eric Laurent81784c32012-11-19 14:55:58 -08002001// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002002#undef LOG_TAG
2003#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002004
Eric Laurent81784c32012-11-19 14:55:58 -08002005AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
2006 PlaybackThread *playbackThread,
2007 DuplicatingThread *sourceThread,
2008 uint32_t sampleRate,
2009 audio_format_t format,
2010 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002011 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002012 const AttributionSourceState& attributionSource)
Eric Laurent223fd5c2014-11-11 13:43:36 -08002013 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002014 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002015 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002016 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002017 AUDIO_SESSION_NONE, getpid(), attributionSource, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08002018 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07002019 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08002020{
2021
2022 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08002023 mOutBuffer.frameCount = 0;
2024 playbackThread->mTracks.add(this);
Andy Hung9d84af52018-09-12 18:03:44 -07002025 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002026 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07002027 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08002028 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08002029 // since client and server are in the same process,
2030 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07002031 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
2032 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07002033 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07002034 mClientProxy->setSendLevel(0.0);
2035 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08002036 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07002037 ALOGW("%s(%d): Error creating output track on thread %d",
2038 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08002039 }
2040}
2041
2042AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
2043{
2044 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08002045 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08002046}
2047
2048status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002049 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002050{
2051 status_t status = Track::start(event, triggerSession);
2052 if (status != NO_ERROR) {
2053 return status;
2054 }
2055
2056 mActive = true;
2057 mRetryCount = 127;
2058 return status;
2059}
2060
2061void AudioFlinger::PlaybackThread::OutputTrack::stop()
2062{
2063 Track::stop();
2064 clearBufferQueue();
2065 mOutBuffer.frameCount = 0;
2066 mActive = false;
2067}
2068
Andy Hung1c86ebe2018-05-29 20:29:08 -07002069ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08002070{
2071 Buffer *pInBuffer;
2072 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08002073 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002074 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08002075
2076 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
2077
2078 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08002079 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08002080 }
2081
2082 while (waitTimeLeftMs) {
2083 // First write pending buffers, then new data
2084 if (mBufferQueue.size()) {
2085 pInBuffer = mBufferQueue.itemAt(0);
2086 } else {
2087 pInBuffer = &inBuffer;
2088 }
2089
2090 if (pInBuffer->frameCount == 0) {
2091 break;
2092 }
2093
2094 if (mOutBuffer.frameCount == 0) {
2095 mOutBuffer.frameCount = pInBuffer->frameCount;
2096 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002097 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002098 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07002099 ALOGV("%s(%d): thread %d no more output buffers; status %d",
2100 __func__, mId,
2101 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08002102 break;
2103 }
2104 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
2105 if (waitTimeLeftMs >= waitTimeMs) {
2106 waitTimeLeftMs -= waitTimeMs;
2107 } else {
2108 waitTimeLeftMs = 0;
2109 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002110 if (status == NOT_ENOUGH_DATA) {
2111 restartIfDisabled();
2112 continue;
2113 }
Eric Laurent81784c32012-11-19 14:55:58 -08002114 }
2115
2116 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
2117 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002118 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002119 Proxy::Buffer buf;
2120 buf.mFrameCount = outFrames;
2121 buf.mRaw = NULL;
2122 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002123 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08002124 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002125 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002126 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002127 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002128
2129 if (pInBuffer->frameCount == 0) {
2130 if (mBufferQueue.size()) {
2131 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08002132 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07002133 if (pInBuffer != &inBuffer) {
2134 delete pInBuffer;
2135 }
Andy Hung9d84af52018-09-12 18:03:44 -07002136 ALOGV("%s(%d): thread %d released overflow buffer %zu",
2137 __func__, mId,
2138 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002139 } else {
2140 break;
2141 }
2142 }
2143 }
2144
2145 // If we could not write all frames, allocate a buffer and queue it for next time.
2146 if (inBuffer.frameCount) {
2147 sp<ThreadBase> thread = mThread.promote();
2148 if (thread != 0 && !thread->standby()) {
2149 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
2150 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08002151 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002152 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002153 pInBuffer->raw = pInBuffer->mBuffer;
2154 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002155 mBufferQueue.add(pInBuffer);
Andy Hung9d84af52018-09-12 18:03:44 -07002156 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
2157 (int)mThreadIoHandle, mBufferQueue.size());
Andy Hung1c86ebe2018-05-29 20:29:08 -07002158 // audio data is consumed (stored locally); set frameCount to 0.
2159 inBuffer.frameCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002160 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07002161 ALOGW("%s(%d): thread %d no more overflow buffers",
2162 __func__, mId, (int)mThreadIoHandle);
Andy Hung1c86ebe2018-05-29 20:29:08 -07002163 // TODO: return error for this.
Eric Laurent81784c32012-11-19 14:55:58 -08002164 }
2165 }
2166 }
2167
Andy Hungc25b84a2015-01-14 19:04:10 -08002168 // Calling write() with a 0 length buffer means that no more data will be written:
2169 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
2170 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
2171 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08002172 }
2173
Andy Hung1c86ebe2018-05-29 20:29:08 -07002174 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08002175}
2176
Kevin Rocard12381092018-04-11 09:19:59 -07002177void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
2178{
2179 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2180 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
2181}
2182
2183void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
2184 {
2185 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2186 mTrackMetadatas = metadatas;
2187 }
2188 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
2189 setMetadataHasChanged();
2190}
2191
Eric Laurent81784c32012-11-19 14:55:58 -08002192status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
2193 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
2194{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002195 ClientProxy::Buffer buf;
2196 buf.mFrameCount = buffer->frameCount;
2197 struct timespec timeout;
2198 timeout.tv_sec = waitTimeMs / 1000;
2199 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
2200 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
2201 buffer->frameCount = buf.mFrameCount;
2202 buffer->raw = buf.mRaw;
2203 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002204}
2205
Eric Laurent81784c32012-11-19 14:55:58 -08002206void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
2207{
2208 size_t size = mBufferQueue.size();
2209
2210 for (size_t i = 0; i < size; i++) {
2211 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08002212 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002213 delete pBuffer;
2214 }
2215 mBufferQueue.clear();
2216}
2217
Eric Laurent4d231dc2016-03-11 18:38:23 -08002218void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
2219{
2220 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2221 if (mActive && (flags & CBLK_DISABLED)) {
2222 start();
2223 }
2224}
Eric Laurent81784c32012-11-19 14:55:58 -08002225
Andy Hung9d84af52018-09-12 18:03:44 -07002226// ----------------------------------------------------------------------------
2227#undef LOG_TAG
2228#define LOG_TAG "AF::PatchTrack"
2229
Eric Laurent83b88082014-06-20 18:31:16 -07002230AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07002231 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07002232 uint32_t sampleRate,
2233 audio_channel_mask_t channelMask,
2234 audio_format_t format,
2235 size_t frameCount,
2236 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002237 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002238 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002239 const Timeout& timeout,
2240 size_t frameCountToBeReady)
Eric Laurent3bcf8592015-04-03 12:13:24 -07002241 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002242 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002243 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002244 buffer, bufferSize, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002245 AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002246 TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
Kevin Rocard45986c72018-12-18 18:22:59 -08002247 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
2248 *playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002249{
Andy Hung9d84af52018-09-12 18:03:44 -07002250 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2251 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002252 (int)mPeerTimeout.tv_sec,
2253 (int)(mPeerTimeout.tv_nsec / 1000000));
2254}
2255
2256AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
2257{
Andy Hungabfab202019-03-07 19:45:54 -08002258 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002259}
2260
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002261size_t AudioFlinger::PlaybackThread::PatchTrack::framesReady() const
2262{
2263 if (mPeerProxy && mPeerProxy->producesBufferOnDemand()) {
2264 return std::numeric_limits<size_t>::max();
2265 } else {
2266 return Track::framesReady();
2267 }
2268}
2269
Eric Laurent4d231dc2016-03-11 18:38:23 -08002270status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002271 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08002272{
2273 status_t status = Track::start(event, triggerSession);
2274 if (status != NO_ERROR) {
2275 return status;
2276 }
2277 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2278 return status;
2279}
2280
Eric Laurent83b88082014-06-20 18:31:16 -07002281// AudioBufferProvider interface
2282status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002283 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002284{
Andy Hung9d84af52018-09-12 18:03:44 -07002285 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002286 Proxy::Buffer buf;
2287 buf.mFrameCount = buffer->frameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002288 if (ATRACE_ENABLED()) {
2289 std::string traceName("PTnReq");
2290 traceName += std::to_string(id());
2291 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2292 }
Eric Laurent83b88082014-06-20 18:31:16 -07002293 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07002294 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002295 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002296 if (ATRACE_ENABLED()) {
2297 std::string traceName("PTnObt");
2298 traceName += std::to_string(id());
2299 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2300 }
Eric Laurent83b88082014-06-20 18:31:16 -07002301 if (buf.mFrameCount == 0) {
2302 return WOULD_BLOCK;
2303 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002304 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002305 return status;
2306}
2307
2308void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2309{
Andy Hung9d84af52018-09-12 18:03:44 -07002310 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002311 Proxy::Buffer buf;
2312 buf.mFrameCount = buffer->frameCount;
2313 buf.mRaw = buffer->raw;
2314 mPeerProxy->releaseBuffer(&buf);
2315 TrackBase::releaseBuffer(buffer);
2316}
2317
2318status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
2319 const struct timespec *timeOut)
2320{
Eric Laurent4d231dc2016-03-11 18:38:23 -08002321 status_t status = NO_ERROR;
2322 static const int32_t kMaxTries = 5;
2323 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07002324 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08002325 do {
2326 if (status == NOT_ENOUGH_DATA) {
2327 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07002328 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08002329 }
2330 status = mProxy->obtainBuffer(buffer, timeOut);
2331 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
2332 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07002333}
2334
2335void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
2336{
2337 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002338 restartIfDisabled();
naoki miyazuf37f9982019-11-28 11:18:18 +09002339
2340 // Check if the PatchTrack has enough data to write once in releaseBuffer().
2341 // If not, prevent an underrun from occurring by moving the track into FS_FILLING;
2342 // this logic avoids glitches when suspending A2DP with AudioPlaybackCapture.
2343 // TODO: perhaps underrun avoidance could be a track property checked in isReady() instead.
2344 if (mFillingUpStatus == FS_ACTIVE
2345 && audio_is_linear_pcm(mFormat)
2346 && !isOffloadedOrDirect()) {
2347 if (sp<ThreadBase> thread = mThread.promote();
2348 thread != 0) {
2349 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2350 const size_t frameCount = playbackThread->frameCount() * sampleRate()
2351 / playbackThread->sampleRate();
2352 if (framesReady() < frameCount) {
2353 ALOGD("%s(%d) Not enough data, wait for buffer to fill", __func__, mId);
2354 mFillingUpStatus = FS_FILLING;
2355 }
2356 }
2357 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002358}
2359
2360void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
2361{
Eric Laurent83b88082014-06-20 18:31:16 -07002362 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07002363 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002364 start();
2365 }
Eric Laurent83b88082014-06-20 18:31:16 -07002366}
2367
Eric Laurent81784c32012-11-19 14:55:58 -08002368// ----------------------------------------------------------------------------
2369// Record
2370// ----------------------------------------------------------------------------
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002371
2372
Andy Hung9d84af52018-09-12 18:03:44 -07002373#undef LOG_TAG
2374#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08002375
2376AudioFlinger::RecordHandle::RecordHandle(
2377 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
2378 : BnAudioRecord(),
2379 mRecordTrack(recordTrack)
2380{
Andy Hung225aef62022-12-06 16:33:20 -08002381 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08002382}
2383
2384AudioFlinger::RecordHandle::~RecordHandle() {
2385 stop_nonvirtual();
2386 mRecordTrack->destroy();
2387}
2388
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002389binder::Status AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
2390 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07002391 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002392 return binderStatusFromStatusT(
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002393 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08002394}
2395
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002396binder::Status AudioFlinger::RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08002397 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002398 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08002399}
2400
2401void AudioFlinger::RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07002402 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08002403 mRecordTrack->stop();
2404}
2405
jiabin653cc0a2018-01-17 17:54:10 -08002406binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
Ytai Ben-Tsvi71109da2020-11-03 15:11:13 -08002407 std::vector<media::MicrophoneInfoData>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07002408 ALOGV("%s()", __func__);
Ytai Ben-Tsvi71109da2020-11-03 15:11:13 -08002409 std::vector<media::MicrophoneInfo> mics;
2410 status_t status = mRecordTrack->getActiveMicrophones(&mics);
2411 activeMicrophones->resize(mics.size());
2412 for (size_t i = 0; status == OK && i < mics.size(); ++i) {
2413 status = mics[i].writeToParcelable(&activeMicrophones->at(i));
2414 }
Andy Hung1131b6e2020-12-08 20:47:45 -08002415 return binderStatusFromStatusT(status);
jiabin653cc0a2018-01-17 17:54:10 -08002416}
2417
Paul McLean12340082019-03-19 09:35:05 -06002418binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002419 int /*audio_microphone_direction_t*/ direction) {
2420 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002421 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002422 static_cast<audio_microphone_direction_t>(direction)));
2423}
2424
Paul McLean12340082019-03-19 09:35:05 -06002425binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002426 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002427 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
Paul McLean03a6e6a2018-12-04 10:54:13 -07002428}
2429
Eric Laurentec376dc2021-04-08 20:41:22 +02002430binder::Status AudioFlinger::RecordHandle::shareAudioHistory(
2431 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2432 return binderStatusFromStatusT(
2433 mRecordTrack->shareAudioHistory(sharedAudioPackageName, sharedAudioStartMs));
2434}
2435
Eric Laurent81784c32012-11-19 14:55:58 -08002436// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002437#undef LOG_TAG
2438#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002439
Glenn Kasten05997e22014-03-13 15:08:33 -07002440// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08002441AudioFlinger::RecordThread::RecordTrack::RecordTrack(
2442 RecordThread *thread,
2443 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002444 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08002445 uint32_t sampleRate,
2446 audio_format_t format,
2447 audio_channel_mask_t channelMask,
2448 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07002449 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002450 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08002451 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002452 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002453 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07002454 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002455 track_type type,
Eric Laurentec376dc2021-04-08 20:41:22 +02002456 audio_port_handle_t portId,
Eric Laurent2407ce32021-04-26 14:56:03 +02002457 int32_t startFrames)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002458 : TrackBase(thread, client, attr, sampleRate, format,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002459 channelMask, frameCount, buffer, bufferSize, sessionId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002460 creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002461 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002462 false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07002463 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07002464 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07002465 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Andy Hungb68f5eb2019-12-03 16:49:17 -08002466 type, portId,
2467 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD) + std::to_string(portId)),
Andy Hung97a893e2015-03-29 01:03:07 -07002468 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07002469 mFramesToDrop(0),
2470 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07002471 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07002472 mFlags(flags),
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002473 mSilenced(false),
Eric Laurent2407ce32021-04-26 14:56:03 +02002474 mStartFrames(startFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002475{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07002476 if (mCblk == NULL) {
2477 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002478 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002479
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002480 if (!isDirect()) {
2481 mRecordBufferConverter = new RecordBufferConverter(
2482 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
2483 channelMask, format, sampleRate);
2484 // Check if the RecordBufferConverter construction was successful.
2485 // If not, don't continue with construction.
2486 //
2487 // NOTE: It would be extremely rare that the record track cannot be created
2488 // for the current device, but a pending or future device change would make
2489 // the record track configuration valid.
2490 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07002491 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002492 return;
2493 }
Andy Hung97a893e2015-03-29 01:03:07 -07002494 }
2495
Andy Hung6ae58432016-02-16 18:32:24 -08002496 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08002497 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08002498
Andy Hung97a893e2015-03-29 01:03:07 -07002499 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002500
Eric Laurent05067782016-06-01 18:27:28 -07002501 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07002502 ALOG_ASSERT(thread->mFastTrackAvail);
2503 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07002504 } else {
2505 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07002506 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002507 }
Andy Hung8946a282018-04-19 20:04:56 -07002508#ifdef TEE_SINK
2509 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
2510 + "_" + std::to_string(mId)
2511 + "_R");
2512#endif
Andy Hungb68f5eb2019-12-03 16:49:17 -08002513
2514 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07002515 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent81784c32012-11-19 14:55:58 -08002516}
2517
2518AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
2519{
Andy Hung9d84af52018-09-12 18:03:44 -07002520 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002521 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002522 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002523}
2524
Andy Hung97a893e2015-03-29 01:03:07 -07002525status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
2526{
2527 status_t status = TrackBase::initCheck();
2528 if (status == NO_ERROR && mServerProxy == 0) {
2529 status = BAD_VALUE;
2530 }
2531 return status;
2532}
2533
Eric Laurent81784c32012-11-19 14:55:58 -08002534// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08002535status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08002536{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002537 ServerProxy::Buffer buf;
2538 buf.mFrameCount = buffer->frameCount;
2539 status_t status = mServerProxy->obtainBuffer(&buf);
2540 buffer->frameCount = buf.mFrameCount;
2541 buffer->raw = buf.mRaw;
2542 if (buf.mFrameCount == 0) {
2543 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002544 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002545 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002546 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002547}
2548
2549status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002550 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002551{
2552 sp<ThreadBase> thread = mThread.promote();
2553 if (thread != 0) {
2554 RecordThread *recordThread = (RecordThread *)thread.get();
2555 return recordThread->start(this, event, triggerSession);
2556 } else {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002557 ALOGW("%s track %d: thread was destroyed", __func__, portId());
2558 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08002559 }
2560}
2561
2562void AudioFlinger::RecordThread::RecordTrack::stop()
2563{
2564 sp<ThreadBase> thread = mThread.promote();
2565 if (thread != 0) {
2566 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07002567 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08002568 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002569 }
2570 }
2571}
2572
2573void AudioFlinger::RecordThread::RecordTrack::destroy()
2574{
2575 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
2576 sp<RecordTrack> keep(this);
2577 {
Andy Hungce685402018-10-05 17:23:27 -07002578 track_state priorState = mState;
Eric Laurent81784c32012-11-19 14:55:58 -08002579 sp<ThreadBase> thread = mThread.promote();
2580 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08002581 Mutex::Autolock _l(thread->mLock);
2582 RecordThread *recordThread = (RecordThread *) thread.get();
Andy Hungce685402018-10-05 17:23:27 -07002583 priorState = mState;
Eric Laurentec376dc2021-04-08 20:41:22 +02002584 if (!mSharedAudioPackageName.empty()) {
Eric Laurent92d0a322021-07-16 15:32:33 +02002585 recordThread->resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002586 }
Andy Hungce685402018-10-05 17:23:27 -07002587 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
2588 }
2589 // APM portid/client management done outside of lock.
2590 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
2591 if (isExternalTrack()) {
2592 switch (priorState) {
2593 case ACTIVE: // invalidated while still active
2594 case STARTING_2: // invalidated/start-aborted after startInput successfully called
2595 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
2596 AudioSystem::stopInput(mPortId);
2597 break;
2598
2599 case STARTING_1: // invalidated/start-aborted and startInput not successful
2600 case PAUSED: // OK, not active
2601 case IDLE: // OK, not active
2602 break;
2603
2604 case STOPPED: // unexpected (destroyed)
2605 default:
2606 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
2607 }
2608 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002609 }
2610 }
2611}
2612
Eric Laurent9a54bc22013-09-09 09:08:44 -07002613void AudioFlinger::RecordThread::RecordTrack::invalidate()
2614{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002615 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07002616 // FIXME should use proxy, and needs work
2617 audio_track_cblk_t* cblk = mCblk;
2618 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2619 android_atomic_release_store(0x40000000, &cblk->mFutex);
2620 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002621 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002622}
2623
Eric Laurent81784c32012-11-19 14:55:58 -08002624
Andy Hung000adb52018-06-01 15:43:26 -07002625void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08002626{
Eric Laurent973db022018-11-20 14:54:31 -08002627 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07002628 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002629 " Server FrmCnt FrmRdy Sil%s\n",
2630 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08002631}
2632
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002633void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08002634{
Eric Laurent973db022018-11-20 14:54:31 -08002635 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002636 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002637 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002638 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002639 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002640 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002641 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002642 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002643 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08002644 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002645 mCblk->mFlags,
2646
Eric Laurent81784c32012-11-19 14:55:58 -08002647 mFormat,
2648 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002649 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002650 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002651
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002652 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002653 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002654 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002655 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002656 );
Andy Hung000adb52018-06-01 15:43:26 -07002657 if (isServerLatencySupported()) {
2658 double latencyMs;
2659 bool fromTrack;
2660 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2661 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2662 // or 'k' if estimated from kernel (usually for debugging).
2663 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2664 } else {
2665 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2666 }
2667 }
2668 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002669}
2670
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002671void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
2672{
2673 if (event == mSyncStartEvent) {
2674 ssize_t framesToDrop = 0;
2675 sp<ThreadBase> threadBase = mThread.promote();
2676 if (threadBase != 0) {
2677 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2678 // from audio HAL
2679 framesToDrop = threadBase->mFrameCount * 2;
2680 }
2681 mFramesToDrop = framesToDrop;
2682 }
2683}
2684
2685void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2686{
2687 if (mSyncStartEvent != 0) {
2688 mSyncStartEvent->cancel();
2689 mSyncStartEvent.clear();
2690 }
2691 mFramesToDrop = 0;
2692}
2693
Andy Hung3f0c9022016-01-15 17:49:46 -08002694void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
2695 int64_t trackFramesReleased, int64_t sourceFramesRead,
2696 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2697{
Andy Hung30282562018-08-08 18:27:03 -07002698 // Make the kernel frametime available.
2699 const FrameTime ft{
2700 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2701 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2702 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2703 mKernelFrameTime.store(ft);
2704 if (!audio_is_linear_pcm(mFormat)) {
Atneya Nair497fff12022-01-18 16:23:04 -05002705 // Stream is direct, return provided timestamp with no conversion
2706 mServerProxy->setTimestamp(timestamp);
Andy Hung30282562018-08-08 18:27:03 -07002707 return;
2708 }
2709
Andy Hung3f0c9022016-01-15 17:49:46 -08002710 ExtendedTimestamp local = timestamp;
2711
2712 // Convert HAL frames to server-side track frames at track sample rate.
2713 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2714 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2715 if (local.mTimeNs[i] != 0) {
2716 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2717 const int64_t relativeTrackFrames = relativeServerFrames
2718 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2719 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2720 }
2721 }
Andy Hung6ae58432016-02-16 18:32:24 -08002722 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002723
2724 // Compute latency info.
2725 const bool useTrackTimestamp = true; // use track unless debugging.
2726 const double latencyMs = - (useTrackTimestamp
2727 ? local.getOutputServerLatencyMs(sampleRate())
2728 : timestamp.getOutputServerLatencyMs(halSampleRate));
2729
2730 mServerLatencyFromTrack.store(useTrackTimestamp);
2731 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08002732}
Eric Laurent83b88082014-06-20 18:31:16 -07002733
jiabin653cc0a2018-01-17 17:54:10 -08002734status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
2735 std::vector<media::MicrophoneInfo>* activeMicrophones)
2736{
2737 sp<ThreadBase> thread = mThread.promote();
2738 if (thread != 0) {
2739 RecordThread *recordThread = (RecordThread *)thread.get();
2740 return recordThread->getActiveMicrophones(activeMicrophones);
2741 } else {
2742 return BAD_VALUE;
2743 }
2744}
2745
Paul McLean12340082019-03-19 09:35:05 -06002746status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002747 audio_microphone_direction_t direction) {
2748 sp<ThreadBase> thread = mThread.promote();
2749 if (thread != 0) {
2750 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002751 return recordThread->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002752 } else {
2753 return BAD_VALUE;
2754 }
2755}
2756
Paul McLean12340082019-03-19 09:35:05 -06002757status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002758 sp<ThreadBase> thread = mThread.promote();
2759 if (thread != 0) {
2760 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002761 return recordThread->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002762 } else {
2763 return BAD_VALUE;
2764 }
2765}
2766
Eric Laurentec376dc2021-04-08 20:41:22 +02002767status_t AudioFlinger::RecordThread::RecordTrack::shareAudioHistory(
2768 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2769
2770 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2771 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
2772 if (callingUid != mUid || callingPid != mCreatorPid) {
2773 return PERMISSION_DENIED;
2774 }
2775
Svet Ganov33761132021-05-13 22:51:08 +00002776 AttributionSourceState attributionSource{};
2777 attributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
2778 attributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
2779 attributionSource.token = sp<BBinder>::make();
2780 if (!captureHotwordAllowed(attributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02002781 return PERMISSION_DENIED;
2782 }
2783
2784 sp<ThreadBase> thread = mThread.promote();
2785 if (thread != 0) {
2786 RecordThread *recordThread = (RecordThread *)thread.get();
2787 status_t status = recordThread->shareAudioHistory(
2788 sharedAudioPackageName, mSessionId, sharedAudioStartMs);
2789 if (status == NO_ERROR) {
2790 mSharedAudioPackageName = sharedAudioPackageName;
2791 }
2792 return status;
2793 } else {
2794 return BAD_VALUE;
2795 }
2796}
2797
Eric Laurent78b07302022-10-07 16:20:34 +02002798void AudioFlinger::RecordThread::RecordTrack::copyMetadataTo(MetadataInserter& backInserter) const
2799{
2800
2801 // Do not forward PatchRecord metadata with unspecified audio source
2802 if (mAttr.source == AUDIO_SOURCE_DEFAULT) {
2803 return;
2804 }
2805
2806 // No track is invalid as this is called after prepareTrack_l in the same critical section
2807 record_track_metadata_v7_t metadata;
2808 metadata.base = {
2809 .source = mAttr.source,
2810 .gain = 1, // capture tracks do not have volumes
2811 };
2812 metadata.channel_mask = mChannelMask;
2813 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
2814
2815 *backInserter++ = metadata;
2816}
Eric Laurentec376dc2021-04-08 20:41:22 +02002817
Andy Hung9d84af52018-09-12 18:03:44 -07002818// ----------------------------------------------------------------------------
2819#undef LOG_TAG
2820#define LOG_TAG "AF::PatchRecord"
2821
Eric Laurent83b88082014-06-20 18:31:16 -07002822AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2823 uint32_t sampleRate,
2824 audio_channel_mask_t channelMask,
2825 audio_format_t format,
2826 size_t frameCount,
2827 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002828 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002829 audio_input_flags_t flags,
Eric Laurent78b07302022-10-07 16:20:34 +02002830 const Timeout& timeout,
2831 audio_source_t source)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002832 : RecordTrack(recordThread, NULL,
Eric Laurent78b07302022-10-07 16:20:34 +02002833 audio_attributes_t{ .source = source } ,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002834 sampleRate, format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002835 buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
Svet Ganov33761132021-05-13 22:51:08 +00002836 audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
Kevin Rocard45986c72018-12-18 18:22:59 -08002837 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
2838 *recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002839{
Andy Hung9d84af52018-09-12 18:03:44 -07002840 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2841 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002842 (int)mPeerTimeout.tv_sec,
2843 (int)(mPeerTimeout.tv_nsec / 1000000));
2844}
2845
2846AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2847{
Andy Hungabfab202019-03-07 19:45:54 -08002848 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002849}
2850
Mikhail Naganov8296c252019-09-25 14:59:54 -07002851static size_t writeFramesHelper(
2852 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2853{
2854 AudioBufferProvider::Buffer patchBuffer;
2855 patchBuffer.frameCount = frameCount;
2856 auto status = dest->getNextBuffer(&patchBuffer);
2857 if (status != NO_ERROR) {
2858 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
2859 __func__, status, strerror(-status));
2860 return 0;
2861 }
2862 ALOG_ASSERT(patchBuffer.frameCount <= frameCount);
2863 memcpy(patchBuffer.raw, src, patchBuffer.frameCount * frameSize);
2864 size_t framesWritten = patchBuffer.frameCount;
2865 dest->releaseBuffer(&patchBuffer);
2866 return framesWritten;
2867}
2868
2869// static
2870size_t AudioFlinger::RecordThread::PatchRecord::writeFrames(
2871 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2872{
2873 size_t framesWritten = writeFramesHelper(dest, src, frameCount, frameSize);
2874 // On buffer wrap, the buffer frame count will be less than requested,
2875 // when this happens a second buffer needs to be used to write the leftover audio
2876 const size_t framesLeft = frameCount - framesWritten;
2877 if (framesWritten != 0 && framesLeft != 0) {
2878 framesWritten += writeFramesHelper(dest, (const char*)src + framesWritten * frameSize,
2879 framesLeft, frameSize);
2880 }
2881 return framesWritten;
2882}
2883
Eric Laurent83b88082014-06-20 18:31:16 -07002884// AudioBufferProvider interface
2885status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002886 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002887{
Andy Hung9d84af52018-09-12 18:03:44 -07002888 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002889 Proxy::Buffer buf;
2890 buf.mFrameCount = buffer->frameCount;
2891 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
2892 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07002893 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002894 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002895 if (ATRACE_ENABLED()) {
2896 std::string traceName("PRnObt");
2897 traceName += std::to_string(id());
2898 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2899 }
Eric Laurent83b88082014-06-20 18:31:16 -07002900 if (buf.mFrameCount == 0) {
2901 return WOULD_BLOCK;
2902 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002903 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002904 return status;
2905}
2906
2907void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2908{
Andy Hung9d84af52018-09-12 18:03:44 -07002909 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002910 Proxy::Buffer buf;
2911 buf.mFrameCount = buffer->frameCount;
2912 buf.mRaw = buffer->raw;
2913 mPeerProxy->releaseBuffer(&buf);
2914 TrackBase::releaseBuffer(buffer);
2915}
2916
2917status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
2918 const struct timespec *timeOut)
2919{
2920 return mProxy->obtainBuffer(buffer, timeOut);
2921}
2922
2923void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2924{
2925 mProxy->releaseBuffer(buffer);
2926}
2927
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002928#undef LOG_TAG
2929#define LOG_TAG "AF::PthrPatchRecord"
2930
2931static std::unique_ptr<void, decltype(free)*> allocAligned(size_t alignment, size_t size)
2932{
2933 void *ptr = nullptr;
2934 (void)posix_memalign(&ptr, alignment, size);
2935 return std::unique_ptr<void, decltype(free)*>(ptr, free);
2936}
2937
2938AudioFlinger::RecordThread::PassthruPatchRecord::PassthruPatchRecord(
2939 RecordThread *recordThread,
2940 uint32_t sampleRate,
2941 audio_channel_mask_t channelMask,
2942 audio_format_t format,
2943 size_t frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02002944 audio_input_flags_t flags,
2945 audio_source_t source)
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002946 : PatchRecord(recordThread, sampleRate, channelMask, format, frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02002947 nullptr /*buffer*/, 0 /*bufferSize*/, flags, {} /* timeout */, source),
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002948 mPatchRecordAudioBufferProvider(*this),
2949 mSinkBuffer(allocAligned(32, mFrameCount * mFrameSize)),
2950 mStubBuffer(allocAligned(32, mFrameCount * mFrameSize))
2951{
2952 memset(mStubBuffer.get(), 0, mFrameCount * mFrameSize);
2953}
2954
2955sp<StreamInHalInterface> AudioFlinger::RecordThread::PassthruPatchRecord::obtainStream(
2956 sp<ThreadBase>* thread)
2957{
2958 *thread = mThread.promote();
2959 if (!*thread) return nullptr;
2960 RecordThread *recordThread = static_cast<RecordThread*>((*thread).get());
2961 Mutex::Autolock _l(recordThread->mLock);
2962 return recordThread->mInput ? recordThread->mInput->stream : nullptr;
2963}
2964
2965// PatchProxyBufferProvider methods are called on DirectOutputThread
2966status_t AudioFlinger::RecordThread::PassthruPatchRecord::obtainBuffer(
2967 Proxy::Buffer* buffer, const struct timespec* timeOut)
2968{
2969 if (mUnconsumedFrames) {
2970 buffer->mFrameCount = std::min(buffer->mFrameCount, mUnconsumedFrames);
2971 // mUnconsumedFrames is decreased in releaseBuffer to use actual frame consumption figure.
2972 return PatchRecord::obtainBuffer(buffer, timeOut);
2973 }
2974
2975 // Otherwise, execute a read from HAL and write into the buffer.
2976 nsecs_t startTimeNs = 0;
2977 if (timeOut && (timeOut->tv_sec != 0 || timeOut->tv_nsec != 0) && timeOut->tv_sec != INT_MAX) {
2978 // Will need to correct timeOut by elapsed time.
2979 startTimeNs = systemTime();
2980 }
2981 const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
2982 buffer->mFrameCount = 0;
2983 buffer->mRaw = nullptr;
2984 sp<ThreadBase> thread;
2985 sp<StreamInHalInterface> stream = obtainStream(&thread);
2986 if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
2987
2988 status_t result = NO_ERROR;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002989 size_t bytesRead = 0;
2990 {
2991 ATRACE_NAME("read");
2992 result = stream->read(mSinkBuffer.get(), framesToRead * mFrameSize, &bytesRead);
2993 if (result != NO_ERROR) goto stream_error;
2994 if (bytesRead == 0) return NO_ERROR;
2995 }
2996
2997 {
2998 std::lock_guard<std::mutex> lock(mReadLock);
2999 mReadBytes += bytesRead;
3000 mReadError = NO_ERROR;
3001 }
3002 mReadCV.notify_one();
3003 // writeFrames handles wraparound and should write all the provided frames.
3004 // If it couldn't, there is something wrong with the client/server buffer of the software patch.
3005 buffer->mFrameCount = writeFrames(
3006 &mPatchRecordAudioBufferProvider,
3007 mSinkBuffer.get(), bytesRead / mFrameSize, mFrameSize);
3008 ALOGW_IF(buffer->mFrameCount < bytesRead / mFrameSize,
3009 "Lost %zu frames obtained from HAL", bytesRead / mFrameSize - buffer->mFrameCount);
3010 mUnconsumedFrames = buffer->mFrameCount;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003011 struct timespec newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003012 if (startTimeNs) {
Mikhail Naganov4de49972019-10-07 09:53:58 -07003013 // Correct the timeout by elapsed time.
3014 nsecs_t newTimeOutNs = audio_utils_ns_from_timespec(timeOut) - (systemTime() - startTimeNs);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003015 if (newTimeOutNs < 0) newTimeOutNs = 0;
3016 newTimeOut.tv_sec = newTimeOutNs / NANOS_PER_SECOND;
3017 newTimeOut.tv_nsec = newTimeOutNs - newTimeOut.tv_sec * NANOS_PER_SECOND;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003018 timeOut = &newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003019 }
Mikhail Naganov4de49972019-10-07 09:53:58 -07003020 return PatchRecord::obtainBuffer(buffer, timeOut);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003021
3022stream_error:
3023 stream->standby();
3024 {
3025 std::lock_guard<std::mutex> lock(mReadLock);
3026 mReadError = result;
3027 }
3028 mReadCV.notify_one();
3029 return result;
3030}
3031
3032void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(Proxy::Buffer* buffer)
3033{
3034 if (buffer->mFrameCount <= mUnconsumedFrames) {
3035 mUnconsumedFrames -= buffer->mFrameCount;
3036 } else {
3037 ALOGW("Write side has consumed more frames than we had: %zu > %zu",
3038 buffer->mFrameCount, mUnconsumedFrames);
3039 mUnconsumedFrames = 0;
3040 }
3041 PatchRecord::releaseBuffer(buffer);
3042}
3043
3044// AudioBufferProvider and Source methods are called on RecordThread
3045// 'read' emulates actual audio data with 0's. This is OK as 'getNextBuffer'
3046// and 'releaseBuffer' are stubbed out and ignore their input.
3047// It's not possible to retrieve actual data here w/o blocking 'obtainBuffer'
3048// until we copy it.
3049status_t AudioFlinger::RecordThread::PassthruPatchRecord::read(
3050 void* buffer, size_t bytes, size_t* read)
3051{
3052 bytes = std::min(bytes, mFrameCount * mFrameSize);
3053 {
3054 std::unique_lock<std::mutex> lock(mReadLock);
3055 mReadCV.wait(lock, [&]{ return mReadError != NO_ERROR || mReadBytes != 0; });
3056 if (mReadError != NO_ERROR) {
3057 mLastReadFrames = 0;
3058 return mReadError;
3059 }
3060 *read = std::min(bytes, mReadBytes);
3061 mReadBytes -= *read;
3062 }
3063 mLastReadFrames = *read / mFrameSize;
3064 memset(buffer, 0, *read);
3065 return 0;
3066}
3067
3068status_t AudioFlinger::RecordThread::PassthruPatchRecord::getCapturePosition(
3069 int64_t* frames, int64_t* time)
3070{
3071 sp<ThreadBase> thread;
3072 sp<StreamInHalInterface> stream = obtainStream(&thread);
3073 return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
3074}
3075
3076status_t AudioFlinger::RecordThread::PassthruPatchRecord::standby()
3077{
3078 // RecordThread issues 'standby' command in two major cases:
3079 // 1. Error on read--this case is handled in 'obtainBuffer'.
3080 // 2. Track is stopping--as PassthruPatchRecord assumes continuous
3081 // output, this can only happen when the software patch
3082 // is being torn down. In this case, the RecordThread
3083 // will terminate and close the HAL stream.
3084 return 0;
3085}
3086
3087// As the buffer gets filled in obtainBuffer, here we only simulate data consumption.
3088status_t AudioFlinger::RecordThread::PassthruPatchRecord::getNextBuffer(
3089 AudioBufferProvider::Buffer* buffer)
3090{
3091 buffer->frameCount = mLastReadFrames;
3092 buffer->raw = buffer->frameCount != 0 ? mStubBuffer.get() : nullptr;
3093 return NO_ERROR;
3094}
3095
3096void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(
3097 AudioBufferProvider::Buffer* buffer)
3098{
3099 buffer->frameCount = 0;
3100 buffer->raw = nullptr;
3101}
3102
Andy Hung9d84af52018-09-12 18:03:44 -07003103// ----------------------------------------------------------------------------
3104#undef LOG_TAG
3105#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08003106
3107AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003108 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003109 uint32_t sampleRate,
3110 audio_format_t format,
3111 audio_channel_mask_t channelMask,
3112 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003113 bool isOut,
Svet Ganov33761132021-05-13 22:51:08 +00003114 const AttributionSourceState& attributionSource,
Eric Laurent09f1ed22019-04-24 17:45:17 -07003115 pid_t creatorPid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003116 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003117 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07003118 channelMask, (size_t)0 /* frameCount */,
3119 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003120 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00003121 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003122 isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003123 ALLOC_NONE,
Andy Hungc2b11cb2020-04-22 09:04:01 -07003124 TYPE_DEFAULT, portId,
3125 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
Svet Ganov33761132021-05-13 22:51:08 +00003126 mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.pid))),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003127 mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003128{
Andy Hungc2b11cb2020-04-22 09:04:01 -07003129 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07003130 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003131}
3132
3133AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
3134{
3135}
3136
3137status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
3138{
3139 return NO_ERROR;
3140}
3141
3142status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003143 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003144{
3145 return NO_ERROR;
3146}
3147
3148void AudioFlinger::MmapThread::MmapTrack::stop()
3149{
3150}
3151
3152// AudioBufferProvider interface
3153status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3154{
3155 buffer->frameCount = 0;
3156 buffer->raw = nullptr;
3157 return INVALID_OPERATION;
3158}
3159
3160// ExtendedAudioBufferProvider interface
3161size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
3162 return 0;
3163}
3164
3165int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
3166{
3167 return 0;
3168}
3169
3170void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
3171{
3172}
3173
Vlad Popaec1788e2022-08-04 11:23:30 +02003174void AudioFlinger::MmapThread::MmapTrack::processMuteEvent_l(const sp<
3175 IAudioManager>& audioManager, mute_state_t muteState)
3176{
3177 if (mMuteState == muteState) {
3178 // mute state did not change, do nothing
3179 return;
3180 }
3181
3182 status_t result = UNKNOWN_ERROR;
3183 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
3184 if (mMuteEventExtras == nullptr) {
3185 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
3186 }
3187 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
3188 static_cast<int>(muteState));
3189
3190 result = audioManager->portEvent(mPortId,
3191 PLAYER_UPDATE_MUTED,
3192 mMuteEventExtras);
3193 }
3194
3195 if (result == OK) {
3196 mMuteState = muteState;
3197 } else {
3198 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
3199 __func__,
3200 id(),
3201 mPortId,
3202 result);
3203 }
3204}
3205
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003206void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003207{
Eric Laurent973db022018-11-20 14:54:31 -08003208 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003209 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003210}
3211
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003212void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003213{
Eric Laurent973db022018-11-20 14:54:31 -08003214 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003215 mPid,
3216 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08003217 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003218 mFormat,
3219 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003220 mSampleRate,
3221 mAttr.flags);
3222 if (isOut()) {
3223 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
3224 } else {
3225 result.appendFormat("%6x", mAttr.source);
3226 }
3227 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003228}
3229
Glenn Kasten63238ef2015-03-02 15:50:29 -08003230} // namespace android