blob: 9ec3ee373a9a9ef839953690d668721a9e70f331 [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
Mikhail Naganov938be412019-09-04 11:38:47 -070021#define ATRACE_TAG ATRACE_TAG_AUDIO
Eric Laurent81784c32012-11-19 14:55:58 -080022
Glenn Kasten153b9fe2013-07-15 11:23:36 -070023#include "Configuration.h"
Glenn Kastenad8510a2015-02-17 16:24:07 -080024#include <linux/futex.h>
Eric Laurent81784c32012-11-19 14:55:58 -080025#include <math.h>
Elliott Hughesee499292014-05-21 17:55:51 -070026#include <sys/syscall.h>
Eric Laurent81784c32012-11-19 14:55:58 -080027#include <utils/Log.h>
Mikhail Naganov938be412019-09-04 11:38:47 -070028#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080029
30#include <private/media/AudioTrackShared.h>
31
Eric Laurent81784c32012-11-19 14:55:58 -080032#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080033
Glenn Kastenda6ef132013-01-10 12:31:01 -080034#include <media/nbaio/Pipe.h>
35#include <media/nbaio/PipeReader.h>
Kuowei Lid4adbdb2020-08-13 14:44:25 +080036#include <media/AudioValidator.h>
Andy Hung89816052017-01-11 17:08:23 -080037#include <media/RecordBufferConverter.h>
Andy Hungab7ef302018-05-15 19:35:29 -070038#include <mediautils/ServiceUtilities.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070039#include <audio_utils/minifloat.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080040
Eric Laurent81784c32012-11-19 14:55:58 -080041// ----------------------------------------------------------------------------
42
43// Note: the following macro is used for extremely verbose logging message. In
44// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
45// 0; but one side effect of this is to turn all LOGV's as well. Some messages
46// are so verbose that we want to suppress them even when we have ALOG_ASSERT
47// turned on. Do not uncomment the #def below unless you really know what you
48// are doing and want to see all of the extremely verbose messages.
49//#define VERY_VERY_VERBOSE_LOGGING
50#ifdef VERY_VERY_VERBOSE_LOGGING
51#define ALOGVV ALOGV
52#else
53#define ALOGVV(a...) do { } while(0)
54#endif
55
Kuowei Lid4adbdb2020-08-13 14:44:25 +080056// TODO: Remove when this is put into AidlConversionUtil.h
57#define VALUE_OR_RETURN_BINDER_STATUS(x) \
58 ({ \
59 auto _tmp = (x); \
60 if (!_tmp.ok()) return ::android::aidl_utils::binderStatusFromStatusT(_tmp.error()); \
61 std::move(_tmp.value()); \
62 })
63
Eric Laurent81784c32012-11-19 14:55:58 -080064namespace android {
65
Kuowei Lid4adbdb2020-08-13 14:44:25 +080066using ::android::aidl_utils::binderStatusFromStatusT;
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -080067using binder::Status;
Svet Ganov33761132021-05-13 22:51:08 +000068using content::AttributionSourceState;
Ivan Lozano8cf3a072017-08-09 09:01:33 -070069using media::VolumeShaper;
Eric Laurent81784c32012-11-19 14:55:58 -080070// ----------------------------------------------------------------------------
71// TrackBase
72// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -070073#undef LOG_TAG
74#define LOG_TAG "AF::TrackBase"
Eric Laurent81784c32012-11-19 14:55:58 -080075
Glenn Kastenda6ef132013-01-10 12:31:01 -080076static volatile int32_t nextTrackId = 55;
77
Eric Laurent81784c32012-11-19 14:55:58 -080078// TrackBase constructor must be called with AudioFlinger::mLock held
79AudioFlinger::ThreadBase::TrackBase::TrackBase(
80 ThreadBase *thread,
81 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070082 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080083 uint32_t sampleRate,
84 audio_format_t format,
85 audio_channel_mask_t channelMask,
86 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070087 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070088 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080089 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070090 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -080091 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -070092 bool isOut,
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -070093 const alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -080094 track_type type,
Andy Hungb68f5eb2019-12-03 16:49:17 -080095 audio_port_handle_t portId,
96 std::string metricsId)
Eric Laurent81784c32012-11-19 14:55:58 -080097 : RefBase(),
98 mThread(thread),
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -070099 mAllocType(alloc),
Eric Laurent81784c32012-11-19 14:55:58 -0800100 mClient(client),
101 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -0700102 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -0800103 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700104 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -0800105 mSampleRate(sampleRate),
106 mFormat(format),
107 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -0700108 mChannelCount(isOut ?
109 audio_channel_count_from_out_mask(channelMask) :
110 audio_channel_count_from_in_mask(channelMask)),
Phil Burkfdb3c072016-02-09 10:47:02 -0800111 mFrameSize(audio_has_proportional_frames(format) ?
Eric Laurent81784c32012-11-19 14:55:58 -0800112 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
113 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800114 mSessionId(sessionId),
115 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -0800116 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -0700117 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700118 mType(type),
Kevin Rocard153f92d2018-12-18 18:33:28 -0800119 mThreadIoHandle(thread ? thread->id() : AUDIO_IO_HANDLE_NONE),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800120 mPortId(portId),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700121 mIsInvalid(false),
Kunal Malhotra3be68902023-02-28 22:03:15 +0000122 mTrackMetrics(std::move(metricsId), isOut, clientUid),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700123 mCreatorPid(creatorPid)
Eric Laurent81784c32012-11-19 14:55:58 -0800124{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700125 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700126 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800127 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Andy Hung9d84af52018-09-12 18:03:44 -0700128 "%s(%d): uid %d tried to pass itself off as %d",
129 __func__, mId, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800130 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800131 }
132 // clientUid contains the uid of the app that is responsible for this track, so we can blame
133 // battery usage on it.
134 mUid = clientUid;
135
Eric Laurent81784c32012-11-19 14:55:58 -0800136 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800137
Andy Hung8fe68032017-06-05 16:17:51 -0700138 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800139 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700140 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800141 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700142 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800143 android_errorWriteLog(0x534e4554, "34749571");
144 return;
145 }
Andy Hung8fe68032017-06-05 16:17:51 -0700146 minBufferSize *= mFrameSize;
147
148 if (buffer == nullptr) {
149 bufferSize = minBufferSize; // allocated here.
150 } else if (minBufferSize > bufferSize) {
151 android_errorWriteLog(0x534e4554, "38340117");
152 return;
153 }
Andy Hung1883f692017-02-13 18:48:39 -0800154
Eric Laurent81784c32012-11-19 14:55:58 -0800155 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700156 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800157 // check overflow when computing allocation size for streaming tracks.
158 if (size > SIZE_MAX - bufferSize) {
159 android_errorWriteLog(0x534e4554, "34749571");
160 return;
161 }
Eric Laurent81784c32012-11-19 14:55:58 -0800162 size += bufferSize;
163 }
164
165 if (client != 0) {
Atneya3c61d882021-09-20 14:52:15 -0400166 mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{{size},
167 std::string("Track ID: ").append(std::to_string(mId))});
Glenn Kasten663c2242013-09-24 11:52:37 -0700168 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700169 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700170 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Atneya3c61d882021-09-20 14:52:15 -0400171 ALOGE("%s", client->allocator().dump().c_str());
Glenn Kasten663c2242013-09-24 11:52:37 -0700172 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800173 return;
174 }
175 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800176 mCblk = (audio_track_cblk_t *) malloc(size);
177 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700178 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800179 return;
180 }
Eric Laurent81784c32012-11-19 14:55:58 -0800181 }
182
183 // construct the shared structure in-place.
184 if (mCblk != NULL) {
185 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700186 switch (alloc) {
187 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700188 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
189 if (roHeap == 0 ||
190 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700191 (mBuffer = mBufferMemory->unsecurePointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700192 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
193 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700194 if (roHeap != 0) {
195 roHeap->dump("buffer");
196 }
197 mCblkMemory.clear();
198 mBufferMemory.clear();
199 return;
200 }
Eric Laurent81784c32012-11-19 14:55:58 -0800201 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700202 } break;
203 case ALLOC_PIPE:
204 mBufferMemory = thread->pipeMemory();
205 // mBuffer is the virtual address as seen from current process (mediaserver),
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700206 // and should normally be coming from mBufferMemory->unsecurePointer().
Glenn Kastenc263ca02014-06-04 20:31:46 -0700207 // However in this case the TrackBase does not reference the buffer directly.
208 // It should references the buffer via the pipe.
209 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
210 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700211 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700212 break;
213 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700214 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700215 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700216 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
217 memset(mBuffer, 0, bufferSize);
218 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700219 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800220#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700221 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800222#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700223 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700224 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700225 case ALLOC_LOCAL:
226 mBuffer = calloc(1, bufferSize);
227 break;
228 case ALLOC_NONE:
229 mBuffer = buffer;
230 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700231 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700232 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800233 }
Andy Hung8fe68032017-06-05 16:17:51 -0700234 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800235
Glenn Kasten46909e72013-02-26 09:20:22 -0800236#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700237 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800238#endif
Andy Hung959b5b82021-09-24 10:46:20 -0700239 // mState is mirrored for the client to read.
240 mState.setMirror(&mCblk->mState);
241 // ensure our state matches up until we consolidate the enumeration.
242 static_assert(CBLK_STATE_IDLE == IDLE);
243 static_assert(CBLK_STATE_PAUSING == PAUSING);
Eric Laurent81784c32012-11-19 14:55:58 -0800244 }
245}
246
Svet Ganov33761132021-05-13 22:51:08 +0000247// TODO b/182392769: use attribution source util
248static AttributionSourceState audioServerAttributionSource(pid_t pid) {
249 AttributionSourceState attributionSource{};
250 attributionSource.uid = AID_AUDIOSERVER;
251 attributionSource.pid = pid;
252 attributionSource.token = sp<BBinder>::make();
253 return attributionSource;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700254}
255
Eric Laurent83b88082014-06-20 18:31:16 -0700256status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
257{
258 status_t status;
259 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
260 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
261 } else {
262 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
263 }
264 return status;
265}
266
Eric Laurent81784c32012-11-19 14:55:58 -0800267AudioFlinger::ThreadBase::TrackBase::~TrackBase()
268{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800269 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700270 mServerProxy.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700271 releaseCblk();
Eric Laurent81784c32012-11-19 14:55:58 -0800272 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
273 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700274 // Client destructor must run with AudioFlinger client mutex locked
275 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800276 // If the client's reference count drops to zero, the associated destructor
277 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
278 // relying on the automatic clear() at end of scope.
279 mClient.clear();
280 }
Dmitry Sidorenkova41c2732023-05-15 13:47:07 -0700281 if (mAllocType == ALLOC_LOCAL) {
282 free(mBuffer);
283 mBuffer = nullptr;
284 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700285 // flush the binder command buffer
286 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800287}
288
289// AudioBufferProvider interface
290// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800291// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800292void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
293{
Glenn Kasten46909e72013-02-26 09:20:22 -0800294#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700295 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800296#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800297
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800298 ServerProxy::Buffer buf;
299 buf.mFrameCount = buffer->frameCount;
300 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800301 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800302 buffer->raw = NULL;
303 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800304}
305
Andy Hung068e08e2023-05-15 19:02:55 -0700306status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(
307 const sp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -0800308{
Andy Hung068e08e2023-05-15 19:02:55 -0700309 mSyncEvents.emplace_back(event);
Eric Laurent81784c32012-11-19 14:55:58 -0800310 return NO_ERROR;
311}
312
Andy Hung71ba4b32022-10-06 12:09:49 -0700313AudioFlinger::ThreadBase::PatchTrackBase::PatchTrackBase(const sp<ClientProxy>& proxy,
Kevin Rocard45986c72018-12-18 18:22:59 -0800314 const ThreadBase& thread,
315 const Timeout& timeout)
316 : mProxy(proxy)
317{
318 if (timeout) {
319 setPeerTimeout(*timeout);
320 } else {
321 // Double buffer mixer
322 uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
323 thread.sampleRate();
324 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
325 }
326}
327
328void AudioFlinger::ThreadBase::PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
329 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
330 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
331}
332
333
Eric Laurent81784c32012-11-19 14:55:58 -0800334// ----------------------------------------------------------------------------
335// Playback
336// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700337#undef LOG_TAG
338#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800339
Andy Hungaaa18282023-06-23 19:27:19 -0700340class TrackHandle : public android::media::BnAudioTrack {
341public:
342 explicit TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track);
343 ~TrackHandle() override;
344
345 binder::Status getCblk(std::optional<media::SharedFileRegion>* _aidl_return) final;
346 binder::Status start(int32_t* _aidl_return) final;
347 binder::Status stop() final;
348 binder::Status flush() final;
349 binder::Status pause() final;
350 binder::Status attachAuxEffect(int32_t effectId, int32_t* _aidl_return) final;
351 binder::Status setParameters(const std::string& keyValuePairs,
352 int32_t* _aidl_return) final;
353 binder::Status selectPresentation(int32_t presentationId, int32_t programId,
354 int32_t* _aidl_return) final;
355 binder::Status getTimestamp(media::AudioTimestampInternal* timestamp,
356 int32_t* _aidl_return) final;
357 binder::Status signal() final;
358 binder::Status applyVolumeShaper(const media::VolumeShaperConfiguration& configuration,
359 const media::VolumeShaperOperation& operation,
360 int32_t* _aidl_return) final;
361 binder::Status getVolumeShaperState(
362 int32_t id,
363 std::optional<media::VolumeShaperState>* _aidl_return) final;
364 binder::Status getDualMonoMode(
365 media::audio::common::AudioDualMonoMode* _aidl_return) final;
366 binder::Status setDualMonoMode(
367 media::audio::common::AudioDualMonoMode mode) final;
368 binder::Status getAudioDescriptionMixLevel(float* _aidl_return) final;
369 binder::Status setAudioDescriptionMixLevel(float leveldB) final;
370 binder::Status getPlaybackRateParameters(
371 media::audio::common::AudioPlaybackRate* _aidl_return) final;
372 binder::Status setPlaybackRateParameters(
373 const media::audio::common::AudioPlaybackRate& playbackRate) final;
374
375private:
376 const sp<AudioFlinger::PlaybackThread::Track> mTrack;
377};
378
379/* static */
380sp<media::IAudioTrack> AudioFlinger::PlaybackThread::Track::createIAudioTrackAdapter(
381 const sp<Track>& track) {
382 return sp<TrackHandle>::make(track);
383}
384
385TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
Eric Laurent81784c32012-11-19 14:55:58 -0800386 : BnAudioTrack(),
387 mTrack(track)
388{
Andy Hungaaa18282023-06-23 19:27:19 -0700389 // TODO(b/288339104) binder thread priority change not needed.
Andy Hung225aef62022-12-06 16:33:20 -0800390 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -0800391}
392
Andy Hungaaa18282023-06-23 19:27:19 -0700393TrackHandle::~TrackHandle() {
Eric Laurent81784c32012-11-19 14:55:58 -0800394 // just stop the track on deletion, associated resources
395 // will be freed from the main thread once all pending buffers have
396 // been played. Unless it's not in the active track list, in which
397 // case we free everything now...
398 mTrack->destroy();
399}
400
Andy Hungaaa18282023-06-23 19:27:19 -0700401Status TrackHandle::getCblk(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800402 std::optional<media::SharedFileRegion>* _aidl_return) {
403 *_aidl_return = legacy2aidl_NullableIMemory_SharedFileRegion(mTrack->getCblk()).value();
404 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800405}
406
Andy Hungaaa18282023-06-23 19:27:19 -0700407Status TrackHandle::start(int32_t* _aidl_return) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800408 *_aidl_return = mTrack->start();
409 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800410}
411
Andy Hungaaa18282023-06-23 19:27:19 -0700412Status TrackHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -0800413 mTrack->stop();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800414 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800415}
416
Andy Hungaaa18282023-06-23 19:27:19 -0700417Status TrackHandle::flush() {
Eric Laurent81784c32012-11-19 14:55:58 -0800418 mTrack->flush();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800419 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800420}
421
Andy Hungaaa18282023-06-23 19:27:19 -0700422Status TrackHandle::pause() {
Eric Laurent81784c32012-11-19 14:55:58 -0800423 mTrack->pause();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800424 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800425}
426
Andy Hungaaa18282023-06-23 19:27:19 -0700427Status TrackHandle::attachAuxEffect(int32_t effectId,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800428 int32_t* _aidl_return) {
429 *_aidl_return = mTrack->attachAuxEffect(effectId);
430 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800431}
432
Andy Hungaaa18282023-06-23 19:27:19 -0700433Status TrackHandle::setParameters(const std::string& keyValuePairs,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800434 int32_t* _aidl_return) {
435 *_aidl_return = mTrack->setParameters(String8(keyValuePairs.c_str()));
436 return Status::ok();
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700437}
438
Andy Hungaaa18282023-06-23 19:27:19 -0700439Status TrackHandle::selectPresentation(int32_t presentationId, int32_t programId,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800440 int32_t* _aidl_return) {
441 *_aidl_return = mTrack->selectPresentation(presentationId, programId);
442 return Status::ok();
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800443}
444
Andy Hungaaa18282023-06-23 19:27:19 -0700445Status TrackHandle::getTimestamp(media::AudioTimestampInternal* timestamp,
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800446 int32_t* _aidl_return) {
447 AudioTimestamp legacy;
448 *_aidl_return = mTrack->getTimestamp(legacy);
449 if (*_aidl_return != OK) {
450 return Status::ok();
451 }
Andy Hung973638a2020-12-08 20:47:45 -0800452 *timestamp = legacy2aidl_AudioTimestamp_AudioTimestampInternal(legacy).value();
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800453 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800454}
455
Andy Hungaaa18282023-06-23 19:27:19 -0700456Status TrackHandle::signal() {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800457 mTrack->signal();
458 return Status::ok();
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800459}
460
Andy Hungaaa18282023-06-23 19:27:19 -0700461Status TrackHandle::applyVolumeShaper(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800462 const media::VolumeShaperConfiguration& configuration,
463 const media::VolumeShaperOperation& operation,
464 int32_t* _aidl_return) {
465 sp<VolumeShaper::Configuration> conf = new VolumeShaper::Configuration();
466 *_aidl_return = conf->readFromParcelable(configuration);
467 if (*_aidl_return != OK) {
468 return Status::ok();
469 }
470
471 sp<VolumeShaper::Operation> op = new VolumeShaper::Operation();
472 *_aidl_return = op->readFromParcelable(operation);
473 if (*_aidl_return != OK) {
474 return Status::ok();
475 }
476
477 *_aidl_return = mTrack->applyVolumeShaper(conf, op);
478 return Status::ok();
Glenn Kasten53cec222013-08-29 09:01:02 -0700479}
480
Andy Hungaaa18282023-06-23 19:27:19 -0700481Status TrackHandle::getVolumeShaperState(
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800482 int32_t id,
483 std::optional<media::VolumeShaperState>* _aidl_return) {
484 sp<VolumeShaper::State> legacy = mTrack->getVolumeShaperState(id);
485 if (legacy == nullptr) {
486 _aidl_return->reset();
487 return Status::ok();
488 }
489 media::VolumeShaperState aidl;
490 legacy->writeToParcelable(&aidl);
491 *_aidl_return = aidl;
492 return Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -0800493}
494
Andy Hungaaa18282023-06-23 19:27:19 -0700495Status TrackHandle::getDualMonoMode(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000496 media::audio::common::AudioDualMonoMode* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800497{
498 audio_dual_mono_mode_t mode = AUDIO_DUAL_MONO_MODE_OFF;
499 const status_t status = mTrack->getDualMonoMode(&mode)
500 ?: AudioValidator::validateDualMonoMode(mode);
501 if (status == OK) {
502 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
503 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(mode));
504 }
505 return binderStatusFromStatusT(status);
506}
507
Andy Hungaaa18282023-06-23 19:27:19 -0700508Status TrackHandle::setDualMonoMode(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000509 media::audio::common::AudioDualMonoMode mode)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800510{
511 const auto localMonoMode = VALUE_OR_RETURN_BINDER_STATUS(
512 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(mode));
513 return binderStatusFromStatusT(AudioValidator::validateDualMonoMode(localMonoMode)
514 ?: mTrack->setDualMonoMode(localMonoMode));
515}
516
Andy Hungaaa18282023-06-23 19:27:19 -0700517Status TrackHandle::getAudioDescriptionMixLevel(float* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800518{
519 float leveldB = -std::numeric_limits<float>::infinity();
520 const status_t status = mTrack->getAudioDescriptionMixLevel(&leveldB)
521 ?: AudioValidator::validateAudioDescriptionMixLevel(leveldB);
522 if (status == OK) *_aidl_return = leveldB;
523 return binderStatusFromStatusT(status);
524}
525
Andy Hungaaa18282023-06-23 19:27:19 -0700526Status TrackHandle::setAudioDescriptionMixLevel(float leveldB)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800527{
528 return binderStatusFromStatusT(AudioValidator::validateAudioDescriptionMixLevel(leveldB)
529 ?: mTrack->setAudioDescriptionMixLevel(leveldB));
530}
531
Andy Hungaaa18282023-06-23 19:27:19 -0700532Status TrackHandle::getPlaybackRateParameters(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000533 media::audio::common::AudioPlaybackRate* _aidl_return)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800534{
535 audio_playback_rate_t localPlaybackRate{};
536 status_t status = mTrack->getPlaybackRateParameters(&localPlaybackRate)
537 ?: AudioValidator::validatePlaybackRate(localPlaybackRate);
538 if (status == NO_ERROR) {
539 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
540 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(localPlaybackRate));
541 }
542 return binderStatusFromStatusT(status);
543}
544
Andy Hungaaa18282023-06-23 19:27:19 -0700545Status TrackHandle::setPlaybackRateParameters(
Mikhail Naganova77d5552022-12-18 02:48:14 +0000546 const media::audio::common::AudioPlaybackRate& playbackRate)
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800547{
548 const audio_playback_rate_t localPlaybackRate = VALUE_OR_RETURN_BINDER_STATUS(
549 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(playbackRate));
550 return binderStatusFromStatusT(AudioValidator::validatePlaybackRate(localPlaybackRate)
551 ?: mTrack->setPlaybackRateParameters(localPlaybackRate));
552}
553
Eric Laurent81784c32012-11-19 14:55:58 -0800554// ----------------------------------------------------------------------------
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800555// AppOp for audio playback
556// -------------------------------
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700557
558// static
559sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
560AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
Vlad Popa103be862023-07-10 20:27:41 -0700561 AudioFlinger::ThreadBase* thread,
Svet Ganov33761132021-05-13 22:51:08 +0000562 const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700563 audio_stream_type_t streamType)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800564{
Vlad Popa103be862023-07-10 20:27:41 -0700565 Vector<String16> packages;
566 const uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000567 getPackagesForUid(uid, packages);
Eric Laurent9066ad32019-05-20 14:40:10 -0700568 if (isServiceUid(uid)) {
Eric Laurent9066ad32019-05-20 14:40:10 -0700569 if (packages.isEmpty()) {
570 ALOGD("OpPlayAudio: not muting track:%d usage:%d for service UID %d",
571 id,
572 attr.usage,
573 uid);
574 return nullptr;
575 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800576 }
577 // stream type has been filtered by audio policy to indicate whether it can be muted
578 if (streamType == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Eric Laurent2dab0302019-05-08 18:15:55 -0700579 ALOGD("OpPlayAudio: not muting track:%d usage:%d ENFORCED_AUDIBLE", id, attr.usage);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700580 return nullptr;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800581 }
Eric Laurent2dab0302019-05-08 18:15:55 -0700582 if ((attr.flags & AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY)
583 == AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY) {
584 ALOGD("OpPlayAudio: not muting track:%d flags %#x have FLAG_BYPASS_INTERRUPTION_POLICY",
585 id, attr.flags);
586 return nullptr;
587 }
Vlad Popa103be862023-07-10 20:27:41 -0700588 return sp<OpPlayAudioMonitor>::make(thread, attributionSource, attr.usage, id, uid);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700589}
590
591AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
Vlad Popa103be862023-07-10 20:27:41 -0700592 AudioFlinger::ThreadBase* thread,
593 const AttributionSourceState& attributionSource,
594 audio_usage_t usage, int id, uid_t uid)
595 : mThread(wp<AudioFlinger::ThreadBase>::fromExisting(thread)),
596 mHasOpPlayAudio(true),
597 mAttributionSource(attributionSource),
598 mUsage((int32_t)usage),
599 mId(id),
600 mUid(uid),
601 mPackageName(VALUE_OR_FATAL(aidl2legacy_string_view_String16(
602 attributionSource.packageName.value_or("")))) {}
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800603
604AudioFlinger::PlaybackThread::OpPlayAudioMonitor::~OpPlayAudioMonitor()
605{
606 if (mOpCallback != 0) {
607 mAppOpsManager.stopWatchingMode(mOpCallback);
608 }
609 mOpCallback.clear();
610}
611
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700612void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
613{
Vlad Popad2152122023-08-02 18:36:04 -0700614 // make sure not to broadcast the initial state since it is not needed and could
615 // cause a deadlock since this method can be called with the mThread->mLock held
616 checkPlayAudioForUsage(/*doBroadcast=*/false);
Svet Ganov33761132021-05-13 22:51:08 +0000617 if (mAttributionSource.packageName.has_value()) {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700618 mOpCallback = new PlayAudioOpCallback(this);
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700619 mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
Vlad Popa103be862023-07-10 20:27:41 -0700620 mPackageName, mOpCallback);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700621 }
622}
623
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800624bool AudioFlinger::PlaybackThread::OpPlayAudioMonitor::hasOpPlayAudio() const {
625 return mHasOpPlayAudio.load();
626}
627
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700628// Note this method is never called (and never to be) for audio server / patch record track
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800629// - not called from constructor due to check on UID,
630// - not called from PlayAudioOpCallback because the callback is not installed in this case
Vlad Popad2152122023-08-02 18:36:04 -0700631void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage(bool doBroadcast)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800632{
Vlad Popa103be862023-07-10 20:27:41 -0700633 const bool hasAppOps = mAttributionSource.packageName.has_value()
634 && mAppOpsManager.checkAudioOpNoThrow(
635 AppOpsManager::OP_PLAY_AUDIO, mUsage, mUid, mPackageName) ==
636 AppOpsManager::MODE_ALLOWED;
637
638 bool shouldChange = !hasAppOps; // check if we need to update.
639 if (mHasOpPlayAudio.compare_exchange_strong(shouldChange, hasAppOps)) {
640 ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasAppOps ? "not " : "");
Vlad Popad2152122023-08-02 18:36:04 -0700641 if (doBroadcast) {
642 auto thread = mThread.promote();
643 if (thread != nullptr && thread->type() == AudioFlinger::ThreadBase::OFFLOAD) {
644 // Wake up Thread if offloaded, otherwise it may be several seconds for update.
645 Mutex::Autolock _l(thread->mLock);
646 thread->broadcast_l();
647 }
Vlad Popa103be862023-07-10 20:27:41 -0700648 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800649 }
650}
651
652AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::PlayAudioOpCallback(
653 const wp<OpPlayAudioMonitor>& monitor) : mMonitor(monitor)
654{ }
655
656void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::opChanged(int32_t op,
657 const String16& packageName) {
658 // we only have uid, so we need to check all package names anyway
659 UNUSED(packageName);
660 if (op != AppOpsManager::OP_PLAY_AUDIO) {
661 return;
662 }
663 sp<OpPlayAudioMonitor> monitor = mMonitor.promote();
664 if (monitor != NULL) {
Vlad Popad2152122023-08-02 18:36:04 -0700665 monitor->checkPlayAudioForUsage(/*doBroadcast=*/true);
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800666 }
667}
668
Eric Laurent9066ad32019-05-20 14:40:10 -0700669// static
670void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::getPackagesForUid(
671 uid_t uid, Vector<String16>& packages)
672{
673 PermissionController permissionController;
674 permissionController.getPackagesForUid(uid, packages);
675}
676
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800677// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700678#undef LOG_TAG
679#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800680
681// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
682AudioFlinger::PlaybackThread::Track::Track(
683 PlaybackThread *thread,
684 const sp<Client>& client,
685 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700686 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800687 uint32_t sampleRate,
688 audio_format_t format,
689 audio_channel_mask_t channelMask,
690 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700691 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700692 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800693 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800694 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700695 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000696 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -0700697 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800698 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100699 audio_port_handle_t portId,
jiabinf042b9b2021-05-07 23:46:28 +0000700 size_t frameCountToBeReady,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200701 float speed,
jiabinc658e452022-10-21 20:52:21 +0000702 bool isSpatialized,
703 bool isBitPerfect)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700704 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700705 // TODO: Using unsecurePointer() has some associated security pitfalls
706 // (see declaration for details).
707 // Either document why it is safe in this case or address the
708 // issue (e.g. by copying).
709 (sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700710 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700711 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000712 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)), true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700713 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800714 type,
715 portId,
716 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK) + std::to_string(portId)),
Eric Laurent81784c32012-11-19 14:55:58 -0800717 mFillingUpStatus(FS_INVALID),
718 // mRetryCount initialized later when needed
719 mSharedBuffer(sharedBuffer),
720 mStreamType(streamType),
rago94a1ee82017-07-21 15:11:02 -0700721 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800722 mAuxBuffer(NULL),
723 mAuxEffectId(0), mHasVolumeController(false),
Andy Hunge10393e2015-06-12 13:59:33 -0700724 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700725 mVolumeHandler(new media::VolumeHandler(sampleRate)),
Vlad Popa103be862023-07-10 20:27:41 -0700726 mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(thread, attributionSource, attr, id(),
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700727 streamType)),
Andy Hunge10393e2015-06-12 13:59:33 -0700728 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800729 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800730 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700731 /* The track might not play immediately after being active, similarly as if its volume was 0.
732 * When the track starts playing, its volume will be computed. */
733 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800734 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700735 mFlushHwPending(false),
jiabinf042b9b2021-05-07 23:46:28 +0000736 mFlags(flags),
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200737 mSpeed(speed),
jiabinc658e452022-10-21 20:52:21 +0000738 mIsSpatialized(isSpatialized),
739 mIsBitPerfect(isBitPerfect)
Eric Laurent81784c32012-11-19 14:55:58 -0800740{
Eric Laurent83b88082014-06-20 18:31:16 -0700741 // client == 0 implies sharedBuffer == 0
742 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
743
Andy Hung9d84af52018-09-12 18:03:44 -0700744 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700745 __func__, mId, sharedBuffer->unsecurePointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700746
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700747 if (mCblk == NULL) {
748 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800749 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700750
Svet Ganov33761132021-05-13 22:51:08 +0000751 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Andy Hung689e82c2019-08-21 17:53:17 -0700752 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
753 ALOGE("%s(%d): no more tracks available", __func__, mId);
754 releaseCblk(); // this makes the track invalid.
755 return;
756 }
757
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700758 if (sharedBuffer == 0) {
759 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700760 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700761 } else {
762 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
Kevin Rocard36862032019-10-10 10:52:19 +0100763 mFrameSize, sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700764 }
765 mServerProxy = mAudioTrackServerProxy;
Andy Hung3c7f47a2021-03-16 17:30:09 -0700766 mServerProxy->setStartThresholdInFrames(frameCountToBeReady); // update the Cblk value
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700767
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700768 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700769 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700770 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
771 // race with setSyncEvent(). However, if we call it, we cannot properly start
772 // static fast tracks (SoundPool) immediately after stopping.
773 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700774 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
775 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700776 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700777 // FIXME This is too eager. We allocate a fast track index before the
778 // fast track becomes active. Since fast tracks are a scarce resource,
779 // this means we are potentially denying other more important fast tracks from
780 // being created. It would be better to allocate the index dynamically.
781 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700782 thread->mFastTrackAvailMask &= ~(1 << i);
783 }
Andy Hung8946a282018-04-19 20:04:56 -0700784
Dean Wheatley7b036912020-06-18 16:22:11 +1000785 mServerLatencySupported = checkServerLatencySupported(format, flags);
Andy Hung8946a282018-04-19 20:04:56 -0700786#ifdef TEE_SINK
787 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800788 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700789#endif
jiabin57303cc2018-12-18 15:45:57 -0800790
jiabineb3bda02020-06-30 14:07:03 -0700791 if (thread->supportsHapticPlayback()) {
792 // If the track is attached to haptic playback thread, it is potentially to have
793 // HapticGenerator effect, which will generate haptic data, on the track. In that case,
794 // external vibration is always created for all tracks attached to haptic playback thread.
jiabin57303cc2018-12-18 15:45:57 -0800795 mAudioVibrationController = new AudioVibrationController(this);
Svet Ganov33761132021-05-13 22:51:08 +0000796 std::string packageName = attributionSource.packageName.has_value() ?
797 attributionSource.packageName.value() : "";
jiabin57303cc2018-12-18 15:45:57 -0800798 mExternalVibration = new os::ExternalVibration(
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700799 mUid, packageName, mAttr, mAudioVibrationController);
jiabin57303cc2018-12-18 15:45:57 -0800800 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800801
802 // Once this item is logged by the server, the client can add properties.
Andy Hunga629bd12020-06-05 16:03:53 -0700803 const char * const traits = sharedBuffer == 0 ? "" : "static";
Andy Hung5837c7f2021-02-25 10:48:24 -0800804 mTrackMetrics.logConstructor(creatorPid, uid, id(), traits, streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800805}
806
807AudioFlinger::PlaybackThread::Track::~Track()
808{
Andy Hung9d84af52018-09-12 18:03:44 -0700809 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700810
811 // The destructor would clear mSharedBuffer,
812 // but it will not push the decremented reference count,
813 // leaving the client's IMemory dangling indefinitely.
814 // This prevents that leak.
815 if (mSharedBuffer != 0) {
816 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700817 }
Eric Laurent81784c32012-11-19 14:55:58 -0800818}
819
Glenn Kasten03003332013-08-06 15:40:54 -0700820status_t AudioFlinger::PlaybackThread::Track::initCheck() const
821{
822 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700823 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700824 status = NO_MEMORY;
825 }
826 return status;
827}
828
Eric Laurent81784c32012-11-19 14:55:58 -0800829void AudioFlinger::PlaybackThread::Track::destroy()
830{
831 // NOTE: destroyTrack_l() can remove a strong reference to this Track
832 // by removing it from mTracks vector, so there is a risk that this Tracks's
833 // destructor is called. As the destructor needs to lock mLock,
834 // we must acquire a strong reference on this Track before locking mLock
835 // here so that the destructor is called only when exiting this function.
836 // On the other hand, as long as Track::destroy() is only called by
837 // TrackHandle destructor, the TrackHandle still holds a strong ref on
838 // this Track with its member mTrack.
839 sp<Track> keep(this);
840 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700841 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800842 sp<ThreadBase> thread = mThread.promote();
843 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800844 Mutex::Autolock _l(thread->mLock);
845 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700846 wasActive = playbackThread->destroyTrack_l(this);
847 }
848 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700849 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800850 }
851 }
Kevin Rocardc43ea142019-01-31 18:17:37 -0800852 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Eric Laurent81784c32012-11-19 14:55:58 -0800853}
854
Andy Hungf6ab58d2018-05-25 12:50:39 -0700855void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800856{
Eric Laurent973db022018-11-20 14:54:31 -0800857 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700858 " Format Chn mask SRate "
859 "ST Usg CT "
860 " G db L dB R dB VS dB "
jiabin5eaf0962022-12-20 20:11:38 +0000861 " Server FrmCnt FrmRdy F Underruns Flushed BitPerfect"
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700862 "%s\n",
863 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800864}
865
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700866void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800867{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700868 char trackType;
869 switch (mType) {
870 case TYPE_DEFAULT:
871 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700872 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700873 trackType = 'S'; // static
874 } else {
875 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800876 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700877 break;
878 case TYPE_PATCH:
879 trackType = 'P';
880 break;
881 default:
882 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800883 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700884
885 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700886 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700887 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700888 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700889 }
890
Eric Laurent81784c32012-11-19 14:55:58 -0800891 char nowInUnderrun;
892 switch (mObservedUnderruns.mBitFields.mMostRecent) {
893 case UNDERRUN_FULL:
894 nowInUnderrun = ' ';
895 break;
896 case UNDERRUN_PARTIAL:
897 nowInUnderrun = '<';
898 break;
899 case UNDERRUN_EMPTY:
900 nowInUnderrun = '*';
901 break;
902 default:
903 nowInUnderrun = '?';
904 break;
905 }
Andy Hungda540db2017-04-20 14:06:17 -0700906
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700907 char fillingStatus;
908 switch (mFillingUpStatus) {
909 case FS_INVALID:
910 fillingStatus = 'I';
911 break;
912 case FS_FILLING:
913 fillingStatus = 'f';
914 break;
915 case FS_FILLED:
916 fillingStatus = 'F';
917 break;
918 case FS_ACTIVE:
919 fillingStatus = 'A';
920 break;
921 default:
922 fillingStatus = '?';
923 break;
924 }
925
926 // clip framesReadySafe to max representation in dump
927 const size_t framesReadySafe =
928 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
929
930 // obtain volumes
931 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
932 const std::pair<float /* volume */, bool /* active */> vsVolume =
933 mVolumeHandler->getLastVolume();
934
935 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
936 // as it may be reduced by the application.
937 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
938 // Check whether the buffer size has been modified by the app.
939 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
940 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
941 ? 'e' /* error */ : ' ' /* identical */;
942
Eric Laurent973db022018-11-20 14:54:31 -0800943 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700944 "%08X %08X %6u "
945 "%2u %3x %2x "
946 "%5.2g %5.2g %5.2g %5.2g%c "
jiabin5eaf0962022-12-20 20:11:38 +0000947 "%08X %6zu%c %6zu %c %9u%c %7u %10s",
Marco Nelissenb2208842014-02-07 14:00:50 -0800948 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700949 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700950 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -0800951 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -0800952 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700953 mCblk->mFlags,
954
Eric Laurent81784c32012-11-19 14:55:58 -0800955 mFormat,
956 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700957 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700958
959 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700960 mAttr.usage,
961 mAttr.content_type,
962
963 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700964 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
965 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700966 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
967 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700968
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700969 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700970 bufferSizeInFrames,
971 modifiedBufferChar,
972 framesReadySafe,
973 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700974 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800975 nowInUnderrun,
jiabin5eaf0962022-12-20 20:11:38 +0000976 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000,
977 isBitPerfect() ? "true" : "false"
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700978 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700979
980 if (isServerLatencySupported()) {
981 double latencyMs;
982 bool fromTrack;
983 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
984 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
985 // or 'k' if estimated from kernel because track frames haven't been presented yet.
986 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700987 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700988 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700989 }
990 }
991 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800992}
993
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800994uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
995 return mAudioTrackServerProxy->getSampleRate();
996}
997
Eric Laurent81784c32012-11-19 14:55:58 -0800998// AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800999status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08001000{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001001 ServerProxy::Buffer buf;
1002 size_t desiredFrames = buffer->frameCount;
1003 buf.mFrameCount = desiredFrames;
1004 status_t status = mServerProxy->obtainBuffer(&buf);
1005 buffer->frameCount = buf.mFrameCount;
1006 buffer->raw = buf.mRaw;
Andy Hungfc629172020-06-22 10:06:23 -07001007 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused() && !isOffloaded()) {
Andy Hung9d84af52018-09-12 18:03:44 -07001008 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
Andy Hung959b5b82021-09-24 10:46:20 -07001009 __func__, mId, buf.mFrameCount, desiredFrames, (int)mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -07001010 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08001011 } else {
1012 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -08001013 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001014 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08001015}
1016
Kevin Rocard153f92d2018-12-18 18:33:28 -08001017void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1018{
1019 interceptBuffer(*buffer);
1020 TrackBase::releaseBuffer(buffer);
1021}
1022
1023// TODO: compensate for time shift between HW modules.
1024void AudioFlinger::PlaybackThread::Track::interceptBuffer(
Kevin Rocarda134b002019-02-07 18:05:31 -08001025 const AudioBufferProvider::Buffer& sourceBuffer) {
Kevin Rocard6057fa22019-02-08 14:08:07 -08001026 auto start = std::chrono::steady_clock::now();
Kevin Rocarda134b002019-02-07 18:05:31 -08001027 const size_t frameCount = sourceBuffer.frameCount;
Kevin Rocardd83b08a2019-02-27 15:05:54 -08001028 if (frameCount == 0) {
1029 return; // No audio to intercept.
1030 // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
1031 // does not allow 0 frame size request contrary to getNextBuffer
1032 }
1033 for (auto& teePatch : mTeePatches) {
1034 RecordThread::PatchRecord* patchRecord = teePatch.patchRecord.get();
Mikhail Naganov8296c252019-09-25 14:59:54 -07001035 const size_t framesWritten = patchRecord->writeFrames(
1036 sourceBuffer.i8, frameCount, mFrameSize);
1037 const size_t framesLeft = frameCount - framesWritten;
Kevin Rocarda134b002019-02-07 18:05:31 -08001038 ALOGW_IF(framesLeft != 0, "%s(%d) PatchRecord %d can not provide big enough "
1039 "buffer %zu/%zu, dropping %zu frames", __func__, mId, patchRecord->mId,
1040 framesWritten, frameCount, framesLeft);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001041 }
Kevin Rocard6057fa22019-02-08 14:08:07 -08001042 auto spent = ceil<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
1043 using namespace std::chrono_literals;
1044 // Average is ~20us per track, this should virtually never be logged (Logging takes >200us)
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001045 ALOGD_IF(spent > 500us, "%s: took %lldus to intercept %zu tracks", __func__,
Kevin Rocard6057fa22019-02-08 14:08:07 -08001046 spent.count(), mTeePatches.size());
Kevin Rocard153f92d2018-12-18 18:33:28 -08001047}
1048
Glenn Kasten6466c9e2013-08-23 10:54:07 -07001049// ExtendedAudioBufferProvider interface
1050
Andy Hung27876c02014-09-09 18:07:55 -07001051// framesReady() may return an approximation of the number of frames if called
1052// from a different thread than the one calling Proxy->obtainBuffer() and
1053// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
1054// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -08001055size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -07001056 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
1057 // Static tracks return zero frames immediately upon stopping (for FastTracks).
1058 // The remainder of the buffer is not drained.
1059 return 0;
1060 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001061 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -08001062}
1063
Andy Hung818e7a32016-02-16 18:08:07 -08001064int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -07001065{
1066 return mAudioTrackServerProxy->framesReleased();
1067}
1068
Andy Hung818e7a32016-02-16 18:08:07 -08001069void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -08001070{
1071 // This call comes from a FastTrack and should be kept lockless.
1072 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -08001073 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -08001074
Andy Hung818e7a32016-02-16 18:08:07 -08001075 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -07001076
1077 // Compute latency.
1078 // TODO: Consider whether the server latency may be passed in by FastMixer
1079 // as a constant for all active FastTracks.
1080 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
1081 mServerLatencyFromTrack.store(true);
1082 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -08001083}
1084
Eric Laurent81784c32012-11-19 14:55:58 -08001085// Don't call for fast tracks; the framesReady() could result in priority inversion
1086bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001087 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
1088 return true;
1089 }
1090
Eric Laurent16498512014-03-17 17:22:08 -07001091 if (isStopping()) {
1092 if (framesReady() > 0) {
1093 mFillingUpStatus = FS_FILLED;
1094 }
Eric Laurent81784c32012-11-19 14:55:58 -08001095 return true;
1096 }
1097
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001098 size_t bufferSizeInFrames = mServerProxy->getBufferSizeInFrames();
Andy Hung3c7f47a2021-03-16 17:30:09 -07001099 // Note: mServerProxy->getStartThresholdInFrames() is clamped.
1100 const size_t startThresholdInFrames = mServerProxy->getStartThresholdInFrames();
1101 const size_t framesToBeReady = std::clamp( // clamp again to validate client values.
1102 std::min(startThresholdInFrames, bufferSizeInFrames), size_t(1), mFrameCount);
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001103
1104 if (framesReady() >= framesToBeReady || (mCblk->mFlags & CBLK_FORCEREADY)) {
1105 ALOGV("%s(%d): consider track ready with %zu/%zu, target was %zu)",
1106 __func__, mId, framesReady(), bufferSizeInFrames, framesToBeReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001107 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001108 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001109 return true;
1110 }
1111 return false;
1112}
1113
Glenn Kasten0f11b512014-01-31 16:18:54 -08001114status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -08001115 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001116{
1117 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -07001118 ALOGV("%s(%d): calling pid %d session %d",
1119 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001120
1121 sp<ThreadBase> thread = mThread.promote();
1122 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001123 if (isOffloaded()) {
1124 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
1125 Mutex::Autolock _lth(thread->mLock);
Andy Hungbd72c542023-06-20 18:56:17 -07001126 sp<IAfEffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001127 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
1128 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001129 invalidate();
1130 return PERMISSION_DENIED;
1131 }
1132 }
1133 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001134 track_state state = mState;
1135 // here the track could be either new, or restarted
1136 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -08001137
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001138 // initial state-stopping. next state-pausing.
1139 // What if resume is called ?
1140
Zhou Song1ed46a22020-08-17 15:36:56 +08001141 if (state == FLUSHED) {
1142 // avoid underrun glitches when starting after flush
1143 reset();
1144 }
1145
kuowei.li576f1362021-05-11 18:02:32 +08001146 // clear mPauseHwPending because of pause (and possibly flush) during underrun.
1147 mPauseHwPending = false;
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001148 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001149 if (mResumeToStopping) {
1150 // happened we need to resume to STOPPING_1
1151 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -07001152 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
1153 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001154 } else {
1155 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -07001156 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
1157 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001158 }
Eric Laurent81784c32012-11-19 14:55:58 -08001159 } else {
1160 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -07001161 ALOGV("%s(%d): ? => ACTIVE on thread %d",
1162 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001163 }
1164
yucliu91503922022-07-20 17:40:39 -07001165 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1166
1167 // states to reset position info for pcm tracks
1168 if (audio_is_linear_pcm(mFormat)
Andy Hunge10393e2015-06-12 13:59:33 -07001169 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
1170 mFrameMap.reset();
yucliu91503922022-07-20 17:40:39 -07001171
1172 if (!isFastTrack() && (isDirect() || isOffloaded())) {
1173 // Start point of track -> sink frame map. If the HAL returns a
1174 // frame position smaller than the first written frame in
1175 // updateTrackFrameInfo, the timestamp can be interpolated
1176 // instead of using a larger value.
1177 mFrameMap.push(mAudioTrackServerProxy->framesReleased(),
1178 playbackThread->framesWritten());
1179 }
Andy Hunge10393e2015-06-12 13:59:33 -07001180 }
Haynes Mathew George240934b2015-03-11 18:25:50 -07001181 if (isFastTrack()) {
1182 // refresh fast track underruns on start because that field is never cleared
1183 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
1184 // after stop.
1185 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
1186 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001187 status = playbackThread->addTrack_l(this);
jiabina84c3d32022-12-02 18:59:55 +00001188 if (status == INVALID_OPERATION || status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurent81784c32012-11-19 14:55:58 -08001189 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001190 // restore previous state if start was rejected by policy manager
jiabina84c3d32022-12-02 18:59:55 +00001191 if (status == PERMISSION_DENIED || status == DEAD_OBJECT) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001192 mState = state;
1193 }
1194 }
Andy Hung1d3556d2018-03-29 16:30:14 -07001195
Andy Hungb68f5eb2019-12-03 16:49:17 -08001196 // Audio timing metrics are computed a few mix cycles after starting.
1197 {
1198 mLogStartCountdown = LOG_START_COUNTDOWN;
1199 mLogStartTimeNs = systemTime();
1200 mLogStartFrames = mAudioTrackServerProxy->getTimestamp()
Andy Hung62921122020-05-18 10:47:31 -07001201 .mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1202 mLogLatencyMs = 0.;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001203 }
Andy Hungcb6cc752022-05-19 19:24:51 -07001204 mLogForceVolumeUpdate = true; // at least one volume logged for metrics when starting.
Andy Hungb68f5eb2019-12-03 16:49:17 -08001205
Andy Hung1d3556d2018-03-29 16:30:14 -07001206 if (status == NO_ERROR || status == ALREADY_EXISTS) {
1207 // for streaming tracks, remove the buffer read stop limit.
1208 mAudioTrackServerProxy->start();
1209 }
1210
Eric Laurentbfb1b832013-01-07 09:53:42 -08001211 // track was already in the active list, not a problem
1212 if (status == ALREADY_EXISTS) {
1213 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -07001214 } else {
1215 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
1216 // It is usually unsafe to access the server proxy from a binder thread.
1217 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
1218 // isn't looking at this track yet: we still hold the normal mixer thread lock,
1219 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -07001220 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -07001221 ServerProxy::Buffer buffer;
1222 buffer.mFrameCount = 1;
1223 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -08001224 }
1225 } else {
1226 status = BAD_VALUE;
1227 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001228 if (status == NO_ERROR) {
1229 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
Jean-Michel Trivi16395ca2022-12-11 22:10:11 +00001230
1231 // send format to AudioManager for playback activity monitoring
1232 sp<IAudioManager> audioManager = thread->mAudioFlinger->getOrCreateAudioManager();
1233 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1234 std::unique_ptr<os::PersistableBundle> bundle =
1235 std::make_unique<os::PersistableBundle>();
1236 bundle->putBoolean(String16(kExtraPlayerEventSpatializedKey),
1237 isSpatialized());
1238 bundle->putInt(String16(kExtraPlayerEventSampleRateKey), mSampleRate);
1239 bundle->putInt(String16(kExtraPlayerEventChannelMaskKey), mChannelMask);
1240 status_t result = audioManager->portEvent(mPortId,
1241 PLAYER_UPDATE_FORMAT, bundle);
1242 if (result != OK) {
1243 ALOGE("%s: unable to send playback format for port ID %d, status error %d",
1244 __func__, mPortId, result);
1245 }
1246 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001247 }
Eric Laurent81784c32012-11-19 14:55:58 -08001248 return status;
1249}
1250
1251void AudioFlinger::PlaybackThread::Track::stop()
1252{
Andy Hungc0691382018-09-12 18:01:57 -07001253 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001254 sp<ThreadBase> thread = mThread.promote();
1255 if (thread != 0) {
1256 Mutex::Autolock _l(thread->mLock);
1257 track_state state = mState;
1258 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
1259 // If the track is not active (PAUSED and buffers full), flush buffers
1260 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1261 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1262 reset();
1263 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -07001264 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001265 mState = STOPPED;
1266 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001267 // For fast tracks prepareTracks_l() will set state to STOPPING_2
1268 // presentation is complete
1269 // For an offloaded track this starts a drain and state will
1270 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -08001271 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -07001272 if (isOffloaded()) {
1273 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
1274 }
Eric Laurent81784c32012-11-19 14:55:58 -08001275 }
Eric Laurentb369caf2015-03-30 20:51:47 -07001276 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -07001277 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
1278 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001279 }
Eric Laurent81784c32012-11-19 14:55:58 -08001280 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001281 forEachTeePatchTrack([](auto patchTrack) { patchTrack->stop(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001282}
1283
1284void AudioFlinger::PlaybackThread::Track::pause()
1285{
Andy Hungc0691382018-09-12 18:01:57 -07001286 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001287 sp<ThreadBase> thread = mThread.promote();
1288 if (thread != 0) {
1289 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001290 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1291 switch (mState) {
1292 case STOPPING_1:
1293 case STOPPING_2:
1294 if (!isOffloaded()) {
1295 /* nothing to do if track is not offloaded */
1296 break;
1297 }
1298
1299 // Offloaded track was draining, we need to carry on draining when resumed
1300 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07001301 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001302 case ACTIVE:
1303 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -08001304 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -07001305 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
1306 __func__, mId, (int)mThreadIoHandle);
Kuowei Li23666472021-01-20 10:23:25 +08001307 if (isOffloadedOrDirect()) {
1308 mPauseHwPending = true;
1309 }
Eric Laurentede6c3b2013-09-19 14:37:46 -07001310 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001311 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001312
Eric Laurentbfb1b832013-01-07 09:53:42 -08001313 default:
1314 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001315 }
1316 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001317 // Pausing the TeePatch to avoid a glitch on underrun, at the cost of buffered audio loss.
1318 forEachTeePatchTrack([](auto patchTrack) { patchTrack->pause(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001319}
1320
1321void AudioFlinger::PlaybackThread::Track::flush()
1322{
Andy Hungc0691382018-09-12 18:01:57 -07001323 ALOGV("%s(%d)", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001324 sp<ThreadBase> thread = mThread.promote();
1325 if (thread != 0) {
1326 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001327 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001328
Phil Burk4bb650b2016-09-09 12:11:17 -07001329 // Flush the ring buffer now if the track is not active in the PlaybackThread.
1330 // Otherwise the flush would not be done until the track is resumed.
1331 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
1332 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1333 (void)mServerProxy->flushBufferIfNeeded();
1334 }
1335
Eric Laurentbfb1b832013-01-07 09:53:42 -08001336 if (isOffloaded()) {
1337 // If offloaded we allow flush during any state except terminated
1338 // and keep the track active to avoid problems if user is seeking
1339 // rapidly and underlying hardware has a significant delay handling
1340 // a pause
1341 if (isTerminated()) {
1342 return;
1343 }
1344
Andy Hung9d84af52018-09-12 18:03:44 -07001345 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001346 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001347
1348 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -07001349 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
1350 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001351 mState = ACTIVE;
1352 }
1353
Haynes Mathew George7844f672014-01-15 12:32:55 -08001354 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001355 mResumeToStopping = false;
1356 } else {
1357 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
1358 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
1359 return;
1360 }
1361 // No point remaining in PAUSED state after a flush => go to
1362 // FLUSHED state
1363 mState = FLUSHED;
1364 // do not reset the track if it is still in the process of being stopped or paused.
1365 // this will be done by prepareTracks_l() when the track is stopped.
1366 // prepareTracks_l() will see mState == FLUSHED, then
1367 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -08001368 if (isDirect()) {
1369 mFlushHwPending = true;
1370 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001371 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1372 reset();
1373 }
Eric Laurent81784c32012-11-19 14:55:58 -08001374 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001375 // Prevent flush being lost if the track is flushed and then resumed
1376 // before mixer thread can run. This is important when offloading
1377 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -07001378 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001379 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001380 // Flush the Tee to avoid on resume playing old data and glitching on the transition to new data
1381 forEachTeePatchTrack([](auto patchTrack) { patchTrack->flush(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001382}
1383
Haynes Mathew George7844f672014-01-15 12:32:55 -08001384// must be called with thread lock held
1385void AudioFlinger::PlaybackThread::Track::flushAck()
1386{
Andy Hung71ba4b32022-10-06 12:09:49 -07001387 if (!isOffloaded() && !isDirect()) {
Haynes Mathew George7844f672014-01-15 12:32:55 -08001388 return;
Andy Hung71ba4b32022-10-06 12:09:49 -07001389 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08001390
Phil Burk4bb650b2016-09-09 12:11:17 -07001391 // Clear the client ring buffer so that the app can prime the buffer while paused.
1392 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1393 mServerProxy->flushBufferIfNeeded();
1394
Haynes Mathew George7844f672014-01-15 12:32:55 -08001395 mFlushHwPending = false;
1396}
1397
Kuowei Li23666472021-01-20 10:23:25 +08001398void AudioFlinger::PlaybackThread::Track::pauseAck()
1399{
1400 mPauseHwPending = false;
1401}
1402
Eric Laurent81784c32012-11-19 14:55:58 -08001403void AudioFlinger::PlaybackThread::Track::reset()
1404{
1405 // Do not reset twice to avoid discarding data written just after a flush and before
1406 // the audioflinger thread detects the track is stopped.
1407 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001408 // Force underrun condition to avoid false underrun callback until first data is
1409 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001410 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001411 mFillingUpStatus = FS_FILLING;
1412 mResetDone = true;
1413 if (mState == FLUSHED) {
1414 mState = IDLE;
1415 }
1416 }
1417}
1418
Eric Laurentbfb1b832013-01-07 09:53:42 -08001419status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
1420{
1421 sp<ThreadBase> thread = mThread.promote();
1422 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001423 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001424 return FAILED_TRANSACTION;
1425 } else if ((thread->type() == ThreadBase::DIRECT) ||
1426 (thread->type() == ThreadBase::OFFLOAD)) {
1427 return thread->setParameters(keyValuePairs);
1428 } else {
1429 return PERMISSION_DENIED;
1430 }
1431}
1432
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001433status_t AudioFlinger::PlaybackThread::Track::selectPresentation(int presentationId,
1434 int programId) {
1435 sp<ThreadBase> thread = mThread.promote();
1436 if (thread == 0) {
1437 ALOGE("thread is dead");
1438 return FAILED_TRANSACTION;
1439 } else if ((thread->type() == ThreadBase::DIRECT) || (thread->type() == ThreadBase::OFFLOAD)) {
1440 DirectOutputThread *directOutputThread = static_cast<DirectOutputThread*>(thread.get());
1441 return directOutputThread->selectPresentation(presentationId, programId);
1442 }
1443 return INVALID_OPERATION;
1444}
1445
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001446VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
1447 const sp<VolumeShaper::Configuration>& configuration,
1448 const sp<VolumeShaper::Operation>& operation)
1449{
Andy Hungee86cee2022-12-13 19:19:53 -08001450 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung10cbff12017-02-21 17:30:14 -08001451
1452 if (isOffloadedOrDirect()) {
1453 // Signal thread to fetch new volume.
1454 sp<ThreadBase> thread = mThread.promote();
1455 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001456 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001457 thread->broadcast_l();
1458 }
1459 }
1460 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001461}
1462
1463sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1464{
1465 // Note: We don't check if Thread exists.
1466
1467 // mVolumeHandler is thread safe.
1468 return mVolumeHandler->getVolumeShaperState(id);
1469}
1470
jiabin76d94692022-12-15 21:51:21 +00001471void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volumeLeft, float volumeRight)
Kevin Rocard12381092018-04-11 09:19:59 -07001472{
jiabin76d94692022-12-15 21:51:21 +00001473 mFinalVolumeLeft = volumeLeft;
1474 mFinalVolumeRight = volumeRight;
1475 const float volume = (volumeLeft + volumeRight) * 0.5f;
Kevin Rocard12381092018-04-11 09:19:59 -07001476 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1477 mFinalVolume = volume;
1478 setMetadataHasChanged();
Andy Hungcb6cc752022-05-19 19:24:51 -07001479 mLogForceVolumeUpdate = true;
1480 }
1481 if (mLogForceVolumeUpdate) {
1482 mLogForceVolumeUpdate = false;
1483 mTrackMetrics.logVolume(mFinalVolume);
Kevin Rocard12381092018-04-11 09:19:59 -07001484 }
1485}
1486
1487void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1488{
Eric Laurent49e39282022-06-24 18:42:45 +02001489 // Do not forward metadata for PatchTrack with unspecified stream type
1490 if (mStreamType == AUDIO_STREAM_PATCH) {
1491 return;
1492 }
1493
Eric Laurent94579172020-11-20 18:41:04 +01001494 playback_track_metadata_v7_t metadata;
1495 metadata.base = {
Kevin Rocard12381092018-04-11 09:19:59 -07001496 .usage = mAttr.usage,
1497 .content_type = mAttr.content_type,
1498 .gain = mFinalVolume,
1499 };
Eric Laurentfdf99502021-11-26 19:05:02 +01001500
1501 // When attributes are undefined, derive default values from stream type.
1502 // See AudioAttributes.java, usageForStreamType() and Builder.setInternalLegacyStreamType()
1503 if (mAttr.usage == AUDIO_USAGE_UNKNOWN) {
1504 switch (mStreamType) {
1505 case AUDIO_STREAM_VOICE_CALL:
1506 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION;
1507 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1508 break;
1509 case AUDIO_STREAM_SYSTEM:
1510 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION;
1511 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1512 break;
1513 case AUDIO_STREAM_RING:
1514 metadata.base.usage = AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
1515 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1516 break;
1517 case AUDIO_STREAM_MUSIC:
1518 metadata.base.usage = AUDIO_USAGE_MEDIA;
1519 metadata.base.content_type = AUDIO_CONTENT_TYPE_MUSIC;
1520 break;
1521 case AUDIO_STREAM_ALARM:
1522 metadata.base.usage = AUDIO_USAGE_ALARM;
1523 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1524 break;
1525 case AUDIO_STREAM_NOTIFICATION:
1526 metadata.base.usage = AUDIO_USAGE_NOTIFICATION;
1527 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1528 break;
1529 case AUDIO_STREAM_DTMF:
1530 metadata.base.usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
1531 metadata.base.content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
1532 break;
1533 case AUDIO_STREAM_ACCESSIBILITY:
1534 metadata.base.usage = AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
1535 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1536 break;
1537 case AUDIO_STREAM_ASSISTANT:
1538 metadata.base.usage = AUDIO_USAGE_ASSISTANT;
1539 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1540 break;
1541 case AUDIO_STREAM_REROUTING:
1542 metadata.base.usage = AUDIO_USAGE_VIRTUAL_SOURCE;
1543 // unknown content type
1544 break;
1545 case AUDIO_STREAM_CALL_ASSISTANT:
1546 metadata.base.usage = AUDIO_USAGE_CALL_ASSISTANT;
1547 metadata.base.content_type = AUDIO_CONTENT_TYPE_SPEECH;
1548 break;
1549 default:
1550 break;
1551 }
1552 }
1553
Eric Laurent78b07302022-10-07 16:20:34 +02001554 metadata.channel_mask = mChannelMask;
Eric Laurent94579172020-11-20 18:41:04 +01001555 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
1556 *backInserter++ = metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07001557}
1558
Jiabin Huangfb476842022-12-06 03:18:10 +00001559void AudioFlinger::PlaybackThread::Track::updateTeePatches() {
1560 if (mTeePatchesToUpdate.has_value()) {
1561 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
1562 mTeePatches = mTeePatchesToUpdate.value();
1563 if (mState == TrackBase::ACTIVE || mState == TrackBase::RESUMING ||
1564 mState == TrackBase::STOPPING_1) {
1565 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1566 }
1567 mTeePatchesToUpdate.reset();
jiabinf042b9b2021-05-07 23:46:28 +00001568 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001569}
1570
Jiabin Huangfb476842022-12-06 03:18:10 +00001571void AudioFlinger::PlaybackThread::Track::setTeePatchesToUpdate(TeePatches teePatchesToUpdate) {
1572 ALOGW_IF(mTeePatchesToUpdate.has_value(),
1573 "%s, existing tee patches to update will be ignored", __func__);
1574 mTeePatchesToUpdate = std::move(teePatchesToUpdate);
1575}
1576
Vlad Popae8d99472022-06-30 16:02:48 +02001577// must be called with player thread lock held
1578void AudioFlinger::PlaybackThread::Track::processMuteEvent_l(const sp<
1579 IAudioManager>& audioManager, mute_state_t muteState)
1580{
1581 if (mMuteState == muteState) {
1582 // mute state did not change, do nothing
1583 return;
1584 }
1585
1586 status_t result = UNKNOWN_ERROR;
1587 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
1588 if (mMuteEventExtras == nullptr) {
1589 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
1590 }
1591 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
1592 static_cast<int>(muteState));
1593
1594 result = audioManager->portEvent(mPortId,
1595 PLAYER_UPDATE_MUTED,
1596 mMuteEventExtras);
1597 }
1598
1599 if (result == OK) {
1600 mMuteState = muteState;
1601 } else {
1602 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
1603 __func__,
1604 id(),
1605 mPortId,
1606 result);
Andy Hung818e7a32016-02-16 18:08:07 -08001607 }
Glenn Kastenfe346c72013-08-30 13:28:22 -07001608}
Glenn Kasten573d80a2013-08-26 09:36:23 -07001609
1610status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
Glenn Kastenfe346c72013-08-30 13:28:22 -07001611{
Glenn Kasten573d80a2013-08-26 09:36:23 -07001612 if (!isOffloaded() && !isDirect()) {
Phil Burk6140c792015-03-19 14:30:21 -07001613 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kasten573d80a2013-08-26 09:36:23 -07001614 }
1615 sp<ThreadBase> thread = mThread.promote();
Andy Hung818e7a32016-02-16 18:08:07 -08001616 if (thread == 0) {
Glenn Kasten573d80a2013-08-26 09:36:23 -07001617 return INVALID_OPERATION;
1618 }
Eric Laurent81784c32012-11-19 14:55:58 -08001619
1620 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001621 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurent6c796322019-04-09 14:13:17 -07001622 return playbackThread->getTimestamp_l(timestamp);
1623}
1624
Eric Laurent81784c32012-11-19 14:55:58 -08001625status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
Eric Laurent6c796322019-04-09 14:13:17 -07001626{
1627 sp<ThreadBase> thread = mThread.promote();
1628 if (thread == nullptr) {
1629 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08001630 }
Eric Laurent6c796322019-04-09 14:13:17 -07001631
1632 sp<PlaybackThread> dstThread = (PlaybackThread *)thread.get();
1633 sp<PlaybackThread> srcThread; // srcThread is initialized by call to moveAuxEffectToIo()
1634 sp<AudioFlinger> af = mClient->audioFlinger();
Eric Laurent81784c32012-11-19 14:55:58 -08001635 status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
Eric Laurent6c796322019-04-09 14:13:17 -07001636
1637 if (EffectId != 0 && status == NO_ERROR) {
1638 status = dstThread->attachAuxEffect(this, EffectId);
1639 if (status == NO_ERROR) {
Eric Laurent81784c32012-11-19 14:55:58 -08001640 AudioSystem::moveEffectsToIo(std::vector<int>(EffectId), dstThread->id());
1641 }
1642 }
1643
1644 if (status != NO_ERROR && srcThread != nullptr) {
1645 af->moveAuxEffectToIo(EffectId, srcThread, &dstThread);
1646 }
1647 return status;
1648}
1649
Andy Hung818e7a32016-02-16 18:08:07 -08001650void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1651{
Eric Laurent81784c32012-11-19 14:55:58 -08001652 mAuxEffectId = EffectId;
Andy Hung818e7a32016-02-16 18:08:07 -08001653 mAuxBuffer = buffer;
1654}
1655
Andy Hung59de4262021-06-14 10:53:54 -07001656// presentationComplete verified by frames, used by Mixed tracks.
Eric Laurent81784c32012-11-19 14:55:58 -08001657bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1658 int64_t framesWritten, size_t audioHalFrames)
1659{
1660 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1661 // This assists in proper timestamp computation as well as wakelock management.
1662
1663 // a track is considered presented when the total number of frames written to audio HAL
1664 // corresponds to the number of frames written when presentationComplete() is called for the
1665 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001666 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1667 // to detect when all frames have been played. In this case framesWritten isn't
1668 // useful because it doesn't always reflect whether there is data in the h/w
1669 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001670 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1671 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001672 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001673 if (mPresentationCompleteFrames == 0) {
1674 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001675 ALOGV("%s(%d): set:"
Andy Hung9d84af52018-09-12 18:03:44 -07001676 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1677 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001678 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001679 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001680
Andy Hungc54b1ff2016-02-23 14:07:07 -08001681 bool complete;
Andy Hung59de4262021-06-14 10:53:54 -07001682 if (isFastTrack()) { // does not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001683 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hung59de4262021-06-14 10:53:54 -07001684 ALOGV("%s(%d): %s framesWritten:%lld mPresentationCompleteFrames:%lld",
1685 __func__, mId, (complete ? "complete" : "waiting"),
1686 (long long) framesWritten, (long long) mPresentationCompleteFrames);
Andy Hungc54b1ff2016-02-23 14:07:07 -08001687 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001688 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001689 && mAudioTrackServerProxy->isDrained();
1690 }
1691
1692 if (complete) {
Andy Hung59de4262021-06-14 10:53:54 -07001693 notifyPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08001694 return true;
1695 }
1696 return false;
1697}
1698
Andy Hung59de4262021-06-14 10:53:54 -07001699// presentationComplete checked by time, used by DirectTracks.
1700bool AudioFlinger::PlaybackThread::Track::presentationComplete(uint32_t latencyMs)
1701{
1702 // For Offloaded or Direct tracks.
1703
1704 // For a direct track, we incorporated time based testing for presentationComplete.
1705
1706 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1707 // to detect when all frames have been played. In this case latencyMs isn't
1708 // useful because it doesn't always reflect whether there is data in the h/w
1709 // buffers, particularly if a track has been paused and resumed during draining
1710
1711 constexpr float MIN_SPEED = 0.125f; // min speed scaling allowed for timely response.
1712 if (mPresentationCompleteTimeNs == 0) {
1713 mPresentationCompleteTimeNs = systemTime() + latencyMs * 1e6 / fmax(mSpeed, MIN_SPEED);
1714 ALOGV("%s(%d): set: latencyMs %u mPresentationCompleteTimeNs:%lld",
1715 __func__, mId, latencyMs, (long long) mPresentationCompleteTimeNs);
1716 }
1717
1718 bool complete;
1719 if (isOffloaded()) {
1720 complete = true;
1721 } else { // Direct
1722 complete = systemTime() >= mPresentationCompleteTimeNs;
1723 ALOGV("%s(%d): %s", __func__, mId, (complete ? "complete" : "waiting"));
1724 }
1725 if (complete) {
1726 notifyPresentationComplete();
1727 return true;
1728 }
1729 return false;
1730}
1731
1732void AudioFlinger::PlaybackThread::Track::notifyPresentationComplete()
1733{
1734 // This only triggers once. TODO: should we enforce this?
1735 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
1736 mAudioTrackServerProxy->setStreamEndDone();
1737}
1738
Eric Laurent81784c32012-11-19 14:55:58 -08001739void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1740{
Andy Hung068e08e2023-05-15 19:02:55 -07001741 for (auto it = mSyncEvents.begin(); it != mSyncEvents.end();) {
1742 if ((*it)->type() == type) {
Andy Hung93bb5732023-05-04 21:16:34 -07001743 ALOGV("%s: triggering SyncEvent type %d", __func__, type);
Andy Hung068e08e2023-05-15 19:02:55 -07001744 (*it)->trigger();
1745 it = mSyncEvents.erase(it);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001746 } else {
Andy Hung068e08e2023-05-15 19:02:55 -07001747 ++it;
Eric Laurent81784c32012-11-19 14:55:58 -08001748 }
1749 }
1750}
1751
1752// implement VolumeBufferProvider interface
1753
Glenn Kastenc56f3422014-03-21 17:53:17 -07001754gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001755{
1756 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1757 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001758 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1759 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1760 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001761 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001762 if (vl > GAIN_FLOAT_UNITY) {
1763 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001764 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001765 if (vr > GAIN_FLOAT_UNITY) {
1766 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001767 }
1768 // now apply the cached master volume and stream type volume;
1769 // this is trusted but lacks any synchronization or barrier so may be stale
1770 float v = mCachedVolume;
1771 vl *= v;
1772 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001773 // re-combine into packed minifloat
1774 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001775 // FIXME look at mute, pause, and stop flags
1776 return vlr;
1777}
1778
Andy Hung068e08e2023-05-15 19:02:55 -07001779status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(
1780 const sp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -08001781{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001782 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001783 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1784 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001785 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1786 __func__, mId,
Andy Hung959b5b82021-09-24 10:46:20 -07001787 (int)mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
Eric Laurent81784c32012-11-19 14:55:58 -08001788 event->cancel();
1789 return INVALID_OPERATION;
1790 }
1791 (void) TrackBase::setSyncEvent(event);
1792 return NO_ERROR;
1793}
1794
Glenn Kasten5736c352012-12-04 12:12:34 -08001795void AudioFlinger::PlaybackThread::Track::invalidate()
1796{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001797 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001798 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001799}
1800
1801void AudioFlinger::PlaybackThread::Track::disable()
1802{
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001803 // TODO(b/142394888): the filling status should also be reset to filling
Eric Laurent4d231dc2016-03-11 18:38:23 -08001804 signalClientFlag(CBLK_DISABLED);
1805}
1806
1807void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1808{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001809 // FIXME should use proxy, and needs work
1810 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001811 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001812 android_atomic_release_store(0x40000000, &cblk->mFutex);
1813 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001814 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001815}
1816
Eric Laurent59fe0102013-09-27 18:48:26 -07001817void AudioFlinger::PlaybackThread::Track::signal()
1818{
1819 sp<ThreadBase> thread = mThread.promote();
1820 if (thread != 0) {
1821 PlaybackThread *t = (PlaybackThread *)thread.get();
1822 Mutex::Autolock _l(t->mLock);
1823 t->broadcast_l();
1824 }
1825}
1826
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001827status_t AudioFlinger::PlaybackThread::Track::getDualMonoMode(audio_dual_mono_mode_t* mode)
1828{
1829 status_t status = INVALID_OPERATION;
1830 if (isOffloadedOrDirect()) {
1831 sp<ThreadBase> thread = mThread.promote();
1832 if (thread != nullptr) {
1833 PlaybackThread *t = (PlaybackThread *)thread.get();
1834 Mutex::Autolock _l(t->mLock);
1835 status = t->mOutput->stream->getDualMonoMode(mode);
1836 ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
1837 "%s: mode %d inconsistent", __func__, mDualMonoMode);
1838 }
1839 }
1840 return status;
1841}
1842
1843status_t AudioFlinger::PlaybackThread::Track::setDualMonoMode(audio_dual_mono_mode_t mode)
1844{
1845 status_t status = INVALID_OPERATION;
1846 if (isOffloadedOrDirect()) {
1847 sp<ThreadBase> thread = mThread.promote();
1848 if (thread != nullptr) {
1849 auto t = static_cast<PlaybackThread *>(thread.get());
1850 Mutex::Autolock lock(t->mLock);
1851 status = t->mOutput->stream->setDualMonoMode(mode);
1852 if (status == NO_ERROR) {
1853 mDualMonoMode = mode;
1854 }
1855 }
1856 }
1857 return status;
1858}
1859
1860status_t AudioFlinger::PlaybackThread::Track::getAudioDescriptionMixLevel(float* leveldB)
1861{
1862 status_t status = INVALID_OPERATION;
1863 if (isOffloadedOrDirect()) {
1864 sp<ThreadBase> thread = mThread.promote();
1865 if (thread != nullptr) {
1866 auto t = static_cast<PlaybackThread *>(thread.get());
1867 Mutex::Autolock lock(t->mLock);
1868 status = t->mOutput->stream->getAudioDescriptionMixLevel(leveldB);
1869 ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
1870 "%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
1871 }
1872 }
1873 return status;
1874}
1875
1876status_t AudioFlinger::PlaybackThread::Track::setAudioDescriptionMixLevel(float leveldB)
1877{
1878 status_t status = INVALID_OPERATION;
1879 if (isOffloadedOrDirect()) {
1880 sp<ThreadBase> thread = mThread.promote();
1881 if (thread != nullptr) {
1882 auto t = static_cast<PlaybackThread *>(thread.get());
1883 Mutex::Autolock lock(t->mLock);
1884 status = t->mOutput->stream->setAudioDescriptionMixLevel(leveldB);
1885 if (status == NO_ERROR) {
1886 mAudioDescriptionMixLevel = leveldB;
1887 }
1888 }
1889 }
1890 return status;
1891}
1892
1893status_t AudioFlinger::PlaybackThread::Track::getPlaybackRateParameters(
1894 audio_playback_rate_t* playbackRate)
1895{
1896 status_t status = INVALID_OPERATION;
1897 if (isOffloadedOrDirect()) {
1898 sp<ThreadBase> thread = mThread.promote();
1899 if (thread != nullptr) {
1900 auto t = static_cast<PlaybackThread *>(thread.get());
1901 Mutex::Autolock lock(t->mLock);
1902 status = t->mOutput->stream->getPlaybackRateParameters(playbackRate);
1903 ALOGD_IF((status == NO_ERROR) &&
1904 !isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
1905 "%s: playbackRate inconsistent", __func__);
1906 }
1907 }
1908 return status;
1909}
1910
1911status_t AudioFlinger::PlaybackThread::Track::setPlaybackRateParameters(
1912 const audio_playback_rate_t& playbackRate)
1913{
1914 status_t status = INVALID_OPERATION;
1915 if (isOffloadedOrDirect()) {
1916 sp<ThreadBase> thread = mThread.promote();
1917 if (thread != nullptr) {
1918 auto t = static_cast<PlaybackThread *>(thread.get());
1919 Mutex::Autolock lock(t->mLock);
1920 status = t->mOutput->stream->setPlaybackRateParameters(playbackRate);
1921 if (status == NO_ERROR) {
1922 mPlaybackRateParameters = playbackRate;
1923 }
1924 }
1925 }
1926 return status;
1927}
1928
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001929//To be called with thread lock held
1930bool AudioFlinger::PlaybackThread::Track::isResumePending() {
Andy Hung71ba4b32022-10-06 12:09:49 -07001931 if (mState == RESUMING) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001932 return true;
Andy Hung71ba4b32022-10-06 12:09:49 -07001933 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001934 /* Resume is pending if track was stopping before pause was called */
1935 if (mState == STOPPING_1 &&
Andy Hung71ba4b32022-10-06 12:09:49 -07001936 mResumeToStopping) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001937 return true;
Andy Hung71ba4b32022-10-06 12:09:49 -07001938 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001939
1940 return false;
1941}
1942
1943//To be called with thread lock held
1944void AudioFlinger::PlaybackThread::Track::resumeAck() {
Andy Hung71ba4b32022-10-06 12:09:49 -07001945 if (mState == RESUMING) {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001946 mState = ACTIVE;
Andy Hung71ba4b32022-10-06 12:09:49 -07001947 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001948
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001949 // Other possibility of pending resume is stopping_1 state
1950 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001951 // drain being called.
1952 if (mState == STOPPING_1) {
1953 mResumeToStopping = false;
1954 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001955}
Andy Hunge10393e2015-06-12 13:59:33 -07001956
1957//To be called with thread lock held
1958void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001959 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001960 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07001961 // Make the kernel frametime available.
1962 const FrameTime ft{
1963 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
1964 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
1965 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
1966 mKernelFrameTime.store(ft);
1967 if (!audio_is_linear_pcm(mFormat)) {
1968 return;
1969 }
1970
Andy Hung818e7a32016-02-16 18:08:07 -08001971 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001972 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001973
1974 // adjust server times and set drained state.
1975 //
1976 // Our timestamps are only updated when the track is on the Thread active list.
1977 // We need to ensure that tracks are not removed before full drain.
1978 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001979 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001980 bool checked = false;
1981 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1982 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1983 // Lookup the track frame corresponding to the sink frame position.
1984 if (local.mTimeNs[i] > 0) {
1985 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1986 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001987 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001988 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001989 checked = true;
1990 }
1991 }
Andy Hunge10393e2015-06-12 13:59:33 -07001992 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001993
Andy Hung93bb5732023-05-04 21:16:34 -07001994 ALOGV("%s: trackFramesReleased:%lld sinkFramesWritten:%lld setDrained: %d",
1995 __func__, (long long)trackFramesReleased, (long long)sinkFramesWritten, drained);
Andy Hungcef2daa2018-06-01 15:31:49 -07001996 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001997 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001998 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001999 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07002000
2001 // Compute latency info.
2002 const bool useTrackTimestamp = !drained;
2003 const double latencyMs = useTrackTimestamp
2004 ? local.getOutputServerLatencyMs(sampleRate())
2005 : timeStamp.getOutputServerLatencyMs(halSampleRate);
2006
2007 mServerLatencyFromTrack.store(useTrackTimestamp);
2008 mServerLatencyMs.store(latencyMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08002009
Andy Hung62921122020-05-18 10:47:31 -07002010 if (mLogStartCountdown > 0
2011 && local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0
2012 && local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] > 0)
2013 {
2014 if (mLogStartCountdown > 1) {
2015 --mLogStartCountdown;
2016 } else if (latencyMs < mLogLatencyMs) { // wait for latency to stabilize (dip)
2017 mLogStartCountdown = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002018 // startup is the difference in times for the current timestamp and our start
2019 double startUpMs =
Andy Hung62921122020-05-18 10:47:31 -07002020 (local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartTimeNs) * 1e-6;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002021 // adjust for frames played.
Andy Hung62921122020-05-18 10:47:31 -07002022 startUpMs -= (local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartFrames)
2023 * 1e3 / mSampleRate;
2024 ALOGV("%s: latencyMs:%lf startUpMs:%lf"
2025 " localTime:%lld startTime:%lld"
2026 " localPosition:%lld startPosition:%lld",
2027 __func__, latencyMs, startUpMs,
2028 (long long)local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08002029 (long long)mLogStartTimeNs,
Andy Hung62921122020-05-18 10:47:31 -07002030 (long long)local.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08002031 (long long)mLogStartFrames);
Andy Hungc2b11cb2020-04-22 09:04:01 -07002032 mTrackMetrics.logLatencyAndStartup(latencyMs, startUpMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08002033 }
Andy Hung62921122020-05-18 10:47:31 -07002034 mLogLatencyMs = latencyMs;
Andy Hungb68f5eb2019-12-03 16:49:17 -08002035 }
Andy Hunge10393e2015-06-12 13:59:33 -07002036}
2037
SPeak Shen0db56b32022-11-11 00:28:50 +08002038bool AudioFlinger::PlaybackThread::Track::AudioVibrationController::setMute(bool muted) {
jiabin57303cc2018-12-18 15:45:57 -08002039 sp<ThreadBase> thread = mTrack->mThread.promote();
2040 if (thread != 0) {
2041 // Lock for updating mHapticPlaybackEnabled.
2042 Mutex::Autolock _l(thread->mLock);
2043 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2044 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
2045 && playbackThread->mHapticChannelCount > 0) {
SPeak Shenc19aa9e2022-11-11 00:28:50 +08002046 ALOGD("%s, haptic playback was %s for track %d",
2047 __func__, muted ? "muted" : "unmuted", mTrack->id());
SPeak Shen0db56b32022-11-11 00:28:50 +08002048 mTrack->setHapticPlaybackEnabled(!muted);
2049 return true;
jiabin57303cc2018-12-18 15:45:57 -08002050 }
2051 }
SPeak Shen0db56b32022-11-11 00:28:50 +08002052 return false;
2053}
2054
2055binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::mute(
2056 /*out*/ bool *ret) {
2057 *ret = setMute(true);
jiabin57303cc2018-12-18 15:45:57 -08002058 return binder::Status::ok();
2059}
2060
2061binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::unmute(
2062 /*out*/ bool *ret) {
SPeak Shen0db56b32022-11-11 00:28:50 +08002063 *ret = setMute(false);
jiabin57303cc2018-12-18 15:45:57 -08002064 return binder::Status::ok();
2065}
2066
Eric Laurent81784c32012-11-19 14:55:58 -08002067// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002068#undef LOG_TAG
2069#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002070
Eric Laurent81784c32012-11-19 14:55:58 -08002071AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
2072 PlaybackThread *playbackThread,
2073 DuplicatingThread *sourceThread,
2074 uint32_t sampleRate,
2075 audio_format_t format,
2076 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002077 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002078 const AttributionSourceState& attributionSource)
Eric Laurent223fd5c2014-11-11 13:43:36 -08002079 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002080 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002081 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002082 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002083 AUDIO_SESSION_NONE, getpid(), attributionSource, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08002084 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07002085 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08002086{
2087
2088 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08002089 mOutBuffer.frameCount = 0;
2090 playbackThread->mTracks.add(this);
Andy Hung9d84af52018-09-12 18:03:44 -07002091 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002092 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07002093 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08002094 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08002095 // since client and server are in the same process,
2096 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07002097 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
2098 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07002099 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07002100 mClientProxy->setSendLevel(0.0);
2101 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08002102 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07002103 ALOGW("%s(%d): Error creating output track on thread %d",
2104 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08002105 }
2106}
2107
2108AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
2109{
2110 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08002111 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08002112}
2113
2114status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002115 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002116{
2117 status_t status = Track::start(event, triggerSession);
2118 if (status != NO_ERROR) {
2119 return status;
2120 }
2121
2122 mActive = true;
2123 mRetryCount = 127;
2124 return status;
2125}
2126
2127void AudioFlinger::PlaybackThread::OutputTrack::stop()
2128{
2129 Track::stop();
2130 clearBufferQueue();
2131 mOutBuffer.frameCount = 0;
2132 mActive = false;
2133}
2134
Andy Hung1c86ebe2018-05-29 20:29:08 -07002135ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08002136{
Eric Laurent19952e12023-04-20 10:08:29 +02002137 if (!mActive && frames != 0) {
2138 sp<ThreadBase> thread = mThread.promote();
2139 if (thread != nullptr && thread->standby()) {
2140 // preload one silent buffer to trigger mixer on start()
2141 ClientProxy::Buffer buf { .mFrameCount = mClientProxy->getStartThresholdInFrames() };
2142 status_t status = mClientProxy->obtainBuffer(&buf);
2143 if (status != NO_ERROR && status != NOT_ENOUGH_DATA && status != WOULD_BLOCK) {
2144 ALOGE("%s(%d): could not obtain buffer on start", __func__, mId);
2145 return 0;
2146 }
2147 memset(buf.mRaw, 0, buf.mFrameCount * mFrameSize);
2148 mClientProxy->releaseBuffer(&buf);
2149
2150 (void) start();
2151
2152 // wait for HAL stream to start before sending actual audio. Doing this on each
2153 // OutputTrack makes that playback start on all output streams is synchronized.
2154 // If another OutputTrack has already started it can underrun but this is OK
2155 // as only silence has been played so far and the retry count is very high on
2156 // OutputTrack.
2157 auto pt = static_cast<PlaybackThread *>(thread.get());
2158 if (!pt->waitForHalStart()) {
2159 ALOGW("%s(%d): timeout waiting for thread to exit standby", __func__, mId);
2160 stop();
2161 return 0;
2162 }
2163
2164 // enqueue the first buffer and exit so that other OutputTracks will also start before
2165 // write() is called again and this buffer actually consumed.
2166 Buffer firstBuffer;
2167 firstBuffer.frameCount = frames;
2168 firstBuffer.raw = data;
2169 queueBuffer(firstBuffer);
2170 return frames;
2171 } else {
2172 (void) start();
2173 }
2174 }
2175
Eric Laurent81784c32012-11-19 14:55:58 -08002176 Buffer *pInBuffer;
2177 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08002178 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002179 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08002180 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
Eric Laurent81784c32012-11-19 14:55:58 -08002181 while (waitTimeLeftMs) {
2182 // First write pending buffers, then new data
2183 if (mBufferQueue.size()) {
2184 pInBuffer = mBufferQueue.itemAt(0);
2185 } else {
2186 pInBuffer = &inBuffer;
2187 }
2188
2189 if (pInBuffer->frameCount == 0) {
2190 break;
2191 }
2192
2193 if (mOutBuffer.frameCount == 0) {
2194 mOutBuffer.frameCount = pInBuffer->frameCount;
2195 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002196 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002197 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07002198 ALOGV("%s(%d): thread %d no more output buffers; status %d",
2199 __func__, mId,
2200 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08002201 break;
2202 }
2203 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
2204 if (waitTimeLeftMs >= waitTimeMs) {
2205 waitTimeLeftMs -= waitTimeMs;
2206 } else {
2207 waitTimeLeftMs = 0;
2208 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002209 if (status == NOT_ENOUGH_DATA) {
2210 restartIfDisabled();
2211 continue;
2212 }
Eric Laurent81784c32012-11-19 14:55:58 -08002213 }
2214
2215 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
2216 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08002217 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002218 Proxy::Buffer buf;
2219 buf.mFrameCount = outFrames;
2220 buf.mRaw = NULL;
2221 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002222 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08002223 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002224 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002225 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08002226 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002227
2228 if (pInBuffer->frameCount == 0) {
2229 if (mBufferQueue.size()) {
2230 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08002231 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07002232 if (pInBuffer != &inBuffer) {
2233 delete pInBuffer;
2234 }
Andy Hung9d84af52018-09-12 18:03:44 -07002235 ALOGV("%s(%d): thread %d released overflow buffer %zu",
2236 __func__, mId,
2237 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002238 } else {
2239 break;
2240 }
2241 }
2242 }
2243
2244 // If we could not write all frames, allocate a buffer and queue it for next time.
2245 if (inBuffer.frameCount) {
2246 sp<ThreadBase> thread = mThread.promote();
2247 if (thread != 0 && !thread->standby()) {
Eric Laurent19952e12023-04-20 10:08:29 +02002248 queueBuffer(inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002249 }
2250 }
2251
Andy Hungc25b84a2015-01-14 19:04:10 -08002252 // Calling write() with a 0 length buffer means that no more data will be written:
2253 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
2254 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
2255 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08002256 }
2257
Andy Hung1c86ebe2018-05-29 20:29:08 -07002258 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08002259}
2260
Eric Laurent19952e12023-04-20 10:08:29 +02002261void AudioFlinger::PlaybackThread::OutputTrack::queueBuffer(Buffer& inBuffer) {
2262
2263 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
2264 Buffer *pInBuffer = new Buffer;
2265 const size_t bufferSize = inBuffer.frameCount * mFrameSize;
2266 pInBuffer->mBuffer = malloc(bufferSize);
2267 LOG_ALWAYS_FATAL_IF(pInBuffer->mBuffer == nullptr,
2268 "%s: Unable to malloc size %zu", __func__, bufferSize);
2269 pInBuffer->frameCount = inBuffer.frameCount;
2270 pInBuffer->raw = pInBuffer->mBuffer;
2271 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
2272 mBufferQueue.add(pInBuffer);
2273 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
2274 (int)mThreadIoHandle, mBufferQueue.size());
2275 // audio data is consumed (stored locally); set frameCount to 0.
2276 inBuffer.frameCount = 0;
2277 } else {
2278 ALOGW("%s(%d): thread %d no more overflow buffers",
2279 __func__, mId, (int)mThreadIoHandle);
2280 // TODO: return error for this.
2281 }
2282}
2283
Kevin Rocard12381092018-04-11 09:19:59 -07002284void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
2285{
2286 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2287 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
2288}
2289
2290void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
2291 {
2292 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
2293 mTrackMetadatas = metadatas;
2294 }
2295 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
2296 setMetadataHasChanged();
2297}
2298
Eric Laurent81784c32012-11-19 14:55:58 -08002299status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
2300 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
2301{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002302 ClientProxy::Buffer buf;
2303 buf.mFrameCount = buffer->frameCount;
2304 struct timespec timeout;
2305 timeout.tv_sec = waitTimeMs / 1000;
2306 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
2307 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
2308 buffer->frameCount = buf.mFrameCount;
2309 buffer->raw = buf.mRaw;
2310 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002311}
2312
Eric Laurent81784c32012-11-19 14:55:58 -08002313void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
2314{
2315 size_t size = mBufferQueue.size();
2316
2317 for (size_t i = 0; i < size; i++) {
2318 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08002319 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002320 delete pBuffer;
2321 }
2322 mBufferQueue.clear();
2323}
2324
Eric Laurent4d231dc2016-03-11 18:38:23 -08002325void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
2326{
2327 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2328 if (mActive && (flags & CBLK_DISABLED)) {
2329 start();
2330 }
2331}
Eric Laurent81784c32012-11-19 14:55:58 -08002332
Andy Hung9d84af52018-09-12 18:03:44 -07002333// ----------------------------------------------------------------------------
2334#undef LOG_TAG
2335#define LOG_TAG "AF::PatchTrack"
2336
Eric Laurent83b88082014-06-20 18:31:16 -07002337AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07002338 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07002339 uint32_t sampleRate,
2340 audio_channel_mask_t channelMask,
2341 audio_format_t format,
2342 size_t frameCount,
2343 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002344 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002345 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002346 const Timeout& timeout,
2347 size_t frameCountToBeReady)
Eric Laurent3bcf8592015-04-03 12:13:24 -07002348 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002349 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002350 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002351 buffer, bufferSize, nullptr /* sharedBuffer */,
Svet Ganov33761132021-05-13 22:51:08 +00002352 AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002353 TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
gaoxiupei8e3a5682023-07-07 20:30:23 +08002354 PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true)
2355 : nullptr,
Kevin Rocard45986c72018-12-18 18:22:59 -08002356 *playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002357{
Andy Hung9d84af52018-09-12 18:03:44 -07002358 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2359 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002360 (int)mPeerTimeout.tv_sec,
2361 (int)(mPeerTimeout.tv_nsec / 1000000));
2362}
2363
2364AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
2365{
Andy Hungabfab202019-03-07 19:45:54 -08002366 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002367}
2368
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002369size_t AudioFlinger::PlaybackThread::PatchTrack::framesReady() const
2370{
2371 if (mPeerProxy && mPeerProxy->producesBufferOnDemand()) {
2372 return std::numeric_limits<size_t>::max();
2373 } else {
2374 return Track::framesReady();
2375 }
2376}
2377
Eric Laurent4d231dc2016-03-11 18:38:23 -08002378status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002379 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08002380{
2381 status_t status = Track::start(event, triggerSession);
2382 if (status != NO_ERROR) {
2383 return status;
2384 }
2385 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2386 return status;
2387}
2388
Eric Laurent83b88082014-06-20 18:31:16 -07002389// AudioBufferProvider interface
2390status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002391 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002392{
Andy Hung9d84af52018-09-12 18:03:44 -07002393 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002394 Proxy::Buffer buf;
2395 buf.mFrameCount = buffer->frameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002396 if (ATRACE_ENABLED()) {
2397 std::string traceName("PTnReq");
2398 traceName += std::to_string(id());
2399 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2400 }
Eric Laurent83b88082014-06-20 18:31:16 -07002401 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07002402 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002403 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002404 if (ATRACE_ENABLED()) {
2405 std::string traceName("PTnObt");
2406 traceName += std::to_string(id());
2407 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2408 }
Eric Laurent83b88082014-06-20 18:31:16 -07002409 if (buf.mFrameCount == 0) {
2410 return WOULD_BLOCK;
2411 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002412 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002413 return status;
2414}
2415
2416void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2417{
Andy Hung9d84af52018-09-12 18:03:44 -07002418 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002419 Proxy::Buffer buf;
2420 buf.mFrameCount = buffer->frameCount;
2421 buf.mRaw = buffer->raw;
2422 mPeerProxy->releaseBuffer(&buf);
Andy Hung71ba4b32022-10-06 12:09:49 -07002423 TrackBase::releaseBuffer(buffer); // Note: this is the base class.
Eric Laurent83b88082014-06-20 18:31:16 -07002424}
2425
2426status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
2427 const struct timespec *timeOut)
2428{
Eric Laurent4d231dc2016-03-11 18:38:23 -08002429 status_t status = NO_ERROR;
2430 static const int32_t kMaxTries = 5;
2431 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07002432 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08002433 do {
2434 if (status == NOT_ENOUGH_DATA) {
2435 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07002436 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08002437 }
2438 status = mProxy->obtainBuffer(buffer, timeOut);
2439 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
2440 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07002441}
2442
2443void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
2444{
2445 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002446 restartIfDisabled();
naoki miyazuf37f9982019-11-28 11:18:18 +09002447
2448 // Check if the PatchTrack has enough data to write once in releaseBuffer().
2449 // If not, prevent an underrun from occurring by moving the track into FS_FILLING;
2450 // this logic avoids glitches when suspending A2DP with AudioPlaybackCapture.
2451 // TODO: perhaps underrun avoidance could be a track property checked in isReady() instead.
2452 if (mFillingUpStatus == FS_ACTIVE
2453 && audio_is_linear_pcm(mFormat)
2454 && !isOffloadedOrDirect()) {
2455 if (sp<ThreadBase> thread = mThread.promote();
2456 thread != 0) {
2457 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2458 const size_t frameCount = playbackThread->frameCount() * sampleRate()
2459 / playbackThread->sampleRate();
2460 if (framesReady() < frameCount) {
2461 ALOGD("%s(%d) Not enough data, wait for buffer to fill", __func__, mId);
2462 mFillingUpStatus = FS_FILLING;
2463 }
2464 }
2465 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002466}
2467
2468void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
2469{
Eric Laurent83b88082014-06-20 18:31:16 -07002470 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07002471 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002472 start();
2473 }
Eric Laurent83b88082014-06-20 18:31:16 -07002474}
2475
Eric Laurent81784c32012-11-19 14:55:58 -08002476// ----------------------------------------------------------------------------
2477// Record
2478// ----------------------------------------------------------------------------
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002479
2480
Andy Hung9d84af52018-09-12 18:03:44 -07002481#undef LOG_TAG
2482#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08002483
Andy Hungaaa18282023-06-23 19:27:19 -07002484class RecordHandle : public android::media::BnAudioRecord {
2485public:
2486 explicit RecordHandle(const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack);
2487 ~RecordHandle() override;
2488 binder::Status start(int /*AudioSystem::sync_event_t*/ event,
2489 int /*audio_session_t*/ triggerSession) final;
2490 binder::Status stop() final;
2491 binder::Status getActiveMicrophones(
2492 std::vector<media::MicrophoneInfoFw>* activeMicrophones) final;
2493 binder::Status setPreferredMicrophoneDirection(
2494 int /*audio_microphone_direction_t*/ direction) final;
2495 binder::Status setPreferredMicrophoneFieldDimension(float zoom) final;
2496 binder::Status shareAudioHistory(
2497 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) final;
2498
2499private:
2500 const sp<AudioFlinger::RecordThread::RecordTrack> mRecordTrack;
2501
2502 // for use from destructor
2503 void stop_nonvirtual();
2504};
2505
2506/* static */
2507sp<media::IAudioRecord> AudioFlinger::RecordThread::RecordTrack::createIAudioRecordAdapter(
2508 const sp<RecordTrack>& recordTrack) {
2509 return sp<RecordHandle>::make(recordTrack);
2510}
2511
2512RecordHandle::RecordHandle(
Eric Laurent81784c32012-11-19 14:55:58 -08002513 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
2514 : BnAudioRecord(),
2515 mRecordTrack(recordTrack)
2516{
Andy Hungaaa18282023-06-23 19:27:19 -07002517 // TODO(b/288339104) binder thread priority change not needed.
Andy Hung225aef62022-12-06 16:33:20 -08002518 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08002519}
2520
Andy Hungaaa18282023-06-23 19:27:19 -07002521RecordHandle::~RecordHandle() {
Eric Laurent81784c32012-11-19 14:55:58 -08002522 stop_nonvirtual();
2523 mRecordTrack->destroy();
2524}
2525
Andy Hungaaa18282023-06-23 19:27:19 -07002526binder::Status RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002527 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07002528 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002529 return binderStatusFromStatusT(
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002530 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08002531}
2532
Andy Hungaaa18282023-06-23 19:27:19 -07002533binder::Status RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08002534 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002535 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08002536}
2537
Andy Hungaaa18282023-06-23 19:27:19 -07002538void RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07002539 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08002540 mRecordTrack->stop();
2541}
2542
Andy Hungaaa18282023-06-23 19:27:19 -07002543binder::Status RecordHandle::getActiveMicrophones(
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08002544 std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07002545 ALOGV("%s()", __func__);
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08002546 return binderStatusFromStatusT(mRecordTrack->getActiveMicrophones(activeMicrophones));
jiabin653cc0a2018-01-17 17:54:10 -08002547}
2548
Andy Hungaaa18282023-06-23 19:27:19 -07002549binder::Status RecordHandle::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002550 int /*audio_microphone_direction_t*/ direction) {
2551 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002552 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002553 static_cast<audio_microphone_direction_t>(direction)));
2554}
2555
Andy Hungaaa18282023-06-23 19:27:19 -07002556binder::Status RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002557 ALOGV("%s()", __func__);
Andy Hung1131b6e2020-12-08 20:47:45 -08002558 return binderStatusFromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
Paul McLean03a6e6a2018-12-04 10:54:13 -07002559}
2560
Andy Hungaaa18282023-06-23 19:27:19 -07002561binder::Status RecordHandle::shareAudioHistory(
Eric Laurentec376dc2021-04-08 20:41:22 +02002562 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2563 return binderStatusFromStatusT(
2564 mRecordTrack->shareAudioHistory(sharedAudioPackageName, sharedAudioStartMs));
2565}
2566
Eric Laurent81784c32012-11-19 14:55:58 -08002567// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002568#undef LOG_TAG
2569#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002570
Glenn Kasten05997e22014-03-13 15:08:33 -07002571// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08002572AudioFlinger::RecordThread::RecordTrack::RecordTrack(
2573 RecordThread *thread,
2574 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002575 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08002576 uint32_t sampleRate,
2577 audio_format_t format,
2578 audio_channel_mask_t channelMask,
2579 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07002580 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002581 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08002582 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002583 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002584 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07002585 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002586 track_type type,
Eric Laurentec376dc2021-04-08 20:41:22 +02002587 audio_port_handle_t portId,
Eric Laurent2407ce32021-04-26 14:56:03 +02002588 int32_t startFrames)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002589 : TrackBase(thread, client, attr, sampleRate, format,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002590 channelMask, frameCount, buffer, bufferSize, sessionId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002591 creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002592 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002593 false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07002594 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07002595 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07002596 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Andy Hungb68f5eb2019-12-03 16:49:17 -08002597 type, portId,
2598 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD) + std::to_string(portId)),
Andy Hung97a893e2015-03-29 01:03:07 -07002599 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07002600 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07002601 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07002602 mFlags(flags),
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002603 mSilenced(false),
Eric Laurent2407ce32021-04-26 14:56:03 +02002604 mStartFrames(startFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002605{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07002606 if (mCblk == NULL) {
2607 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002608 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002609
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002610 if (!isDirect()) {
2611 mRecordBufferConverter = new RecordBufferConverter(
2612 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
2613 channelMask, format, sampleRate);
2614 // Check if the RecordBufferConverter construction was successful.
2615 // If not, don't continue with construction.
2616 //
2617 // NOTE: It would be extremely rare that the record track cannot be created
2618 // for the current device, but a pending or future device change would make
2619 // the record track configuration valid.
2620 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07002621 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002622 return;
2623 }
Andy Hung97a893e2015-03-29 01:03:07 -07002624 }
2625
Andy Hung6ae58432016-02-16 18:32:24 -08002626 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08002627 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08002628
Andy Hung97a893e2015-03-29 01:03:07 -07002629 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002630
Eric Laurent05067782016-06-01 18:27:28 -07002631 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07002632 ALOG_ASSERT(thread->mFastTrackAvail);
2633 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07002634 } else {
2635 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07002636 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002637 }
Andy Hung8946a282018-04-19 20:04:56 -07002638#ifdef TEE_SINK
2639 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
2640 + "_" + std::to_string(mId)
2641 + "_R");
2642#endif
Andy Hungb68f5eb2019-12-03 16:49:17 -08002643
2644 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07002645 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent81784c32012-11-19 14:55:58 -08002646}
2647
2648AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
2649{
Andy Hung9d84af52018-09-12 18:03:44 -07002650 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002651 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002652 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002653}
2654
Andy Hung97a893e2015-03-29 01:03:07 -07002655status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
2656{
2657 status_t status = TrackBase::initCheck();
2658 if (status == NO_ERROR && mServerProxy == 0) {
2659 status = BAD_VALUE;
2660 }
2661 return status;
2662}
2663
Eric Laurent81784c32012-11-19 14:55:58 -08002664// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08002665status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08002666{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002667 ServerProxy::Buffer buf;
2668 buf.mFrameCount = buffer->frameCount;
2669 status_t status = mServerProxy->obtainBuffer(&buf);
2670 buffer->frameCount = buf.mFrameCount;
2671 buffer->raw = buf.mRaw;
2672 if (buf.mFrameCount == 0) {
2673 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002674 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002675 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002676 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002677}
2678
2679status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002680 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002681{
2682 sp<ThreadBase> thread = mThread.promote();
2683 if (thread != 0) {
2684 RecordThread *recordThread = (RecordThread *)thread.get();
2685 return recordThread->start(this, event, triggerSession);
2686 } else {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002687 ALOGW("%s track %d: thread was destroyed", __func__, portId());
2688 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08002689 }
2690}
2691
2692void AudioFlinger::RecordThread::RecordTrack::stop()
2693{
2694 sp<ThreadBase> thread = mThread.promote();
2695 if (thread != 0) {
2696 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07002697 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08002698 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002699 }
2700 }
2701}
2702
2703void AudioFlinger::RecordThread::RecordTrack::destroy()
2704{
2705 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
2706 sp<RecordTrack> keep(this);
2707 {
Andy Hungce685402018-10-05 17:23:27 -07002708 track_state priorState = mState;
Eric Laurent81784c32012-11-19 14:55:58 -08002709 sp<ThreadBase> thread = mThread.promote();
2710 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08002711 Mutex::Autolock _l(thread->mLock);
2712 RecordThread *recordThread = (RecordThread *) thread.get();
Andy Hungce685402018-10-05 17:23:27 -07002713 priorState = mState;
Eric Laurentec376dc2021-04-08 20:41:22 +02002714 if (!mSharedAudioPackageName.empty()) {
Eric Laurent92d0a322021-07-16 15:32:33 +02002715 recordThread->resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002716 }
Andy Hungce685402018-10-05 17:23:27 -07002717 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
2718 }
2719 // APM portid/client management done outside of lock.
2720 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
2721 if (isExternalTrack()) {
2722 switch (priorState) {
2723 case ACTIVE: // invalidated while still active
2724 case STARTING_2: // invalidated/start-aborted after startInput successfully called
2725 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
2726 AudioSystem::stopInput(mPortId);
2727 break;
2728
2729 case STARTING_1: // invalidated/start-aborted and startInput not successful
2730 case PAUSED: // OK, not active
2731 case IDLE: // OK, not active
2732 break;
2733
2734 case STOPPED: // unexpected (destroyed)
2735 default:
2736 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
2737 }
2738 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002739 }
2740 }
2741}
2742
Eric Laurent9a54bc22013-09-09 09:08:44 -07002743void AudioFlinger::RecordThread::RecordTrack::invalidate()
2744{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002745 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07002746 // FIXME should use proxy, and needs work
2747 audio_track_cblk_t* cblk = mCblk;
2748 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2749 android_atomic_release_store(0x40000000, &cblk->mFutex);
2750 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002751 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002752}
2753
Eric Laurent81784c32012-11-19 14:55:58 -08002754
Andy Hung000adb52018-06-01 15:43:26 -07002755void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08002756{
Eric Laurent973db022018-11-20 14:54:31 -08002757 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07002758 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002759 " Server FrmCnt FrmRdy Sil%s\n",
2760 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08002761}
2762
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002763void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08002764{
Eric Laurent973db022018-11-20 14:54:31 -08002765 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002766 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002767 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002768 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002769 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002770 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002771 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002772 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002773 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08002774 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002775 mCblk->mFlags,
2776
Eric Laurent81784c32012-11-19 14:55:58 -08002777 mFormat,
2778 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002779 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002780 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002781
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002782 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002783 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002784 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002785 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002786 );
Andy Hung000adb52018-06-01 15:43:26 -07002787 if (isServerLatencySupported()) {
2788 double latencyMs;
2789 bool fromTrack;
2790 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2791 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2792 // or 'k' if estimated from kernel (usually for debugging).
2793 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2794 } else {
2795 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2796 }
2797 }
2798 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002799}
2800
Andy Hung93bb5732023-05-04 21:16:34 -07002801// This is invoked by SyncEvent callback.
Andy Hung068e08e2023-05-15 19:02:55 -07002802void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(
2803 const sp<audioflinger::SyncEvent>& event)
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002804{
Andy Hung93bb5732023-05-04 21:16:34 -07002805 size_t framesToDrop = 0;
2806 sp<ThreadBase> threadBase = mThread.promote();
2807 if (threadBase != 0) {
2808 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2809 // from audio HAL
2810 framesToDrop = threadBase->mFrameCount * 2;
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002811 }
Andy Hung93bb5732023-05-04 21:16:34 -07002812
2813 mSynchronizedRecordState.onPlaybackFinished(event, framesToDrop);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002814}
2815
2816void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2817{
Andy Hung93bb5732023-05-04 21:16:34 -07002818 mSynchronizedRecordState.clear();
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002819}
2820
Andy Hung3f0c9022016-01-15 17:49:46 -08002821void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
2822 int64_t trackFramesReleased, int64_t sourceFramesRead,
2823 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2824{
Andy Hung30282562018-08-08 18:27:03 -07002825 // Make the kernel frametime available.
2826 const FrameTime ft{
2827 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2828 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2829 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2830 mKernelFrameTime.store(ft);
2831 if (!audio_is_linear_pcm(mFormat)) {
Atneya Nair497fff12022-01-18 16:23:04 -05002832 // Stream is direct, return provided timestamp with no conversion
2833 mServerProxy->setTimestamp(timestamp);
Andy Hung30282562018-08-08 18:27:03 -07002834 return;
2835 }
2836
Andy Hung3f0c9022016-01-15 17:49:46 -08002837 ExtendedTimestamp local = timestamp;
2838
2839 // Convert HAL frames to server-side track frames at track sample rate.
2840 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2841 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2842 if (local.mTimeNs[i] != 0) {
2843 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2844 const int64_t relativeTrackFrames = relativeServerFrames
2845 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2846 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2847 }
2848 }
Andy Hung6ae58432016-02-16 18:32:24 -08002849 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002850
2851 // Compute latency info.
2852 const bool useTrackTimestamp = true; // use track unless debugging.
2853 const double latencyMs = - (useTrackTimestamp
2854 ? local.getOutputServerLatencyMs(sampleRate())
2855 : timestamp.getOutputServerLatencyMs(halSampleRate));
2856
2857 mServerLatencyFromTrack.store(useTrackTimestamp);
2858 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08002859}
Eric Laurent83b88082014-06-20 18:31:16 -07002860
jiabin653cc0a2018-01-17 17:54:10 -08002861status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08002862 std::vector<media::MicrophoneInfoFw>* activeMicrophones)
jiabin653cc0a2018-01-17 17:54:10 -08002863{
2864 sp<ThreadBase> thread = mThread.promote();
2865 if (thread != 0) {
2866 RecordThread *recordThread = (RecordThread *)thread.get();
2867 return recordThread->getActiveMicrophones(activeMicrophones);
2868 } else {
2869 return BAD_VALUE;
2870 }
2871}
2872
Paul McLean12340082019-03-19 09:35:05 -06002873status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002874 audio_microphone_direction_t direction) {
2875 sp<ThreadBase> thread = mThread.promote();
2876 if (thread != 0) {
2877 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002878 return recordThread->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002879 } else {
2880 return BAD_VALUE;
2881 }
2882}
2883
Paul McLean12340082019-03-19 09:35:05 -06002884status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002885 sp<ThreadBase> thread = mThread.promote();
2886 if (thread != 0) {
2887 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002888 return recordThread->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002889 } else {
2890 return BAD_VALUE;
2891 }
2892}
2893
Eric Laurentec376dc2021-04-08 20:41:22 +02002894status_t AudioFlinger::RecordThread::RecordTrack::shareAudioHistory(
2895 const std::string& sharedAudioPackageName, int64_t sharedAudioStartMs) {
2896
2897 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2898 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
2899 if (callingUid != mUid || callingPid != mCreatorPid) {
2900 return PERMISSION_DENIED;
2901 }
2902
Svet Ganov33761132021-05-13 22:51:08 +00002903 AttributionSourceState attributionSource{};
2904 attributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
2905 attributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
2906 attributionSource.token = sp<BBinder>::make();
2907 if (!captureHotwordAllowed(attributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02002908 return PERMISSION_DENIED;
2909 }
2910
2911 sp<ThreadBase> thread = mThread.promote();
2912 if (thread != 0) {
2913 RecordThread *recordThread = (RecordThread *)thread.get();
2914 status_t status = recordThread->shareAudioHistory(
2915 sharedAudioPackageName, mSessionId, sharedAudioStartMs);
2916 if (status == NO_ERROR) {
2917 mSharedAudioPackageName = sharedAudioPackageName;
2918 }
2919 return status;
2920 } else {
2921 return BAD_VALUE;
2922 }
2923}
2924
Eric Laurent78b07302022-10-07 16:20:34 +02002925void AudioFlinger::RecordThread::RecordTrack::copyMetadataTo(MetadataInserter& backInserter) const
2926{
2927
2928 // Do not forward PatchRecord metadata with unspecified audio source
2929 if (mAttr.source == AUDIO_SOURCE_DEFAULT) {
2930 return;
2931 }
2932
2933 // No track is invalid as this is called after prepareTrack_l in the same critical section
2934 record_track_metadata_v7_t metadata;
2935 metadata.base = {
2936 .source = mAttr.source,
2937 .gain = 1, // capture tracks do not have volumes
2938 };
2939 metadata.channel_mask = mChannelMask;
2940 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
2941
2942 *backInserter++ = metadata;
2943}
Eric Laurentec376dc2021-04-08 20:41:22 +02002944
Andy Hung9d84af52018-09-12 18:03:44 -07002945// ----------------------------------------------------------------------------
2946#undef LOG_TAG
2947#define LOG_TAG "AF::PatchRecord"
2948
Eric Laurent83b88082014-06-20 18:31:16 -07002949AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2950 uint32_t sampleRate,
2951 audio_channel_mask_t channelMask,
2952 audio_format_t format,
2953 size_t frameCount,
2954 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002955 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002956 audio_input_flags_t flags,
Eric Laurent78b07302022-10-07 16:20:34 +02002957 const Timeout& timeout,
2958 audio_source_t source)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002959 : RecordTrack(recordThread, NULL,
Eric Laurent78b07302022-10-07 16:20:34 +02002960 audio_attributes_t{ .source = source } ,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002961 sampleRate, format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002962 buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
Svet Ganov33761132021-05-13 22:51:08 +00002963 audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
gaoxiupei8e3a5682023-07-07 20:30:23 +08002964 PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true)
2965 : nullptr,
Kevin Rocard45986c72018-12-18 18:22:59 -08002966 *recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002967{
Andy Hung9d84af52018-09-12 18:03:44 -07002968 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2969 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002970 (int)mPeerTimeout.tv_sec,
2971 (int)(mPeerTimeout.tv_nsec / 1000000));
2972}
2973
2974AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2975{
Andy Hungabfab202019-03-07 19:45:54 -08002976 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002977}
2978
Mikhail Naganov8296c252019-09-25 14:59:54 -07002979static size_t writeFramesHelper(
2980 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2981{
2982 AudioBufferProvider::Buffer patchBuffer;
2983 patchBuffer.frameCount = frameCount;
2984 auto status = dest->getNextBuffer(&patchBuffer);
2985 if (status != NO_ERROR) {
2986 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
2987 __func__, status, strerror(-status));
2988 return 0;
2989 }
2990 ALOG_ASSERT(patchBuffer.frameCount <= frameCount);
2991 memcpy(patchBuffer.raw, src, patchBuffer.frameCount * frameSize);
2992 size_t framesWritten = patchBuffer.frameCount;
2993 dest->releaseBuffer(&patchBuffer);
2994 return framesWritten;
2995}
2996
2997// static
2998size_t AudioFlinger::RecordThread::PatchRecord::writeFrames(
2999 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
3000{
3001 size_t framesWritten = writeFramesHelper(dest, src, frameCount, frameSize);
3002 // On buffer wrap, the buffer frame count will be less than requested,
3003 // when this happens a second buffer needs to be used to write the leftover audio
3004 const size_t framesLeft = frameCount - framesWritten;
3005 if (framesWritten != 0 && framesLeft != 0) {
3006 framesWritten += writeFramesHelper(dest, (const char*)src + framesWritten * frameSize,
3007 framesLeft, frameSize);
3008 }
3009 return framesWritten;
3010}
3011
Eric Laurent83b88082014-06-20 18:31:16 -07003012// AudioBufferProvider interface
3013status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08003014 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07003015{
Andy Hung9d84af52018-09-12 18:03:44 -07003016 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07003017 Proxy::Buffer buf;
3018 buf.mFrameCount = buffer->frameCount;
3019 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
3020 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07003021 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07003022 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07003023 if (ATRACE_ENABLED()) {
3024 std::string traceName("PRnObt");
3025 traceName += std::to_string(id());
3026 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
3027 }
Eric Laurent83b88082014-06-20 18:31:16 -07003028 if (buf.mFrameCount == 0) {
3029 return WOULD_BLOCK;
3030 }
Glenn Kastend79072e2016-01-06 08:41:20 -08003031 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07003032 return status;
3033}
3034
3035void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
3036{
Andy Hung9d84af52018-09-12 18:03:44 -07003037 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07003038 Proxy::Buffer buf;
3039 buf.mFrameCount = buffer->frameCount;
3040 buf.mRaw = buffer->raw;
3041 mPeerProxy->releaseBuffer(&buf);
3042 TrackBase::releaseBuffer(buffer);
3043}
3044
3045status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
3046 const struct timespec *timeOut)
3047{
3048 return mProxy->obtainBuffer(buffer, timeOut);
3049}
3050
3051void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
3052{
3053 mProxy->releaseBuffer(buffer);
3054}
3055
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003056#undef LOG_TAG
3057#define LOG_TAG "AF::PthrPatchRecord"
3058
3059static std::unique_ptr<void, decltype(free)*> allocAligned(size_t alignment, size_t size)
3060{
3061 void *ptr = nullptr;
3062 (void)posix_memalign(&ptr, alignment, size);
Andy Hung71ba4b32022-10-06 12:09:49 -07003063 return {ptr, free};
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003064}
3065
3066AudioFlinger::RecordThread::PassthruPatchRecord::PassthruPatchRecord(
3067 RecordThread *recordThread,
3068 uint32_t sampleRate,
3069 audio_channel_mask_t channelMask,
3070 audio_format_t format,
3071 size_t frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02003072 audio_input_flags_t flags,
3073 audio_source_t source)
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003074 : PatchRecord(recordThread, sampleRate, channelMask, format, frameCount,
Eric Laurent78b07302022-10-07 16:20:34 +02003075 nullptr /*buffer*/, 0 /*bufferSize*/, flags, {} /* timeout */, source),
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003076 mPatchRecordAudioBufferProvider(*this),
3077 mSinkBuffer(allocAligned(32, mFrameCount * mFrameSize)),
3078 mStubBuffer(allocAligned(32, mFrameCount * mFrameSize))
3079{
3080 memset(mStubBuffer.get(), 0, mFrameCount * mFrameSize);
3081}
3082
3083sp<StreamInHalInterface> AudioFlinger::RecordThread::PassthruPatchRecord::obtainStream(
3084 sp<ThreadBase>* thread)
3085{
3086 *thread = mThread.promote();
3087 if (!*thread) return nullptr;
3088 RecordThread *recordThread = static_cast<RecordThread*>((*thread).get());
3089 Mutex::Autolock _l(recordThread->mLock);
3090 return recordThread->mInput ? recordThread->mInput->stream : nullptr;
3091}
3092
3093// PatchProxyBufferProvider methods are called on DirectOutputThread
3094status_t AudioFlinger::RecordThread::PassthruPatchRecord::obtainBuffer(
3095 Proxy::Buffer* buffer, const struct timespec* timeOut)
3096{
3097 if (mUnconsumedFrames) {
3098 buffer->mFrameCount = std::min(buffer->mFrameCount, mUnconsumedFrames);
3099 // mUnconsumedFrames is decreased in releaseBuffer to use actual frame consumption figure.
3100 return PatchRecord::obtainBuffer(buffer, timeOut);
3101 }
3102
3103 // Otherwise, execute a read from HAL and write into the buffer.
3104 nsecs_t startTimeNs = 0;
3105 if (timeOut && (timeOut->tv_sec != 0 || timeOut->tv_nsec != 0) && timeOut->tv_sec != INT_MAX) {
3106 // Will need to correct timeOut by elapsed time.
3107 startTimeNs = systemTime();
3108 }
3109 const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
3110 buffer->mFrameCount = 0;
3111 buffer->mRaw = nullptr;
3112 sp<ThreadBase> thread;
3113 sp<StreamInHalInterface> stream = obtainStream(&thread);
3114 if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
3115
3116 status_t result = NO_ERROR;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003117 size_t bytesRead = 0;
3118 {
3119 ATRACE_NAME("read");
3120 result = stream->read(mSinkBuffer.get(), framesToRead * mFrameSize, &bytesRead);
3121 if (result != NO_ERROR) goto stream_error;
3122 if (bytesRead == 0) return NO_ERROR;
3123 }
3124
3125 {
3126 std::lock_guard<std::mutex> lock(mReadLock);
3127 mReadBytes += bytesRead;
3128 mReadError = NO_ERROR;
3129 }
3130 mReadCV.notify_one();
3131 // writeFrames handles wraparound and should write all the provided frames.
3132 // If it couldn't, there is something wrong with the client/server buffer of the software patch.
3133 buffer->mFrameCount = writeFrames(
3134 &mPatchRecordAudioBufferProvider,
3135 mSinkBuffer.get(), bytesRead / mFrameSize, mFrameSize);
3136 ALOGW_IF(buffer->mFrameCount < bytesRead / mFrameSize,
3137 "Lost %zu frames obtained from HAL", bytesRead / mFrameSize - buffer->mFrameCount);
3138 mUnconsumedFrames = buffer->mFrameCount;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003139 struct timespec newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003140 if (startTimeNs) {
Mikhail Naganov4de49972019-10-07 09:53:58 -07003141 // Correct the timeout by elapsed time.
3142 nsecs_t newTimeOutNs = audio_utils_ns_from_timespec(timeOut) - (systemTime() - startTimeNs);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003143 if (newTimeOutNs < 0) newTimeOutNs = 0;
3144 newTimeOut.tv_sec = newTimeOutNs / NANOS_PER_SECOND;
3145 newTimeOut.tv_nsec = newTimeOutNs - newTimeOut.tv_sec * NANOS_PER_SECOND;
Mikhail Naganov4de49972019-10-07 09:53:58 -07003146 timeOut = &newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003147 }
Mikhail Naganov4de49972019-10-07 09:53:58 -07003148 return PatchRecord::obtainBuffer(buffer, timeOut);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07003149
3150stream_error:
3151 stream->standby();
3152 {
3153 std::lock_guard<std::mutex> lock(mReadLock);
3154 mReadError = result;
3155 }
3156 mReadCV.notify_one();
3157 return result;
3158}
3159
3160void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(Proxy::Buffer* buffer)
3161{
3162 if (buffer->mFrameCount <= mUnconsumedFrames) {
3163 mUnconsumedFrames -= buffer->mFrameCount;
3164 } else {
3165 ALOGW("Write side has consumed more frames than we had: %zu > %zu",
3166 buffer->mFrameCount, mUnconsumedFrames);
3167 mUnconsumedFrames = 0;
3168 }
3169 PatchRecord::releaseBuffer(buffer);
3170}
3171
3172// AudioBufferProvider and Source methods are called on RecordThread
3173// 'read' emulates actual audio data with 0's. This is OK as 'getNextBuffer'
3174// and 'releaseBuffer' are stubbed out and ignore their input.
3175// It's not possible to retrieve actual data here w/o blocking 'obtainBuffer'
3176// until we copy it.
3177status_t AudioFlinger::RecordThread::PassthruPatchRecord::read(
3178 void* buffer, size_t bytes, size_t* read)
3179{
3180 bytes = std::min(bytes, mFrameCount * mFrameSize);
3181 {
3182 std::unique_lock<std::mutex> lock(mReadLock);
3183 mReadCV.wait(lock, [&]{ return mReadError != NO_ERROR || mReadBytes != 0; });
3184 if (mReadError != NO_ERROR) {
3185 mLastReadFrames = 0;
3186 return mReadError;
3187 }
3188 *read = std::min(bytes, mReadBytes);
3189 mReadBytes -= *read;
3190 }
3191 mLastReadFrames = *read / mFrameSize;
3192 memset(buffer, 0, *read);
3193 return 0;
3194}
3195
3196status_t AudioFlinger::RecordThread::PassthruPatchRecord::getCapturePosition(
3197 int64_t* frames, int64_t* time)
3198{
3199 sp<ThreadBase> thread;
3200 sp<StreamInHalInterface> stream = obtainStream(&thread);
3201 return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
3202}
3203
3204status_t AudioFlinger::RecordThread::PassthruPatchRecord::standby()
3205{
3206 // RecordThread issues 'standby' command in two major cases:
3207 // 1. Error on read--this case is handled in 'obtainBuffer'.
3208 // 2. Track is stopping--as PassthruPatchRecord assumes continuous
3209 // output, this can only happen when the software patch
3210 // is being torn down. In this case, the RecordThread
3211 // will terminate and close the HAL stream.
3212 return 0;
3213}
3214
3215// As the buffer gets filled in obtainBuffer, here we only simulate data consumption.
3216status_t AudioFlinger::RecordThread::PassthruPatchRecord::getNextBuffer(
3217 AudioBufferProvider::Buffer* buffer)
3218{
3219 buffer->frameCount = mLastReadFrames;
3220 buffer->raw = buffer->frameCount != 0 ? mStubBuffer.get() : nullptr;
3221 return NO_ERROR;
3222}
3223
3224void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(
3225 AudioBufferProvider::Buffer* buffer)
3226{
3227 buffer->frameCount = 0;
3228 buffer->raw = nullptr;
3229}
3230
Andy Hung9d84af52018-09-12 18:03:44 -07003231// ----------------------------------------------------------------------------
3232#undef LOG_TAG
3233#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08003234
3235AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003236 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003237 uint32_t sampleRate,
3238 audio_format_t format,
3239 audio_channel_mask_t channelMask,
3240 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003241 bool isOut,
Svet Ganov33761132021-05-13 22:51:08 +00003242 const AttributionSourceState& attributionSource,
Eric Laurent09f1ed22019-04-24 17:45:17 -07003243 pid_t creatorPid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003244 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07003245 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07003246 channelMask, (size_t)0 /* frameCount */,
3247 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003248 sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00003249 VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003250 isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003251 ALLOC_NONE,
Andy Hungc2b11cb2020-04-22 09:04:01 -07003252 TYPE_DEFAULT, portId,
3253 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
Svet Ganov33761132021-05-13 22:51:08 +00003254 mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.pid))),
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003255 mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003256{
Andy Hungc2b11cb2020-04-22 09:04:01 -07003257 // Once this item is logged by the server, the client can add properties.
Andy Hung94235282021-03-24 15:50:14 -07003258 mTrackMetrics.logConstructor(creatorPid, uid(), id());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003259}
3260
3261AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
3262{
3263}
3264
3265status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
3266{
3267 return NO_ERROR;
3268}
3269
3270status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003271 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003272{
3273 return NO_ERROR;
3274}
3275
3276void AudioFlinger::MmapThread::MmapTrack::stop()
3277{
3278}
3279
3280// AudioBufferProvider interface
3281status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3282{
3283 buffer->frameCount = 0;
3284 buffer->raw = nullptr;
3285 return INVALID_OPERATION;
3286}
3287
3288// ExtendedAudioBufferProvider interface
3289size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
3290 return 0;
3291}
3292
3293int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
3294{
3295 return 0;
3296}
3297
3298void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
3299{
3300}
3301
Vlad Popaec1788e2022-08-04 11:23:30 +02003302void AudioFlinger::MmapThread::MmapTrack::processMuteEvent_l(const sp<
3303 IAudioManager>& audioManager, mute_state_t muteState)
3304{
3305 if (mMuteState == muteState) {
3306 // mute state did not change, do nothing
3307 return;
3308 }
3309
3310 status_t result = UNKNOWN_ERROR;
3311 if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
3312 if (mMuteEventExtras == nullptr) {
3313 mMuteEventExtras = std::make_unique<os::PersistableBundle>();
3314 }
3315 mMuteEventExtras->putInt(String16(kExtraPlayerEventMuteKey),
3316 static_cast<int>(muteState));
3317
3318 result = audioManager->portEvent(mPortId,
3319 PLAYER_UPDATE_MUTED,
3320 mMuteEventExtras);
3321 }
3322
3323 if (result == OK) {
3324 mMuteState = muteState;
3325 } else {
3326 ALOGW("%s(%d): cannot process mute state for port ID %d, status error %d",
3327 __func__,
3328 id(),
3329 mPortId,
3330 result);
3331 }
3332}
3333
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003334void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003335{
Eric Laurent973db022018-11-20 14:54:31 -08003336 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003337 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003338}
3339
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003340void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003341{
Eric Laurent973db022018-11-20 14:54:31 -08003342 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003343 mPid,
3344 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08003345 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003346 mFormat,
3347 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003348 mSampleRate,
3349 mAttr.flags);
3350 if (isOut()) {
3351 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
3352 } else {
3353 result.appendFormat("%6x", mAttr.source);
3354 }
3355 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003356}
3357
Glenn Kasten63238ef2015-03-02 15:50:29 -08003358} // namespace android