blob: 481158618910f2b68920d4e9234c3be7dfe99e7c [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
Eric Laurent81784c32012-11-19 14:55:58 -080018#define LOG_TAG "AudioFlinger"
19//#define LOG_NDEBUG 0
Mikhail Naganov938be412019-09-04 11:38:47 -070020#define ATRACE_TAG ATRACE_TAG_AUDIO
Eric Laurent81784c32012-11-19 14:55:58 -080021
Andy Hungce240472023-07-19 11:40:07 -070022#include "MmapTracks.h"
23#include "PlaybackTracks.h"
24#include "RecordTracks.h"
25
26#include "Client.h"
27#include "IAfEffect.h"
28#include "IAfThread.h"
29#include "ResamplerBufferProvider.h"
30
31#include <audio_utils/minifloat.h>
32#include <media/AudioValidator.h>
33#include <media/RecordBufferConverter.h>
34#include <media/nbaio/Pipe.h>
35#include <media/nbaio/PipeReader.h>
36#include <mediautils/ServiceUtilities.h>
37#include <mediautils/SharedMemoryAllocator.h>
38#include <private/media/AudioTrackShared.h>
Eric Laurent81784c32012-11-19 14:55:58 -080039#include <utils/Log.h>
Mikhail Naganov938be412019-09-04 11:38:47 -070040#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080041
Andy Hungce240472023-07-19 11:40:07 -070042#include <linux/futex.h>
43#include <math.h>
44#include <sys/syscall.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080045
Eric Laurent81784c32012-11-19 14:55:58 -080046// ----------------------------------------------------------------------------
47
48// Note: the following macro is used for extremely verbose logging message. In
49// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
50// 0; but one side effect of this is to turn all LOGV's as well. Some messages
51// are so verbose that we want to suppress them even when we have ALOG_ASSERT
52// turned on. Do not uncomment the #def below unless you really know what you
53// are doing and want to see all of the extremely verbose messages.
54//#define VERY_VERY_VERBOSE_LOGGING
55#ifdef VERY_VERY_VERBOSE_LOGGING
56#define ALOGVV ALOGV
57#else
58#define ALOGVV(a...) do { } while(0)
59#endif
60
Kuowei Lid4adbdb2020-08-13 14:44:25 +080061// TODO: Remove when this is put into AidlConversionUtil.h
62#define VALUE_OR_RETURN_BINDER_STATUS(x) \
63 ({ \
64 auto _tmp = (x); \
65 if (!_tmp.ok()) return ::android::aidl_utils::binderStatusFromStatusT(_tmp.error()); \
66 std::move(_tmp.value()); \
67 })
68
Eric Laurent81784c32012-11-19 14:55:58 -080069namespace android {
70
Kuowei Lid4adbdb2020-08-13 14:44:25 +080071using ::android::aidl_utils::binderStatusFromStatusT;
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -080072using binder::Status;
Svet Ganov33761132021-05-13 22:51:08 +000073using content::AttributionSourceState;
Ivan Lozano8cf3a072017-08-09 09:01:33 -070074using media::VolumeShaper;
Eric Laurent81784c32012-11-19 14:55:58 -080075// ----------------------------------------------------------------------------
76// TrackBase
77// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -070078#undef LOG_TAG
79#define LOG_TAG "AF::TrackBase"
Eric Laurent81784c32012-11-19 14:55:58 -080080
Glenn Kastenda6ef132013-01-10 12:31:01 -080081static volatile int32_t nextTrackId = 55;
82
Eric Laurent81784c32012-11-19 14:55:58 -080083// TrackBase constructor must be called with AudioFlinger::mLock held
Andy Hung3ff4b552023-06-26 19:20:57 -070084TrackBase::TrackBase(
Andy Hung44f27182023-07-06 20:56:16 -070085 IAfThreadBase *thread,
Eric Laurent81784c32012-11-19 14:55:58 -080086 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070087 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080088 uint32_t sampleRate,
89 audio_format_t format,
90 audio_channel_mask_t channelMask,
91 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070092 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070093 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080094 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070095 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -080096 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -070097 bool isOut,
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -070098 const alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -080099 track_type type,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800100 audio_port_handle_t portId,
101 std::string metricsId)
Andy Hung02a6c4e2023-06-23 19:27:19 -0700102 :
Eric Laurent81784c32012-11-19 14:55:58 -0800103 mThread(thread),
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -0700104 mAllocType(alloc),
Eric Laurent81784c32012-11-19 14:55:58 -0800105 mClient(client),
106 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -0700107 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -0800108 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700109 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -0800110 mSampleRate(sampleRate),
111 mFormat(format),
112 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -0700113 mChannelCount(isOut ?
114 audio_channel_count_from_out_mask(channelMask) :
115 audio_channel_count_from_in_mask(channelMask)),
Dean Wheatleyd883e302023-10-20 06:11:43 +1100116 mFrameSize(audio_bytes_per_frame(mChannelCount, format)),
Eric Laurent81784c32012-11-19 14:55:58 -0800117 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800118 mSessionId(sessionId),
119 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -0800120 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -0700121 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700122 mType(type),
Kevin Rocard153f92d2018-12-18 18:33:28 -0800123 mThreadIoHandle(thread ? thread->id() : AUDIO_IO_HANDLE_NONE),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800124 mPortId(portId),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700125 mIsInvalid(false),
Kunal Malhotra3be68902023-02-28 22:03:15 +0000126 mTrackMetrics(std::move(metricsId), isOut, clientUid),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700127 mCreatorPid(creatorPid)
Eric Laurent81784c32012-11-19 14:55:58 -0800128{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700129 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700130 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800131 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Andy Hung9d84af52018-09-12 18:03:44 -0700132 "%s(%d): uid %d tried to pass itself off as %d",
133 __func__, mId, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800134 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800135 }
136 // clientUid contains the uid of the app that is responsible for this track, so we can blame
137 // battery usage on it.
138 mUid = clientUid;
139
Eric Laurent81784c32012-11-19 14:55:58 -0800140 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800141
Andy Hung8fe68032017-06-05 16:17:51 -0700142 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800143 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700144 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800145 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700146 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800147 android_errorWriteLog(0x534e4554, "34749571");
148 return;
149 }
Andy Hung8fe68032017-06-05 16:17:51 -0700150 minBufferSize *= mFrameSize;
151
152 if (buffer == nullptr) {
153 bufferSize = minBufferSize; // allocated here.
154 } else if (minBufferSize > bufferSize) {
155 android_errorWriteLog(0x534e4554, "38340117");
156 return;
157 }
Andy Hung1883f692017-02-13 18:48:39 -0800158
Eric Laurent81784c32012-11-19 14:55:58 -0800159 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700160 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800161 // check overflow when computing allocation size for streaming tracks.
162 if (size > SIZE_MAX - bufferSize) {
163 android_errorWriteLog(0x534e4554, "34749571");
164 return;
165 }
Eric Laurent81784c32012-11-19 14:55:58 -0800166 size += bufferSize;
167 }
168
169 if (client != 0) {
Atneya3c61d882021-09-20 14:52:15 -0400170 mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{{size},
171 std::string("Track ID: ").append(std::to_string(mId))});
Glenn Kasten663c2242013-09-24 11:52:37 -0700172 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700173 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700174 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Atneya3c61d882021-09-20 14:52:15 -0400175 ALOGE("%s", client->allocator().dump().c_str());
Glenn Kasten663c2242013-09-24 11:52:37 -0700176 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800177 return;
178 }
179 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800180 mCblk = (audio_track_cblk_t *) malloc(size);
181 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700182 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800183 return;
184 }
Eric Laurent81784c32012-11-19 14:55:58 -0800185 }
186
187 // construct the shared structure in-place.
188 if (mCblk != NULL) {
189 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700190 switch (alloc) {
191 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700192 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
193 if (roHeap == 0 ||
194 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700195 (mBuffer = mBufferMemory->unsecurePointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700196 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
197 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700198 if (roHeap != 0) {
199 roHeap->dump("buffer");
200 }
201 mCblkMemory.clear();
202 mBufferMemory.clear();
203 return;
204 }
Eric Laurent81784c32012-11-19 14:55:58 -0800205 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700206 } break;
207 case ALLOC_PIPE:
208 mBufferMemory = thread->pipeMemory();
209 // mBuffer is the virtual address as seen from current process (mediaserver),
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700210 // and should normally be coming from mBufferMemory->unsecurePointer().
Glenn Kastenc263ca02014-06-04 20:31:46 -0700211 // However in this case the TrackBase does not reference the buffer directly.
212 // It should references the buffer via the pipe.
213 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
214 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700215 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700216 break;
217 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700218 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700219 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700220 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
221 memset(mBuffer, 0, bufferSize);
222 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700223 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800224#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700225 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800226#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700227 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700228 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700229 case ALLOC_LOCAL:
230 mBuffer = calloc(1, bufferSize);
231 break;
232 case ALLOC_NONE:
233 mBuffer = buffer;
234 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700235 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700236 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800237 }
Andy Hung8fe68032017-06-05 16:17:51 -0700238 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800239
Glenn Kasten46909e72013-02-26 09:20:22 -0800240#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700241 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800242#endif
Andy Hung959b5b82021-09-24 10:46:20 -0700243 // mState is mirrored for the client to read.
244 mState.setMirror(&mCblk->mState);
245 // ensure our state matches up until we consolidate the enumeration.
246 static_assert(CBLK_STATE_IDLE == IDLE);
247 static_assert(CBLK_STATE_PAUSING == PAUSING);
Eric Laurent81784c32012-11-19 14:55:58 -0800248 }
249}
250
Svet Ganov33761132021-05-13 22:51:08 +0000251// TODO b/182392769: use attribution source util
252static AttributionSourceState audioServerAttributionSource(pid_t pid) {
253 AttributionSourceState attributionSource{};
254 attributionSource.uid = AID_AUDIOSERVER;
255 attributionSource.pid = pid;
256 attributionSource.token = sp<BBinder>::make();
257 return attributionSource;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700258}
259
Andy Hung3ff4b552023-06-26 19:20:57 -0700260status_t TrackBase::initCheck() const
Eric Laurent83b88082014-06-20 18:31:16 -0700261{
262 status_t status;
263 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
264 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
265 } else {
266 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
267 }
268 return status;
269}
270
Andy Hung3ff4b552023-06-26 19:20:57 -0700271TrackBase::~TrackBase()
Eric Laurent81784c32012-11-19 14:55:58 -0800272{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800273 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700274 mServerProxy.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700275 releaseCblk();
Eric Laurent81784c32012-11-19 14:55:58 -0800276 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
277 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700278 // Client destructor must run with AudioFlinger client mutex locked
Andy Hung2ac52f12023-08-28 18:36:53 -0700279 audio_utils::lock_guard _l(mClient->afClientCallback()->clientMutex());
Eric Laurent81784c32012-11-19 14:55:58 -0800280 // If the client's reference count drops to zero, the associated destructor
281 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
282 // relying on the automatic clear() at end of scope.
283 mClient.clear();
284 }
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -0700285 if (mAllocType == ALLOC_LOCAL) {
286 free(mBuffer);
287 mBuffer = nullptr;
288 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700289 // flush the binder command buffer
290 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800291}
292
293// AudioBufferProvider interface
294// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800295// This implementation of releaseBuffer() is used by Track and RecordTrack
Andy Hung3ff4b552023-06-26 19:20:57 -0700296void TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800297{
Glenn Kasten46909e72013-02-26 09:20:22 -0800298#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700299 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800300#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800301
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800302 ServerProxy::Buffer buf;
303 buf.mFrameCount = buffer->frameCount;
304 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800305 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800306 buffer->raw = NULL;
307 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800308}
309
Andy Hung3ff4b552023-06-26 19:20:57 -0700310status_t TrackBase::setSyncEvent(
Andy Hung068e08e2023-05-15 19:02:55 -0700311 const sp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -0800312{
Andy Hung068e08e2023-05-15 19:02:55 -0700313 mSyncEvents.emplace_back(event);
Eric Laurent81784c32012-11-19 14:55:58 -0800314 return NO_ERROR;
315}
316
Andy Hung3ff4b552023-06-26 19:20:57 -0700317PatchTrackBase::PatchTrackBase(const sp<ClientProxy>& proxy,
Andy Hung837229a2023-07-14 16:57:01 -0700318 IAfThreadBase* thread, const Timeout& timeout)
Kevin Rocard45986c72018-12-18 18:22:59 -0800319 : mProxy(proxy)
320{
321 if (timeout) {
322 setPeerTimeout(*timeout);
323 } else {
324 // Double buffer mixer
Andy Hung837229a2023-07-14 16:57:01 -0700325 uint64_t mixBufferNs = ((uint64_t)2 * thread->frameCount() * 1000000000) /
326 thread->sampleRate();
Kevin Rocard45986c72018-12-18 18:22:59 -0800327 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
328 }
329}
330
Andy Hung3ff4b552023-06-26 19:20:57 -0700331void PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
Kevin Rocard45986c72018-12-18 18:22:59 -0800332 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
333 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
334}
335
336
Eric Laurent81784c32012-11-19 14:55:58 -0800337// ----------------------------------------------------------------------------
338// Playback
339// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700340#undef LOG_TAG
341#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800342
Andy Hungaaa18282023-06-23 19:27:19 -0700343class TrackHandle : public android::media::BnAudioTrack {
344public:
Andy Hung02a6c4e2023-06-23 19:27:19 -0700345 explicit TrackHandle(const sp<IAfTrack>& track);
Andy Hungaaa18282023-06-23 19:27:19 -0700346 ~TrackHandle() override;
347
348 binder::Status getCblk(std::optional<media::SharedFileRegion>* _aidl_return) final;
349 binder::Status start(int32_t* _aidl_return) final;
350 binder::Status stop() final;
351 binder::Status flush() final;
352 binder::Status pause() final;
353 binder::Status attachAuxEffect(int32_t effectId, int32_t* _aidl_return) final;
354 binder::Status setParameters(const std::string& keyValuePairs,
355 int32_t* _aidl_return) final;
356 binder::Status selectPresentation(int32_t presentationId, int32_t programId,
357 int32_t* _aidl_return) final;
358 binder::Status getTimestamp(media::AudioTimestampInternal* timestamp,
359 int32_t* _aidl_return) final;
360 binder::Status signal() final;
361 binder::Status applyVolumeShaper(const media::VolumeShaperConfiguration& configuration,
362 const media::VolumeShaperOperation& operation,
363 int32_t* _aidl_return) final;
364 binder::Status getVolumeShaperState(
365 int32_t id,
366 std::optional<media::VolumeShaperState>* _aidl_return) final;
367 binder::Status getDualMonoMode(
368 media::audio::common::AudioDualMonoMode* _aidl_return) final;
369 binder::Status setDualMonoMode(
370 media::audio::common::AudioDualMonoMode mode) final;
371 binder::Status getAudioDescriptionMixLevel(float* _aidl_return) final;
372 binder::Status setAudioDescriptionMixLevel(float leveldB) final;
373 binder::Status getPlaybackRateParameters(
374 media::audio::common::AudioPlaybackRate* _aidl_return) final;
375 binder::Status setPlaybackRateParameters(
376 const media::audio::common::AudioPlaybackRate& playbackRate) final;
377
378private:
Andy Hung02a6c4e2023-06-23 19:27:19 -0700379 const sp<IAfTrack> mTrack;
Andy Hungaaa18282023-06-23 19:27:19 -0700380};
381
382/* static */
Andy Hung02a6c4e2023-06-23 19:27:19 -0700383sp<media::IAudioTrack> IAfTrack::createIAudioTrackAdapter(const sp<IAfTrack>& track) {
Andy Hungaaa18282023-06-23 19:27:19 -0700384 return sp<TrackHandle>::make(track);
385}
386
Andy Hung02a6c4e2023-06-23 19:27:19 -0700387TrackHandle::TrackHandle(const sp<IAfTrack>& track)
Eric Laurent81784c32012-11-19 14:55:58 -0800388 : BnAudioTrack(),
389 mTrack(track)
390{
Andy Hung225aef62022-12-06 16:33:20 -0800391 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -0800392}
393
Andy Hungaaa18282023-06-23 19:27:19 -0700394TrackHandle::~TrackHandle() {
Eric Laurent81784c32012-11-19 14:55:58 -0800395 // just stop the track on deletion, associated resources
396 // will be freed from the main thread once all pending buffers have
397 // been played. Unless it's not in the active track list, in which
398 // case we free everything now...
399 mTrack->destroy();
400}
401
Andy Hungaaa18282023-06-23 19:27:19 -0700402Status TrackHandle::getCblk(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800403 std::optional<media::SharedFileRegion>* _aidl_return) {
404 *_aidl_return = legacy2aidl_NullableIMemory_SharedFileRegion(mTrack->getCblk()).value();
405 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800406}
407
Andy Hungaaa18282023-06-23 19:27:19 -0700408Status TrackHandle::start(int32_t* _aidl_return) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800409 *_aidl_return = mTrack->start();
410 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800411}
412
Andy Hungaaa18282023-06-23 19:27:19 -0700413Status TrackHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -0800414 mTrack->stop();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800415 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800416}
417
Andy Hungaaa18282023-06-23 19:27:19 -0700418Status TrackHandle::flush() {
Eric Laurent81784c32012-11-19 14:55:58 -0800419 mTrack->flush();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800420 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800421}
422
Andy Hungaaa18282023-06-23 19:27:19 -0700423Status TrackHandle::pause() {
Eric Laurent81784c32012-11-19 14:55:58 -0800424 mTrack->pause();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800425 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800426}
427
Andy Hungaaa18282023-06-23 19:27:19 -0700428Status TrackHandle::attachAuxEffect(int32_t effectId,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800429 int32_t* _aidl_return) {
430 *_aidl_return = mTrack->attachAuxEffect(effectId);
431 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800432}
433
Andy Hungaaa18282023-06-23 19:27:19 -0700434Status TrackHandle::setParameters(const std::string& keyValuePairs,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800435 int32_t* _aidl_return) {
436 *_aidl_return = mTrack->setParameters(String8(keyValuePairs.c_str()));
437 return Status::ok();
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700438}
439
Andy Hungaaa18282023-06-23 19:27:19 -0700440Status TrackHandle::selectPresentation(int32_t presentationId, int32_t programId,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800441 int32_t* _aidl_return) {
442 *_aidl_return = mTrack->selectPresentation(presentationId, programId);
443 return Status::ok();
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800444}
445
Andy Hungaaa18282023-06-23 19:27:19 -0700446Status TrackHandle::getTimestamp(media::AudioTimestampInternal* timestamp,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800447 int32_t* _aidl_return) {
448 AudioTimestamp legacy;
449 *_aidl_return = mTrack->getTimestamp(legacy);
450 if (*_aidl_return != OK) {
451 return Status::ok();
452 }
Dorin Drimusbbddde02023-11-13 15:01:33 +0000453
454 // restrict position modulo INT_MAX to avoid integer sanitization abort
455 legacy.mPosition &= INT_MAX;
456
Andy Hung973638a2020-12-08 20:47:45 -0800457 *timestamp = legacy2aidl_AudioTimestamp_AudioTimestampInternal(legacy).value();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800458 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800459}
460
Andy Hungaaa18282023-06-23 19:27:19 -0700461Status TrackHandle::signal() {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800462 mTrack->signal();
463 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800464}
465
Andy Hungaaa18282023-06-23 19:27:19 -0700466Status TrackHandle::applyVolumeShaper(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800467 const media::VolumeShaperConfiguration& configuration,
468 const media::VolumeShaperOperation& operation,
469 int32_t* _aidl_return) {
470 sp<VolumeShaper::Configuration> conf = new VolumeShaper::Configuration();
471 *_aidl_return = conf->readFromParcelable(configuration);
472 if (*_aidl_return != OK) {
473 return Status::ok();
474 }
475
476 sp<VolumeShaper::Operation> op = new VolumeShaper::Operation();
477 *_aidl_return = op->readFromParcelable(operation);
478 if (*_aidl_return != OK) {
479 return Status::ok();
480 }
481
482 *_aidl_return = mTrack->applyVolumeShaper(conf, op);
483 return Status::ok();
Glenn Kasten53cec222013-08-29 09:01:02 -0700484}
485
Andy Hungaaa18282023-06-23 19:27:19 -0700486Status TrackHandle::getVolumeShaperState(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800487 int32_t id,
488 std::optional<media::VolumeShaperState>* _aidl_return) {
489 sp<VolumeShaper::State> legacy = mTrack->getVolumeShaperState(id);
490 if (legacy == nullptr) {
491 _aidl_return->reset();
492 return Status::ok();
493 }
494 media::VolumeShaperState aidl;
495 legacy->writeToParcelable(&aidl);
496 *_aidl_return = aidl;
497 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800498}
499
Andy Hungaaa18282023-06-23 19:27:19 -0700500Status TrackHandle::getDualMonoMode(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000501 media::audio::common::AudioDualMonoMode* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800502{
503 audio_dual_mono_mode_t mode = AUDIO_DUAL_MONO_MODE_OFF;
504 const status_t status = mTrack->getDualMonoMode(&mode)
505 ?: AudioValidator::validateDualMonoMode(mode);
506 if (status == OK) {
507 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
508 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(mode));
509 }
510 return binderStatusFromStatusT(status);
511}
512
Andy Hungaaa18282023-06-23 19:27:19 -0700513Status TrackHandle::setDualMonoMode(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000514 media::audio::common::AudioDualMonoMode mode)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800515{
516 const auto localMonoMode = VALUE_OR_RETURN_BINDER_STATUS(
517 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(mode));
518 return binderStatusFromStatusT(AudioValidator::validateDualMonoMode(localMonoMode)
519 ?: mTrack->setDualMonoMode(localMonoMode));
520}
521
Andy Hungaaa18282023-06-23 19:27:19 -0700522Status TrackHandle::getAudioDescriptionMixLevel(float* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800523{
524 float leveldB = -std::numeric_limits<float>::infinity();
525 const status_t status = mTrack->getAudioDescriptionMixLevel(&leveldB)
526 ?: AudioValidator::validateAudioDescriptionMixLevel(leveldB);
527 if (status == OK) *_aidl_return = leveldB;
528 return binderStatusFromStatusT(status);
529}
530
Andy Hungaaa18282023-06-23 19:27:19 -0700531Status TrackHandle::setAudioDescriptionMixLevel(float leveldB)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800532{
533 return binderStatusFromStatusT(AudioValidator::validateAudioDescriptionMixLevel(leveldB)
534 ?: mTrack->setAudioDescriptionMixLevel(leveldB));
535}
536
Andy Hungaaa18282023-06-23 19:27:19 -0700537Status TrackHandle::getPlaybackRateParameters(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000538 media::audio::common::AudioPlaybackRate* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800539{
540 audio_playback_rate_t localPlaybackRate{};
541 status_t status = mTrack->getPlaybackRateParameters(&localPlaybackRate)
542 ?: AudioValidator::validatePlaybackRate(localPlaybackRate);
543 if (status == NO_ERROR) {
544 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
545 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(localPlaybackRate));
546 }
547 return binderStatusFromStatusT(status);
548}
549
Andy Hungaaa18282023-06-23 19:27:19 -0700550Status TrackHandle::setPlaybackRateParameters(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000551 const media::audio::common::AudioPlaybackRate& playbackRate)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800552{
553 const audio_playback_rate_t localPlaybackRate = VALUE_OR_RETURN_BINDER_STATUS(
554 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(playbackRate));
555 return binderStatusFromStatusT(AudioValidator::validatePlaybackRate(localPlaybackRate)
556 ?: mTrack->setPlaybackRateParameters(localPlaybackRate));
557}
558
Eric Laurent81784c32012-11-19 14:55:58 -0800559// ----------------------------------------------------------------------------
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800560// AppOp for audio playback
561// -------------------------------
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700562
563// static
Andy Hung3ff4b552023-06-26 19:20:57 -0700564sp<OpPlayAudioMonitor> OpPlayAudioMonitor::createIfNeeded(
Andy Hung44f27182023-07-06 20:56:16 -0700565 IAfThreadBase* thread,
Svet Ganov33761132021-05-13 22:51:08 +0000566 const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700567 audio_stream_type_t streamType)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800568{
Vlad Popa103be862023-07-10 20:27:41 -0700569 Vector<String16> packages;
570 const uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000571 getPackagesForUid(uid, packages);
Eric Laurent9066ad32019-05-20 14:40:10 -0700572 if (isServiceUid(uid)) {
Eric Laurent9066ad32019-05-20 14:40:10 -0700573 if (packages.isEmpty()) {
574 ALOGD("OpPlayAudio: not muting track:%d usage:%d for service UID %d",
575 id,
576 attr.usage,
577 uid);
578 return nullptr;
579 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800580 }
581 // stream type has been filtered by audio policy to indicate whether it can be muted
582 if (streamType == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Eric Laurent2dab0302019-05-08 18:15:55 -0700583 ALOGD("OpPlayAudio: not muting track:%d usage:%d ENFORCED_AUDIBLE", id, attr.usage);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700584 return nullptr;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800585 }
Eric Laurent2dab0302019-05-08 18:15:55 -0700586 if ((attr.flags & AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY)
587 == AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY) {
588 ALOGD("OpPlayAudio: not muting track:%d flags %#x have FLAG_BYPASS_INTERRUPTION_POLICY",
589 id, attr.flags);
590 return nullptr;
591 }
Vlad Popa103be862023-07-10 20:27:41 -0700592 return sp<OpPlayAudioMonitor>::make(thread, attributionSource, attr.usage, id, uid);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700593}
594
Andy Hung44f27182023-07-06 20:56:16 -0700595OpPlayAudioMonitor::OpPlayAudioMonitor(IAfThreadBase* thread,
596 const AttributionSourceState& attributionSource,
597 audio_usage_t usage, int id, uid_t uid)
598 : mThread(wp<IAfThreadBase>::fromExisting(thread)),
Vlad Popa103be862023-07-10 20:27:41 -0700599 mHasOpPlayAudio(true),
600 mAttributionSource(attributionSource),
601 mUsage((int32_t)usage),
602 mId(id),
603 mUid(uid),
604 mPackageName(VALUE_OR_FATAL(aidl2legacy_string_view_String16(
605 attributionSource.packageName.value_or("")))) {}
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800606
Andy Hung3ff4b552023-06-26 19:20:57 -0700607OpPlayAudioMonitor::~OpPlayAudioMonitor()
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800608{
609 if (mOpCallback != 0) {
610 mAppOpsManager.stopWatchingMode(mOpCallback);
611 }
612 mOpCallback.clear();
613}
614
Andy Hung3ff4b552023-06-26 19:20:57 -0700615void OpPlayAudioMonitor::onFirstRef()
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700616{
Vlad Popad2152122023-08-02 18:36:04 -0700617 // make sure not to broadcast the initial state since it is not needed and could
618 // cause a deadlock since this method can be called with the mThread->mLock held
619 checkPlayAudioForUsage(/*doBroadcast=*/false);
Svet Ganov33761132021-05-13 22:51:08 +0000620 if (mAttributionSource.packageName.has_value()) {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700621 mOpCallback = new PlayAudioOpCallback(this);
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700622 mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
Vlad Popa103be862023-07-10 20:27:41 -0700623 mPackageName, mOpCallback);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700624 }
625}
626
Andy Hung3ff4b552023-06-26 19:20:57 -0700627bool OpPlayAudioMonitor::hasOpPlayAudio() const {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800628 return mHasOpPlayAudio.load();
629}
630
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700631// Note this method is never called (and never to be) for audio server / patch record track
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800632// - not called from constructor due to check on UID,
633// - not called from PlayAudioOpCallback because the callback is not installed in this case
Andy Hung3ff4b552023-06-26 19:20:57 -0700634void OpPlayAudioMonitor::checkPlayAudioForUsage(bool doBroadcast)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800635{
Vlad Popa103be862023-07-10 20:27:41 -0700636 const bool hasAppOps = mAttributionSource.packageName.has_value()
637 && mAppOpsManager.checkAudioOpNoThrow(
638 AppOpsManager::OP_PLAY_AUDIO, mUsage, mUid, mPackageName) ==
639 AppOpsManager::MODE_ALLOWED;
640
641 bool shouldChange = !hasAppOps; // check if we need to update.
642 if (mHasOpPlayAudio.compare_exchange_strong(shouldChange, hasAppOps)) {
643 ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasAppOps ? "not " : "");
Vlad Popad2152122023-08-02 18:36:04 -0700644 if (doBroadcast) {
645 auto thread = mThread.promote();
Andy Hung71742ab2023-07-07 13:47:37 -0700646 if (thread != nullptr && thread->type() == IAfThreadBase::OFFLOAD) {
Vlad Popad2152122023-08-02 18:36:04 -0700647 // Wake up Thread if offloaded, otherwise it may be several seconds for update.
Andy Hung87e82412023-08-29 14:26:09 -0700648 audio_utils::lock_guard _l(thread->mutex());
Vlad Popad2152122023-08-02 18:36:04 -0700649 thread->broadcast_l();
650 }
Vlad Popa103be862023-07-10 20:27:41 -0700651 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800652 }
653}
654
Andy Hung3ff4b552023-06-26 19:20:57 -0700655OpPlayAudioMonitor::PlayAudioOpCallback::PlayAudioOpCallback(
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800656 const wp<OpPlayAudioMonitor>& monitor) : mMonitor(monitor)
657{ }
658
Andy Hung3ff4b552023-06-26 19:20:57 -0700659void OpPlayAudioMonitor::PlayAudioOpCallback::opChanged(int32_t op,
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800660 const String16& packageName) {
661 // we only have uid, so we need to check all package names anyway
662 UNUSED(packageName);
663 if (op != AppOpsManager::OP_PLAY_AUDIO) {
664 return;
665 }
666 sp<OpPlayAudioMonitor> monitor = mMonitor.promote();
667 if (monitor != NULL) {
Vlad Popad2152122023-08-02 18:36:04 -0700668 monitor->checkPlayAudioForUsage(/*doBroadcast=*/true);
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800669 }
670}
671
Eric Laurent9066ad32019-05-20 14:40:10 -0700672// static
Andy Hung3ff4b552023-06-26 19:20:57 -0700673void OpPlayAudioMonitor::getPackagesForUid(
Eric Laurent9066ad32019-05-20 14:40:10 -0700674 uid_t uid, Vector<String16>& packages)
675{
676 PermissionController permissionController;
677 permissionController.getPackagesForUid(uid, packages);
678}
679
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800680// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700681#undef LOG_TAG
682#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800683
Andy Hung3ff4b552023-06-26 19:20:57 -0700684/* static */
Andy Hung44f27182023-07-06 20:56:16 -0700685sp<IAfTrack> IAfTrack::create(
686 IAfPlaybackThread* thread,
Andy Hung3ff4b552023-06-26 19:20:57 -0700687 const sp<Client>& client,
688 audio_stream_type_t streamType,
689 const audio_attributes_t& attr,
690 uint32_t sampleRate,
691 audio_format_t format,
692 audio_channel_mask_t channelMask,
693 size_t frameCount,
694 void *buffer,
695 size_t bufferSize,
696 const sp<IMemory>& sharedBuffer,
697 audio_session_t sessionId,
698 pid_t creatorPid,
699 const AttributionSourceState& attributionSource,
700 audio_output_flags_t flags,
701 track_type type,
702 audio_port_handle_t portId,
703 /** default behaviour is to start when there are as many frames
704 * ready as possible (aka. Buffer is full). */
705 size_t frameCountToBeReady,
706 float speed,
707 bool isSpatialized,
708 bool isBitPerfect) {
Andy Hung44f27182023-07-06 20:56:16 -0700709 return sp<Track>::make(thread,
Andy Hung3ff4b552023-06-26 19:20:57 -0700710 client,
711 streamType,
712 attr,
713 sampleRate,
714 format,
715 channelMask,
716 frameCount,
717 buffer,
718 bufferSize,
719 sharedBuffer,
720 sessionId,
721 creatorPid,
722 attributionSource,
723 flags,
724 type,
725 portId,
726 frameCountToBeReady,
727 speed,
728 isSpatialized,
729 isBitPerfect);
730}
731
Eric Laurent81784c32012-11-19 14:55:58 -0800732// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Andy Hung3ff4b552023-06-26 19:20:57 -0700733Track::Track(
Andy Hung44f27182023-07-06 20:56:16 -0700734 IAfPlaybackThread* thread,
Eric Laurent81784c32012-11-19 14:55:58 -0800735 const sp<Client>& client,
736 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700737 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800738 uint32_t sampleRate,
739 audio_format_t format,
740 audio_channel_mask_t channelMask,
741 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700742 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700743 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800744 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800745 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700746 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000747 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -0700748 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800749 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100750 audio_port_handle_t portId,
jiabinf042b9b2021-05-07 23:46:28 +0000751 size_t frameCountToBeReady,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200752 float speed,
jiabinc658e452022-10-21 20:52:21 +0000753 bool isSpatialized,
754 bool isBitPerfect)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700755 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700756 // TODO: Using unsecurePointer() has some associated security pitfalls
757 // (see declaration for details).
758 // Either document why it is safe in this case or address the
759 // issue (e.g. by copying).
760 (sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700761 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700762 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000763 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)), true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700764 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800765 type,
766 portId,
767 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK) + std::to_string(portId)),
Andy Hung3ff4b552023-06-26 19:20:57 -0700768 mFillingStatus(FS_INVALID),
Eric Laurent81784c32012-11-19 14:55:58 -0800769 // mRetryCount initialized later when needed
770 mSharedBuffer(sharedBuffer),
771 mStreamType(streamType),
rago94a1ee82017-07-21 15:11:02 -0700772 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800773 mAuxBuffer(NULL),
774 mAuxEffectId(0), mHasVolumeController(false),
Andy Hunge10393e2015-06-12 13:59:33 -0700775 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700776 mVolumeHandler(new media::VolumeHandler(sampleRate)),
Vlad Popa103be862023-07-10 20:27:41 -0700777 mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(thread, attributionSource, attr, id(),
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700778 streamType)),
Andy Hunge10393e2015-06-12 13:59:33 -0700779 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800780 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800781 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700782 /* The track might not play immediately after being active, similarly as if its volume was 0.
783 * When the track starts playing, its volume will be computed. */
784 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800785 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700786 mFlushHwPending(false),
jiabinf042b9b2021-05-07 23:46:28 +0000787 mFlags(flags),
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200788 mSpeed(speed),
jiabinc658e452022-10-21 20:52:21 +0000789 mIsSpatialized(isSpatialized),
790 mIsBitPerfect(isBitPerfect)
Eric Laurent81784c32012-11-19 14:55:58 -0800791{
Eric Laurent83b88082014-06-20 18:31:16 -0700792 // client == 0 implies sharedBuffer == 0
793 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
794
Andy Hung9d84af52018-09-12 18:03:44 -0700795 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700796 __func__, mId, sharedBuffer->unsecurePointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700797
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700798 if (mCblk == NULL) {
799 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800800 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700801
Svet Ganov33761132021-05-13 22:51:08 +0000802 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Andy Hung689e82c2019-08-21 17:53:17 -0700803 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
804 ALOGE("%s(%d): no more tracks available", __func__, mId);
805 releaseCblk(); // this makes the track invalid.
806 return;
807 }
808
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700809 if (sharedBuffer == 0) {
810 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700811 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700812 } else {
813 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
Kevin Rocard36862032019-10-10 10:52:19 +0100814 mFrameSize, sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700815 }
816 mServerProxy = mAudioTrackServerProxy;
Andy Hung3c7f47a2021-03-16 17:30:09 -0700817 mServerProxy->setStartThresholdInFrames(frameCountToBeReady); // update the Cblk value
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700818
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700819 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700820 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700821 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
822 // race with setSyncEvent(). However, if we call it, we cannot properly start
823 // static fast tracks (SoundPool) immediately after stopping.
824 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Andy Hung44f27182023-07-06 20:56:16 -0700825 ALOG_ASSERT(thread->fastTrackAvailMask_l() != 0);
826 const int i = __builtin_ctz(thread->fastTrackAvailMask_l());
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700827 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700828 // FIXME This is too eager. We allocate a fast track index before the
829 // fast track becomes active. Since fast tracks are a scarce resource,
830 // this means we are potentially denying other more important fast tracks from
831 // being created. It would be better to allocate the index dynamically.
832 mFastIndex = i;
Andy Hung44f27182023-07-06 20:56:16 -0700833 thread->fastTrackAvailMask_l() &= ~(1 << i);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700834 }
Andy Hung8946a282018-04-19 20:04:56 -0700835
Dean Wheatley7b036912020-06-18 16:22:11 +1000836 mServerLatencySupported = checkServerLatencySupported(format, flags);
Andy Hung8946a282018-04-19 20:04:56 -0700837#ifdef TEE_SINK
838 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800839 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700840#endif
jiabin57303cc2018-12-18 15:45:57 -0800841
jiabineb3bda02020-06-30 14:07:03 -0700842 if (thread->supportsHapticPlayback()) {
843 // If the track is attached to haptic playback thread, it is potentially to have
844 // HapticGenerator effect, which will generate haptic data, on the track. In that case,
845 // external vibration is always created for all tracks attached to haptic playback thread.
jiabin57303cc2018-12-18 15:45:57 -0800846 mAudioVibrationController = new AudioVibrationController(this);
Svet Ganov33761132021-05-13 22:51:08 +0000847 std::string packageName = attributionSource.packageName.has_value() ?
848 attributionSource.packageName.value() : "";
jiabin57303cc2018-12-18 15:45:57 -0800849 mExternalVibration = new os::ExternalVibration(
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700850 mUid, packageName, mAttr, mAudioVibrationController);
jiabin57303cc2018-12-18 15:45:57 -0800851 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800852
853 // Once this item is logged by the server, the client can add properties.
Andy Hunga629bd12020-06-05 16:03:53 -0700854 const char * const traits = sharedBuffer == 0 ? "" : "static";
Andy Hung5837c7f2021-02-25 10:48:24 -0800855 mTrackMetrics.logConstructor(creatorPid, uid, id(), traits, streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800856}
857
Andy Hung3ff4b552023-06-26 19:20:57 -0700858Track::~Track()
Eric Laurent81784c32012-11-19 14:55:58 -0800859{
Andy Hung9d84af52018-09-12 18:03:44 -0700860 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700861
862 // The destructor would clear mSharedBuffer,
863 // but it will not push the decremented reference count,
864 // leaving the client's IMemory dangling indefinitely.
865 // This prevents that leak.
866 if (mSharedBuffer != 0) {
867 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700868 }
Eric Laurent81784c32012-11-19 14:55:58 -0800869}
870
Andy Hung3ff4b552023-06-26 19:20:57 -0700871status_t Track::initCheck() const
Glenn Kasten03003332013-08-06 15:40:54 -0700872{
873 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700874 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700875 status = NO_MEMORY;
876 }
877 return status;
878}
879
Andy Hung3ff4b552023-06-26 19:20:57 -0700880void Track::destroy()
Eric Laurent81784c32012-11-19 14:55:58 -0800881{
882 // NOTE: destroyTrack_l() can remove a strong reference to this Track
883 // by removing it from mTracks vector, so there is a risk that this Tracks's
884 // destructor is called. As the destructor needs to lock mLock,
885 // we must acquire a strong reference on this Track before locking mLock
886 // here so that the destructor is called only when exiting this function.
887 // On the other hand, as long as Track::destroy() is only called by
888 // TrackHandle destructor, the TrackHandle still holds a strong ref on
889 // this Track with its member mTrack.
890 sp<Track> keep(this);
891 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700892 bool wasActive = false;
Andy Hung44f27182023-07-06 20:56:16 -0700893 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -0800894 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -0700895 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -0700896 auto* const playbackThread = thread->asIAfPlaybackThread().get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700897 wasActive = playbackThread->destroyTrack_l(this);
898 }
899 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700900 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800901 }
902 }
Kevin Rocardc43ea142019-01-31 18:17:37 -0800903 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Eric Laurent81784c32012-11-19 14:55:58 -0800904}
905
Andy Hung3ff4b552023-06-26 19:20:57 -0700906void Track::appendDumpHeader(String8& result) const
Eric Laurent81784c32012-11-19 14:55:58 -0800907{
Eric Laurent973db022018-11-20 14:54:31 -0800908 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700909 " Format Chn mask SRate "
910 "ST Usg CT "
911 " G db L dB R dB VS dB "
jiabin5eaf0962022-12-20 20:11:38 +0000912 " Server FrmCnt FrmRdy F Underruns Flushed BitPerfect"
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700913 "%s\n",
914 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800915}
916
Andy Hung3ff4b552023-06-26 19:20:57 -0700917void Track::appendDump(String8& result, bool active) const
Eric Laurent81784c32012-11-19 14:55:58 -0800918{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700919 char trackType;
920 switch (mType) {
921 case TYPE_DEFAULT:
922 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700923 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700924 trackType = 'S'; // static
925 } else {
926 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800927 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700928 break;
929 case TYPE_PATCH:
930 trackType = 'P';
931 break;
932 default:
933 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800934 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700935
936 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700937 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700938 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700939 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700940 }
941
Eric Laurent81784c32012-11-19 14:55:58 -0800942 char nowInUnderrun;
943 switch (mObservedUnderruns.mBitFields.mMostRecent) {
944 case UNDERRUN_FULL:
945 nowInUnderrun = ' ';
946 break;
947 case UNDERRUN_PARTIAL:
948 nowInUnderrun = '<';
949 break;
950 case UNDERRUN_EMPTY:
951 nowInUnderrun = '*';
952 break;
953 default:
954 nowInUnderrun = '?';
955 break;
956 }
Andy Hungda540db2017-04-20 14:06:17 -0700957
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700958 char fillingStatus;
Andy Hung3ff4b552023-06-26 19:20:57 -0700959 switch (mFillingStatus) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700960 case FS_INVALID:
961 fillingStatus = 'I';
962 break;
963 case FS_FILLING:
964 fillingStatus = 'f';
965 break;
966 case FS_FILLED:
967 fillingStatus = 'F';
968 break;
969 case FS_ACTIVE:
970 fillingStatus = 'A';
971 break;
972 default:
973 fillingStatus = '?';
974 break;
975 }
976
977 // clip framesReadySafe to max representation in dump
978 const size_t framesReadySafe =
979 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
980
981 // obtain volumes
982 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
983 const std::pair<float /* volume */, bool /* active */> vsVolume =
984 mVolumeHandler->getLastVolume();
985
986 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
987 // as it may be reduced by the application.
988 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
989 // Check whether the buffer size has been modified by the app.
990 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
991 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
992 ? 'e' /* error */ : ' ' /* identical */;
993
Eric Laurent973db022018-11-20 14:54:31 -0800994 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700995 "%08X %08X %6u "
996 "%2u %3x %2x "
997 "%5.2g %5.2g %5.2g %5.2g%c "
jiabin5eaf0962022-12-20 20:11:38 +0000998 "%08X %6zu%c %6zu %c %9u%c %7u %10s",
Marco Nelissenb2208842014-02-07 14:00:50 -0800999 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -07001000 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001001 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08001002 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08001003 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001004 mCblk->mFlags,
1005
Eric Laurent81784c32012-11-19 14:55:58 -08001006 mFormat,
1007 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -07001008 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001009
1010 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001011 mAttr.usage,
1012 mAttr.content_type,
1013
1014 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -07001015 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
1016 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -07001017 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
1018 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001019
Glenn Kastenf20e1d82013-07-12 09:45:18 -07001020 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001021 bufferSizeInFrames,
1022 modifiedBufferChar,
1023 framesReadySafe,
1024 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -07001025 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -08001026 nowInUnderrun,
jiabin5eaf0962022-12-20 20:11:38 +00001027 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000,
1028 isBitPerfect() ? "true" : "false"
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001029 );
Andy Hungcef2daa2018-06-01 15:31:49 -07001030
1031 if (isServerLatencySupported()) {
1032 double latencyMs;
1033 bool fromTrack;
1034 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
1035 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
1036 // or 'k' if estimated from kernel because track frames haven't been presented yet.
1037 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -07001038 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -07001039 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -07001040 }
1041 }
1042 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08001043}
1044
Andy Hung3ff4b552023-06-26 19:20:57 -07001045uint32_t Track::sampleRate() const {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001046 return mAudioTrackServerProxy->getSampleRate();
1047}
1048
Eric Laurent81784c32012-11-19 14:55:58 -08001049// AudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07001050status_t Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08001051{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001052 ServerProxy::Buffer buf;
1053 size_t desiredFrames = buffer->frameCount;
1054 buf.mFrameCount = desiredFrames;
1055 status_t status = mServerProxy->obtainBuffer(&buf);
1056 buffer->frameCount = buf.mFrameCount;
1057 buffer->raw = buf.mRaw;
Andy Hungfc629172020-06-22 10:06:23 -07001058 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused() && !isOffloaded()) {
Andy Hung9d84af52018-09-12 18:03:44 -07001059 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
Andy Hung959b5b82021-09-24 10:46:20 -07001060 __func__, mId, buf.mFrameCount, desiredFrames, (int)mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -07001061 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08001062 } else {
1063 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -08001064 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001065 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001066}
1067
Andy Hung3ff4b552023-06-26 19:20:57 -07001068void Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
Kevin Rocard153f92d2018-12-18 18:33:28 -08001069{
1070 interceptBuffer(*buffer);
1071 TrackBase::releaseBuffer(buffer);
1072}
1073
1074// TODO: compensate for time shift between HW modules.
Andy Hung3ff4b552023-06-26 19:20:57 -07001075void Track::interceptBuffer(
Kevin Rocarda134b002019-02-07 18:05:31 -08001076 const AudioBufferProvider::Buffer& sourceBuffer) {
Kevin Rocard6057fa22019-02-08 14:08:07 -08001077 auto start = std::chrono::steady_clock::now();
Kevin Rocarda134b002019-02-07 18:05:31 -08001078 const size_t frameCount = sourceBuffer.frameCount;
Kevin Rocardd83b08a2019-02-27 15:05:54 -08001079 if (frameCount == 0) {
1080 return; // No audio to intercept.
1081 // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
1082 // does not allow 0 frame size request contrary to getNextBuffer
1083 }
1084 for (auto& teePatch : mTeePatches) {
Andy Hung3ff4b552023-06-26 19:20:57 -07001085 IAfPatchRecord* patchRecord = teePatch.patchRecord.get();
Mikhail Naganov8296c252019-09-25 14:59:54 -07001086 const size_t framesWritten = patchRecord->writeFrames(
1087 sourceBuffer.i8, frameCount, mFrameSize);
1088 const size_t framesLeft = frameCount - framesWritten;
Kevin Rocarda134b002019-02-07 18:05:31 -08001089 ALOGW_IF(framesLeft != 0, "%s(%d) PatchRecord %d can not provide big enough "
Andy Hung3ff4b552023-06-26 19:20:57 -07001090 "buffer %zu/%zu, dropping %zu frames", __func__, mId, patchRecord->id(),
Kevin Rocarda134b002019-02-07 18:05:31 -08001091 framesWritten, frameCount, framesLeft);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001092 }
Kevin Rocard6057fa22019-02-08 14:08:07 -08001093 auto spent = ceil<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
1094 using namespace std::chrono_literals;
1095 // Average is ~20us per track, this should virtually never be logged (Logging takes >200us)
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001096 ALOGD_IF(spent > 500us, "%s: took %lldus to intercept %zu tracks", __func__,
Kevin Rocard6057fa22019-02-08 14:08:07 -08001097 spent.count(), mTeePatches.size());
Kevin Rocard153f92d2018-12-18 18:33:28 -08001098}
1099
Glenn Kasten6466c9e2013-08-23 10:54:07 -07001100// ExtendedAudioBufferProvider interface
1101
Andy Hung27876c02014-09-09 18:07:55 -07001102// framesReady() may return an approximation of the number of frames if called
1103// from a different thread than the one calling Proxy->obtainBuffer() and
1104// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
1105// AudioTrackServerProxy so be especially careful calling with FastTracks.
Andy Hung3ff4b552023-06-26 19:20:57 -07001106size_t Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -07001107 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
1108 // Static tracks return zero frames immediately upon stopping (for FastTracks).
1109 // The remainder of the buffer is not drained.
1110 return 0;
1111 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001112 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -08001113}
1114
Andy Hung3ff4b552023-06-26 19:20:57 -07001115int64_t Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -07001116{
1117 return mAudioTrackServerProxy->framesReleased();
1118}
1119
Andy Hung3ff4b552023-06-26 19:20:57 -07001120void Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -08001121{
1122 // This call comes from a FastTrack and should be kept lockless.
1123 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -08001124 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -08001125
Andy Hung818e7a32016-02-16 18:08:07 -08001126 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -07001127
1128 // Compute latency.
1129 // TODO: Consider whether the server latency may be passed in by FastMixer
1130 // as a constant for all active FastTracks.
1131 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
1132 mServerLatencyFromTrack.store(true);
1133 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -08001134}
1135
Eric Laurent81784c32012-11-19 14:55:58 -08001136// Don't call for fast tracks; the framesReady() could result in priority inversion
Andy Hung3ff4b552023-06-26 19:20:57 -07001137bool Track::isReady() const {
1138 if (mFillingStatus != FS_FILLING || isStopped() || isPausing()) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001139 return true;
1140 }
1141
Eric Laurent16498512014-03-17 17:22:08 -07001142 if (isStopping()) {
1143 if (framesReady() > 0) {
Andy Hung3ff4b552023-06-26 19:20:57 -07001144 mFillingStatus = FS_FILLED;
Eric Laurent16498512014-03-17 17:22:08 -07001145 }
Eric Laurent81784c32012-11-19 14:55:58 -08001146 return true;
1147 }
1148
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001149 size_t bufferSizeInFrames = mServerProxy->getBufferSizeInFrames();
Andy Hung3c7f47a2021-03-16 17:30:09 -07001150 // Note: mServerProxy->getStartThresholdInFrames() is clamped.
1151 const size_t startThresholdInFrames = mServerProxy->getStartThresholdInFrames();
1152 const size_t framesToBeReady = std::clamp( // clamp again to validate client values.
1153 std::min(startThresholdInFrames, bufferSizeInFrames), size_t(1), mFrameCount);
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001154
1155 if (framesReady() >= framesToBeReady || (mCblk->mFlags & CBLK_FORCEREADY)) {
1156 ALOGV("%s(%d): consider track ready with %zu/%zu, target was %zu)",
1157 __func__, mId, framesReady(), bufferSizeInFrames, framesToBeReady);
Andy Hung3ff4b552023-06-26 19:20:57 -07001158 mFillingStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001159 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001160 return true;
1161 }
1162 return false;
1163}
1164
Andy Hung3ff4b552023-06-26 19:20:57 -07001165status_t Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -08001166 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001167{
1168 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -07001169 ALOGV("%s(%d): calling pid %d session %d",
1170 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001171
Andy Hung44f27182023-07-06 20:56:16 -07001172 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001173 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001174 if (isOffloaded()) {
Andy Hung2ac52f12023-08-28 18:36:53 -07001175 audio_utils::lock_guard _laf(thread->afThreadCallback()->mutex());
Andy Hung94dfbb42023-09-06 19:41:47 -07001176 const bool nonOffloadableGlobalEffectEnabled =
1177 thread->afThreadCallback()->isNonOffloadableGlobalEffectEnabled_l();
Andy Hung87e82412023-08-29 14:26:09 -07001178 audio_utils::lock_guard _lth(thread->mutex());
Andy Hungbd72c542023-06-20 18:56:17 -07001179 sp<IAfEffectChain> ec = thread->getEffectChain_l(mSessionId);
Andy Hung94dfbb42023-09-06 19:41:47 -07001180 if (nonOffloadableGlobalEffectEnabled ||
Eric Laurent5baf2af2013-09-12 17:37:00 -07001181 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001182 invalidate();
1183 return PERMISSION_DENIED;
1184 }
1185 }
Andy Hung87e82412023-08-29 14:26:09 -07001186 audio_utils::lock_guard _lth(thread->mutex());
Eric Laurent81784c32012-11-19 14:55:58 -08001187 track_state state = mState;
1188 // here the track could be either new, or restarted
1189 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -08001190
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001191 // initial state-stopping. next state-pausing.
1192 // What if resume is called ?
1193
Zhou Song1ed46a22020-08-17 15:36:56 +08001194 if (state == FLUSHED) {
1195 // avoid underrun glitches when starting after flush
1196 reset();
1197 }
1198
kuowei.li576f1362021-05-11 18:02:32 +08001199 // clear mPauseHwPending because of pause (and possibly flush) during underrun.
1200 mPauseHwPending = false;
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001201 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001202 if (mResumeToStopping) {
1203 // happened we need to resume to STOPPING_1
1204 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -07001205 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
1206 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001207 } else {
1208 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -07001209 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
1210 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001211 }
Eric Laurent81784c32012-11-19 14:55:58 -08001212 } else {
1213 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -07001214 ALOGV("%s(%d): ? => ACTIVE on thread %d",
1215 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001216 }
1217
Andy Hung44f27182023-07-06 20:56:16 -07001218 auto* const playbackThread = thread->asIAfPlaybackThread().get();
yucliu91503922022-07-20 17:40:39 -07001219
1220 // states to reset position info for pcm tracks
1221 if (audio_is_linear_pcm(mFormat)
Andy Hunge10393e2015-06-12 13:59:33 -07001222 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
1223 mFrameMap.reset();
yucliu91503922022-07-20 17:40:39 -07001224
1225 if (!isFastTrack() && (isDirect() || isOffloaded())) {
1226 // Start point of track -> sink frame map. If the HAL returns a
1227 // frame position smaller than the first written frame in
1228 // updateTrackFrameInfo, the timestamp can be interpolated
1229 // instead of using a larger value.
1230 mFrameMap.push(mAudioTrackServerProxy->framesReleased(),
1231 playbackThread->framesWritten());
1232 }
Andy Hunge10393e2015-06-12 13:59:33 -07001233 }
Haynes Mathew George240934b2015-03-11 18:25:50 -07001234 if (isFastTrack()) {
1235 // refresh fast track underruns on start because that field is never cleared
1236 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
1237 // after stop.
1238 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
1239 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001240 status = playbackThread->addTrack_l(this);
jiabina84c3d32022-12-02 18:59:55 +00001241 if (status == INVALID_OPERATION || status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurent81784c32012-11-19 14:55:58 -08001242 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001243 // restore previous state if start was rejected by policy manager
jiabina84c3d32022-12-02 18:59:55 +00001244 if (status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001245 mState = state;
1246 }
1247 }
Andy Hung1d3556d2018-03-29 16:30:14 -07001248
Andy Hungb68f5eb2019-12-03 16:49:17 -08001249 // Audio timing metrics are computed a few mix cycles after starting.
1250 {
1251 mLogStartCountdown = LOG_START_COUNTDOWN;
1252 mLogStartTimeNs = systemTime();
1253 mLogStartFrames = mAudioTrackServerProxy->getTimestamp()
Andy Hung62921122020-05-18 10:47:31 -07001254 .mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1255 mLogLatencyMs = 0.;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001256 }
Andy Hungcb6cc752022-05-19 19:24:51 -07001257 mLogForceVolumeUpdate = true; // at least one volume logged for metrics when starting.
Andy Hungb68f5eb2019-12-03 16:49:17 -08001258
Andy Hung1d3556d2018-03-29 16:30:14 -07001259 if (status == NO_ERROR || status == ALREADY_EXISTS) {
1260 // for streaming tracks, remove the buffer read stop limit.
1261 mAudioTrackServerProxy->start();
1262 }
1263
Eric Laurentbfb1b832013-01-07 09:53:42 -08001264 // track was already in the active list, not a problem
1265 if (status == ALREADY_EXISTS) {
1266 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -07001267 } else {
1268 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
1269 // It is usually unsafe to access the server proxy from a binder thread.
1270 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
1271 // isn't looking at this track yet: we still hold the normal mixer thread lock,
1272 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -07001273 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -07001274 ServerProxy::Buffer buffer;
1275 buffer.mFrameCount = 1;
1276 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -08001277 }
1278 } else {
1279 status = BAD_VALUE;
1280 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001281 if (status == NO_ERROR) {
1282 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
Jean-Michel Trivi16395ca2022-12-11 22:10:11 +00001283
1284 // send format to AudioManager for playback activity monitoring
Andy Hung2cbc2722023-07-17 17:05:00 -07001285 const sp<IAudioManager> audioManager =
1286 thread->afThreadCallback()->getOrCreateAudioManager();
Jean-Michel Trivi16395ca2022-12-11 22:10:11 +00001287 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1288 std::unique_ptr<os::PersistableBundle> bundle =
1289 std::make_unique<os::PersistableBundle>();
1290 bundle->putBoolean(String16(kExtraPlayerEventSpatializedKey),
1291 isSpatialized());
1292 bundle->putInt(String16(kExtraPlayerEventSampleRateKey), mSampleRate);
1293 bundle->putInt(String16(kExtraPlayerEventChannelMaskKey), mChannelMask);
1294 status_t result = audioManager->portEvent(mPortId,
1295 PLAYER_UPDATE_FORMAT, bundle);
1296 if (result != OK) {
1297 ALOGE("%s: unable to send playback format for port ID %d, status error %d",
1298 __func__, mPortId, result);
1299 }
1300 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001301 }
Eric Laurent81784c32012-11-19 14:55:58 -08001302 return status;
1303}
1304
Andy Hung3ff4b552023-06-26 19:20:57 -07001305void Track::stop()
Eric Laurent81784c32012-11-19 14:55:58 -08001306{
Andy Hungc0691382018-09-12 18:01:57 -07001307 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Andy Hung44f27182023-07-06 20:56:16 -07001308 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001309 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -07001310 audio_utils::lock_guard _l(thread->mutex());
Eric Laurent81784c32012-11-19 14:55:58 -08001311 track_state state = mState;
1312 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
1313 // If the track is not active (PAUSED and buffers full), flush buffers
Andy Hung44f27182023-07-06 20:56:16 -07001314 auto* const playbackThread = thread->asIAfPlaybackThread().get();
1315 if (!playbackThread->isTrackActive(this)) {
Eric Laurent81784c32012-11-19 14:55:58 -08001316 reset();
1317 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -07001318 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001319 mState = STOPPED;
1320 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001321 // For fast tracks prepareTracks_l() will set state to STOPPING_2
1322 // presentation is complete
1323 // For an offloaded track this starts a drain and state will
1324 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -08001325 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -07001326 if (isOffloaded()) {
Andy Hung44f27182023-07-06 20:56:16 -07001327 mRetryCount = IAfPlaybackThread::kMaxTrackStopRetriesOffload;
Eric Laurente93cc032016-05-05 10:15:10 -07001328 }
Eric Laurent81784c32012-11-19 14:55:58 -08001329 }
Eric Laurentb369caf2015-03-30 20:51:47 -07001330 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -07001331 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
1332 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001333 }
Eric Laurent81784c32012-11-19 14:55:58 -08001334 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001335 forEachTeePatchTrack([](auto patchTrack) { patchTrack->stop(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001336}
1337
Andy Hung3ff4b552023-06-26 19:20:57 -07001338void Track::pause()
Eric Laurent81784c32012-11-19 14:55:58 -08001339{
Andy Hungc0691382018-09-12 18:01:57 -07001340 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Andy Hung44f27182023-07-06 20:56:16 -07001341 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001342 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -07001343 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001344 auto* const playbackThread = thread->asIAfPlaybackThread().get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001345 switch (mState) {
1346 case STOPPING_1:
1347 case STOPPING_2:
1348 if (!isOffloaded()) {
1349 /* nothing to do if track is not offloaded */
1350 break;
1351 }
1352
1353 // Offloaded track was draining, we need to carry on draining when resumed
1354 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07001355 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001356 case ACTIVE:
1357 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -08001358 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -07001359 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
1360 __func__, mId, (int)mThreadIoHandle);
Kuowei Li23666472021-01-20 10:23:25 +08001361 if (isOffloadedOrDirect()) {
1362 mPauseHwPending = true;
1363 }
Eric Laurentede6c3b2013-09-19 14:37:46 -07001364 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001365 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001366
Eric Laurentbfb1b832013-01-07 09:53:42 -08001367 default:
1368 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001369 }
1370 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001371 // Pausing the TeePatch to avoid a glitch on underrun, at the cost of buffered audio loss.
1372 forEachTeePatchTrack([](auto patchTrack) { patchTrack->pause(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001373}
1374
Andy Hung3ff4b552023-06-26 19:20:57 -07001375void Track::flush()
Eric Laurent81784c32012-11-19 14:55:58 -08001376{
Andy Hungc0691382018-09-12 18:01:57 -07001377 ALOGV("%s(%d)", __func__, mId);
Andy Hung44f27182023-07-06 20:56:16 -07001378 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001379 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -07001380 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001381 auto* const playbackThread = thread->asIAfPlaybackThread().get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001382
Phil Burk4bb650b2016-09-09 12:11:17 -07001383 // Flush the ring buffer now if the track is not active in the PlaybackThread.
1384 // Otherwise the flush would not be done until the track is resumed.
1385 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
Andy Hung44f27182023-07-06 20:56:16 -07001386 if (!playbackThread->isTrackActive(this)) {
Phil Burk4bb650b2016-09-09 12:11:17 -07001387 (void)mServerProxy->flushBufferIfNeeded();
1388 }
1389
Eric Laurentbfb1b832013-01-07 09:53:42 -08001390 if (isOffloaded()) {
1391 // If offloaded we allow flush during any state except terminated
1392 // and keep the track active to avoid problems if user is seeking
1393 // rapidly and underlying hardware has a significant delay handling
1394 // a pause
1395 if (isTerminated()) {
1396 return;
1397 }
1398
Andy Hung9d84af52018-09-12 18:03:44 -07001399 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001400 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001401
1402 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -07001403 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
1404 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001405 mState = ACTIVE;
1406 }
1407
Haynes Mathew George7844f672014-01-15 12:32:55 -08001408 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001409 mResumeToStopping = false;
1410 } else {
1411 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
1412 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
1413 return;
1414 }
1415 // No point remaining in PAUSED state after a flush => go to
1416 // FLUSHED state
1417 mState = FLUSHED;
1418 // do not reset the track if it is still in the process of being stopped or paused.
1419 // this will be done by prepareTracks_l() when the track is stopped.
1420 // prepareTracks_l() will see mState == FLUSHED, then
1421 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -08001422 if (isDirect()) {
1423 mFlushHwPending = true;
1424 }
Andy Hung44f27182023-07-06 20:56:16 -07001425 if (!playbackThread->isTrackActive(this)) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001426 reset();
1427 }
Eric Laurent81784c32012-11-19 14:55:58 -08001428 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001429 // Prevent flush being lost if the track is flushed and then resumed
1430 // before mixer thread can run. This is important when offloading
1431 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -07001432 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001433 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001434 // Flush the Tee to avoid on resume playing old data and glitching on the transition to new data
1435 forEachTeePatchTrack([](auto patchTrack) { patchTrack->flush(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001436}
1437
Haynes Mathew George7844f672014-01-15 12:32:55 -08001438// must be called with thread lock held
Andy Hung3ff4b552023-06-26 19:20:57 -07001439void Track::flushAck()
Haynes Mathew George7844f672014-01-15 12:32:55 -08001440{
Andy Hung71ba4b32022-10-06 12:09:49 -07001441 if (!isOffloaded() && !isDirect()) {
Haynes Mathew George7844f672014-01-15 12:32:55 -08001442 return;
Andy Hung71ba4b32022-10-06 12:09:49 -07001443 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08001444
Phil Burk4bb650b2016-09-09 12:11:17 -07001445 // Clear the client ring buffer so that the app can prime the buffer while paused.
1446 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1447 mServerProxy->flushBufferIfNeeded();
1448
Haynes Mathew George7844f672014-01-15 12:32:55 -08001449 mFlushHwPending = false;
1450}
1451
Andy Hung3ff4b552023-06-26 19:20:57 -07001452void Track::pauseAck()
Kuowei Li23666472021-01-20 10:23:25 +08001453{
1454 mPauseHwPending = false;
1455}
1456
Andy Hung3ff4b552023-06-26 19:20:57 -07001457void Track::reset()
Eric Laurent81784c32012-11-19 14:55:58 -08001458{
1459 // Do not reset twice to avoid discarding data written just after a flush and before
1460 // the audioflinger thread detects the track is stopped.
1461 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001462 // Force underrun condition to avoid false underrun callback until first data is
1463 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001464 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Andy Hung3ff4b552023-06-26 19:20:57 -07001465 mFillingStatus = FS_FILLING;
Eric Laurent81784c32012-11-19 14:55:58 -08001466 mResetDone = true;
1467 if (mState == FLUSHED) {
1468 mState = IDLE;
1469 }
1470 }
1471}
1472
Andy Hung3ff4b552023-06-26 19:20:57 -07001473status_t Track::setParameters(const String8& keyValuePairs)
Eric Laurentbfb1b832013-01-07 09:53:42 -08001474{
Andy Hung44f27182023-07-06 20:56:16 -07001475 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001476 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001477 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001478 return FAILED_TRANSACTION;
Andy Hung44f27182023-07-06 20:56:16 -07001479 } else if (thread->type() == IAfThreadBase::DIRECT
1480 || thread->type() == IAfThreadBase::OFFLOAD) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001481 return thread->setParameters(keyValuePairs);
1482 } else {
1483 return PERMISSION_DENIED;
1484 }
1485}
1486
Andy Hung3ff4b552023-06-26 19:20:57 -07001487status_t Track::selectPresentation(int presentationId,
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001488 int programId) {
Andy Hung44f27182023-07-06 20:56:16 -07001489 const sp<IAfThreadBase> thread = mThread.promote();
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001490 if (thread == 0) {
1491 ALOGE("thread is dead");
1492 return FAILED_TRANSACTION;
Andy Hung44f27182023-07-06 20:56:16 -07001493 } else if (thread->type() == IAfThreadBase::DIRECT
1494 || thread->type() == IAfThreadBase::OFFLOAD) {
1495 auto directOutputThread = thread->asIAfDirectOutputThread().get();
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001496 return directOutputThread->selectPresentation(presentationId, programId);
1497 }
1498 return INVALID_OPERATION;
1499}
1500
Andy Hung3ff4b552023-06-26 19:20:57 -07001501VolumeShaper::Status Track::applyVolumeShaper(
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001502 const sp<VolumeShaper::Configuration>& configuration,
1503 const sp<VolumeShaper::Operation>& operation)
1504{
Andy Hungee86cee2022-12-13 19:19:53 -08001505 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung10cbff12017-02-21 17:30:14 -08001506
1507 if (isOffloadedOrDirect()) {
1508 // Signal thread to fetch new volume.
Andy Hung44f27182023-07-06 20:56:16 -07001509 const sp<IAfThreadBase> thread = mThread.promote();
Andy Hung10cbff12017-02-21 17:30:14 -08001510 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -07001511 audio_utils::lock_guard _l(thread->mutex());
Andy Hung10cbff12017-02-21 17:30:14 -08001512 thread->broadcast_l();
1513 }
1514 }
1515 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001516}
1517
Andy Hung3ff4b552023-06-26 19:20:57 -07001518sp<VolumeShaper::State> Track::getVolumeShaperState(int id) const
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001519{
1520 // Note: We don't check if Thread exists.
1521
1522 // mVolumeHandler is thread safe.
1523 return mVolumeHandler->getVolumeShaperState(id);
1524}
1525
Andy Hung3ff4b552023-06-26 19:20:57 -07001526void Track::setFinalVolume(float volumeLeft, float volumeRight)
Kevin Rocard12381092018-04-11 09:19:59 -07001527{
jiabin76d94692022-12-15 21:51:21 +00001528 mFinalVolumeLeft = volumeLeft;
1529 mFinalVolumeRight = volumeRight;
1530 const float volume = (volumeLeft + volumeRight) * 0.5f;
Kevin Rocard12381092018-04-11 09:19:59 -07001531 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1532 mFinalVolume = volume;
1533 setMetadataHasChanged();
Andy Hungcb6cc752022-05-19 19:24:51 -07001534 mLogForceVolumeUpdate = true;
1535 }
1536 if (mLogForceVolumeUpdate) {
1537 mLogForceVolumeUpdate = false;
1538 mTrackMetrics.logVolume(mFinalVolume);
Kevin Rocard12381092018-04-11 09:19:59 -07001539 }
1540}
1541
Andy Hung3ff4b552023-06-26 19:20:57 -07001542void Track::copyMetadataTo(MetadataInserter& backInserter) const
Kevin Rocard12381092018-04-11 09:19:59 -07001543{
Eric Laurent49e39282022-06-24 18:42:45 +02001544 // Do not forward metadata for PatchTrack with unspecified stream type
1545 if (mStreamType == AUDIO_STREAM_PATCH) {
1546 return;
1547 }
1548
Eric Laurent94579172020-11-20 18:41:04 +01001549 playback_track_metadata_v7_t metadata;
1550 metadata.base = {
Kevin Rocard12381092018-04-11 09:19:59 -07001551 .usage = mAttr.usage,
1552 .content_type = mAttr.content_type,
1553 .gain = mFinalVolume,
1554 };
Eric Laurentfdf99502021-11-26 19:05:02 +01001555
1556 // When attributes are undefined, derive default values from stream type.
1557 // See AudioAttributes.java, usageForStreamType() and Builder.setInternalLegacyStreamType()
1558 if (mAttr.usage == AUDIO_USAGE_UNKNOWN) {
1559 switch (mStreamType) {
1560 case AUDIO_STREAM_VOICE_CALL:
1561 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION;
1562 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1563 break;
1564 case AUDIO_STREAM_SYSTEM:
1565 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1566 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1567 break;
1568 case AUDIO_STREAM_RING:
1569 metadata.base.usage = AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1570 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1571 break;
1572 case AUDIO_STREAM_MUSIC:
1573 metadata.base.usage = AUDIO_USAGE_MEDIA;
1574 metadata.base.content_type = AUDIO_CONTENT_TYPE_MUSIC;
1575 break;
1576 case AUDIO_STREAM_ALARM:
1577 metadata.base.usage = AUDIO_USAGE_ALARM;
1578 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1579 break;
1580 case AUDIO_STREAM_NOTIFICATION:
1581 metadata.base.usage = AUDIO_USAGE_NOTIFICATION;
1582 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1583 break;
1584 case AUDIO_STREAM_DTMF:
1585 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1586 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1587 break;
1588 case AUDIO_STREAM_ACCESSIBILITY:
1589 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1590 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1591 break;
1592 case AUDIO_STREAM_ASSISTANT:
1593 metadata.base.usage = AUDIO_USAGE_ASSISTANT;
1594 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1595 break;
1596 case AUDIO_STREAM_REROUTING:
1597 metadata.base.usage = AUDIO_USAGE_VIRTUAL_SOURCE;
1598 // unknown content type
1599 break;
1600 case AUDIO_STREAM_CALL_ASSISTANT:
1601 metadata.base.usage = AUDIO_USAGE_CALL_ASSISTANT;
1602 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1603 break;
1604 default:
1605 break;
1606 }
1607 }
1608
Eric Laurent78b07302022-10-07 16:20:34 +02001609 metadata.channel_mask = mChannelMask;
Eric Laurent94579172020-11-20 18:41:04 +01001610 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
1611 *backInserter++ = metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07001612}
1613
Andy Hung3ff4b552023-06-26 19:20:57 -07001614void Track::updateTeePatches() {
Jiabin Huangfb476842022-12-06 03:18:10 +00001615 if (mTeePatchesToUpdate.has_value()) {
1616 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
1617 mTeePatches = mTeePatchesToUpdate.value();
1618 if (mState == TrackBase::ACTIVE || mState == TrackBase::RESUMING ||
1619 mState == TrackBase::STOPPING_1) {
1620 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1621 }
1622 mTeePatchesToUpdate.reset();
jiabinf042b9b2021-05-07 23:46:28 +00001623 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001624}
1625
Andy Hung34645da2023-07-14 11:45:38 -07001626void Track::setTeePatchesToUpdate(TeePatches teePatchesToUpdate) {
Jiabin Huangfb476842022-12-06 03:18:10 +00001627 ALOGW_IF(mTeePatchesToUpdate.has_value(),
1628 "%s, existing tee patches to update will be ignored", __func__);
1629 mTeePatchesToUpdate = std::move(teePatchesToUpdate);
1630}
1631
Vlad Popae8d99472022-06-30 16:02:48 +02001632// must be called with player thread lock held
Andy Hung3ff4b552023-06-26 19:20:57 -07001633void Track::processMuteEvent_l(const sp<
Vlad Popae8d99472022-06-30 16:02:48 +02001634 IAudioManager>& audioManager, mute_state_t muteState)
1635{
1636 if (mMuteState == muteState) {
1637 // mute state did not change, do nothing
1638 return;
1639 }
1640
1641 status_t result = UNKNOWN_ERROR;
1642 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1643 if (mMuteEventExtras == nullptr) {
1644 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
1645 }
1646 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
1647 static_cast<int>(muteState));
1648
1649 result = audioManager->portEvent(mPortId,
1650 PLAYER_UPDATE_MUTED,
1651 mMuteEventExtras);
1652 }
1653
1654 if (result == OK) {
1655 mMuteState = muteState;
1656 } else {
1657 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
1658 __func__,
1659 id(),
1660 mPortId,
1661 result);
Andy Hung818e7a32016-02-16 18:08:07 -08001662 }
Glenn Kastenfe346c72013-08-30 13:28:22 -07001663}
Glenn Kasten573d80a2013-08-26 09:36:23 -07001664
Andy Hung3ff4b552023-06-26 19:20:57 -07001665status_t Track::getTimestamp(AudioTimestamp& timestamp)
Eric Laurent81784c32012-11-19 14:55:58 -08001666{
1667 if (!isOffloaded() && !isDirect()) {
Glenn Kasten573d80a2013-08-26 09:36:23 -07001668 return INVALID_OPERATION; // normal tracks handled through SSQ
1669 }
Andy Hung44f27182023-07-06 20:56:16 -07001670 const sp<IAfThreadBase> thread = mThread.promote();
Glenn Kasten573d80a2013-08-26 09:36:23 -07001671 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001672 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001673 }
Phil Burk6140c792015-03-19 14:30:21 -07001674
Andy Hung87e82412023-08-29 14:26:09 -07001675 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001676 auto* const playbackThread = thread->asIAfPlaybackThread().get();
Andy Hung818e7a32016-02-16 18:08:07 -08001677 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001678}
1679
Andy Hung3ff4b552023-06-26 19:20:57 -07001680status_t Track::attachAuxEffect(int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001681{
Andy Hung44f27182023-07-06 20:56:16 -07001682 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent6c796322019-04-09 14:13:17 -07001683 if (thread == nullptr) {
1684 return DEAD_OBJECT;
1685 }
Eric Laurent81784c32012-11-19 14:55:58 -08001686
Andy Hung44f27182023-07-06 20:56:16 -07001687 auto dstThread = thread->asIAfPlaybackThread();
Andy Hung3ff4b552023-06-26 19:20:57 -07001688 // srcThread is initialized by call to moveAuxEffectToIo()
Andy Hung44f27182023-07-06 20:56:16 -07001689 sp<IAfPlaybackThread> srcThread;
Andy Hungfa2f4f32023-07-17 12:40:43 -07001690 const auto& af = mClient->afClientCallback();
Eric Laurent6c796322019-04-09 14:13:17 -07001691 status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001692
Eric Laurent6c796322019-04-09 14:13:17 -07001693 if (EffectId != 0 && status == NO_ERROR) {
1694 status = dstThread->attachAuxEffect(this, EffectId);
1695 if (status == NO_ERROR) {
1696 AudioSystem::moveEffectsToIo(std::vector<int>(EffectId), dstThread->id());
Eric Laurent81784c32012-11-19 14:55:58 -08001697 }
Eric Laurent6c796322019-04-09 14:13:17 -07001698 }
1699
1700 if (status != NO_ERROR && srcThread != nullptr) {
1701 af->moveAuxEffectToIo(EffectId, srcThread, &dstThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001702 }
1703 return status;
1704}
1705
Andy Hung3ff4b552023-06-26 19:20:57 -07001706void Track::setAuxBuffer(int EffectId, int32_t *buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08001707{
1708 mAuxEffectId = EffectId;
1709 mAuxBuffer = buffer;
1710}
1711
Andy Hung59de4262021-06-14 10:53:54 -07001712// presentationComplete verified by frames, used by Mixed tracks.
Andy Hung3ff4b552023-06-26 19:20:57 -07001713bool Track::presentationComplete(
Andy Hung818e7a32016-02-16 18:08:07 -08001714 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001715{
Andy Hung818e7a32016-02-16 18:08:07 -08001716 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1717 // This assists in proper timestamp computation as well as wakelock management.
1718
Eric Laurent81784c32012-11-19 14:55:58 -08001719 // a track is considered presented when the total number of frames written to audio HAL
1720 // corresponds to the number of frames written when presentationComplete() is called for the
1721 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001722 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1723 // to detect when all frames have been played. In this case framesWritten isn't
1724 // useful because it doesn't always reflect whether there is data in the h/w
1725 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001726 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1727 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001728 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001729 if (mPresentationCompleteFrames == 0) {
1730 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001731 ALOGV("%s(%d): set:"
Andy Hung9d84af52018-09-12 18:03:44 -07001732 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1733 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001734 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001735 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001736
Andy Hungc54b1ff2016-02-23 14:07:07 -08001737 bool complete;
Andy Hung59de4262021-06-14 10:53:54 -07001738 if (isFastTrack()) { // does not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001739 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001740 ALOGV("%s(%d): %s framesWritten:%lld mPresentationCompleteFrames:%lld",
1741 __func__, mId, (complete ? "complete" : "waiting"),
1742 (long long) framesWritten, (long long) mPresentationCompleteFrames);
Andy Hungc54b1ff2016-02-23 14:07:07 -08001743 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001744 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001745 && mAudioTrackServerProxy->isDrained();
1746 }
1747
1748 if (complete) {
Andy Hung59de4262021-06-14 10:53:54 -07001749 notifyPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08001750 return true;
1751 }
1752 return false;
1753}
1754
Andy Hung59de4262021-06-14 10:53:54 -07001755// presentationComplete checked by time, used by DirectTracks.
Andy Hung3ff4b552023-06-26 19:20:57 -07001756bool Track::presentationComplete(uint32_t latencyMs)
Andy Hung59de4262021-06-14 10:53:54 -07001757{
1758 // For Offloaded or Direct tracks.
1759
1760 // For a direct track, we incorporated time based testing for presentationComplete.
1761
1762 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1763 // to detect when all frames have been played. In this case latencyMs isn't
1764 // useful because it doesn't always reflect whether there is data in the h/w
1765 // buffers, particularly if a track has been paused and resumed during draining
1766
1767 constexpr float MIN_SPEED = 0.125f; // min speed scaling allowed for timely response.
1768 if (mPresentationCompleteTimeNs == 0) {
1769 mPresentationCompleteTimeNs = systemTime() + latencyMs * 1e6 / fmax(mSpeed, MIN_SPEED);
1770 ALOGV("%s(%d): set: latencyMs %u mPresentationCompleteTimeNs:%lld",
1771 __func__, mId, latencyMs, (long long) mPresentationCompleteTimeNs);
1772 }
1773
1774 bool complete;
1775 if (isOffloaded()) {
1776 complete = true;
1777 } else { // Direct
1778 complete = systemTime() >= mPresentationCompleteTimeNs;
1779 ALOGV("%s(%d): %s", __func__, mId, (complete ? "complete" : "waiting"));
1780 }
1781 if (complete) {
1782 notifyPresentationComplete();
1783 return true;
1784 }
1785 return false;
1786}
1787
Andy Hung3ff4b552023-06-26 19:20:57 -07001788void Track::notifyPresentationComplete()
Andy Hung59de4262021-06-14 10:53:54 -07001789{
1790 // This only triggers once. TODO: should we enforce this?
1791 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
1792 mAudioTrackServerProxy->setStreamEndDone();
1793}
1794
Andy Hung3ff4b552023-06-26 19:20:57 -07001795void Track::triggerEvents(AudioSystem::sync_event_t type)
Eric Laurent81784c32012-11-19 14:55:58 -08001796{
Andy Hung068e08e2023-05-15 19:02:55 -07001797 for (auto it = mSyncEvents.begin(); it != mSyncEvents.end();) {
1798 if ((*it)->type() == type) {
Andy Hung93bb5732023-05-04 21:16:34 -07001799 ALOGV("%s: triggering SyncEvent type %d", __func__, type);
Andy Hung068e08e2023-05-15 19:02:55 -07001800 (*it)->trigger();
1801 it = mSyncEvents.erase(it);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001802 } else {
Andy Hung068e08e2023-05-15 19:02:55 -07001803 ++it;
Eric Laurent81784c32012-11-19 14:55:58 -08001804 }
1805 }
1806}
1807
1808// implement VolumeBufferProvider interface
1809
Andy Hung3ff4b552023-06-26 19:20:57 -07001810gain_minifloat_packed_t Track::getVolumeLR() const
Eric Laurent81784c32012-11-19 14:55:58 -08001811{
1812 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1813 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001814 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1815 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1816 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001817 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001818 if (vl > GAIN_FLOAT_UNITY) {
1819 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001820 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001821 if (vr > GAIN_FLOAT_UNITY) {
1822 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001823 }
1824 // now apply the cached master volume and stream type volume;
1825 // this is trusted but lacks any synchronization or barrier so may be stale
1826 float v = mCachedVolume;
1827 vl *= v;
1828 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001829 // re-combine into packed minifloat
1830 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001831 // FIXME look at mute, pause, and stop flags
1832 return vlr;
1833}
1834
Andy Hung3ff4b552023-06-26 19:20:57 -07001835status_t Track::setSyncEvent(
Andy Hung068e08e2023-05-15 19:02:55 -07001836 const sp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -08001837{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001838 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001839 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1840 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001841 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1842 __func__, mId,
Andy Hung959b5b82021-09-24 10:46:20 -07001843 (int)mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
Eric Laurent81784c32012-11-19 14:55:58 -08001844 event->cancel();
1845 return INVALID_OPERATION;
1846 }
1847 (void) TrackBase::setSyncEvent(event);
1848 return NO_ERROR;
1849}
1850
Andy Hung3ff4b552023-06-26 19:20:57 -07001851void Track::invalidate()
Glenn Kasten5736c352012-12-04 12:12:34 -08001852{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001853 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001854 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001855}
1856
Andy Hung3ff4b552023-06-26 19:20:57 -07001857void Track::disable()
Eric Laurent4d231dc2016-03-11 18:38:23 -08001858{
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001859 // TODO(b/142394888): the filling status should also be reset to filling
Eric Laurent4d231dc2016-03-11 18:38:23 -08001860 signalClientFlag(CBLK_DISABLED);
1861}
1862
Andy Hung3ff4b552023-06-26 19:20:57 -07001863void Track::signalClientFlag(int32_t flag)
Eric Laurent4d231dc2016-03-11 18:38:23 -08001864{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001865 // FIXME should use proxy, and needs work
1866 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001867 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001868 android_atomic_release_store(0x40000000, &cblk->mFutex);
1869 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001870 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001871}
1872
Andy Hung3ff4b552023-06-26 19:20:57 -07001873void Track::signal()
Eric Laurent59fe0102013-09-27 18:48:26 -07001874{
Andy Hung44f27182023-07-06 20:56:16 -07001875 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent59fe0102013-09-27 18:48:26 -07001876 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07001877 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001878 audio_utils::lock_guard _l(t->mutex());
Eric Laurent59fe0102013-09-27 18:48:26 -07001879 t->broadcast_l();
1880 }
1881}
1882
Andy Hung3ff4b552023-06-26 19:20:57 -07001883status_t Track::getDualMonoMode(audio_dual_mono_mode_t* mode) const
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001884{
1885 status_t status = INVALID_OPERATION;
1886 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001887 const sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001888 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001889 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001890 audio_utils::lock_guard _l(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001891 status = t->getOutput_l()->stream->getDualMonoMode(mode);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001892 ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
1893 "%s: mode %d inconsistent", __func__, mDualMonoMode);
1894 }
1895 }
1896 return status;
1897}
1898
Andy Hung3ff4b552023-06-26 19:20:57 -07001899status_t Track::setDualMonoMode(audio_dual_mono_mode_t mode)
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001900{
1901 status_t status = INVALID_OPERATION;
1902 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001903 const sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001904 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001905 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001906 audio_utils::lock_guard lock(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001907 status = t->getOutput_l()->stream->setDualMonoMode(mode);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001908 if (status == NO_ERROR) {
1909 mDualMonoMode = mode;
1910 }
1911 }
1912 }
1913 return status;
1914}
1915
Andy Hung3ff4b552023-06-26 19:20:57 -07001916status_t Track::getAudioDescriptionMixLevel(float* leveldB) const
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001917{
1918 status_t status = INVALID_OPERATION;
1919 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001920 sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001921 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001922 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001923 audio_utils::lock_guard lock(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001924 status = t->getOutput_l()->stream->getAudioDescriptionMixLevel(leveldB);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001925 ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
1926 "%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
1927 }
1928 }
1929 return status;
1930}
1931
Andy Hung3ff4b552023-06-26 19:20:57 -07001932status_t Track::setAudioDescriptionMixLevel(float leveldB)
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001933{
1934 status_t status = INVALID_OPERATION;
1935 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001936 const sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001937 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001938 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001939 audio_utils::lock_guard lock(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001940 status = t->getOutput_l()->stream->setAudioDescriptionMixLevel(leveldB);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001941 if (status == NO_ERROR) {
1942 mAudioDescriptionMixLevel = leveldB;
1943 }
1944 }
1945 }
1946 return status;
1947}
1948
Andy Hung3ff4b552023-06-26 19:20:57 -07001949status_t Track::getPlaybackRateParameters(
Andy Hung02a6c4e2023-06-23 19:27:19 -07001950 audio_playback_rate_t* playbackRate) const
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001951{
1952 status_t status = INVALID_OPERATION;
1953 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001954 const sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001955 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001956 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001957 audio_utils::lock_guard lock(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001958 status = t->getOutput_l()->stream->getPlaybackRateParameters(playbackRate);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001959 ALOGD_IF((status == NO_ERROR) &&
1960 !isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
1961 "%s: playbackRate inconsistent", __func__);
1962 }
1963 }
1964 return status;
1965}
1966
Andy Hung3ff4b552023-06-26 19:20:57 -07001967status_t Track::setPlaybackRateParameters(
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001968 const audio_playback_rate_t& playbackRate)
1969{
1970 status_t status = INVALID_OPERATION;
1971 if (isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07001972 const sp<IAfThreadBase> thread = mThread.promote();
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001973 if (thread != nullptr) {
Andy Hung44f27182023-07-06 20:56:16 -07001974 auto* const t = thread->asIAfPlaybackThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07001975 audio_utils::lock_guard lock(t->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07001976 status = t->getOutput_l()->stream->setPlaybackRateParameters(playbackRate);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001977 if (status == NO_ERROR) {
1978 mPlaybackRateParameters = playbackRate;
1979 }
1980 }
1981 }
1982 return status;
1983}
1984
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001985//To be called with thread lock held
Andy Hung3ff4b552023-06-26 19:20:57 -07001986bool Track::isResumePending() const {
Andy Hung71ba4b32022-10-06 12:09:49 -07001987 if (mState == RESUMING) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001988 return true;
Andy Hung71ba4b32022-10-06 12:09:49 -07001989 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001990 /* Resume is pending if track was stopping before pause was called */
1991 if (mState == STOPPING_1 &&
Andy Hung71ba4b32022-10-06 12:09:49 -07001992 mResumeToStopping) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001993 return true;
Andy Hung71ba4b32022-10-06 12:09:49 -07001994 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001995
1996 return false;
1997}
1998
1999//To be called with thread lock held
Andy Hung3ff4b552023-06-26 19:20:57 -07002000void Track::resumeAck() {
Andy Hung71ba4b32022-10-06 12:09:49 -07002001 if (mState == RESUMING) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08002002 mState = ACTIVE;
Andy Hung71ba4b32022-10-06 12:09:49 -07002003 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08002004
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08002005 // Other possibility of pending resume is stopping_1 state
2006 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08002007 // drain being called.
2008 if (mState == STOPPING_1) {
2009 mResumeToStopping = false;
2010 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08002011}
Andy Hunge10393e2015-06-12 13:59:33 -07002012
2013//To be called with thread lock held
Andy Hung3ff4b552023-06-26 19:20:57 -07002014void Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08002015 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07002016 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07002017 // Make the kernel frametime available.
2018 const FrameTime ft{
2019 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2020 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2021 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2022 mKernelFrameTime.store(ft);
2023 if (!audio_is_linear_pcm(mFormat)) {
2024 return;
2025 }
2026
Andy Hung818e7a32016-02-16 18:08:07 -08002027 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07002028 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08002029
2030 // adjust server times and set drained state.
2031 //
2032 // Our timestamps are only updated when the track is on the Thread active list.
2033 // We need to ensure that tracks are not removed before full drain.
2034 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07002035 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08002036 bool checked = false;
2037 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
2038 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
2039 // Lookup the track frame corresponding to the sink frame position.
2040 if (local.mTimeNs[i] > 0) {
2041 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
2042 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07002043 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07002044 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08002045 checked = true;
2046 }
2047 }
Andy Hunge10393e2015-06-12 13:59:33 -07002048 }
Andy Hungcef2daa2018-06-01 15:31:49 -07002049
Andy Hung93bb5732023-05-04 21:16:34 -07002050 ALOGV("%s: trackFramesReleased:%lld sinkFramesWritten:%lld setDrained: %d",
2051 __func__, (long long)trackFramesReleased, (long long)sinkFramesWritten, drained);
Andy Hungcef2daa2018-06-01 15:31:49 -07002052 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08002053 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08002054 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08002055 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07002056
2057 // Compute latency info.
2058 const bool useTrackTimestamp = !drained;
2059 const double latencyMs = useTrackTimestamp
2060 ? local.getOutputServerLatencyMs(sampleRate())
2061 : timeStamp.getOutputServerLatencyMs(halSampleRate);
2062
2063 mServerLatencyFromTrack.store(useTrackTimestamp);
2064 mServerLatencyMs.store(latencyMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08002065
Andy Hung62921122020-05-18 10:47:31 -07002066 if (mLogStartCountdown > 0
2067 && local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0
2068 && local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] > 0)
2069 {
2070 if (mLogStartCountdown > 1) {
2071 --mLogStartCountdown;
2072 } else if (latencyMs < mLogLatencyMs) { // wait for latency to stabilize (dip)
2073 mLogStartCountdown = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002074 // startup is the difference in times for the current timestamp and our start
2075 double startUpMs =
Andy Hung62921122020-05-18 10:47:31 -07002076 (local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartTimeNs) * 1e-6;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002077 // adjust for frames played.
Andy Hung62921122020-05-18 10:47:31 -07002078 startUpMs -= (local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartFrames)
2079 * 1e3 / mSampleRate;
2080 ALOGV("%s: latencyMs:%lf startUpMs:%lf"
2081 " localTime:%lld startTime:%lld"
2082 " localPosition:%lld startPosition:%lld",
2083 __func__, latencyMs, startUpMs,
2084 (long long)local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08002085 (long long)mLogStartTimeNs,
Andy Hung62921122020-05-18 10:47:31 -07002086 (long long)local.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08002087 (long long)mLogStartFrames);
Andy Hungc2b11cb2020-04-22 09:04:01 -07002088 mTrackMetrics.logLatencyAndStartup(latencyMs, startUpMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08002089 }
Andy Hung62921122020-05-18 10:47:31 -07002090 mLogLatencyMs = latencyMs;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002091 }
Andy Hunge10393e2015-06-12 13:59:33 -07002092}
2093
Andy Hung3ff4b552023-06-26 19:20:57 -07002094bool Track::AudioVibrationController::setMute(bool muted) {
Andy Hung44f27182023-07-06 20:56:16 -07002095 const sp<IAfThreadBase> thread = mTrack->mThread.promote();
jiabin57303cc2018-12-18 15:45:57 -08002096 if (thread != 0) {
2097 // Lock for updating mHapticPlaybackEnabled.
Andy Hung87e82412023-08-29 14:26:09 -07002098 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07002099 auto* const playbackThread = thread->asIAfPlaybackThread().get();
jiabin57303cc2018-12-18 15:45:57 -08002100 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
Andy Hung44f27182023-07-06 20:56:16 -07002101 && playbackThread->hapticChannelCount() > 0) {
SPeak Shenc19aa9e2022-11-11 00:28:50 +08002102 ALOGD("%s, haptic playback was %s for track %d",
2103 __func__, muted ? "muted" : "unmuted", mTrack->id());
SPeak Shen0db56b32022-11-11 00:28:50 +08002104 mTrack->setHapticPlaybackEnabled(!muted);
2105 return true;
jiabin57303cc2018-12-18 15:45:57 -08002106 }
2107 }
SPeak Shen0db56b32022-11-11 00:28:50 +08002108 return false;
2109}
2110
Andy Hung3ff4b552023-06-26 19:20:57 -07002111binder::Status Track::AudioVibrationController::mute(
SPeak Shen0db56b32022-11-11 00:28:50 +08002112 /*out*/ bool *ret) {
2113 *ret = setMute(true);
jiabin57303cc2018-12-18 15:45:57 -08002114 return binder::Status::ok();
2115}
2116
Andy Hung3ff4b552023-06-26 19:20:57 -07002117binder::Status Track::AudioVibrationController::unmute(
jiabin57303cc2018-12-18 15:45:57 -08002118 /*out*/ bool *ret) {
SPeak Shen0db56b32022-11-11 00:28:50 +08002119 *ret = setMute(false);
jiabin57303cc2018-12-18 15:45:57 -08002120 return binder::Status::ok();
2121}
2122
Eric Laurent81784c32012-11-19 14:55:58 -08002123// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002124#undef LOG_TAG
2125#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002126
Andy Hung3ff4b552023-06-26 19:20:57 -07002127/* static */
Andy Hung44f27182023-07-06 20:56:16 -07002128sp<IAfOutputTrack> IAfOutputTrack::create(
2129 IAfPlaybackThread* playbackThread,
2130 IAfDuplicatingThread* sourceThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002131 uint32_t sampleRate,
2132 audio_format_t format,
2133 audio_channel_mask_t channelMask,
2134 size_t frameCount,
2135 const AttributionSourceState& attributionSource) {
2136 return sp<OutputTrack>::make(
Andy Hung44f27182023-07-06 20:56:16 -07002137 playbackThread,
2138 sourceThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002139 sampleRate,
2140 format,
2141 channelMask,
2142 frameCount,
2143 attributionSource);
2144}
2145
2146OutputTrack::OutputTrack(
Andy Hung44f27182023-07-06 20:56:16 -07002147 IAfPlaybackThread* playbackThread,
2148 IAfDuplicatingThread* sourceThread,
Eric Laurent81784c32012-11-19 14:55:58 -08002149 uint32_t sampleRate,
2150 audio_format_t format,
2151 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002152 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002153 const AttributionSourceState& attributionSource)
Eric Laurent223fd5c2014-11-11 13:43:36 -08002154 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002155 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002156 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002157 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002158 AUDIO_SESSION_NONE, getpid(), attributionSource, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08002159 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07002160 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08002161{
2162
2163 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08002164 mOutBuffer.frameCount = 0;
Andy Hung44f27182023-07-06 20:56:16 -07002165 playbackThread->addOutputTrack_l(this);
Andy Hung9d84af52018-09-12 18:03:44 -07002166 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002167 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07002168 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08002169 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08002170 // since client and server are in the same process,
2171 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07002172 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
2173 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07002174 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07002175 mClientProxy->setSendLevel(0.0);
2176 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08002177 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07002178 ALOGW("%s(%d): Error creating output track on thread %d",
2179 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08002180 }
2181}
2182
Andy Hung3ff4b552023-06-26 19:20:57 -07002183OutputTrack::~OutputTrack()
Eric Laurent81784c32012-11-19 14:55:58 -08002184{
2185 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08002186 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08002187}
2188
Andy Hung3ff4b552023-06-26 19:20:57 -07002189status_t OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002190 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002191{
2192 status_t status = Track::start(event, triggerSession);
2193 if (status != NO_ERROR) {
2194 return status;
2195 }
2196
2197 mActive = true;
2198 mRetryCount = 127;
2199 return status;
2200}
2201
Andy Hung3ff4b552023-06-26 19:20:57 -07002202void OutputTrack::stop()
Eric Laurent81784c32012-11-19 14:55:58 -08002203{
2204 Track::stop();
2205 clearBufferQueue();
2206 mOutBuffer.frameCount = 0;
2207 mActive = false;
2208}
2209
Andy Hung3ff4b552023-06-26 19:20:57 -07002210ssize_t OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08002211{
Eric Laurent19952e12023-04-20 10:08:29 +02002212 if (!mActive && frames != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07002213 const sp<IAfThreadBase> thread = mThread.promote();
Andy Hung4989d312023-06-29 21:19:25 -07002214 if (thread != nullptr && thread->inStandby()) {
Eric Laurent19952e12023-04-20 10:08:29 +02002215 // preload one silent buffer to trigger mixer on start()
2216 ClientProxy::Buffer buf { .mFrameCount = mClientProxy->getStartThresholdInFrames() };
2217 status_t status = mClientProxy->obtainBuffer(&buf);
2218 if (status != NO_ERROR && status != NOT_ENOUGH_DATA && status != WOULD_BLOCK) {
2219 ALOGE("%s(%d): could not obtain buffer on start", __func__, mId);
2220 return 0;
2221 }
2222 memset(buf.mRaw, 0, buf.mFrameCount * mFrameSize);
2223 mClientProxy->releaseBuffer(&buf);
2224
2225 (void) start();
2226
2227 // wait for HAL stream to start before sending actual audio. Doing this on each
2228 // OutputTrack makes that playback start on all output streams is synchronized.
2229 // If another OutputTrack has already started it can underrun but this is OK
2230 // as only silence has been played so far and the retry count is very high on
2231 // OutputTrack.
Andy Hung44f27182023-07-06 20:56:16 -07002232 auto* const pt = thread->asIAfPlaybackThread().get();
Eric Laurent19952e12023-04-20 10:08:29 +02002233 if (!pt->waitForHalStart()) {
2234 ALOGW("%s(%d): timeout waiting for thread to exit standby", __func__, mId);
2235 stop();
2236 return 0;
2237 }
2238
2239 // enqueue the first buffer and exit so that other OutputTracks will also start before
2240 // write() is called again and this buffer actually consumed.
2241 Buffer firstBuffer;
2242 firstBuffer.frameCount = frames;
2243 firstBuffer.raw = data;
2244 queueBuffer(firstBuffer);
2245 return frames;
2246 } else {
2247 (void) start();
2248 }
2249 }
2250
Eric Laurent81784c32012-11-19 14:55:58 -08002251 Buffer *pInBuffer;
2252 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08002253 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002254 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08002255 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
Eric Laurent81784c32012-11-19 14:55:58 -08002256 while (waitTimeLeftMs) {
2257 // First write pending buffers, then new data
2258 if (mBufferQueue.size()) {
2259 pInBuffer = mBufferQueue.itemAt(0);
2260 } else {
2261 pInBuffer = &inBuffer;
2262 }
2263
2264 if (pInBuffer->frameCount == 0) {
2265 break;
2266 }
2267
2268 if (mOutBuffer.frameCount == 0) {
2269 mOutBuffer.frameCount = pInBuffer->frameCount;
2270 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002271 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002272 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07002273 ALOGV("%s(%d): thread %d no more output buffers; status %d",
2274 __func__, mId,
2275 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08002276 break;
2277 }
2278 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
2279 if (waitTimeLeftMs >= waitTimeMs) {
2280 waitTimeLeftMs -= waitTimeMs;
2281 } else {
2282 waitTimeLeftMs = 0;
2283 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002284 if (status == NOT_ENOUGH_DATA) {
2285 restartIfDisabled();
2286 continue;
2287 }
Eric Laurent81784c32012-11-19 14:55:58 -08002288 }
2289
2290 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
2291 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002292 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002293 Proxy::Buffer buf;
2294 buf.mFrameCount = outFrames;
2295 buf.mRaw = NULL;
2296 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002297 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08002298 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002299 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002300 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002301 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002302
2303 if (pInBuffer->frameCount == 0) {
2304 if (mBufferQueue.size()) {
2305 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08002306 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07002307 if (pInBuffer != &inBuffer) {
2308 delete pInBuffer;
2309 }
Andy Hung9d84af52018-09-12 18:03:44 -07002310 ALOGV("%s(%d): thread %d released overflow buffer %zu",
2311 __func__, mId,
2312 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002313 } else {
2314 break;
2315 }
2316 }
2317 }
2318
2319 // If we could not write all frames, allocate a buffer and queue it for next time.
2320 if (inBuffer.frameCount) {
Andy Hung44f27182023-07-06 20:56:16 -07002321 const sp<IAfThreadBase> thread = mThread.promote();
Andy Hung4989d312023-06-29 21:19:25 -07002322 if (thread != nullptr && !thread->inStandby()) {
Eric Laurent19952e12023-04-20 10:08:29 +02002323 queueBuffer(inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002324 }
2325 }
2326
Andy Hungc25b84a2015-01-14 19:04:10 -08002327 // Calling write() with a 0 length buffer means that no more data will be written:
2328 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
2329 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
2330 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08002331 }
2332
Andy Hung1c86ebe2018-05-29 20:29:08 -07002333 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08002334}
2335
Andy Hung3ff4b552023-06-26 19:20:57 -07002336void OutputTrack::queueBuffer(Buffer& inBuffer) {
Eric Laurent19952e12023-04-20 10:08:29 +02002337
2338 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
2339 Buffer *pInBuffer = new Buffer;
2340 const size_t bufferSize = inBuffer.frameCount * mFrameSize;
2341 pInBuffer->mBuffer = malloc(bufferSize);
2342 LOG_ALWAYS_FATAL_IF(pInBuffer->mBuffer == nullptr,
2343 "%s: Unable to malloc size %zu", __func__, bufferSize);
2344 pInBuffer->frameCount = inBuffer.frameCount;
2345 pInBuffer->raw = pInBuffer->mBuffer;
2346 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
2347 mBufferQueue.add(pInBuffer);
2348 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
2349 (int)mThreadIoHandle, mBufferQueue.size());
2350 // audio data is consumed (stored locally); set frameCount to 0.
2351 inBuffer.frameCount = 0;
2352 } else {
2353 ALOGW("%s(%d): thread %d no more overflow buffers",
2354 __func__, mId, (int)mThreadIoHandle);
2355 // TODO: return error for this.
2356 }
2357}
2358
Andy Hung3ff4b552023-06-26 19:20:57 -07002359void OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
Kevin Rocard12381092018-04-11 09:19:59 -07002360{
Andy Hung87e82412023-08-29 14:26:09 -07002361 audio_utils::lock_guard lock(trackMetadataMutex());
Kevin Rocard12381092018-04-11 09:19:59 -07002362 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
2363}
2364
Andy Hung3ff4b552023-06-26 19:20:57 -07002365void OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
Kevin Rocard12381092018-04-11 09:19:59 -07002366 {
Andy Hung87e82412023-08-29 14:26:09 -07002367 audio_utils::lock_guard lock(trackMetadataMutex());
Kevin Rocard12381092018-04-11 09:19:59 -07002368 mTrackMetadatas = metadatas;
2369 }
2370 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
2371 setMetadataHasChanged();
2372}
2373
Andy Hung3ff4b552023-06-26 19:20:57 -07002374status_t OutputTrack::obtainBuffer(
Eric Laurent81784c32012-11-19 14:55:58 -08002375 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
2376{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002377 ClientProxy::Buffer buf;
2378 buf.mFrameCount = buffer->frameCount;
2379 struct timespec timeout;
2380 timeout.tv_sec = waitTimeMs / 1000;
2381 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
2382 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
2383 buffer->frameCount = buf.mFrameCount;
2384 buffer->raw = buf.mRaw;
2385 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002386}
2387
Andy Hung3ff4b552023-06-26 19:20:57 -07002388void OutputTrack::clearBufferQueue()
Eric Laurent81784c32012-11-19 14:55:58 -08002389{
2390 size_t size = mBufferQueue.size();
2391
2392 for (size_t i = 0; i < size; i++) {
2393 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08002394 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002395 delete pBuffer;
2396 }
2397 mBufferQueue.clear();
2398}
2399
Andy Hung3ff4b552023-06-26 19:20:57 -07002400void OutputTrack::restartIfDisabled()
Eric Laurent4d231dc2016-03-11 18:38:23 -08002401{
2402 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2403 if (mActive && (flags & CBLK_DISABLED)) {
2404 start();
2405 }
2406}
Eric Laurent81784c32012-11-19 14:55:58 -08002407
Andy Hung9d84af52018-09-12 18:03:44 -07002408// ----------------------------------------------------------------------------
2409#undef LOG_TAG
2410#define LOG_TAG "AF::PatchTrack"
2411
Andy Hung3ff4b552023-06-26 19:20:57 -07002412/* static */
2413sp<IAfPatchTrack> IAfPatchTrack::create(
Andy Hung44f27182023-07-06 20:56:16 -07002414 IAfPlaybackThread* playbackThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002415 audio_stream_type_t streamType,
2416 uint32_t sampleRate,
2417 audio_channel_mask_t channelMask,
2418 audio_format_t format,
2419 size_t frameCount,
2420 void* buffer,
2421 size_t bufferSize,
2422 audio_output_flags_t flags,
2423 const Timeout& timeout,
2424 size_t frameCountToBeReady /** Default behaviour is to start
2425 * as soon as possible to have
2426 * the lowest possible latency
2427 * even if it might glitch. */)
2428{
2429 return sp<PatchTrack>::make(
Andy Hung44f27182023-07-06 20:56:16 -07002430 playbackThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002431 streamType,
2432 sampleRate,
2433 channelMask,
2434 format,
2435 frameCount,
2436 buffer,
2437 bufferSize,
2438 flags,
2439 timeout,
2440 frameCountToBeReady);
2441}
2442
Andy Hung44f27182023-07-06 20:56:16 -07002443PatchTrack::PatchTrack(IAfPlaybackThread* playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07002444 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07002445 uint32_t sampleRate,
2446 audio_channel_mask_t channelMask,
2447 audio_format_t format,
2448 size_t frameCount,
2449 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002450 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002451 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002452 const Timeout& timeout,
2453 size_t frameCountToBeReady)
Eric Laurent3bcf8592015-04-03 12:13:24 -07002454 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002455 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002456 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002457 buffer, bufferSize, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002458 AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002459 TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
gaoxiupei8e3a5682023-07-07 20:30:23 +08002460 PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true)
2461 : nullptr,
Andy Hung837229a2023-07-14 16:57:01 -07002462 playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002463{
Andy Hung9d84af52018-09-12 18:03:44 -07002464 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2465 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002466 (int)mPeerTimeout.tv_sec,
2467 (int)(mPeerTimeout.tv_nsec / 1000000));
2468}
2469
Andy Hung3ff4b552023-06-26 19:20:57 -07002470PatchTrack::~PatchTrack()
Eric Laurent83b88082014-06-20 18:31:16 -07002471{
Andy Hungabfab202019-03-07 19:45:54 -08002472 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002473}
2474
Andy Hung3ff4b552023-06-26 19:20:57 -07002475size_t PatchTrack::framesReady() const
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002476{
2477 if (mPeerProxy && mPeerProxy->producesBufferOnDemand()) {
2478 return std::numeric_limits<size_t>::max();
2479 } else {
2480 return Track::framesReady();
2481 }
2482}
2483
Andy Hung3ff4b552023-06-26 19:20:57 -07002484status_t PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002485 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08002486{
2487 status_t status = Track::start(event, triggerSession);
2488 if (status != NO_ERROR) {
2489 return status;
2490 }
2491 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2492 return status;
2493}
2494
Eric Laurent83b88082014-06-20 18:31:16 -07002495// AudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07002496status_t PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002497 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002498{
Andy Hung9d84af52018-09-12 18:03:44 -07002499 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002500 Proxy::Buffer buf;
2501 buf.mFrameCount = buffer->frameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002502 if (ATRACE_ENABLED()) {
2503 std::string traceName("PTnReq");
2504 traceName += std::to_string(id());
2505 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2506 }
Eric Laurent83b88082014-06-20 18:31:16 -07002507 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07002508 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002509 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002510 if (ATRACE_ENABLED()) {
2511 std::string traceName("PTnObt");
2512 traceName += std::to_string(id());
2513 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2514 }
Eric Laurent83b88082014-06-20 18:31:16 -07002515 if (buf.mFrameCount == 0) {
2516 return WOULD_BLOCK;
2517 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002518 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002519 return status;
2520}
2521
Andy Hung3ff4b552023-06-26 19:20:57 -07002522void PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002523{
Andy Hung9d84af52018-09-12 18:03:44 -07002524 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002525 Proxy::Buffer buf;
2526 buf.mFrameCount = buffer->frameCount;
2527 buf.mRaw = buffer->raw;
2528 mPeerProxy->releaseBuffer(&buf);
Andy Hung71ba4b32022-10-06 12:09:49 -07002529 TrackBase::releaseBuffer(buffer); // Note: this is the base class.
Eric Laurent83b88082014-06-20 18:31:16 -07002530}
2531
Andy Hung3ff4b552023-06-26 19:20:57 -07002532status_t PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
Eric Laurent83b88082014-06-20 18:31:16 -07002533 const struct timespec *timeOut)
2534{
Eric Laurent4d231dc2016-03-11 18:38:23 -08002535 status_t status = NO_ERROR;
2536 static const int32_t kMaxTries = 5;
2537 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07002538 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08002539 do {
2540 if (status == NOT_ENOUGH_DATA) {
2541 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07002542 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08002543 }
2544 status = mProxy->obtainBuffer(buffer, timeOut);
2545 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
2546 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07002547}
2548
Andy Hung3ff4b552023-06-26 19:20:57 -07002549void PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002550{
2551 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002552 restartIfDisabled();
naoki miyazuf37f9982019-11-28 11:18:18 +09002553
2554 // Check if the PatchTrack has enough data to write once in releaseBuffer().
2555 // If not, prevent an underrun from occurring by moving the track into FS_FILLING;
2556 // this logic avoids glitches when suspending A2DP with AudioPlaybackCapture.
2557 // TODO: perhaps underrun avoidance could be a track property checked in isReady() instead.
Andy Hung3ff4b552023-06-26 19:20:57 -07002558 if (mFillingStatus == FS_ACTIVE
naoki miyazuf37f9982019-11-28 11:18:18 +09002559 && audio_is_linear_pcm(mFormat)
2560 && !isOffloadedOrDirect()) {
Andy Hung44f27182023-07-06 20:56:16 -07002561 if (const sp<IAfThreadBase> thread = mThread.promote();
naoki miyazuf37f9982019-11-28 11:18:18 +09002562 thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07002563 auto* const playbackThread = thread->asIAfPlaybackThread().get();
naoki miyazuf37f9982019-11-28 11:18:18 +09002564 const size_t frameCount = playbackThread->frameCount() * sampleRate()
2565 / playbackThread->sampleRate();
2566 if (framesReady() < frameCount) {
2567 ALOGD("%s(%d) Not enough data, wait for buffer to fill", __func__, mId);
Andy Hung3ff4b552023-06-26 19:20:57 -07002568 mFillingStatus = FS_FILLING;
naoki miyazuf37f9982019-11-28 11:18:18 +09002569 }
2570 }
2571 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002572}
2573
Andy Hung3ff4b552023-06-26 19:20:57 -07002574void PatchTrack::restartIfDisabled()
Eric Laurent4d231dc2016-03-11 18:38:23 -08002575{
Eric Laurent83b88082014-06-20 18:31:16 -07002576 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07002577 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002578 start();
2579 }
Eric Laurent83b88082014-06-20 18:31:16 -07002580}
2581
Eric Laurent81784c32012-11-19 14:55:58 -08002582// ----------------------------------------------------------------------------
2583// Record
2584// ----------------------------------------------------------------------------
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002585
2586
Andy Hung9d84af52018-09-12 18:03:44 -07002587#undef LOG_TAG
2588#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08002589
Andy Hungaaa18282023-06-23 19:27:19 -07002590class RecordHandle : public android::media::BnAudioRecord {
2591public:
Andy Hung02a6c4e2023-06-23 19:27:19 -07002592 explicit RecordHandle(const sp<IAfRecordTrack>& recordTrack);
Andy Hungaaa18282023-06-23 19:27:19 -07002593 ~RecordHandle() override;
2594 binder::Status start(int /*AudioSystem::sync_event_t*/ event,
2595 int /*audio_session_t*/ triggerSession) final;
2596 binder::Status stop() final;
2597 binder::Status getActiveMicrophones(
2598 std::vector<media::MicrophoneInfoFw>* activeMicrophones) final;
2599 binder::Status setPreferredMicrophoneDirection(
2600 int /*audio_microphone_direction_t*/ direction) final;
2601 binder::Status setPreferredMicrophoneFieldDimension(float zoom) final;
2602 binder::Status shareAudioHistory(
2603 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) final;
2604
2605private:
Andy Hung02a6c4e2023-06-23 19:27:19 -07002606 const sp<IAfRecordTrack> mRecordTrack;
Andy Hungaaa18282023-06-23 19:27:19 -07002607
2608 // for use from destructor
2609 void stop_nonvirtual();
2610};
2611
2612/* static */
Andy Hung02a6c4e2023-06-23 19:27:19 -07002613sp<media::IAudioRecord> IAfRecordTrack::createIAudioRecordAdapter(
2614 const sp<IAfRecordTrack>& recordTrack) {
Andy Hungaaa18282023-06-23 19:27:19 -07002615 return sp<RecordHandle>::make(recordTrack);
2616}
2617
2618RecordHandle::RecordHandle(
Andy Hung02a6c4e2023-06-23 19:27:19 -07002619 const sp<IAfRecordTrack>& recordTrack)
Eric Laurent81784c32012-11-19 14:55:58 -08002620 : BnAudioRecord(),
2621 mRecordTrack(recordTrack)
2622{
Andy Hung225aef62022-12-06 16:33:20 -08002623 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08002624}
2625
Andy Hungaaa18282023-06-23 19:27:19 -07002626RecordHandle::~RecordHandle() {
Eric Laurent81784c32012-11-19 14:55:58 -08002627 stop_nonvirtual();
2628 mRecordTrack->destroy();
2629}
2630
Andy Hungaaa18282023-06-23 19:27:19 -07002631binder::Status RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002632 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07002633 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002634 return binderStatusFromStatusT(
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002635 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08002636}
2637
Andy Hungaaa18282023-06-23 19:27:19 -07002638binder::Status RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08002639 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002640 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08002641}
2642
Andy Hungaaa18282023-06-23 19:27:19 -07002643void RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07002644 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08002645 mRecordTrack->stop();
2646}
2647
Andy Hungaaa18282023-06-23 19:27:19 -07002648binder::Status RecordHandle::getActiveMicrophones(
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08002649 std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07002650 ALOGV("%s()", __func__);
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08002651 return binderStatusFromStatusT(mRecordTrack->getActiveMicrophones(activeMicrophones));
jiabin653cc0a2018-01-17 17:54:10 -08002652}
2653
Andy Hungaaa18282023-06-23 19:27:19 -07002654binder::Status RecordHandle::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002655 int /*audio_microphone_direction_t*/ direction) {
2656 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002657 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002658 static_cast<audio_microphone_direction_t>(direction)));
2659}
2660
Andy Hungaaa18282023-06-23 19:27:19 -07002661binder::Status RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002662 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002663 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
Paul McLean03a6e6a2018-12-04 10:54:13 -07002664}
2665
Andy Hungaaa18282023-06-23 19:27:19 -07002666binder::Status RecordHandle::shareAudioHistory(
Eric Laurentec376dc2021-04-08 20:41:22 +02002667 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2668 return binderStatusFromStatusT(
2669 mRecordTrack->shareAudioHistory(sharedAudioPackageName, sharedAudioStartMs));
2670}
2671
Eric Laurent81784c32012-11-19 14:55:58 -08002672// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002673#undef LOG_TAG
2674#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002675
Andy Hung3ff4b552023-06-26 19:20:57 -07002676
Andy Hung56126702023-07-14 11:00:08 -07002677/* static */
Andy Hung44f27182023-07-06 20:56:16 -07002678sp<IAfRecordTrack> IAfRecordTrack::create(IAfRecordThread* thread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002679 const sp<Client>& client,
2680 const audio_attributes_t& attr,
2681 uint32_t sampleRate,
2682 audio_format_t format,
2683 audio_channel_mask_t channelMask,
2684 size_t frameCount,
2685 void* buffer,
2686 size_t bufferSize,
2687 audio_session_t sessionId,
2688 pid_t creatorPid,
2689 const AttributionSourceState& attributionSource,
2690 audio_input_flags_t flags,
2691 track_type type,
2692 audio_port_handle_t portId,
2693 int32_t startFrames)
2694{
2695 return sp<RecordTrack>::make(
Andy Hung44f27182023-07-06 20:56:16 -07002696 thread,
Andy Hung3ff4b552023-06-26 19:20:57 -07002697 client,
2698 attr,
2699 sampleRate,
2700 format,
2701 channelMask,
2702 frameCount,
2703 buffer,
2704 bufferSize,
2705 sessionId,
2706 creatorPid,
2707 attributionSource,
2708 flags,
2709 type,
2710 portId,
2711 startFrames);
2712}
2713
Glenn Kasten05997e22014-03-13 15:08:33 -07002714// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Andy Hung3ff4b552023-06-26 19:20:57 -07002715RecordTrack::RecordTrack(
Andy Hung44f27182023-07-06 20:56:16 -07002716 IAfRecordThread* thread,
Eric Laurent81784c32012-11-19 14:55:58 -08002717 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002718 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08002719 uint32_t sampleRate,
2720 audio_format_t format,
2721 audio_channel_mask_t channelMask,
2722 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07002723 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002724 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08002725 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002726 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002727 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07002728 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002729 track_type type,
Eric Laurentec376dc2021-04-08 20:41:22 +02002730 audio_port_handle_t portId,
Eric Laurent2407ce32021-04-26 14:56:03 +02002731 int32_t startFrames)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002732 : TrackBase(thread, client, attr, sampleRate, format,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002733 channelMask, frameCount, buffer, bufferSize, sessionId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002734 creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002735 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002736 false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07002737 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07002738 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07002739 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Andy Hungb68f5eb2019-12-03 16:49:17 -08002740 type, portId,
2741 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD) + std::to_string(portId)),
Andy Hung97a893e2015-03-29 01:03:07 -07002742 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07002743 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07002744 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07002745 mFlags(flags),
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002746 mSilenced(false),
Eric Laurent2407ce32021-04-26 14:56:03 +02002747 mStartFrames(startFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002748{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07002749 if (mCblk == NULL) {
2750 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002751 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002752
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002753 if (!isDirect()) {
2754 mRecordBufferConverter = new RecordBufferConverter(
Andy Hung44f27182023-07-06 20:56:16 -07002755 thread->channelMask(), thread->format(), thread->sampleRate(),
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002756 channelMask, format, sampleRate);
2757 // Check if the RecordBufferConverter construction was successful.
2758 // If not, don't continue with construction.
2759 //
2760 // NOTE: It would be extremely rare that the record track cannot be created
2761 // for the current device, but a pending or future device change would make
2762 // the record track configuration valid.
2763 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07002764 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002765 return;
2766 }
Andy Hung97a893e2015-03-29 01:03:07 -07002767 }
2768
Andy Hung6ae58432016-02-16 18:32:24 -08002769 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08002770 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08002771
Andy Hung97a893e2015-03-29 01:03:07 -07002772 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002773
Eric Laurent05067782016-06-01 18:27:28 -07002774 if (flags & AUDIO_INPUT_FLAG_FAST) {
Andy Hung44f27182023-07-06 20:56:16 -07002775 ALOG_ASSERT(thread->fastTrackAvailable());
2776 thread->setFastTrackAvailable(false);
Andy Hung000adb52018-06-01 15:43:26 -07002777 } else {
2778 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07002779 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002780 }
Andy Hung8946a282018-04-19 20:04:56 -07002781#ifdef TEE_SINK
2782 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
2783 + "_" + std::to_string(mId)
2784 + "_R");
2785#endif
Andy Hungb68f5eb2019-12-03 16:49:17 -08002786
2787 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07002788 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent81784c32012-11-19 14:55:58 -08002789}
2790
Andy Hung3ff4b552023-06-26 19:20:57 -07002791RecordTrack::~RecordTrack()
Eric Laurent81784c32012-11-19 14:55:58 -08002792{
Andy Hung9d84af52018-09-12 18:03:44 -07002793 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002794 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002795 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002796}
2797
Andy Hung3ff4b552023-06-26 19:20:57 -07002798status_t RecordTrack::initCheck() const
Andy Hung97a893e2015-03-29 01:03:07 -07002799{
2800 status_t status = TrackBase::initCheck();
2801 if (status == NO_ERROR && mServerProxy == 0) {
2802 status = BAD_VALUE;
2803 }
2804 return status;
2805}
2806
Eric Laurent81784c32012-11-19 14:55:58 -08002807// AudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07002808status_t RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08002809{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002810 ServerProxy::Buffer buf;
2811 buf.mFrameCount = buffer->frameCount;
2812 status_t status = mServerProxy->obtainBuffer(&buf);
2813 buffer->frameCount = buf.mFrameCount;
2814 buffer->raw = buf.mRaw;
2815 if (buf.mFrameCount == 0) {
2816 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002817 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002818 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002819 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002820}
2821
Andy Hung3ff4b552023-06-26 19:20:57 -07002822status_t RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002823 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002824{
Andy Hung44f27182023-07-06 20:56:16 -07002825 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08002826 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07002827 auto* const recordThread = thread->asIAfRecordThread().get();
Eric Laurent81784c32012-11-19 14:55:58 -08002828 return recordThread->start(this, event, triggerSession);
2829 } else {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002830 ALOGW("%s track %d: thread was destroyed", __func__, portId());
2831 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08002832 }
2833}
2834
Andy Hung3ff4b552023-06-26 19:20:57 -07002835void RecordTrack::stop()
Eric Laurent81784c32012-11-19 14:55:58 -08002836{
Andy Hung44f27182023-07-06 20:56:16 -07002837 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08002838 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07002839 auto* const recordThread = thread->asIAfRecordThread().get();
Eric Laurent83b88082014-06-20 18:31:16 -07002840 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08002841 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002842 }
2843 }
2844}
2845
Andy Hung3ff4b552023-06-26 19:20:57 -07002846void RecordTrack::destroy()
Eric Laurent81784c32012-11-19 14:55:58 -08002847{
Andy Hung3ff4b552023-06-26 19:20:57 -07002848 // see comments at Track::destroy()
Eric Laurent81784c32012-11-19 14:55:58 -08002849 sp<RecordTrack> keep(this);
2850 {
Andy Hungce685402018-10-05 17:23:27 -07002851 track_state priorState = mState;
Andy Hung44f27182023-07-06 20:56:16 -07002852 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08002853 if (thread != 0) {
Andy Hung87e82412023-08-29 14:26:09 -07002854 audio_utils::lock_guard _l(thread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07002855 auto* const recordThread = thread->asIAfRecordThread().get();
Andy Hungce685402018-10-05 17:23:27 -07002856 priorState = mState;
Eric Laurentec376dc2021-04-08 20:41:22 +02002857 if (!mSharedAudioPackageName.empty()) {
Eric Laurent92d0a322021-07-16 15:32:33 +02002858 recordThread->resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002859 }
Andy Hungce685402018-10-05 17:23:27 -07002860 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
2861 }
2862 // APM portid/client management done outside of lock.
2863 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
2864 if (isExternalTrack()) {
2865 switch (priorState) {
2866 case ACTIVE: // invalidated while still active
2867 case STARTING_2: // invalidated/start-aborted after startInput successfully called
2868 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
2869 AudioSystem::stopInput(mPortId);
2870 break;
2871
2872 case STARTING_1: // invalidated/start-aborted and startInput not successful
2873 case PAUSED: // OK, not active
2874 case IDLE: // OK, not active
2875 break;
2876
2877 case STOPPED: // unexpected (destroyed)
2878 default:
2879 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
2880 }
2881 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002882 }
2883 }
2884}
2885
Andy Hung3ff4b552023-06-26 19:20:57 -07002886void RecordTrack::invalidate()
Eric Laurent9a54bc22013-09-09 09:08:44 -07002887{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002888 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07002889 // FIXME should use proxy, and needs work
2890 audio_track_cblk_t* cblk = mCblk;
2891 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2892 android_atomic_release_store(0x40000000, &cblk->mFutex);
2893 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002894 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002895}
2896
Eric Laurent81784c32012-11-19 14:55:58 -08002897
Andy Hung3ff4b552023-06-26 19:20:57 -07002898void RecordTrack::appendDumpHeader(String8& result) const
Eric Laurent81784c32012-11-19 14:55:58 -08002899{
Eric Laurent973db022018-11-20 14:54:31 -08002900 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07002901 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002902 " Server FrmCnt FrmRdy Sil%s\n",
2903 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08002904}
2905
Andy Hung3ff4b552023-06-26 19:20:57 -07002906void RecordTrack::appendDump(String8& result, bool active) const
Eric Laurent81784c32012-11-19 14:55:58 -08002907{
Eric Laurent973db022018-11-20 14:54:31 -08002908 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002909 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002910 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002911 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002912 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002913 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002914 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002915 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002916 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08002917 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002918 mCblk->mFlags,
2919
Eric Laurent81784c32012-11-19 14:55:58 -08002920 mFormat,
2921 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002922 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002923 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002924
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002925 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002926 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002927 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002928 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002929 );
Andy Hung000adb52018-06-01 15:43:26 -07002930 if (isServerLatencySupported()) {
2931 double latencyMs;
2932 bool fromTrack;
2933 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2934 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2935 // or 'k' if estimated from kernel (usually for debugging).
2936 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2937 } else {
2938 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2939 }
2940 }
2941 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002942}
2943
Andy Hung93bb5732023-05-04 21:16:34 -07002944// This is invoked by SyncEvent callback.
Andy Hung3ff4b552023-06-26 19:20:57 -07002945void RecordTrack::handleSyncStartEvent(
Andy Hung068e08e2023-05-15 19:02:55 -07002946 const sp<audioflinger::SyncEvent>& event)
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002947{
Andy Hung93bb5732023-05-04 21:16:34 -07002948 size_t framesToDrop = 0;
Andy Hung44f27182023-07-06 20:56:16 -07002949 const sp<IAfThreadBase> threadBase = mThread.promote();
Andy Hung93bb5732023-05-04 21:16:34 -07002950 if (threadBase != 0) {
2951 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2952 // from audio HAL
Andy Hung44f27182023-07-06 20:56:16 -07002953 framesToDrop = threadBase->frameCount() * 2;
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002954 }
Andy Hung93bb5732023-05-04 21:16:34 -07002955
2956 mSynchronizedRecordState.onPlaybackFinished(event, framesToDrop);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002957}
2958
Andy Hung3ff4b552023-06-26 19:20:57 -07002959void RecordTrack::clearSyncStartEvent()
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002960{
Andy Hung93bb5732023-05-04 21:16:34 -07002961 mSynchronizedRecordState.clear();
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002962}
2963
Andy Hung3ff4b552023-06-26 19:20:57 -07002964void RecordTrack::updateTrackFrameInfo(
Andy Hung3f0c9022016-01-15 17:49:46 -08002965 int64_t trackFramesReleased, int64_t sourceFramesRead,
2966 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2967{
Andy Hung30282562018-08-08 18:27:03 -07002968 // Make the kernel frametime available.
2969 const FrameTime ft{
2970 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2971 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2972 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2973 mKernelFrameTime.store(ft);
2974 if (!audio_is_linear_pcm(mFormat)) {
Atneya Nair497fff12022-01-18 16:23:04 -05002975 // Stream is direct, return provided timestamp with no conversion
2976 mServerProxy->setTimestamp(timestamp);
Andy Hung30282562018-08-08 18:27:03 -07002977 return;
2978 }
2979
Andy Hung3f0c9022016-01-15 17:49:46 -08002980 ExtendedTimestamp local = timestamp;
2981
2982 // Convert HAL frames to server-side track frames at track sample rate.
2983 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2984 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2985 if (local.mTimeNs[i] != 0) {
2986 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2987 const int64_t relativeTrackFrames = relativeServerFrames
2988 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2989 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2990 }
2991 }
Andy Hung6ae58432016-02-16 18:32:24 -08002992 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002993
2994 // Compute latency info.
2995 const bool useTrackTimestamp = true; // use track unless debugging.
2996 const double latencyMs = - (useTrackTimestamp
2997 ? local.getOutputServerLatencyMs(sampleRate())
2998 : timestamp.getOutputServerLatencyMs(halSampleRate));
2999
3000 mServerLatencyFromTrack.store(useTrackTimestamp);
3001 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08003002}
Eric Laurent83b88082014-06-20 18:31:16 -07003003
Andy Hung3ff4b552023-06-26 19:20:57 -07003004status_t RecordTrack::getActiveMicrophones(
Andy Hung02a6c4e2023-06-23 19:27:19 -07003005 std::vector<media::MicrophoneInfoFw>* activeMicrophones) const
jiabin653cc0a2018-01-17 17:54:10 -08003006{
Andy Hung44f27182023-07-06 20:56:16 -07003007 const sp<IAfThreadBase> thread = mThread.promote();
jiabin653cc0a2018-01-17 17:54:10 -08003008 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07003009 auto* const recordThread = thread->asIAfRecordThread().get();
jiabin653cc0a2018-01-17 17:54:10 -08003010 return recordThread->getActiveMicrophones(activeMicrophones);
3011 } else {
3012 return BAD_VALUE;
3013 }
3014}
3015
Andy Hung3ff4b552023-06-26 19:20:57 -07003016status_t RecordTrack::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07003017 audio_microphone_direction_t direction) {
Andy Hung44f27182023-07-06 20:56:16 -07003018 const sp<IAfThreadBase> thread = mThread.promote();
Paul McLean03a6e6a2018-12-04 10:54:13 -07003019 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07003020 auto* const recordThread = thread->asIAfRecordThread().get();
Paul McLean12340082019-03-19 09:35:05 -06003021 return recordThread->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07003022 } else {
3023 return BAD_VALUE;
3024 }
3025}
3026
Andy Hung3ff4b552023-06-26 19:20:57 -07003027status_t RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
Andy Hung44f27182023-07-06 20:56:16 -07003028 const sp<IAfThreadBase> thread = mThread.promote();
Paul McLean03a6e6a2018-12-04 10:54:13 -07003029 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07003030 auto* const recordThread = thread->asIAfRecordThread().get();
Paul McLean12340082019-03-19 09:35:05 -06003031 return recordThread->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07003032 } else {
3033 return BAD_VALUE;
3034 }
3035}
3036
Andy Hung3ff4b552023-06-26 19:20:57 -07003037status_t RecordTrack::shareAudioHistory(
Eric Laurentec376dc2021-04-08 20:41:22 +02003038 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
3039
3040 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
3041 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
3042 if (callingUid != mUid || callingPid != mCreatorPid) {
3043 return PERMISSION_DENIED;
3044 }
3045
Svet Ganov33761132021-05-13 22:51:08 +00003046 AttributionSourceState attributionSource{};
3047 attributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
3048 attributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
3049 attributionSource.token = sp<BBinder>::make();
3050 if (!captureHotwordAllowed(attributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02003051 return PERMISSION_DENIED;
3052 }
3053
Andy Hung44f27182023-07-06 20:56:16 -07003054 const sp<IAfThreadBase> thread = mThread.promote();
Eric Laurentec376dc2021-04-08 20:41:22 +02003055 if (thread != 0) {
Andy Hung44f27182023-07-06 20:56:16 -07003056 auto* const recordThread = thread->asIAfRecordThread().get();
Eric Laurentec376dc2021-04-08 20:41:22 +02003057 status_t status = recordThread->shareAudioHistory(
3058 sharedAudioPackageName, mSessionId, sharedAudioStartMs);
3059 if (status == NO_ERROR) {
3060 mSharedAudioPackageName = sharedAudioPackageName;
3061 }
3062 return status;
3063 } else {
3064 return BAD_VALUE;
3065 }
3066}
3067
Andy Hung3ff4b552023-06-26 19:20:57 -07003068void RecordTrack::copyMetadataTo(MetadataInserter& backInserter) const
Eric Laurent78b07302022-10-07 16:20:34 +02003069{
3070
3071 // Do not forward PatchRecord metadata with unspecified audio source
3072 if (mAttr.source == AUDIO_SOURCE_DEFAULT) {
3073 return;
3074 }
3075
3076 // No track is invalid as this is called after prepareTrack_l in the same critical section
3077 record_track_metadata_v7_t metadata;
3078 metadata.base = {
3079 .source = mAttr.source,
3080 .gain = 1, // capture tracks do not have volumes
3081 };
3082 metadata.channel_mask = mChannelMask;
3083 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
3084
3085 *backInserter++ = metadata;
3086}
Eric Laurentec376dc2021-04-08 20:41:22 +02003087
Andy Hung9d84af52018-09-12 18:03:44 -07003088// ----------------------------------------------------------------------------
3089#undef LOG_TAG
3090#define LOG_TAG "AF::PatchRecord"
3091
Andy Hung3ff4b552023-06-26 19:20:57 -07003092/* static */
3093sp<IAfPatchRecord> IAfPatchRecord::create(
Andy Hung44f27182023-07-06 20:56:16 -07003094 IAfRecordThread* recordThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003095 uint32_t sampleRate,
3096 audio_channel_mask_t channelMask,
3097 audio_format_t format,
3098 size_t frameCount,
3099 void *buffer,
3100 size_t bufferSize,
3101 audio_input_flags_t flags,
3102 const Timeout& timeout,
3103 audio_source_t source)
3104{
3105 return sp<PatchRecord>::make(
Andy Hung44f27182023-07-06 20:56:16 -07003106 recordThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003107 sampleRate,
3108 channelMask,
3109 format,
3110 frameCount,
3111 buffer,
3112 bufferSize,
3113 flags,
3114 timeout,
3115 source);
3116}
3117
Andy Hung44f27182023-07-06 20:56:16 -07003118PatchRecord::PatchRecord(IAfRecordThread* recordThread,
Eric Laurent83b88082014-06-20 18:31:16 -07003119 uint32_t sampleRate,
3120 audio_channel_mask_t channelMask,
3121 audio_format_t format,
3122 size_t frameCount,
3123 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07003124 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08003125 audio_input_flags_t flags,
Eric Laurent78b07302022-10-07 16:20:34 +02003126 const Timeout& timeout,
3127 audio_source_t source)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003128 : RecordTrack(recordThread, NULL,
Eric Laurent78b07302022-10-07 16:20:34 +02003129 audio_attributes_t{ .source = source } ,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003130 sampleRate, format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003131 buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
Svet Ganov33761132021-05-13 22:51:08 +00003132 audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
gaoxiupei8e3a5682023-07-07 20:30:23 +08003133 PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true)
3134 : nullptr,
Andy Hung837229a2023-07-14 16:57:01 -07003135 recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07003136{
Andy Hung9d84af52018-09-12 18:03:44 -07003137 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
3138 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07003139 (int)mPeerTimeout.tv_sec,
3140 (int)(mPeerTimeout.tv_nsec / 1000000));
3141}
3142
Andy Hung3ff4b552023-06-26 19:20:57 -07003143PatchRecord::~PatchRecord()
Eric Laurent83b88082014-06-20 18:31:16 -07003144{
Andy Hungabfab202019-03-07 19:45:54 -08003145 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07003146}
3147
Mikhail Naganov8296c252019-09-25 14:59:54 -07003148static size_t writeFramesHelper(
3149 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
3150{
3151 AudioBufferProvider::Buffer patchBuffer;
3152 patchBuffer.frameCount = frameCount;
3153 auto status = dest->getNextBuffer(&patchBuffer);
3154 if (status != NO_ERROR) {
3155 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
3156 __func__, status, strerror(-status));
3157 return 0;
3158 }
3159 ALOG_ASSERT(patchBuffer.frameCount <= frameCount);
3160 memcpy(patchBuffer.raw, src, patchBuffer.frameCount * frameSize);
3161 size_t framesWritten = patchBuffer.frameCount;
3162 dest->releaseBuffer(&patchBuffer);
3163 return framesWritten;
3164}
3165
3166// static
Andy Hung3ff4b552023-06-26 19:20:57 -07003167size_t PatchRecord::writeFrames(
Mikhail Naganov8296c252019-09-25 14:59:54 -07003168 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
3169{
3170 size_t framesWritten = writeFramesHelper(dest, src, frameCount, frameSize);
3171 // On buffer wrap, the buffer frame count will be less than requested,
3172 // when this happens a second buffer needs to be used to write the leftover audio
3173 const size_t framesLeft = frameCount - framesWritten;
3174 if (framesWritten != 0 && framesLeft != 0) {
3175 framesWritten += writeFramesHelper(dest, (const char*)src + framesWritten * frameSize,
3176 framesLeft, frameSize);
3177 }
3178 return framesWritten;
3179}
3180
Eric Laurent83b88082014-06-20 18:31:16 -07003181// AudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07003182status_t PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08003183 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07003184{
Andy Hung9d84af52018-09-12 18:03:44 -07003185 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07003186 Proxy::Buffer buf;
3187 buf.mFrameCount = buffer->frameCount;
3188 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
3189 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07003190 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07003191 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07003192 if (ATRACE_ENABLED()) {
3193 std::string traceName("PRnObt");
3194 traceName += std::to_string(id());
3195 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
3196 }
Eric Laurent83b88082014-06-20 18:31:16 -07003197 if (buf.mFrameCount == 0) {
3198 return WOULD_BLOCK;
3199 }
Glenn Kastend79072e2016-01-06 08:41:20 -08003200 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07003201 return status;
3202}
3203
Andy Hung3ff4b552023-06-26 19:20:57 -07003204void PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07003205{
Andy Hung9d84af52018-09-12 18:03:44 -07003206 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07003207 Proxy::Buffer buf;
3208 buf.mFrameCount = buffer->frameCount;
3209 buf.mRaw = buffer->raw;
3210 mPeerProxy->releaseBuffer(&buf);
3211 TrackBase::releaseBuffer(buffer);
3212}
3213
Andy Hung3ff4b552023-06-26 19:20:57 -07003214status_t PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
Eric Laurent83b88082014-06-20 18:31:16 -07003215 const struct timespec *timeOut)
3216{
3217 return mProxy->obtainBuffer(buffer, timeOut);
3218}
3219
Andy Hung3ff4b552023-06-26 19:20:57 -07003220void PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07003221{
3222 mProxy->releaseBuffer(buffer);
3223}
3224
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003225#undef LOG_TAG
3226#define LOG_TAG "AF::PthrPatchRecord"
3227
3228static std::unique_ptr<void, decltype(free)*> allocAligned(size_t alignment, size_t size)
3229{
3230 void *ptr = nullptr;
3231 (void)posix_memalign(&ptr, alignment, size);
Andy Hung71ba4b32022-10-06 12:09:49 -07003232 return {ptr, free};
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003233}
3234
Andy Hung3ff4b552023-06-26 19:20:57 -07003235/* static */
3236sp<IAfPatchRecord> IAfPatchRecord::createPassThru(
Andy Hung44f27182023-07-06 20:56:16 -07003237 IAfRecordThread* recordThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003238 uint32_t sampleRate,
3239 audio_channel_mask_t channelMask,
3240 audio_format_t format,
3241 size_t frameCount,
3242 audio_input_flags_t flags,
3243 audio_source_t source)
3244{
3245 return sp<PassthruPatchRecord>::make(
Andy Hung44f27182023-07-06 20:56:16 -07003246 recordThread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003247 sampleRate,
3248 channelMask,
3249 format,
3250 frameCount,
3251 flags,
3252 source);
3253}
3254
3255PassthruPatchRecord::PassthruPatchRecord(
Andy Hung44f27182023-07-06 20:56:16 -07003256 IAfRecordThread* recordThread,
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003257 uint32_t sampleRate,
3258 audio_channel_mask_t channelMask,
3259 audio_format_t format,
3260 size_t frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02003261 audio_input_flags_t flags,
3262 audio_source_t source)
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003263 : PatchRecord(recordThread, sampleRate, channelMask, format, frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02003264 nullptr /*buffer*/, 0 /*bufferSize*/, flags, {} /* timeout */, source),
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003265 mPatchRecordAudioBufferProvider(*this),
3266 mSinkBuffer(allocAligned(32, mFrameCount * mFrameSize)),
3267 mStubBuffer(allocAligned(32, mFrameCount * mFrameSize))
3268{
3269 memset(mStubBuffer.get(), 0, mFrameCount * mFrameSize);
3270}
3271
Andy Hung3ff4b552023-06-26 19:20:57 -07003272sp<StreamInHalInterface> PassthruPatchRecord::obtainStream(
Andy Hung44f27182023-07-06 20:56:16 -07003273 sp<IAfThreadBase>* thread)
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003274{
3275 *thread = mThread.promote();
3276 if (!*thread) return nullptr;
Andy Hung44f27182023-07-06 20:56:16 -07003277 auto* const recordThread = (*thread)->asIAfRecordThread().get();
Andy Hung87e82412023-08-29 14:26:09 -07003278 audio_utils::lock_guard _l(recordThread->mutex());
Andy Hung44f27182023-07-06 20:56:16 -07003279 return recordThread->getInput() ? recordThread->getInput()->stream : nullptr;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003280}
3281
3282// PatchProxyBufferProvider methods are called on DirectOutputThread
Andy Hung3ff4b552023-06-26 19:20:57 -07003283status_t PassthruPatchRecord::obtainBuffer(
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003284 Proxy::Buffer* buffer, const struct timespec* timeOut)
3285{
3286 if (mUnconsumedFrames) {
3287 buffer->mFrameCount = std::min(buffer->mFrameCount, mUnconsumedFrames);
3288 // mUnconsumedFrames is decreased in releaseBuffer to use actual frame consumption figure.
3289 return PatchRecord::obtainBuffer(buffer, timeOut);
3290 }
3291
3292 // Otherwise, execute a read from HAL and write into the buffer.
3293 nsecs_t startTimeNs = 0;
3294 if (timeOut && (timeOut->tv_sec != 0 || timeOut->tv_nsec != 0) && timeOut->tv_sec != INT_MAX) {
3295 // Will need to correct timeOut by elapsed time.
3296 startTimeNs = systemTime();
3297 }
3298 const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
3299 buffer->mFrameCount = 0;
3300 buffer->mRaw = nullptr;
Andy Hung44f27182023-07-06 20:56:16 -07003301 sp<IAfThreadBase> thread;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003302 sp<StreamInHalInterface> stream = obtainStream(&thread);
3303 if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
3304
3305 status_t result = NO_ERROR;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003306 size_t bytesRead = 0;
3307 {
3308 ATRACE_NAME("read");
3309 result = stream->read(mSinkBuffer.get(), framesToRead * mFrameSize, &bytesRead);
3310 if (result != NO_ERROR) goto stream_error;
3311 if (bytesRead == 0) return NO_ERROR;
3312 }
3313
3314 {
Andy Hung094dc762023-08-28 19:12:14 -07003315 audio_utils::lock_guard lock(readMutex());
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003316 mReadBytes += bytesRead;
3317 mReadError = NO_ERROR;
3318 }
3319 mReadCV.notify_one();
3320 // writeFrames handles wraparound and should write all the provided frames.
3321 // If it couldn't, there is something wrong with the client/server buffer of the software patch.
3322 buffer->mFrameCount = writeFrames(
3323 &mPatchRecordAudioBufferProvider,
3324 mSinkBuffer.get(), bytesRead / mFrameSize, mFrameSize);
3325 ALOGW_IF(buffer->mFrameCount < bytesRead / mFrameSize,
3326 "Lost %zu frames obtained from HAL", bytesRead / mFrameSize - buffer->mFrameCount);
3327 mUnconsumedFrames = buffer->mFrameCount;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003328 struct timespec newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003329 if (startTimeNs) {
Mikhail Naganov4de49972019-10-07 09:53:58 -07003330 // Correct the timeout by elapsed time.
3331 nsecs_t newTimeOutNs = audio_utils_ns_from_timespec(timeOut) - (systemTime() - startTimeNs);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003332 if (newTimeOutNs < 0) newTimeOutNs = 0;
3333 newTimeOut.tv_sec = newTimeOutNs / NANOS_PER_SECOND;
3334 newTimeOut.tv_nsec = newTimeOutNs - newTimeOut.tv_sec * NANOS_PER_SECOND;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003335 timeOut = &newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003336 }
Mikhail Naganov4de49972019-10-07 09:53:58 -07003337 return PatchRecord::obtainBuffer(buffer, timeOut);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003338
3339stream_error:
3340 stream->standby();
3341 {
Andy Hung094dc762023-08-28 19:12:14 -07003342 audio_utils::lock_guard lock(readMutex());
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003343 mReadError = result;
3344 }
3345 mReadCV.notify_one();
3346 return result;
3347}
3348
Andy Hung3ff4b552023-06-26 19:20:57 -07003349void PassthruPatchRecord::releaseBuffer(Proxy::Buffer* buffer)
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003350{
3351 if (buffer->mFrameCount <= mUnconsumedFrames) {
3352 mUnconsumedFrames -= buffer->mFrameCount;
3353 } else {
3354 ALOGW("Write side has consumed more frames than we had: %zu > %zu",
3355 buffer->mFrameCount, mUnconsumedFrames);
3356 mUnconsumedFrames = 0;
3357 }
3358 PatchRecord::releaseBuffer(buffer);
3359}
3360
3361// AudioBufferProvider and Source methods are called on RecordThread
3362// 'read' emulates actual audio data with 0's. This is OK as 'getNextBuffer'
3363// and 'releaseBuffer' are stubbed out and ignore their input.
3364// It's not possible to retrieve actual data here w/o blocking 'obtainBuffer'
3365// until we copy it.
Andy Hung3ff4b552023-06-26 19:20:57 -07003366status_t PassthruPatchRecord::read(
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003367 void* buffer, size_t bytes, size_t* read)
3368{
3369 bytes = std::min(bytes, mFrameCount * mFrameSize);
3370 {
Andy Hung094dc762023-08-28 19:12:14 -07003371 audio_utils::unique_lock lock(readMutex());
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003372 mReadCV.wait(lock, [&]{ return mReadError != NO_ERROR || mReadBytes != 0; });
3373 if (mReadError != NO_ERROR) {
3374 mLastReadFrames = 0;
3375 return mReadError;
3376 }
3377 *read = std::min(bytes, mReadBytes);
3378 mReadBytes -= *read;
3379 }
3380 mLastReadFrames = *read / mFrameSize;
3381 memset(buffer, 0, *read);
3382 return 0;
3383}
3384
Andy Hung3ff4b552023-06-26 19:20:57 -07003385status_t PassthruPatchRecord::getCapturePosition(
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003386 int64_t* frames, int64_t* time)
3387{
Andy Hung44f27182023-07-06 20:56:16 -07003388 sp<IAfThreadBase> thread;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003389 sp<StreamInHalInterface> stream = obtainStream(&thread);
3390 return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
3391}
3392
Andy Hung3ff4b552023-06-26 19:20:57 -07003393status_t PassthruPatchRecord::standby()
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003394{
3395 // RecordThread issues 'standby' command in two major cases:
3396 // 1. Error on read--this case is handled in 'obtainBuffer'.
3397 // 2. Track is stopping--as PassthruPatchRecord assumes continuous
3398 // output, this can only happen when the software patch
3399 // is being torn down. In this case, the RecordThread
3400 // will terminate and close the HAL stream.
3401 return 0;
3402}
3403
3404// As the buffer gets filled in obtainBuffer, here we only simulate data consumption.
Andy Hung3ff4b552023-06-26 19:20:57 -07003405status_t PassthruPatchRecord::getNextBuffer(
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003406 AudioBufferProvider::Buffer* buffer)
3407{
3408 buffer->frameCount = mLastReadFrames;
3409 buffer->raw = buffer->frameCount != 0 ? mStubBuffer.get() : nullptr;
3410 return NO_ERROR;
3411}
3412
Andy Hung3ff4b552023-06-26 19:20:57 -07003413void PassthruPatchRecord::releaseBuffer(
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003414 AudioBufferProvider::Buffer* buffer)
3415{
3416 buffer->frameCount = 0;
3417 buffer->raw = nullptr;
3418}
3419
Andy Hung9d84af52018-09-12 18:03:44 -07003420// ----------------------------------------------------------------------------
3421#undef LOG_TAG
3422#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08003423
Andy Hung3ff4b552023-06-26 19:20:57 -07003424/* static */
Andy Hung44f27182023-07-06 20:56:16 -07003425sp<IAfMmapTrack> IAfMmapTrack::create(IAfThreadBase* thread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003426 const audio_attributes_t& attr,
3427 uint32_t sampleRate,
3428 audio_format_t format,
3429 audio_channel_mask_t channelMask,
3430 audio_session_t sessionId,
3431 bool isOut,
3432 const android::content::AttributionSourceState& attributionSource,
3433 pid_t creatorPid,
3434 audio_port_handle_t portId)
3435{
3436 return sp<MmapTrack>::make(
Andy Hung44f27182023-07-06 20:56:16 -07003437 thread,
Andy Hung3ff4b552023-06-26 19:20:57 -07003438 attr,
3439 sampleRate,
3440 format,
3441 channelMask,
3442 sessionId,
3443 isOut,
3444 attributionSource,
3445 creatorPid,
3446 portId);
3447}
3448
Andy Hung44f27182023-07-06 20:56:16 -07003449MmapTrack::MmapTrack(IAfThreadBase* thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003450 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003451 uint32_t sampleRate,
3452 audio_format_t format,
3453 audio_channel_mask_t channelMask,
3454 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003455 bool isOut,
Svet Ganov33761132021-05-13 22:51:08 +00003456 const AttributionSourceState& attributionSource,
Eric Laurent09f1ed22019-04-24 17:45:17 -07003457 pid_t creatorPid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003458 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003459 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07003460 channelMask, (size_t)0 /* frameCount */,
3461 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003462 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00003463 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003464 isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003465 ALLOC_NONE,
Andy Hungc2b11cb2020-04-22 09:04:01 -07003466 TYPE_DEFAULT, portId,
3467 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
Svet Ganov33761132021-05-13 22:51:08 +00003468 mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.pid))),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003469 mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003470{
Andy Hungc2b11cb2020-04-22 09:04:01 -07003471 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07003472 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003473}
3474
Andy Hung3ff4b552023-06-26 19:20:57 -07003475MmapTrack::~MmapTrack()
Eric Laurent6acd1d42017-01-04 14:23:29 -08003476{
3477}
3478
Andy Hung3ff4b552023-06-26 19:20:57 -07003479status_t MmapTrack::initCheck() const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003480{
3481 return NO_ERROR;
3482}
3483
Andy Hung3ff4b552023-06-26 19:20:57 -07003484status_t MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003485 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003486{
3487 return NO_ERROR;
3488}
3489
Andy Hung3ff4b552023-06-26 19:20:57 -07003490void MmapTrack::stop()
Eric Laurent6acd1d42017-01-04 14:23:29 -08003491{
3492}
3493
3494// AudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07003495status_t MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003496{
3497 buffer->frameCount = 0;
3498 buffer->raw = nullptr;
3499 return INVALID_OPERATION;
3500}
3501
3502// ExtendedAudioBufferProvider interface
Andy Hung3ff4b552023-06-26 19:20:57 -07003503size_t MmapTrack::framesReady() const {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003504 return 0;
3505}
3506
Andy Hung3ff4b552023-06-26 19:20:57 -07003507int64_t MmapTrack::framesReleased() const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003508{
3509 return 0;
3510}
3511
Andy Hung3ff4b552023-06-26 19:20:57 -07003512void MmapTrack::onTimestamp(const ExtendedTimestamp& timestamp __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003513{
3514}
3515
Andy Hung3ff4b552023-06-26 19:20:57 -07003516void MmapTrack::processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState)
Vlad Popaec1788e2022-08-04 11:23:30 +02003517{
3518 if (mMuteState == muteState) {
3519 // mute state did not change, do nothing
3520 return;
3521 }
3522
3523 status_t result = UNKNOWN_ERROR;
3524 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
3525 if (mMuteEventExtras == nullptr) {
3526 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
3527 }
3528 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
3529 static_cast<int>(muteState));
3530
3531 result = audioManager->portEvent(mPortId,
3532 PLAYER_UPDATE_MUTED,
3533 mMuteEventExtras);
3534 }
3535
3536 if (result == OK) {
3537 mMuteState = muteState;
3538 } else {
3539 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
3540 __func__,
3541 id(),
3542 mPortId,
3543 result);
3544 }
3545}
3546
Andy Hung3ff4b552023-06-26 19:20:57 -07003547void MmapTrack::appendDumpHeader(String8& result) const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003548{
Eric Laurent973db022018-11-20 14:54:31 -08003549 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003550 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003551}
3552
Andy Hung3ff4b552023-06-26 19:20:57 -07003553void MmapTrack::appendDump(String8& result, bool active __unused) const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003554{
Eric Laurent973db022018-11-20 14:54:31 -08003555 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003556 mPid,
3557 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08003558 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003559 mFormat,
3560 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003561 mSampleRate,
3562 mAttr.flags);
3563 if (isOut()) {
3564 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
3565 } else {
3566 result.appendFormat("%6x", mAttr.source);
3567 }
3568 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003569}
3570
Glenn Kasten63238ef2015-03-02 15:50:29 -08003571} // namespace android