blob: af261e94d2dcfd8185c3a80d258679473b329682 [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>
Andy Hung89816052017-01-11 17:08:23 -080036#include <media/RecordBufferConverter.h>
Andy Hungab7ef302018-05-15 19:35:29 -070037#include <mediautils/ServiceUtilities.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070038#include <audio_utils/minifloat.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080039
Eric Laurent81784c32012-11-19 14:55:58 -080040// ----------------------------------------------------------------------------
41
42// Note: the following macro is used for extremely verbose logging message. In
43// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
44// 0; but one side effect of this is to turn all LOGV's as well. Some messages
45// are so verbose that we want to suppress them even when we have ALOG_ASSERT
46// turned on. Do not uncomment the #def below unless you really know what you
47// are doing and want to see all of the extremely verbose messages.
48//#define VERY_VERY_VERBOSE_LOGGING
49#ifdef VERY_VERY_VERBOSE_LOGGING
50#define ALOGVV ALOGV
51#else
52#define ALOGVV(a...) do { } while(0)
53#endif
54
55namespace android {
56
Kuowei Li3bea3a42020-08-13 14:44:25 +080057// Validation methods for input
58namespace {
59
60status_t validateAudioDescriptionMixLevel(float leveldB)
61{
62 constexpr float MAX_AUDIO_DESCRIPTION_MIX_LEVEL = 48.f;
63 return std::isnan(leveldB) || leveldB > MAX_AUDIO_DESCRIPTION_MIX_LEVEL ? BAD_VALUE : OK;
64}
65
66status_t validateDualMonoMode(audio_dual_mono_mode_t dualMonoMode)
67{
68 switch (dualMonoMode) {
69 case AUDIO_DUAL_MONO_MODE_OFF:
70 case AUDIO_DUAL_MONO_MODE_LR:
71 case AUDIO_DUAL_MONO_MODE_LL:
72 case AUDIO_DUAL_MONO_MODE_RR:
73 return OK;
74 }
75 return BAD_VALUE;
76}
77
78status_t validatePlaybackRateFallbackMode(
79 audio_timestretch_fallback_mode_t fallbackMode)
80{
81 switch (fallbackMode) {
82 case AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT:
83 break; // warning if not listed.
84 case AUDIO_TIMESTRETCH_FALLBACK_DEFAULT:
85 case AUDIO_TIMESTRETCH_FALLBACK_MUTE:
86 case AUDIO_TIMESTRETCH_FALLBACK_FAIL:
87 return OK;
88 }
89 return BAD_VALUE;
90}
91
92status_t validatePlaybackRateStretchMode(audio_timestretch_stretch_mode_t stretchMode)
93{
94 switch (stretchMode) {
95 case AUDIO_TIMESTRETCH_STRETCH_DEFAULT:
96 case AUDIO_TIMESTRETCH_STRETCH_VOICE:
97 return OK;
98 }
99 return BAD_VALUE;
100}
101
102status_t validatePlaybackRate(const audio_playback_rate_t& playbackRate)
103{
104 if (playbackRate.mSpeed < 0.f || playbackRate.mPitch < 0.f) return BAD_VALUE;
105 return validatePlaybackRateFallbackMode(playbackRate.mFallbackMode) ?:
106 validatePlaybackRateStretchMode(playbackRate.mStretchMode);
107}
108
109} // namespace
110
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700111using media::VolumeShaper;
Eric Laurent81784c32012-11-19 14:55:58 -0800112// ----------------------------------------------------------------------------
113// TrackBase
114// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700115#undef LOG_TAG
116#define LOG_TAG "AF::TrackBase"
Eric Laurent81784c32012-11-19 14:55:58 -0800117
Glenn Kastenda6ef132013-01-10 12:31:01 -0800118static volatile int32_t nextTrackId = 55;
119
Eric Laurent81784c32012-11-19 14:55:58 -0800120// TrackBase constructor must be called with AudioFlinger::mLock held
121AudioFlinger::ThreadBase::TrackBase::TrackBase(
122 ThreadBase *thread,
123 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700124 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800125 uint32_t sampleRate,
126 audio_format_t format,
127 audio_channel_mask_t channelMask,
128 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700129 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700130 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -0800131 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700132 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800133 uid_t clientUid,
Glenn Kastend776ac62014-05-07 09:16:09 -0700134 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -0700135 alloc_type alloc,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800136 track_type type,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800137 audio_port_handle_t portId,
138 std::string metricsId)
Eric Laurent81784c32012-11-19 14:55:58 -0800139 : RefBase(),
140 mThread(thread),
141 mClient(client),
142 mCblk(NULL),
Andy Hung8fe68032017-06-05 16:17:51 -0700143 // mBuffer, mBufferSize
Eric Laurent81784c32012-11-19 14:55:58 -0800144 mState(IDLE),
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700145 mAttr(attr),
Eric Laurent81784c32012-11-19 14:55:58 -0800146 mSampleRate(sampleRate),
147 mFormat(format),
148 mChannelMask(channelMask),
Andy Hunge5412692014-05-16 11:25:07 -0700149 mChannelCount(isOut ?
150 audio_channel_count_from_out_mask(channelMask) :
151 audio_channel_count_from_in_mask(channelMask)),
Phil Burkfdb3c072016-02-09 10:47:02 -0800152 mFrameSize(audio_has_proportional_frames(format) ?
Eric Laurent81784c32012-11-19 14:55:58 -0800153 mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)),
154 mFrameCount(frameCount),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800155 mSessionId(sessionId),
156 mIsOut(isOut),
Eric Laurentbfb1b832013-01-07 09:53:42 -0800157 mId(android_atomic_inc(&nextTrackId)),
Eric Laurent83b88082014-06-20 18:31:16 -0700158 mTerminated(false),
Eric Laurentaaa44472014-09-12 17:41:50 -0700159 mType(type),
Kevin Rocard153f92d2018-12-18 18:33:28 -0800160 mThreadIoHandle(thread ? thread->id() : AUDIO_IO_HANDLE_NONE),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800161 mPortId(portId),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700162 mIsInvalid(false),
Andy Hungc2b11cb2020-04-22 09:04:01 -0700163 mTrackMetrics(std::move(metricsId), isOut),
Eric Laurent09f1ed22019-04-24 17:45:17 -0700164 mCreatorPid(creatorPid)
Eric Laurent81784c32012-11-19 14:55:58 -0800165{
Marco Nelissendcb346b2015-09-09 10:47:29 -0700166 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700167 if (!isAudioServerOrMediaServerUid(callingUid) || clientUid == AUDIO_UID_INVALID) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800168 ALOGW_IF(clientUid != AUDIO_UID_INVALID && clientUid != callingUid,
Andy Hung9d84af52018-09-12 18:03:44 -0700169 "%s(%d): uid %d tried to pass itself off as %d",
170 __func__, mId, callingUid, clientUid);
Andy Hung1f12a8a2016-11-07 16:10:30 -0800171 clientUid = callingUid;
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800172 }
173 // clientUid contains the uid of the app that is responsible for this track, so we can blame
174 // battery usage on it.
175 mUid = clientUid;
176
Eric Laurent81784c32012-11-19 14:55:58 -0800177 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Andy Hung1883f692017-02-13 18:48:39 -0800178
Andy Hung8fe68032017-06-05 16:17:51 -0700179 size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;
Andy Hung1883f692017-02-13 18:48:39 -0800180 // check overflow when computing bufferSize due to multiplication by mFrameSize.
Andy Hung8fe68032017-06-05 16:17:51 -0700181 if (minBufferSize < frameCount // roundup rounds down for values above UINT_MAX / 2
Andy Hung1883f692017-02-13 18:48:39 -0800182 || mFrameSize == 0 // format needs to be correct
Andy Hung8fe68032017-06-05 16:17:51 -0700183 || minBufferSize > SIZE_MAX / mFrameSize) {
Andy Hung1883f692017-02-13 18:48:39 -0800184 android_errorWriteLog(0x534e4554, "34749571");
185 return;
186 }
Andy Hung8fe68032017-06-05 16:17:51 -0700187 minBufferSize *= mFrameSize;
188
189 if (buffer == nullptr) {
190 bufferSize = minBufferSize; // allocated here.
191 } else if (minBufferSize > bufferSize) {
192 android_errorWriteLog(0x534e4554, "38340117");
193 return;
194 }
Andy Hung1883f692017-02-13 18:48:39 -0800195
Eric Laurent81784c32012-11-19 14:55:58 -0800196 size_t size = sizeof(audio_track_cblk_t);
Eric Laurent83b88082014-06-20 18:31:16 -0700197 if (buffer == NULL && alloc == ALLOC_CBLK) {
Andy Hung1883f692017-02-13 18:48:39 -0800198 // check overflow when computing allocation size for streaming tracks.
199 if (size > SIZE_MAX - bufferSize) {
200 android_errorWriteLog(0x534e4554, "34749571");
201 return;
202 }
Eric Laurent81784c32012-11-19 14:55:58 -0800203 size += bufferSize;
204 }
205
206 if (client != 0) {
207 mCblkMemory = client->heap()->allocate(size);
Glenn Kasten663c2242013-09-24 11:52:37 -0700208 if (mCblkMemory == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700209 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700210 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Eric Laurent81784c32012-11-19 14:55:58 -0800211 client->heap()->dump("AudioTrack");
Glenn Kasten663c2242013-09-24 11:52:37 -0700212 mCblkMemory.clear();
Eric Laurent81784c32012-11-19 14:55:58 -0800213 return;
214 }
215 } else {
Andy Hungafb31482017-02-13 18:50:48 -0800216 mCblk = (audio_track_cblk_t *) malloc(size);
217 if (mCblk == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700218 ALOGE("%s(%d): not enough memory for AudioTrack size=%zu", __func__, mId, size);
Andy Hungafb31482017-02-13 18:50:48 -0800219 return;
220 }
Eric Laurent81784c32012-11-19 14:55:58 -0800221 }
222
223 // construct the shared structure in-place.
224 if (mCblk != NULL) {
225 new(mCblk) audio_track_cblk_t();
Glenn Kastenc263ca02014-06-04 20:31:46 -0700226 switch (alloc) {
227 case ALLOC_READONLY: {
Glenn Kastend776ac62014-05-07 09:16:09 -0700228 const sp<MemoryDealer> roHeap(thread->readOnlyHeap());
229 if (roHeap == 0 ||
230 (mBufferMemory = roHeap->allocate(bufferSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700231 (mBuffer = mBufferMemory->unsecurePointer()) == NULL) {
Andy Hung9d84af52018-09-12 18:03:44 -0700232 ALOGE("%s(%d): not enough memory for read-only buffer size=%zu",
233 __func__, mId, bufferSize);
Glenn Kastend776ac62014-05-07 09:16:09 -0700234 if (roHeap != 0) {
235 roHeap->dump("buffer");
236 }
237 mCblkMemory.clear();
238 mBufferMemory.clear();
239 return;
240 }
Eric Laurent81784c32012-11-19 14:55:58 -0800241 memset(mBuffer, 0, bufferSize);
Glenn Kastenc263ca02014-06-04 20:31:46 -0700242 } break;
243 case ALLOC_PIPE:
244 mBufferMemory = thread->pipeMemory();
245 // mBuffer is the virtual address as seen from current process (mediaserver),
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700246 // and should normally be coming from mBufferMemory->unsecurePointer().
Glenn Kastenc263ca02014-06-04 20:31:46 -0700247 // However in this case the TrackBase does not reference the buffer directly.
248 // It should references the buffer via the pipe.
249 // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL.
250 mBuffer = NULL;
Andy Hung8fe68032017-06-05 16:17:51 -0700251 bufferSize = 0;
Glenn Kastenc263ca02014-06-04 20:31:46 -0700252 break;
253 case ALLOC_CBLK:
Glenn Kastend776ac62014-05-07 09:16:09 -0700254 // clear all buffers
Eric Laurent83b88082014-06-20 18:31:16 -0700255 if (buffer == NULL) {
Glenn Kastend776ac62014-05-07 09:16:09 -0700256 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
257 memset(mBuffer, 0, bufferSize);
258 } else {
Eric Laurent83b88082014-06-20 18:31:16 -0700259 mBuffer = buffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800260#if 0
Glenn Kastend776ac62014-05-07 09:16:09 -0700261 mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800262#endif
Glenn Kastend776ac62014-05-07 09:16:09 -0700263 }
Glenn Kastenc263ca02014-06-04 20:31:46 -0700264 break;
Eric Laurent83b88082014-06-20 18:31:16 -0700265 case ALLOC_LOCAL:
266 mBuffer = calloc(1, bufferSize);
267 break;
268 case ALLOC_NONE:
269 mBuffer = buffer;
270 break;
Andy Hung8fe68032017-06-05 16:17:51 -0700271 default:
Andy Hung9d84af52018-09-12 18:03:44 -0700272 LOG_ALWAYS_FATAL("%s(%d): invalid allocation type: %d", __func__, mId, (int)alloc);
Eric Laurent81784c32012-11-19 14:55:58 -0800273 }
Andy Hung8fe68032017-06-05 16:17:51 -0700274 mBufferSize = bufferSize;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800275
Glenn Kasten46909e72013-02-26 09:20:22 -0800276#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700277 mTee.set(sampleRate, mChannelCount, format, NBAIO_Tee::TEE_FLAG_TRACK);
Glenn Kasten46909e72013-02-26 09:20:22 -0800278#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800279
Eric Laurent81784c32012-11-19 14:55:58 -0800280 }
281}
282
Eric Laurent83b88082014-06-20 18:31:16 -0700283status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
284{
285 status_t status;
286 if (mType == TYPE_OUTPUT || mType == TYPE_PATCH) {
287 status = cblk() != NULL ? NO_ERROR : NO_MEMORY;
288 } else {
289 status = getCblk() != 0 ? NO_ERROR : NO_MEMORY;
290 }
291 return status;
292}
293
Eric Laurent81784c32012-11-19 14:55:58 -0800294AudioFlinger::ThreadBase::TrackBase::~TrackBase()
295{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800296 // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference
Eric Laurent5bba2f62016-03-18 11:14:14 -0700297 mServerProxy.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700298 releaseCblk();
Eric Laurent81784c32012-11-19 14:55:58 -0800299 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
300 if (mClient != 0) {
Eric Laurent021cf962014-05-13 10:18:14 -0700301 // Client destructor must run with AudioFlinger client mutex locked
302 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
Eric Laurent81784c32012-11-19 14:55:58 -0800303 // If the client's reference count drops to zero, the associated destructor
304 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
305 // relying on the automatic clear() at end of scope.
306 mClient.clear();
307 }
Eric Laurent3bcffa12014-06-12 18:38:45 -0700308 // flush the binder command buffer
309 IPCThreadState::self()->flushCommands();
Eric Laurent81784c32012-11-19 14:55:58 -0800310}
311
312// AudioBufferProvider interface
313// getNextBuffer() = 0;
Glenn Kastend79072e2016-01-06 08:41:20 -0800314// This implementation of releaseBuffer() is used by Track and RecordTrack
Eric Laurent81784c32012-11-19 14:55:58 -0800315void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
316{
Glenn Kasten46909e72013-02-26 09:20:22 -0800317#ifdef TEE_SINK
Andy Hung8946a282018-04-19 20:04:56 -0700318 mTee.write(buffer->raw, buffer->frameCount);
Glenn Kasten46909e72013-02-26 09:20:22 -0800319#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800320
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800321 ServerProxy::Buffer buf;
322 buf.mFrameCount = buffer->frameCount;
323 buf.mRaw = buffer->raw;
Eric Laurent81784c32012-11-19 14:55:58 -0800324 buffer->frameCount = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800325 buffer->raw = NULL;
326 mServerProxy->releaseBuffer(&buf);
Eric Laurent81784c32012-11-19 14:55:58 -0800327}
328
Eric Laurent81784c32012-11-19 14:55:58 -0800329status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
330{
331 mSyncEvents.add(event);
332 return NO_ERROR;
333}
334
Kevin Rocard45986c72018-12-18 18:22:59 -0800335AudioFlinger::ThreadBase::PatchTrackBase::PatchTrackBase(sp<ClientProxy> proxy,
336 const ThreadBase& thread,
337 const Timeout& timeout)
338 : mProxy(proxy)
339{
340 if (timeout) {
341 setPeerTimeout(*timeout);
342 } else {
343 // Double buffer mixer
344 uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
345 thread.sampleRate();
346 setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
347 }
348}
349
350void AudioFlinger::ThreadBase::PatchTrackBase::setPeerTimeout(std::chrono::nanoseconds timeout) {
351 mPeerTimeout.tv_sec = timeout.count() / std::nano::den;
352 mPeerTimeout.tv_nsec = timeout.count() % std::nano::den;
353}
354
355
Eric Laurent81784c32012-11-19 14:55:58 -0800356// ----------------------------------------------------------------------------
357// Playback
358// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700359#undef LOG_TAG
360#define LOG_TAG "AF::TrackHandle"
Eric Laurent81784c32012-11-19 14:55:58 -0800361
362AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
363 : BnAudioTrack(),
364 mTrack(track)
365{
366}
367
368AudioFlinger::TrackHandle::~TrackHandle() {
369 // just stop the track on deletion, associated resources
370 // will be freed from the main thread once all pending buffers have
371 // been played. Unless it's not in the active track list, in which
372 // case we free everything now...
373 mTrack->destroy();
374}
375
376sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
377 return mTrack->getCblk();
378}
379
380status_t AudioFlinger::TrackHandle::start() {
381 return mTrack->start();
382}
383
384void AudioFlinger::TrackHandle::stop() {
385 mTrack->stop();
386}
387
388void AudioFlinger::TrackHandle::flush() {
389 mTrack->flush();
390}
391
Eric Laurent81784c32012-11-19 14:55:58 -0800392void AudioFlinger::TrackHandle::pause() {
393 mTrack->pause();
394}
395
396status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
397{
398 return mTrack->attachAuxEffect(EffectId);
399}
400
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700401status_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) {
402 return mTrack->setParameters(keyValuePairs);
403}
404
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800405status_t AudioFlinger::TrackHandle::selectPresentation(int presentationId, int programId) {
406 return mTrack->selectPresentation(presentationId, programId);
407}
408
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800409VolumeShaper::Status AudioFlinger::TrackHandle::applyVolumeShaper(
410 const sp<VolumeShaper::Configuration>& configuration,
411 const sp<VolumeShaper::Operation>& operation) {
412 return mTrack->applyVolumeShaper(configuration, operation);
413}
414
415sp<VolumeShaper::State> AudioFlinger::TrackHandle::getVolumeShaperState(int id) {
416 return mTrack->getVolumeShaperState(id);
417}
418
Glenn Kasten53cec222013-08-29 09:01:02 -0700419status_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp)
420{
Glenn Kasten573d80a2013-08-26 09:36:23 -0700421 return mTrack->getTimestamp(timestamp);
Glenn Kasten53cec222013-08-29 09:01:02 -0700422}
423
Eric Laurent59fe0102013-09-27 18:48:26 -0700424void AudioFlinger::TrackHandle::signal()
425{
426 return mTrack->signal();
427}
428
Kuowei Li3bea3a42020-08-13 14:44:25 +0800429status_t AudioFlinger::TrackHandle::getDualMonoMode(audio_dual_mono_mode_t* mode)
430{
431 return mTrack->getDualMonoMode(mode);
432}
433
434status_t AudioFlinger::TrackHandle::setDualMonoMode(audio_dual_mono_mode_t mode)
435{
436 return validateDualMonoMode(mode) ?: mTrack->setDualMonoMode(mode);
437}
438
439status_t AudioFlinger::TrackHandle::getAudioDescriptionMixLevel(float* leveldB)
440{
441 return mTrack->getAudioDescriptionMixLevel(leveldB);
442}
443
444status_t AudioFlinger::TrackHandle::setAudioDescriptionMixLevel(float leveldB)
445{
446 return validateAudioDescriptionMixLevel(leveldB)
447 ?: mTrack->setAudioDescriptionMixLevel(leveldB);
448}
449
450status_t AudioFlinger::TrackHandle::getPlaybackRateParameters(
451 audio_playback_rate_t* playbackRate)
452{
453 return mTrack->getPlaybackRateParameters(playbackRate);
454}
455
456status_t AudioFlinger::TrackHandle::setPlaybackRateParameters(
457 const audio_playback_rate_t& playbackRate)
458{
459 return validatePlaybackRate(playbackRate)
460 ?: mTrack->setPlaybackRateParameters(playbackRate);
461}
462
Eric Laurent81784c32012-11-19 14:55:58 -0800463status_t AudioFlinger::TrackHandle::onTransact(
464 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
465{
466 return BnAudioTrack::onTransact(code, data, reply, flags);
467}
468
469// ----------------------------------------------------------------------------
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800470// AppOp for audio playback
471// -------------------------------
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700472
473// static
474sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
475AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
jiabin375283d2020-08-21 18:14:43 -0700476 uid_t uid, const audio_attributes_t& attr, int id, audio_stream_type_t streamType,
477 const std::string& opPackageName)
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800478{
jiabin375283d2020-08-21 18:14:43 -0700479 Vector <String16> packages;
480 getPackagesForUid(uid, packages);
Eric Laurent9066ad32019-05-20 14:40:10 -0700481 if (isServiceUid(uid)) {
Eric Laurent9066ad32019-05-20 14:40:10 -0700482 if (packages.isEmpty()) {
483 ALOGD("OpPlayAudio: not muting track:%d usage:%d for service UID %d",
484 id,
485 attr.usage,
486 uid);
487 return nullptr;
488 }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800489 }
490 // stream type has been filtered by audio policy to indicate whether it can be muted
491 if (streamType == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Eric Laurent2dab0302019-05-08 18:15:55 -0700492 ALOGD("OpPlayAudio: not muting track:%d usage:%d ENFORCED_AUDIBLE", id, attr.usage);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700493 return nullptr;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800494 }
Eric Laurent2dab0302019-05-08 18:15:55 -0700495 if ((attr.flags & AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY)
496 == AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY) {
497 ALOGD("OpPlayAudio: not muting track:%d flags %#x have FLAG_BYPASS_INTERRUPTION_POLICY",
498 id, attr.flags);
499 return nullptr;
500 }
jiabin375283d2020-08-21 18:14:43 -0700501
502 String16 opPackageNameStr(opPackageName.c_str());
503 if (opPackageName.empty()) {
504 // If no package name is provided by the client, use the first associated with the uid
505 if (!packages.isEmpty()) {
506 opPackageNameStr = packages[0];
507 }
508 } else {
509 // If the provided package name is invalid, we force app ops denial by clearing the package
510 // name passed to OpPlayAudioMonitor
511 if (std::find_if(packages.begin(), packages.end(),
512 [&opPackageNameStr](const auto& package) {
513 return opPackageNameStr == package; }) == packages.end()) {
514 ALOGW("The package name(%s) provided does not correspond to the uid %d, "
515 "force muting the track", opPackageName.c_str(), uid);
516 // Set package name as an empty string so that hasOpPlayAudio will always return false.
517 opPackageNameStr = String16("");
518 }
519 }
520 return new OpPlayAudioMonitor(uid, attr.usage, id, opPackageNameStr);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700521}
522
523AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
jiabin375283d2020-08-21 18:14:43 -0700524 uid_t uid, audio_usage_t usage, int id, const String16& opPackageName)
525 : mHasOpPlayAudio(true), mUid(uid), mUsage((int32_t) usage), mId(id),
526 mOpPackageName(opPackageName)
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700527{
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800528}
529
530AudioFlinger::PlaybackThread::OpPlayAudioMonitor::~OpPlayAudioMonitor()
531{
532 if (mOpCallback != 0) {
533 mAppOpsManager.stopWatchingMode(mOpCallback);
534 }
535 mOpCallback.clear();
536}
537
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700538void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
539{
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700540 checkPlayAudioForUsage();
jiabin375283d2020-08-21 18:14:43 -0700541 if (mOpPackageName.size() != 0) {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700542 mOpCallback = new PlayAudioOpCallback(this);
jiabin375283d2020-08-21 18:14:43 -0700543 mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO, mOpPackageName, mOpCallback);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700544 }
545}
546
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800547bool AudioFlinger::PlaybackThread::OpPlayAudioMonitor::hasOpPlayAudio() const {
548 return mHasOpPlayAudio.load();
549}
550
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700551// Note this method is never called (and never to be) for audio server / patch record track
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800552// - not called from constructor due to check on UID,
553// - not called from PlayAudioOpCallback because the callback is not installed in this case
554void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage()
555{
jiabin375283d2020-08-21 18:14:43 -0700556 if (mOpPackageName.size() == 0) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800557 mHasOpPlayAudio.store(false);
558 } else {
jiabin375283d2020-08-21 18:14:43 -0700559 bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
560 mUsage, mUid, mOpPackageName) == AppOpsManager::MODE_ALLOWED;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800561 ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
562 mHasOpPlayAudio.store(hasIt);
563 }
564}
565
566AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::PlayAudioOpCallback(
567 const wp<OpPlayAudioMonitor>& monitor) : mMonitor(monitor)
568{ }
569
570void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::PlayAudioOpCallback::opChanged(int32_t op,
571 const String16& packageName) {
572 // we only have uid, so we need to check all package names anyway
573 UNUSED(packageName);
574 if (op != AppOpsManager::OP_PLAY_AUDIO) {
575 return;
576 }
577 sp<OpPlayAudioMonitor> monitor = mMonitor.promote();
578 if (monitor != NULL) {
579 monitor->checkPlayAudioForUsage();
580 }
581}
582
Eric Laurent9066ad32019-05-20 14:40:10 -0700583// static
584void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::getPackagesForUid(
585 uid_t uid, Vector<String16>& packages)
586{
587 PermissionController permissionController;
588 permissionController.getPackagesForUid(uid, packages);
589}
590
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800591// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -0700592#undef LOG_TAG
593#define LOG_TAG "AF::Track"
Eric Laurent81784c32012-11-19 14:55:58 -0800594
595// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
596AudioFlinger::PlaybackThread::Track::Track(
597 PlaybackThread *thread,
598 const sp<Client>& client,
599 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700600 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -0800601 uint32_t sampleRate,
602 audio_format_t format,
603 audio_channel_mask_t channelMask,
604 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700605 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700606 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -0800607 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800608 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700609 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800610 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -0700611 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800612 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100613 audio_port_handle_t portId,
jiabin375283d2020-08-21 18:14:43 -0700614 size_t frameCountToBeReady,
615 const std::string opPackageName)
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700616 : TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700617 // TODO: Using unsecurePointer() has some associated security pitfalls
618 // (see declaration for details).
619 // Either document why it is safe in this case or address the
620 // issue (e.g. by copying).
621 (sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700622 (sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700623 sessionId, creatorPid, uid, true /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -0700624 (type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
Andy Hungb68f5eb2019-12-03 16:49:17 -0800625 type,
626 portId,
627 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK) + std::to_string(portId)),
Eric Laurent81784c32012-11-19 14:55:58 -0800628 mFillingUpStatus(FS_INVALID),
629 // mRetryCount initialized later when needed
630 mSharedBuffer(sharedBuffer),
631 mStreamType(streamType),
rago94a1ee82017-07-21 15:11:02 -0700632 mMainBuffer(thread->sinkBuffer()),
Eric Laurent81784c32012-11-19 14:55:58 -0800633 mAuxBuffer(NULL),
634 mAuxEffectId(0), mHasVolumeController(false),
635 mPresentationCompleteFrames(0),
Andy Hunge10393e2015-06-12 13:59:33 -0700636 mFrameMap(16 /* sink-frame-to-track-frame map memory */),
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700637 mVolumeHandler(new media::VolumeHandler(sampleRate)),
jiabin375283d2020-08-21 18:14:43 -0700638 mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(
639 uid, attr, id(), streamType, opPackageName)),
Andy Hunge10393e2015-06-12 13:59:33 -0700640 // mSinkTimestamp
Eric Laurent81784c32012-11-19 14:55:58 -0800641 mFastIndex(-1),
Glenn Kasten5736c352012-12-04 12:12:34 -0800642 mCachedVolume(1.0),
Kevin Rocard12381092018-04-11 09:19:59 -0700643 /* The track might not play immediately after being active, similarly as if its volume was 0.
644 * When the track starts playing, its volume will be computed. */
645 mFinalVolume(0.f),
Haynes Mathew George7844f672014-01-15 12:32:55 -0800646 mResumeToStopping(false),
Eric Laurent05067782016-06-01 18:27:28 -0700647 mFlushHwPending(false),
648 mFlags(flags)
Eric Laurent81784c32012-11-19 14:55:58 -0800649{
Eric Laurent83b88082014-06-20 18:31:16 -0700650 // client == 0 implies sharedBuffer == 0
651 ALOG_ASSERT(!(client == 0 && sharedBuffer != 0));
652
Andy Hung9d84af52018-09-12 18:03:44 -0700653 ALOGV_IF(sharedBuffer != 0, "%s(%d): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700654 __func__, mId, sharedBuffer->unsecurePointer(), sharedBuffer->size());
Eric Laurent83b88082014-06-20 18:31:16 -0700655
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700656 if (mCblk == NULL) {
657 return;
Eric Laurent81784c32012-11-19 14:55:58 -0800658 }
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700659
Andy Hung689e82c2019-08-21 17:53:17 -0700660 if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
661 ALOGE("%s(%d): no more tracks available", __func__, mId);
662 releaseCblk(); // this makes the track invalid.
663 return;
664 }
665
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700666 if (sharedBuffer == 0) {
667 mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -0700668 mFrameSize, !isExternalTrack(), sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700669 } else {
670 mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
Kevin Rocard36862032019-10-10 10:52:19 +0100671 mFrameSize, sampleRate);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700672 }
673 mServerProxy = mAudioTrackServerProxy;
Andy Hung63a35832021-03-16 17:30:09 -0700674 mServerProxy->setStartThresholdInFrames(frameCountToBeReady); // update the Cblk value
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700675
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700676 // only allocate a fast track index if we were able to allocate a normal track name
Eric Laurent05067782016-06-01 18:27:28 -0700677 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hunga5427822015-09-11 16:15:35 -0700678 // FIXME: Not calling framesReadyIsCalledByMultipleThreads() exposes a potential
679 // race with setSyncEvent(). However, if we call it, we cannot properly start
680 // static fast tracks (SoundPool) immediately after stopping.
681 //mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700682 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
683 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700684 ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700685 // FIXME This is too eager. We allocate a fast track index before the
686 // fast track becomes active. Since fast tracks are a scarce resource,
687 // this means we are potentially denying other more important fast tracks from
688 // being created. It would be better to allocate the index dynamically.
689 mFastIndex = i;
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700690 thread->mFastTrackAvailMask &= ~(1 << i);
691 }
Andy Hung8946a282018-04-19 20:04:56 -0700692
Andy Hung1c86ebe2018-05-29 20:29:08 -0700693 mServerLatencySupported = thread->type() == ThreadBase::MIXER
694 || thread->type() == ThreadBase::DUPLICATING;
Andy Hung8946a282018-04-19 20:04:56 -0700695#ifdef TEE_SINK
696 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
Kevin Rocard51f0e982019-02-01 19:19:11 -0800697 + "_" + std::to_string(mId) + "_T");
Andy Hung8946a282018-04-19 20:04:56 -0700698#endif
jiabin57303cc2018-12-18 15:45:57 -0800699
700 if (channelMask & AUDIO_CHANNEL_HAPTIC_ALL) {
701 mAudioVibrationController = new AudioVibrationController(this);
702 mExternalVibration = new os::ExternalVibration(
jiabin375283d2020-08-21 18:14:43 -0700703 mUid, opPackageName, mAttr, mAudioVibrationController);
jiabin57303cc2018-12-18 15:45:57 -0800704 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800705
706 // Once this item is logged by the server, the client can add properties.
Andy Hunga629bd12020-06-05 16:03:53 -0700707 const char * const traits = sharedBuffer == 0 ? "" : "static";
708 mTrackMetrics.logConstructor(creatorPid, uid, traits, streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800709}
710
711AudioFlinger::PlaybackThread::Track::~Track()
712{
Andy Hung9d84af52018-09-12 18:03:44 -0700713 ALOGV("%s(%d)", __func__, mId);
Glenn Kasten0c72b242013-09-11 09:14:16 -0700714
715 // The destructor would clear mSharedBuffer,
716 // but it will not push the decremented reference count,
717 // leaving the client's IMemory dangling indefinitely.
718 // This prevents that leak.
719 if (mSharedBuffer != 0) {
720 mSharedBuffer.clear();
Glenn Kasten0c72b242013-09-11 09:14:16 -0700721 }
Eric Laurent81784c32012-11-19 14:55:58 -0800722}
723
Glenn Kasten03003332013-08-06 15:40:54 -0700724status_t AudioFlinger::PlaybackThread::Track::initCheck() const
725{
726 status_t status = TrackBase::initCheck();
Andy Hungc0691382018-09-12 18:01:57 -0700727 if (status == NO_ERROR && mCblk == nullptr) {
Glenn Kasten03003332013-08-06 15:40:54 -0700728 status = NO_MEMORY;
729 }
730 return status;
731}
732
Eric Laurent81784c32012-11-19 14:55:58 -0800733void AudioFlinger::PlaybackThread::Track::destroy()
734{
735 // NOTE: destroyTrack_l() can remove a strong reference to this Track
736 // by removing it from mTracks vector, so there is a risk that this Tracks's
737 // destructor is called. As the destructor needs to lock mLock,
738 // we must acquire a strong reference on this Track before locking mLock
739 // here so that the destructor is called only when exiting this function.
740 // On the other hand, as long as Track::destroy() is only called by
741 // TrackHandle destructor, the TrackHandle still holds a strong ref on
742 // this Track with its member mTrack.
743 sp<Track> keep(this);
744 { // scope for mLock
Eric Laurentaaa44472014-09-12 17:41:50 -0700745 bool wasActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -0800746 sp<ThreadBase> thread = mThread.promote();
747 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -0800748 Mutex::Autolock _l(thread->mLock);
749 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentaaa44472014-09-12 17:41:50 -0700750 wasActive = playbackThread->destroyTrack_l(this);
751 }
752 if (isExternalTrack() && !wasActive) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700753 AudioSystem::releaseOutput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -0800754 }
755 }
Kevin Rocardc43ea142019-01-31 18:17:37 -0800756 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Eric Laurent81784c32012-11-19 14:55:58 -0800757}
758
Andy Hungf6ab58d2018-05-25 12:50:39 -0700759void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -0800760{
Eric Laurent973db022018-11-20 14:54:31 -0800761 result.appendFormat("Type Id Active Client Session Port Id S Flags "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700762 " Format Chn mask SRate "
763 "ST Usg CT "
764 " G db L dB R dB VS dB "
765 " Server FrmCnt FrmRdy F Underruns Flushed"
766 "%s\n",
767 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -0800768}
769
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700770void AudioFlinger::PlaybackThread::Track::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -0800771{
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700772 char trackType;
773 switch (mType) {
774 case TYPE_DEFAULT:
775 case TYPE_OUTPUT:
Andy Hungf6ab58d2018-05-25 12:50:39 -0700776 if (isStatic()) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700777 trackType = 'S'; // static
778 } else {
779 trackType = ' '; // normal
Eric Laurentbfb1b832013-01-07 09:53:42 -0800780 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700781 break;
782 case TYPE_PATCH:
783 trackType = 'P';
784 break;
785 default:
786 trackType = '?';
Eric Laurent81784c32012-11-19 14:55:58 -0800787 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700788
789 if (isFastTrack()) {
Andy Hungc0691382018-09-12 18:01:57 -0700790 result.appendFormat("F%d %c %6d", mFastIndex, trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700791 } else {
Andy Hungc0691382018-09-12 18:01:57 -0700792 result.appendFormat(" %c %6d", trackType, mId);
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700793 }
794
Eric Laurent81784c32012-11-19 14:55:58 -0800795 char nowInUnderrun;
796 switch (mObservedUnderruns.mBitFields.mMostRecent) {
797 case UNDERRUN_FULL:
798 nowInUnderrun = ' ';
799 break;
800 case UNDERRUN_PARTIAL:
801 nowInUnderrun = '<';
802 break;
803 case UNDERRUN_EMPTY:
804 nowInUnderrun = '*';
805 break;
806 default:
807 nowInUnderrun = '?';
808 break;
809 }
Andy Hungda540db2017-04-20 14:06:17 -0700810
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700811 char fillingStatus;
812 switch (mFillingUpStatus) {
813 case FS_INVALID:
814 fillingStatus = 'I';
815 break;
816 case FS_FILLING:
817 fillingStatus = 'f';
818 break;
819 case FS_FILLED:
820 fillingStatus = 'F';
821 break;
822 case FS_ACTIVE:
823 fillingStatus = 'A';
824 break;
825 default:
826 fillingStatus = '?';
827 break;
828 }
829
830 // clip framesReadySafe to max representation in dump
831 const size_t framesReadySafe =
832 std::min(mAudioTrackServerProxy->framesReadySafe(), (size_t)99999999);
833
834 // obtain volumes
835 const gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
836 const std::pair<float /* volume */, bool /* active */> vsVolume =
837 mVolumeHandler->getLastVolume();
838
839 // Our effective frame count is obtained by ServerProxy::getBufferSizeInFrames()
840 // as it may be reduced by the application.
841 const size_t bufferSizeInFrames = (size_t)mAudioTrackServerProxy->getBufferSizeInFrames();
842 // Check whether the buffer size has been modified by the app.
843 const char modifiedBufferChar = bufferSizeInFrames < mFrameCount
844 ? 'r' /* buffer reduced */: bufferSizeInFrames > mFrameCount
845 ? 'e' /* error */ : ' ' /* identical */;
846
Eric Laurent973db022018-11-20 14:54:31 -0800847 result.appendFormat("%7s %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700848 "%08X %08X %6u "
849 "%2u %3x %2x "
850 "%5.2g %5.2g %5.2g %5.2g%c "
851 "%08X %6zu%c %6zu %c %9u%c %7u",
Marco Nelissenb2208842014-02-07 14:00:50 -0800852 active ? "yes" : "no",
Andy Hung4ef19fa2018-05-15 19:35:29 -0700853 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700854 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -0800855 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -0800856 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700857 mCblk->mFlags,
858
Eric Laurent81784c32012-11-19 14:55:58 -0800859 mFormat,
860 mChannelMask,
Andy Hungcef2daa2018-06-01 15:31:49 -0700861 sampleRate(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700862
863 mStreamType,
Kevin Rocard5f2136e2018-05-11 22:03:00 -0700864 mAttr.usage,
865 mAttr.content_type,
866
867 20.0 * log10(mFinalVolume),
Glenn Kastenc56f3422014-03-21 17:53:17 -0700868 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))),
869 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))),
Andy Hungda540db2017-04-20 14:06:17 -0700870 20.0 * log10(vsVolume.first), // VolumeShaper(s) total volume
871 vsVolume.second ? 'A' : ' ', // if any VolumeShapers active
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700872
Glenn Kastenf20e1d82013-07-12 09:45:18 -0700873 mCblk->mServer,
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700874 bufferSizeInFrames,
875 modifiedBufferChar,
876 framesReadySafe,
877 fillingStatus,
Glenn Kasten82aaf942013-07-17 16:05:07 -0700878 mAudioTrackServerProxy->getUnderrunFrames(),
Andy Hung2148bf02016-11-28 19:01:02 -0800879 nowInUnderrun,
Andy Hungf6ab58d2018-05-25 12:50:39 -0700880 (unsigned)mAudioTrackServerProxy->framesFlushed() % 10000000
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700881 );
Andy Hungcef2daa2018-06-01 15:31:49 -0700882
883 if (isServerLatencySupported()) {
884 double latencyMs;
885 bool fromTrack;
886 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
887 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
888 // or 'k' if estimated from kernel because track frames haven't been presented yet.
889 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
Andy Hungf6ab58d2018-05-25 12:50:39 -0700890 } else {
Andy Hungcef2daa2018-06-01 15:31:49 -0700891 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
Andy Hungf6ab58d2018-05-25 12:50:39 -0700892 }
893 }
894 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800895}
896
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800897uint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const {
898 return mAudioTrackServerProxy->getSampleRate();
899}
900
Eric Laurent81784c32012-11-19 14:55:58 -0800901// AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800902status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -0800903{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800904 ServerProxy::Buffer buf;
905 size_t desiredFrames = buffer->frameCount;
906 buf.mFrameCount = desiredFrames;
907 status_t status = mServerProxy->obtainBuffer(&buf);
908 buffer->frameCount = buf.mFrameCount;
909 buffer->raw = buf.mRaw;
Andy Hungfc629172020-06-22 10:06:23 -0700910 if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused() && !isOffloaded()) {
Andy Hung9d84af52018-09-12 18:03:44 -0700911 ALOGV("%s(%d): underrun, framesReady(%zu) < framesDesired(%zd), state: %d",
912 __func__, mId, buf.mFrameCount, desiredFrames, mState);
Glenn Kasten82aaf942013-07-17 16:05:07 -0700913 mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -0800914 } else {
915 mAudioTrackServerProxy->tallyUnderrunFrames(0);
Eric Laurent81784c32012-11-19 14:55:58 -0800916 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800917 return status;
Eric Laurent81784c32012-11-19 14:55:58 -0800918}
919
Kevin Rocard153f92d2018-12-18 18:33:28 -0800920void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
921{
922 interceptBuffer(*buffer);
923 TrackBase::releaseBuffer(buffer);
924}
925
926// TODO: compensate for time shift between HW modules.
927void AudioFlinger::PlaybackThread::Track::interceptBuffer(
Kevin Rocarda134b002019-02-07 18:05:31 -0800928 const AudioBufferProvider::Buffer& sourceBuffer) {
Kevin Rocard6057fa22019-02-08 14:08:07 -0800929 auto start = std::chrono::steady_clock::now();
Kevin Rocarda134b002019-02-07 18:05:31 -0800930 const size_t frameCount = sourceBuffer.frameCount;
Kevin Rocardd83b08a2019-02-27 15:05:54 -0800931 if (frameCount == 0) {
932 return; // No audio to intercept.
933 // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
934 // does not allow 0 frame size request contrary to getNextBuffer
935 }
936 for (auto& teePatch : mTeePatches) {
937 RecordThread::PatchRecord* patchRecord = teePatch.patchRecord.get();
Mikhail Naganov8296c252019-09-25 14:59:54 -0700938 const size_t framesWritten = patchRecord->writeFrames(
939 sourceBuffer.i8, frameCount, mFrameSize);
940 const size_t framesLeft = frameCount - framesWritten;
Kevin Rocarda134b002019-02-07 18:05:31 -0800941 ALOGW_IF(framesLeft != 0, "%s(%d) PatchRecord %d can not provide big enough "
942 "buffer %zu/%zu, dropping %zu frames", __func__, mId, patchRecord->mId,
943 framesWritten, frameCount, framesLeft);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800944 }
Kevin Rocard6057fa22019-02-08 14:08:07 -0800945 auto spent = ceil<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
946 using namespace std::chrono_literals;
947 // Average is ~20us per track, this should virtually never be logged (Logging takes >200us)
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100948 ALOGD_IF(spent > 500us, "%s: took %lldus to intercept %zu tracks", __func__,
Kevin Rocard6057fa22019-02-08 14:08:07 -0800949 spent.count(), mTeePatches.size());
Kevin Rocard153f92d2018-12-18 18:33:28 -0800950}
951
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700952// ExtendedAudioBufferProvider interface
953
Andy Hung27876c02014-09-09 18:07:55 -0700954// framesReady() may return an approximation of the number of frames if called
955// from a different thread than the one calling Proxy->obtainBuffer() and
956// Proxy->releaseBuffer(). Also note there is no mutual exclusion in the
957// AudioTrackServerProxy so be especially careful calling with FastTracks.
Eric Laurent81784c32012-11-19 14:55:58 -0800958size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
Andy Hung27876c02014-09-09 18:07:55 -0700959 if (mSharedBuffer != 0 && (isStopped() || isStopping())) {
960 // Static tracks return zero frames immediately upon stopping (for FastTracks).
961 // The remainder of the buffer is not drained.
962 return 0;
963 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800964 return mAudioTrackServerProxy->framesReady();
Eric Laurent81784c32012-11-19 14:55:58 -0800965}
966
Andy Hung818e7a32016-02-16 18:08:07 -0800967int64_t AudioFlinger::PlaybackThread::Track::framesReleased() const
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700968{
969 return mAudioTrackServerProxy->framesReleased();
970}
971
Andy Hung818e7a32016-02-16 18:08:07 -0800972void AudioFlinger::PlaybackThread::Track::onTimestamp(const ExtendedTimestamp &timestamp)
Andy Hung6ae58432016-02-16 18:32:24 -0800973{
974 // This call comes from a FastTrack and should be kept lockless.
975 // The server side frames are already translated to client frames.
Andy Hung818e7a32016-02-16 18:08:07 -0800976 mAudioTrackServerProxy->setTimestamp(timestamp);
Andy Hung6ae58432016-02-16 18:32:24 -0800977
Andy Hung818e7a32016-02-16 18:08:07 -0800978 // We do not set drained here, as FastTrack timestamp may not go to very last frame.
Andy Hungcef2daa2018-06-01 15:31:49 -0700979
980 // Compute latency.
981 // TODO: Consider whether the server latency may be passed in by FastMixer
982 // as a constant for all active FastTracks.
983 const double latencyMs = timestamp.getOutputServerLatencyMs(sampleRate());
984 mServerLatencyFromTrack.store(true);
985 mServerLatencyMs.store(latencyMs);
Andy Hung6ae58432016-02-16 18:32:24 -0800986}
987
Eric Laurent81784c32012-11-19 14:55:58 -0800988// Don't call for fast tracks; the framesReady() could result in priority inversion
989bool AudioFlinger::PlaybackThread::Track::isReady() const {
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800990 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) {
991 return true;
992 }
993
Eric Laurent16498512014-03-17 17:22:08 -0700994 if (isStopping()) {
995 if (framesReady() > 0) {
996 mFillingUpStatus = FS_FILLED;
997 }
Eric Laurent81784c32012-11-19 14:55:58 -0800998 return true;
999 }
1000
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001001 size_t bufferSizeInFrames = mServerProxy->getBufferSizeInFrames();
Andy Hung63a35832021-03-16 17:30:09 -07001002 // Note: mServerProxy->getStartThresholdInFrames() is clamped.
1003 const size_t startThresholdInFrames = mServerProxy->getStartThresholdInFrames();
1004 const size_t framesToBeReady = std::clamp( // clamp again to validate client values.
1005 std::min(startThresholdInFrames, bufferSizeInFrames), size_t(1), mFrameCount);
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001006
1007 if (framesReady() >= framesToBeReady || (mCblk->mFlags & CBLK_FORCEREADY)) {
1008 ALOGV("%s(%d): consider track ready with %zu/%zu, target was %zu)",
1009 __func__, mId, framesReady(), bufferSizeInFrames, framesToBeReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001010 mFillingUpStatus = FS_FILLED;
Glenn Kasten96f60d82013-07-12 10:21:18 -07001011 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001012 return true;
1013 }
1014 return false;
1015}
1016
Glenn Kasten0f11b512014-01-31 16:18:54 -08001017status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
Glenn Kastend848eb42016-03-08 13:42:11 -08001018 audio_session_t triggerSession __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001019{
1020 status_t status = NO_ERROR;
Andy Hungc0691382018-09-12 18:01:57 -07001021 ALOGV("%s(%d): calling pid %d session %d",
1022 __func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001023
1024 sp<ThreadBase> thread = mThread.promote();
1025 if (thread != 0) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001026 if (isOffloaded()) {
1027 Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
1028 Mutex::Autolock _lth(thread->mLock);
1029 sp<EffectChain> ec = thread->getEffectChain_l(mSessionId);
Eric Laurent5baf2af2013-09-12 17:37:00 -07001030 if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
1031 (ec != 0 && ec->isNonOffloadableEnabled())) {
Eric Laurent813e2a72013-08-31 12:59:48 -07001032 invalidate();
1033 return PERMISSION_DENIED;
1034 }
1035 }
1036 Mutex::Autolock _lth(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001037 track_state state = mState;
1038 // here the track could be either new, or restarted
1039 // in both cases "unstop" the track
Eric Laurentbfb1b832013-01-07 09:53:42 -08001040
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001041 // initial state-stopping. next state-pausing.
1042 // What if resume is called ?
1043
Zhou Song8735d0d2020-08-17 15:36:56 +08001044 if (state == FLUSHED) {
1045 // avoid underrun glitches when starting after flush
1046 reset();
1047 }
1048
kuowei.lie2cd1df2021-05-11 18:02:32 +08001049 // clear mPauseHwPending because of pause (and possibly flush) during underrun.
1050 mPauseHwPending = false;
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001051 if (state == PAUSED || state == PAUSING) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001052 if (mResumeToStopping) {
1053 // happened we need to resume to STOPPING_1
1054 mState = TrackBase::STOPPING_1;
Andy Hungc0691382018-09-12 18:01:57 -07001055 ALOGV("%s(%d): PAUSED => STOPPING_1 on thread %d",
1056 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001057 } else {
1058 mState = TrackBase::RESUMING;
Andy Hungc0691382018-09-12 18:01:57 -07001059 ALOGV("%s(%d): PAUSED => RESUMING on thread %d",
1060 __func__, mId, (int)mThreadIoHandle);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001061 }
Eric Laurent81784c32012-11-19 14:55:58 -08001062 } else {
1063 mState = TrackBase::ACTIVE;
Andy Hungc0691382018-09-12 18:01:57 -07001064 ALOGV("%s(%d): ? => ACTIVE on thread %d",
1065 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001066 }
1067
Andy Hunge10393e2015-06-12 13:59:33 -07001068 // states to reset position info for non-offloaded/direct tracks
1069 if (!isOffloaded() && !isDirect()
1070 && (state == IDLE || state == STOPPED || state == FLUSHED)) {
1071 mFrameMap.reset();
1072 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001073 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Haynes Mathew George240934b2015-03-11 18:25:50 -07001074 if (isFastTrack()) {
1075 // refresh fast track underruns on start because that field is never cleared
1076 // by the fast mixer; furthermore, the same track can be recycled, i.e. start
1077 // after stop.
1078 mObservedUnderruns = playbackThread->getFastTrackUnderruns(mFastIndex);
1079 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001080 status = playbackThread->addTrack_l(this);
1081 if (status == INVALID_OPERATION || status == PERMISSION_DENIED) {
Eric Laurent81784c32012-11-19 14:55:58 -08001082 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001083 // restore previous state if start was rejected by policy manager
1084 if (status == PERMISSION_DENIED) {
1085 mState = state;
1086 }
1087 }
Andy Hung1d3556d2018-03-29 16:30:14 -07001088
Andy Hungb68f5eb2019-12-03 16:49:17 -08001089 // Audio timing metrics are computed a few mix cycles after starting.
1090 {
1091 mLogStartCountdown = LOG_START_COUNTDOWN;
1092 mLogStartTimeNs = systemTime();
1093 mLogStartFrames = mAudioTrackServerProxy->getTimestamp()
Andy Hung62921122020-05-18 10:47:31 -07001094 .mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1095 mLogLatencyMs = 0.;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001096 }
1097
Andy Hung1d3556d2018-03-29 16:30:14 -07001098 if (status == NO_ERROR || status == ALREADY_EXISTS) {
1099 // for streaming tracks, remove the buffer read stop limit.
1100 mAudioTrackServerProxy->start();
1101 }
1102
Eric Laurentbfb1b832013-01-07 09:53:42 -08001103 // track was already in the active list, not a problem
1104 if (status == ALREADY_EXISTS) {
1105 status = NO_ERROR;
Glenn Kasten12022ff2013-10-17 11:32:39 -07001106 } else {
1107 // Acknowledge any pending flush(), so that subsequent new data isn't discarded.
1108 // It is usually unsafe to access the server proxy from a binder thread.
1109 // But in this case we know the mixer thread (whether normal mixer or fast mixer)
1110 // isn't looking at this track yet: we still hold the normal mixer thread lock,
1111 // and for fast tracks the track is not yet in the fast mixer thread's active set.
Andy Hunge6fb82a2015-09-09 14:39:02 -07001112 // For static tracks, this is used to acknowledge change in position or loop.
Eric Laurent564d1442015-09-09 12:26:52 -07001113 ServerProxy::Buffer buffer;
1114 buffer.mFrameCount = 1;
1115 (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
Eric Laurent81784c32012-11-19 14:55:58 -08001116 }
1117 } else {
1118 status = BAD_VALUE;
1119 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001120 if (status == NO_ERROR) {
1121 forEachTeePatchTrack([](auto patchTrack) { patchTrack->start(); });
1122 }
Eric Laurent81784c32012-11-19 14:55:58 -08001123 return status;
1124}
1125
1126void AudioFlinger::PlaybackThread::Track::stop()
1127{
Andy Hungc0691382018-09-12 18:01:57 -07001128 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001129 sp<ThreadBase> thread = mThread.promote();
1130 if (thread != 0) {
1131 Mutex::Autolock _l(thread->mLock);
1132 track_state state = mState;
1133 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
1134 // If the track is not active (PAUSED and buffers full), flush buffers
1135 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1136 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1137 reset();
1138 mState = STOPPED;
Eric Laurentab5cdba2014-06-09 17:22:27 -07001139 } else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001140 mState = STOPPED;
1141 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08001142 // For fast tracks prepareTracks_l() will set state to STOPPING_2
1143 // presentation is complete
1144 // For an offloaded track this starts a drain and state will
1145 // move to STOPPING_2 when drain completes and then STOPPED
Eric Laurent81784c32012-11-19 14:55:58 -08001146 mState = STOPPING_1;
Eric Laurente93cc032016-05-05 10:15:10 -07001147 if (isOffloaded()) {
1148 mRetryCount = PlaybackThread::kMaxTrackStopRetriesOffload;
1149 }
Eric Laurent81784c32012-11-19 14:55:58 -08001150 }
Eric Laurentb369caf2015-03-30 20:51:47 -07001151 playbackThread->broadcast_l();
Andy Hungc0691382018-09-12 18:01:57 -07001152 ALOGV("%s(%d): not stopping/stopped => stopping/stopped on thread %d",
1153 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001154 }
Eric Laurent81784c32012-11-19 14:55:58 -08001155 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001156 forEachTeePatchTrack([](auto patchTrack) { patchTrack->stop(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001157}
1158
1159void AudioFlinger::PlaybackThread::Track::pause()
1160{
Andy Hungc0691382018-09-12 18:01:57 -07001161 ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001162 sp<ThreadBase> thread = mThread.promote();
1163 if (thread != 0) {
1164 Mutex::Autolock _l(thread->mLock);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001165 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1166 switch (mState) {
1167 case STOPPING_1:
1168 case STOPPING_2:
1169 if (!isOffloaded()) {
1170 /* nothing to do if track is not offloaded */
1171 break;
1172 }
1173
1174 // Offloaded track was draining, we need to carry on draining when resumed
1175 mResumeToStopping = true;
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07001176 FALLTHROUGH_INTENDED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001177 case ACTIVE:
1178 case RESUMING:
Eric Laurent81784c32012-11-19 14:55:58 -08001179 mState = PAUSING;
Andy Hungc0691382018-09-12 18:01:57 -07001180 ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
1181 __func__, mId, (int)mThreadIoHandle);
Kuowei Li23666472021-01-20 10:23:25 +08001182 if (isOffloadedOrDirect()) {
1183 mPauseHwPending = true;
1184 }
Eric Laurentede6c3b2013-09-19 14:37:46 -07001185 playbackThread->broadcast_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001186 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001187
Eric Laurentbfb1b832013-01-07 09:53:42 -08001188 default:
1189 break;
Eric Laurent81784c32012-11-19 14:55:58 -08001190 }
1191 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001192 // Pausing the TeePatch to avoid a glitch on underrun, at the cost of buffered audio loss.
1193 forEachTeePatchTrack([](auto patchTrack) { patchTrack->pause(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001194}
1195
1196void AudioFlinger::PlaybackThread::Track::flush()
1197{
Andy Hungc0691382018-09-12 18:01:57 -07001198 ALOGV("%s(%d)", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001199 sp<ThreadBase> thread = mThread.promote();
1200 if (thread != 0) {
1201 Mutex::Autolock _l(thread->mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08001202 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001203
Phil Burk4bb650b2016-09-09 12:11:17 -07001204 // Flush the ring buffer now if the track is not active in the PlaybackThread.
1205 // Otherwise the flush would not be done until the track is resumed.
1206 // Requires FastTrack removal be BLOCK_UNTIL_ACKED
1207 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1208 (void)mServerProxy->flushBufferIfNeeded();
1209 }
1210
Eric Laurentbfb1b832013-01-07 09:53:42 -08001211 if (isOffloaded()) {
1212 // If offloaded we allow flush during any state except terminated
1213 // and keep the track active to avoid problems if user is seeking
1214 // rapidly and underlying hardware has a significant delay handling
1215 // a pause
1216 if (isTerminated()) {
1217 return;
1218 }
1219
Andy Hung9d84af52018-09-12 18:03:44 -07001220 ALOGV("%s(%d): offload flush", __func__, mId);
Eric Laurent81784c32012-11-19 14:55:58 -08001221 reset();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001222
1223 if (mState == STOPPING_1 || mState == STOPPING_2) {
Andy Hung9d84af52018-09-12 18:03:44 -07001224 ALOGV("%s(%d): flushed in STOPPING_1 or 2 state, change state to ACTIVE",
1225 __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001226 mState = ACTIVE;
1227 }
1228
Haynes Mathew George7844f672014-01-15 12:32:55 -08001229 mFlushHwPending = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001230 mResumeToStopping = false;
1231 } else {
1232 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED &&
1233 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) {
1234 return;
1235 }
1236 // No point remaining in PAUSED state after a flush => go to
1237 // FLUSHED state
1238 mState = FLUSHED;
1239 // do not reset the track if it is still in the process of being stopped or paused.
1240 // this will be done by prepareTracks_l() when the track is stopped.
1241 // prepareTracks_l() will see mState == FLUSHED, then
1242 // remove from active track list, reset(), and trigger presentation complete
Eric Laurentd1f69b02014-12-15 14:33:13 -08001243 if (isDirect()) {
1244 mFlushHwPending = true;
1245 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001246 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
1247 reset();
1248 }
Eric Laurent81784c32012-11-19 14:55:58 -08001249 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001250 // Prevent flush being lost if the track is flushed and then resumed
1251 // before mixer thread can run. This is important when offloading
1252 // because the hardware buffer could hold a large amount of audio
Eric Laurentede6c3b2013-09-19 14:37:46 -07001253 playbackThread->broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001254 }
Kevin Rocardc43ea142019-01-31 18:17:37 -08001255 // Flush the Tee to avoid on resume playing old data and glitching on the transition to new data
1256 forEachTeePatchTrack([](auto patchTrack) { patchTrack->flush(); });
Eric Laurent81784c32012-11-19 14:55:58 -08001257}
1258
Haynes Mathew George7844f672014-01-15 12:32:55 -08001259// must be called with thread lock held
1260void AudioFlinger::PlaybackThread::Track::flushAck()
1261{
Eric Laurentd1f69b02014-12-15 14:33:13 -08001262 if (!isOffloaded() && !isDirect())
Haynes Mathew George7844f672014-01-15 12:32:55 -08001263 return;
1264
Phil Burk4bb650b2016-09-09 12:11:17 -07001265 // Clear the client ring buffer so that the app can prime the buffer while paused.
1266 // Otherwise it might not get cleared until playback is resumed and obtainBuffer() is called.
1267 mServerProxy->flushBufferIfNeeded();
1268
Haynes Mathew George7844f672014-01-15 12:32:55 -08001269 mFlushHwPending = false;
1270}
1271
Kuowei Li23666472021-01-20 10:23:25 +08001272void AudioFlinger::PlaybackThread::Track::pauseAck()
1273{
1274 mPauseHwPending = false;
1275}
1276
Eric Laurent81784c32012-11-19 14:55:58 -08001277void AudioFlinger::PlaybackThread::Track::reset()
1278{
1279 // Do not reset twice to avoid discarding data written just after a flush and before
1280 // the audioflinger thread detects the track is stopped.
1281 if (!mResetDone) {
Eric Laurent81784c32012-11-19 14:55:58 -08001282 // Force underrun condition to avoid false underrun callback until first data is
1283 // written to buffer
Glenn Kasten96f60d82013-07-12 10:21:18 -07001284 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08001285 mFillingUpStatus = FS_FILLING;
1286 mResetDone = true;
1287 if (mState == FLUSHED) {
1288 mState = IDLE;
1289 }
1290 }
1291}
1292
Eric Laurentbfb1b832013-01-07 09:53:42 -08001293status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs)
1294{
1295 sp<ThreadBase> thread = mThread.promote();
1296 if (thread == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001297 ALOGE("%s(%d): thread is dead", __func__, mId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001298 return FAILED_TRANSACTION;
1299 } else if ((thread->type() == ThreadBase::DIRECT) ||
1300 (thread->type() == ThreadBase::OFFLOAD)) {
1301 return thread->setParameters(keyValuePairs);
1302 } else {
1303 return PERMISSION_DENIED;
1304 }
1305}
1306
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001307status_t AudioFlinger::PlaybackThread::Track::selectPresentation(int presentationId,
1308 int programId) {
1309 sp<ThreadBase> thread = mThread.promote();
1310 if (thread == 0) {
1311 ALOGE("thread is dead");
1312 return FAILED_TRANSACTION;
1313 } else if ((thread->type() == ThreadBase::DIRECT) || (thread->type() == ThreadBase::OFFLOAD)) {
1314 DirectOutputThread *directOutputThread = static_cast<DirectOutputThread*>(thread.get());
1315 return directOutputThread->selectPresentation(presentationId, programId);
1316 }
1317 return INVALID_OPERATION;
1318}
1319
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001320VolumeShaper::Status AudioFlinger::PlaybackThread::Track::applyVolumeShaper(
1321 const sp<VolumeShaper::Configuration>& configuration,
1322 const sp<VolumeShaper::Operation>& operation)
1323{
Andy Hung10cbff12017-02-21 17:30:14 -08001324 sp<VolumeShaper::Configuration> newConfiguration;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001325
Andy Hung10cbff12017-02-21 17:30:14 -08001326 if (isOffloadedOrDirect()) {
1327 const VolumeShaper::Configuration::OptionFlag optionFlag
1328 = configuration->getOptionFlags();
1329 if ((optionFlag & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) == 0) {
Andy Hung9d84af52018-09-12 18:03:44 -07001330 ALOGW("%s(%d): %s tracks do not support frame counted VolumeShaper,"
1331 " using clock time instead",
1332 __func__, mId,
1333 isOffloaded() ? "Offload" : "Direct");
Andy Hung10cbff12017-02-21 17:30:14 -08001334 newConfiguration = new VolumeShaper::Configuration(*configuration);
1335 newConfiguration->setOptionFlags(
1336 VolumeShaper::Configuration::OptionFlag(optionFlag
1337 | VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME));
1338 }
1339 }
1340
1341 VolumeShaper::Status status = mVolumeHandler->applyVolumeShaper(
1342 (newConfiguration.get() != nullptr ? newConfiguration : configuration), operation);
1343
1344 if (isOffloadedOrDirect()) {
1345 // Signal thread to fetch new volume.
1346 sp<ThreadBase> thread = mThread.promote();
1347 if (thread != 0) {
Kevin Rocard5f2136e2018-05-11 22:03:00 -07001348 Mutex::Autolock _l(thread->mLock);
Andy Hung10cbff12017-02-21 17:30:14 -08001349 thread->broadcast_l();
1350 }
1351 }
1352 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001353}
1354
1355sp<VolumeShaper::State> AudioFlinger::PlaybackThread::Track::getVolumeShaperState(int id)
1356{
1357 // Note: We don't check if Thread exists.
1358
1359 // mVolumeHandler is thread safe.
1360 return mVolumeHandler->getVolumeShaperState(id);
1361}
1362
Kevin Rocard12381092018-04-11 09:19:59 -07001363void AudioFlinger::PlaybackThread::Track::setFinalVolume(float volume)
1364{
1365 if (mFinalVolume != volume) { // Compare to an epsilon if too many meaningless updates
1366 mFinalVolume = volume;
1367 setMetadataHasChanged();
Andy Hungc2b11cb2020-04-22 09:04:01 -07001368 mTrackMetrics.logVolume(volume);
Kevin Rocard12381092018-04-11 09:19:59 -07001369 }
1370}
1371
1372void AudioFlinger::PlaybackThread::Track::copyMetadataTo(MetadataInserter& backInserter) const
1373{
Eric Laurent6109cdb2020-11-20 18:41:04 +01001374 playback_track_metadata_v7_t metadata;
1375 metadata.base = {
Kevin Rocard12381092018-04-11 09:19:59 -07001376 .usage = mAttr.usage,
1377 .content_type = mAttr.content_type,
1378 .gain = mFinalVolume,
1379 };
Eric Laurent6109cdb2020-11-20 18:41:04 +01001380 metadata.channel_mask = mChannelMask,
1381 strncpy(metadata.tags, mAttr.tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
1382 *backInserter++ = metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07001383}
1384
Kevin Rocard153f92d2018-12-18 18:33:28 -08001385void AudioFlinger::PlaybackThread::Track::setTeePatches(TeePatches teePatches) {
Kevin Rocardc43ea142019-01-31 18:17:37 -08001386 forEachTeePatchTrack([](auto patchTrack) { patchTrack->destroy(); });
Kevin Rocard153f92d2018-12-18 18:33:28 -08001387 mTeePatches = std::move(teePatches);
1388}
1389
Glenn Kasten573d80a2013-08-26 09:36:23 -07001390status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp)
1391{
Andy Hung818e7a32016-02-16 18:08:07 -08001392 if (!isOffloaded() && !isDirect()) {
1393 return INVALID_OPERATION; // normal tracks handled through SSQ
Glenn Kastenfe346c72013-08-30 13:28:22 -07001394 }
Glenn Kasten573d80a2013-08-26 09:36:23 -07001395 sp<ThreadBase> thread = mThread.promote();
1396 if (thread == 0) {
Glenn Kastenfe346c72013-08-30 13:28:22 -07001397 return INVALID_OPERATION;
Glenn Kasten573d80a2013-08-26 09:36:23 -07001398 }
Phil Burk6140c792015-03-19 14:30:21 -07001399
Glenn Kasten573d80a2013-08-26 09:36:23 -07001400 Mutex::Autolock _l(thread->mLock);
1401 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Andy Hung818e7a32016-02-16 18:08:07 -08001402 return playbackThread->getTimestamp_l(timestamp);
Glenn Kasten573d80a2013-08-26 09:36:23 -07001403}
1404
Eric Laurent81784c32012-11-19 14:55:58 -08001405status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
1406{
Eric Laurent81784c32012-11-19 14:55:58 -08001407 sp<ThreadBase> thread = mThread.promote();
Eric Laurent6c796322019-04-09 14:13:17 -07001408 if (thread == nullptr) {
1409 return DEAD_OBJECT;
1410 }
Eric Laurent81784c32012-11-19 14:55:58 -08001411
Eric Laurent6c796322019-04-09 14:13:17 -07001412 sp<PlaybackThread> dstThread = (PlaybackThread *)thread.get();
1413 sp<PlaybackThread> srcThread; // srcThread is initialized by call to moveAuxEffectToIo()
1414 sp<AudioFlinger> af = mClient->audioFlinger();
1415 status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001416
Eric Laurent6c796322019-04-09 14:13:17 -07001417 if (EffectId != 0 && status == NO_ERROR) {
1418 status = dstThread->attachAuxEffect(this, EffectId);
1419 if (status == NO_ERROR) {
1420 AudioSystem::moveEffectsToIo(std::vector<int>(EffectId), dstThread->id());
Eric Laurent81784c32012-11-19 14:55:58 -08001421 }
Eric Laurent6c796322019-04-09 14:13:17 -07001422 }
1423
1424 if (status != NO_ERROR && srcThread != nullptr) {
1425 af->moveAuxEffectToIo(EffectId, srcThread, &dstThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001426 }
1427 return status;
1428}
1429
1430void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
1431{
1432 mAuxEffectId = EffectId;
1433 mAuxBuffer = buffer;
1434}
1435
Andy Hung818e7a32016-02-16 18:08:07 -08001436bool AudioFlinger::PlaybackThread::Track::presentationComplete(
1437 int64_t framesWritten, size_t audioHalFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08001438{
Andy Hung818e7a32016-02-16 18:08:07 -08001439 // TODO: improve this based on FrameMap if it exists, to ensure full drain.
1440 // This assists in proper timestamp computation as well as wakelock management.
1441
Eric Laurent81784c32012-11-19 14:55:58 -08001442 // a track is considered presented when the total number of frames written to audio HAL
1443 // corresponds to the number of frames written when presentationComplete() is called for the
1444 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001445 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used
1446 // to detect when all frames have been played. In this case framesWritten isn't
1447 // useful because it doesn't always reflect whether there is data in the h/w
1448 // buffers, particularly if a track has been paused and resumed during draining
Andy Hung9d84af52018-09-12 18:03:44 -07001449 ALOGV("%s(%d): presentationComplete() mPresentationCompleteFrames %lld framesWritten %lld",
1450 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001451 (long long)mPresentationCompleteFrames, (long long)framesWritten);
Eric Laurent81784c32012-11-19 14:55:58 -08001452 if (mPresentationCompleteFrames == 0) {
1453 mPresentationCompleteFrames = framesWritten + audioHalFrames;
Andy Hung9d84af52018-09-12 18:03:44 -07001454 ALOGV("%s(%d): presentationComplete() reset:"
1455 " mPresentationCompleteFrames %lld audioHalFrames %zu",
1456 __func__, mId,
Andy Hung818e7a32016-02-16 18:08:07 -08001457 (long long)mPresentationCompleteFrames, audioHalFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08001458 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001459
Andy Hungc54b1ff2016-02-23 14:07:07 -08001460 bool complete;
1461 if (isOffloaded()) {
1462 complete = true;
1463 } else if (isDirect() || isFastTrack()) { // these do not go through linear map
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001464 complete = framesWritten >= (int64_t) mPresentationCompleteFrames;
Andy Hungc54b1ff2016-02-23 14:07:07 -08001465 } else { // Normal tracks, OutputTracks, and PatchTracks
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001466 complete = framesWritten >= (int64_t) mPresentationCompleteFrames
Andy Hungc54b1ff2016-02-23 14:07:07 -08001467 && mAudioTrackServerProxy->isDrained();
1468 }
1469
1470 if (complete) {
Eric Laurent81784c32012-11-19 14:55:58 -08001471 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001472 mAudioTrackServerProxy->setStreamEndDone();
Eric Laurent81784c32012-11-19 14:55:58 -08001473 return true;
1474 }
1475 return false;
1476}
1477
1478void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
1479{
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001480 for (size_t i = 0; i < mSyncEvents.size();) {
Eric Laurent81784c32012-11-19 14:55:58 -08001481 if (mSyncEvents[i]->type() == type) {
1482 mSyncEvents[i]->trigger();
1483 mSyncEvents.removeAt(i);
Ivan Lozano5ec161b2017-12-06 10:00:28 -08001484 } else {
1485 ++i;
Eric Laurent81784c32012-11-19 14:55:58 -08001486 }
1487 }
1488}
1489
1490// implement VolumeBufferProvider interface
1491
Glenn Kastenc56f3422014-03-21 17:53:17 -07001492gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
Eric Laurent81784c32012-11-19 14:55:58 -08001493{
1494 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
1495 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
Glenn Kastenc56f3422014-03-21 17:53:17 -07001496 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR();
1497 float vl = float_from_gain(gain_minifloat_unpack_left(vlr));
1498 float vr = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08001499 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07001500 if (vl > GAIN_FLOAT_UNITY) {
1501 vl = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001502 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07001503 if (vr > GAIN_FLOAT_UNITY) {
1504 vr = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08001505 }
1506 // now apply the cached master volume and stream type volume;
1507 // this is trusted but lacks any synchronization or barrier so may be stale
1508 float v = mCachedVolume;
1509 vl *= v;
1510 vr *= v;
Glenn Kastenc56f3422014-03-21 17:53:17 -07001511 // re-combine into packed minifloat
1512 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr));
Eric Laurent81784c32012-11-19 14:55:58 -08001513 // FIXME look at mute, pause, and stop flags
1514 return vlr;
1515}
1516
1517status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
1518{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001519 if (isTerminated() || mState == PAUSED ||
Eric Laurent81784c32012-11-19 14:55:58 -08001520 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
1521 (mState == STOPPED)))) {
Andy Hung9d84af52018-09-12 18:03:44 -07001522 ALOGW("%s(%d): in invalid state %d on session %d %s mode, framesReady %zu",
1523 __func__, mId,
Eric Laurent81784c32012-11-19 14:55:58 -08001524 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
1525 event->cancel();
1526 return INVALID_OPERATION;
1527 }
1528 (void) TrackBase::setSyncEvent(event);
1529 return NO_ERROR;
1530}
1531
Glenn Kasten5736c352012-12-04 12:12:34 -08001532void AudioFlinger::PlaybackThread::Track::invalidate()
1533{
Eric Laurent6acd1d42017-01-04 14:23:29 -08001534 TrackBase::invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -08001535 signalClientFlag(CBLK_INVALID);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001536}
1537
1538void AudioFlinger::PlaybackThread::Track::disable()
1539{
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01001540 // TODO(b/142394888): the filling status should also be reset to filling
Eric Laurent4d231dc2016-03-11 18:38:23 -08001541 signalClientFlag(CBLK_DISABLED);
1542}
1543
1544void AudioFlinger::PlaybackThread::Track::signalClientFlag(int32_t flag)
1545{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001546 // FIXME should use proxy, and needs work
1547 audio_track_cblk_t* cblk = mCblk;
Eric Laurent4d231dc2016-03-11 18:38:23 -08001548 android_atomic_or(flag, &cblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001549 android_atomic_release_store(0x40000000, &cblk->mFutex);
1550 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07001551 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Glenn Kasten5736c352012-12-04 12:12:34 -08001552}
1553
Eric Laurent59fe0102013-09-27 18:48:26 -07001554void AudioFlinger::PlaybackThread::Track::signal()
1555{
1556 sp<ThreadBase> thread = mThread.promote();
1557 if (thread != 0) {
1558 PlaybackThread *t = (PlaybackThread *)thread.get();
1559 Mutex::Autolock _l(t->mLock);
1560 t->broadcast_l();
1561 }
1562}
1563
Kuowei Li3bea3a42020-08-13 14:44:25 +08001564status_t AudioFlinger::PlaybackThread::Track::getDualMonoMode(audio_dual_mono_mode_t* mode)
1565{
1566 status_t status = INVALID_OPERATION;
1567 if (isOffloadedOrDirect()) {
1568 sp<ThreadBase> thread = mThread.promote();
1569 if (thread != nullptr) {
1570 PlaybackThread *t = (PlaybackThread *)thread.get();
1571 Mutex::Autolock _l(t->mLock);
1572 status = t->mOutput->stream->getDualMonoMode(mode);
1573 ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
1574 "%s: mode %d inconsistent", __func__, mDualMonoMode);
1575 }
1576 }
1577 return status;
1578}
1579
1580status_t AudioFlinger::PlaybackThread::Track::setDualMonoMode(audio_dual_mono_mode_t mode)
1581{
1582 status_t status = INVALID_OPERATION;
1583 if (isOffloadedOrDirect()) {
1584 sp<ThreadBase> thread = mThread.promote();
1585 if (thread != nullptr) {
1586 auto t = static_cast<PlaybackThread *>(thread.get());
1587 Mutex::Autolock lock(t->mLock);
1588 status = t->mOutput->stream->setDualMonoMode(mode);
1589 if (status == NO_ERROR) {
1590 mDualMonoMode = mode;
1591 }
1592 }
1593 }
1594 return status;
1595}
1596
1597status_t AudioFlinger::PlaybackThread::Track::getAudioDescriptionMixLevel(float* leveldB)
1598{
1599 status_t status = INVALID_OPERATION;
1600 if (isOffloadedOrDirect()) {
1601 sp<ThreadBase> thread = mThread.promote();
1602 if (thread != nullptr) {
1603 auto t = static_cast<PlaybackThread *>(thread.get());
1604 Mutex::Autolock lock(t->mLock);
1605 status = t->mOutput->stream->getAudioDescriptionMixLevel(leveldB);
1606 ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
1607 "%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
1608 }
1609 }
1610 return status;
1611}
1612
1613status_t AudioFlinger::PlaybackThread::Track::setAudioDescriptionMixLevel(float leveldB)
1614{
1615 status_t status = INVALID_OPERATION;
1616 if (isOffloadedOrDirect()) {
1617 sp<ThreadBase> thread = mThread.promote();
1618 if (thread != nullptr) {
1619 auto t = static_cast<PlaybackThread *>(thread.get());
1620 Mutex::Autolock lock(t->mLock);
1621 status = t->mOutput->stream->setAudioDescriptionMixLevel(leveldB);
1622 if (status == NO_ERROR) {
1623 mAudioDescriptionMixLevel = leveldB;
1624 }
1625 }
1626 }
1627 return status;
1628}
1629
1630status_t AudioFlinger::PlaybackThread::Track::getPlaybackRateParameters(
1631 audio_playback_rate_t* playbackRate)
1632{
1633 status_t status = INVALID_OPERATION;
1634 if (isOffloadedOrDirect()) {
1635 sp<ThreadBase> thread = mThread.promote();
1636 if (thread != nullptr) {
1637 auto t = static_cast<PlaybackThread *>(thread.get());
1638 Mutex::Autolock lock(t->mLock);
1639 status = t->mOutput->stream->getPlaybackRateParameters(playbackRate);
1640 ALOGD_IF((status == NO_ERROR) &&
1641 !isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
1642 "%s: playbackRate inconsistent", __func__);
1643 }
1644 }
1645 return status;
1646}
1647
1648status_t AudioFlinger::PlaybackThread::Track::setPlaybackRateParameters(
1649 const audio_playback_rate_t& playbackRate)
1650{
1651 status_t status = INVALID_OPERATION;
1652 if (isOffloadedOrDirect()) {
1653 sp<ThreadBase> thread = mThread.promote();
1654 if (thread != nullptr) {
1655 auto t = static_cast<PlaybackThread *>(thread.get());
1656 Mutex::Autolock lock(t->mLock);
1657 status = t->mOutput->stream->setPlaybackRateParameters(playbackRate);
1658 if (status == NO_ERROR) {
1659 mPlaybackRateParameters = playbackRate;
1660 }
1661 }
1662 }
1663 return status;
1664}
1665
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001666//To be called with thread lock held
1667bool AudioFlinger::PlaybackThread::Track::isResumePending() {
1668
1669 if (mState == RESUMING)
1670 return true;
1671 /* Resume is pending if track was stopping before pause was called */
1672 if (mState == STOPPING_1 &&
1673 mResumeToStopping)
1674 return true;
1675
1676 return false;
1677}
1678
1679//To be called with thread lock held
1680void AudioFlinger::PlaybackThread::Track::resumeAck() {
1681
1682
1683 if (mState == RESUMING)
1684 mState = ACTIVE;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001685
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001686 // Other possibility of pending resume is stopping_1 state
1687 // Do not update the state from stopping as this prevents
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08001688 // drain being called.
1689 if (mState == STOPPING_1) {
1690 mResumeToStopping = false;
1691 }
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -08001692}
Andy Hunge10393e2015-06-12 13:59:33 -07001693
1694//To be called with thread lock held
1695void AudioFlinger::PlaybackThread::Track::updateTrackFrameInfo(
Andy Hung818e7a32016-02-16 18:08:07 -08001696 int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07001697 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp) {
Andy Hung30282562018-08-08 18:27:03 -07001698 // Make the kernel frametime available.
1699 const FrameTime ft{
1700 timeStamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
1701 timeStamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
1702 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
1703 mKernelFrameTime.store(ft);
1704 if (!audio_is_linear_pcm(mFormat)) {
1705 return;
1706 }
1707
Andy Hung818e7a32016-02-16 18:08:07 -08001708 //update frame map
Andy Hunge10393e2015-06-12 13:59:33 -07001709 mFrameMap.push(trackFramesReleased, sinkFramesWritten);
Andy Hung818e7a32016-02-16 18:08:07 -08001710
1711 // adjust server times and set drained state.
1712 //
1713 // Our timestamps are only updated when the track is on the Thread active list.
1714 // We need to ensure that tracks are not removed before full drain.
1715 ExtendedTimestamp local = timeStamp;
Andy Hungcef2daa2018-06-01 15:31:49 -07001716 bool drained = true; // default assume drained, if no server info found
Andy Hung818e7a32016-02-16 18:08:07 -08001717 bool checked = false;
1718 for (int i = ExtendedTimestamp::LOCATION_MAX - 1;
1719 i >= ExtendedTimestamp::LOCATION_SERVER; --i) {
1720 // Lookup the track frame corresponding to the sink frame position.
1721 if (local.mTimeNs[i] > 0) {
1722 local.mPosition[i] = mFrameMap.findX(local.mPosition[i]);
1723 // check drain state from the latest stage in the pipeline.
Andy Hung6d7b1192016-05-07 22:59:48 -07001724 if (!checked && i <= ExtendedTimestamp::LOCATION_KERNEL) {
Andy Hungcef2daa2018-06-01 15:31:49 -07001725 drained = local.mPosition[i] >= mAudioTrackServerProxy->framesReleased();
Andy Hung818e7a32016-02-16 18:08:07 -08001726 checked = true;
1727 }
1728 }
Andy Hunge10393e2015-06-12 13:59:33 -07001729 }
Andy Hungcef2daa2018-06-01 15:31:49 -07001730
1731 mAudioTrackServerProxy->setDrained(drained);
Andy Hungea2b9c02016-02-12 17:06:53 -08001732 // Set correction for flushed frames that are not accounted for in released.
Andy Hungea2b9c02016-02-12 17:06:53 -08001733 local.mFlushed = mAudioTrackServerProxy->framesFlushed();
Andy Hung818e7a32016-02-16 18:08:07 -08001734 mServerProxy->setTimestamp(local);
Andy Hungcef2daa2018-06-01 15:31:49 -07001735
1736 // Compute latency info.
1737 const bool useTrackTimestamp = !drained;
1738 const double latencyMs = useTrackTimestamp
1739 ? local.getOutputServerLatencyMs(sampleRate())
1740 : timeStamp.getOutputServerLatencyMs(halSampleRate);
1741
1742 mServerLatencyFromTrack.store(useTrackTimestamp);
1743 mServerLatencyMs.store(latencyMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001744
Andy Hung62921122020-05-18 10:47:31 -07001745 if (mLogStartCountdown > 0
1746 && local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0
1747 && local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] > 0)
1748 {
1749 if (mLogStartCountdown > 1) {
1750 --mLogStartCountdown;
1751 } else if (latencyMs < mLogLatencyMs) { // wait for latency to stabilize (dip)
1752 mLogStartCountdown = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001753 // startup is the difference in times for the current timestamp and our start
1754 double startUpMs =
Andy Hung62921122020-05-18 10:47:31 -07001755 (local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartTimeNs) * 1e-6;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001756 // adjust for frames played.
Andy Hung62921122020-05-18 10:47:31 -07001757 startUpMs -= (local.mPosition[ExtendedTimestamp::LOCATION_KERNEL] - mLogStartFrames)
1758 * 1e3 / mSampleRate;
1759 ALOGV("%s: latencyMs:%lf startUpMs:%lf"
1760 " localTime:%lld startTime:%lld"
1761 " localPosition:%lld startPosition:%lld",
1762 __func__, latencyMs, startUpMs,
1763 (long long)local.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001764 (long long)mLogStartTimeNs,
Andy Hung62921122020-05-18 10:47:31 -07001765 (long long)local.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
Andy Hungb68f5eb2019-12-03 16:49:17 -08001766 (long long)mLogStartFrames);
Andy Hungc2b11cb2020-04-22 09:04:01 -07001767 mTrackMetrics.logLatencyAndStartup(latencyMs, startUpMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08001768 }
Andy Hung62921122020-05-18 10:47:31 -07001769 mLogLatencyMs = latencyMs;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001770 }
Andy Hunge10393e2015-06-12 13:59:33 -07001771}
1772
jiabin57303cc2018-12-18 15:45:57 -08001773binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::mute(
1774 /*out*/ bool *ret) {
1775 *ret = false;
1776 sp<ThreadBase> thread = mTrack->mThread.promote();
1777 if (thread != 0) {
1778 // Lock for updating mHapticPlaybackEnabled.
1779 Mutex::Autolock _l(thread->mLock);
1780 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1781 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1782 && playbackThread->mHapticChannelCount > 0) {
1783 mTrack->setHapticPlaybackEnabled(false);
1784 *ret = true;
1785 }
1786 }
1787 return binder::Status::ok();
1788}
1789
1790binder::Status AudioFlinger::PlaybackThread::Track::AudioVibrationController::unmute(
1791 /*out*/ bool *ret) {
1792 *ret = false;
1793 sp<ThreadBase> thread = mTrack->mThread.promote();
1794 if (thread != 0) {
1795 // Lock for updating mHapticPlaybackEnabled.
1796 Mutex::Autolock _l(thread->mLock);
1797 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
1798 if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
1799 && playbackThread->mHapticChannelCount > 0) {
1800 mTrack->setHapticPlaybackEnabled(true);
1801 *ret = true;
1802 }
1803 }
1804 return binder::Status::ok();
1805}
1806
Eric Laurent81784c32012-11-19 14:55:58 -08001807// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07001808#undef LOG_TAG
1809#define LOG_TAG "AF::OutputTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08001810
Eric Laurent81784c32012-11-19 14:55:58 -08001811AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
1812 PlaybackThread *playbackThread,
1813 DuplicatingThread *sourceThread,
1814 uint32_t sampleRate,
1815 audio_format_t format,
1816 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001817 size_t frameCount,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001818 uid_t uid)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001819 : Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001820 audio_attributes_t{} /* currently unused for output track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08001821 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07001822 nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001823 AUDIO_SESSION_NONE, getpid(), uid, AUDIO_OUTPUT_FLAG_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -08001824 TYPE_OUTPUT),
Eric Laurent5bba2f62016-03-18 11:14:14 -07001825 mActive(false), mSourceThread(sourceThread)
Eric Laurent81784c32012-11-19 14:55:58 -08001826{
1827
1828 if (mCblk != NULL) {
Eric Laurent81784c32012-11-19 14:55:58 -08001829 mOutBuffer.frameCount = 0;
1830 playbackThread->mTracks.add(this);
Andy Hung9d84af52018-09-12 18:03:44 -07001831 ALOGV("%s(): mCblk %p, mBuffer %p, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001832 "frameCount %zu, mChannelMask 0x%08x",
Andy Hung9d84af52018-09-12 18:03:44 -07001833 __func__, mCblk, mBuffer,
Glenn Kasten74935e42013-12-19 08:56:45 -08001834 frameCount, mChannelMask);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001835 // since client and server are in the same process,
1836 // the buffer has the same virtual address on both sides
Glenn Kasten529c61b2014-07-18 15:31:02 -07001837 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize,
1838 true /*clientInServer*/);
Glenn Kastenc56f3422014-03-21 17:53:17 -07001839 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY);
Eric Laurent8d2d4932013-04-25 12:56:18 -07001840 mClientProxy->setSendLevel(0.0);
1841 mClientProxy->setSampleRate(sampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08001842 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07001843 ALOGW("%s(%d): Error creating output track on thread %d",
1844 __func__, mId, (int)mThreadIoHandle);
Eric Laurent81784c32012-11-19 14:55:58 -08001845 }
1846}
1847
1848AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
1849{
1850 clearBufferQueue();
Glenn Kastene3aa6592012-12-04 12:22:46 -08001851 // superclass destructor will now delete the server proxy and shared memory both refer to
Eric Laurent81784c32012-11-19 14:55:58 -08001852}
1853
1854status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001855 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08001856{
1857 status_t status = Track::start(event, triggerSession);
1858 if (status != NO_ERROR) {
1859 return status;
1860 }
1861
1862 mActive = true;
1863 mRetryCount = 127;
1864 return status;
1865}
1866
1867void AudioFlinger::PlaybackThread::OutputTrack::stop()
1868{
1869 Track::stop();
1870 clearBufferQueue();
1871 mOutBuffer.frameCount = 0;
1872 mActive = false;
1873}
1874
Andy Hung1c86ebe2018-05-29 20:29:08 -07001875ssize_t AudioFlinger::PlaybackThread::OutputTrack::write(void* data, uint32_t frames)
Eric Laurent81784c32012-11-19 14:55:58 -08001876{
1877 Buffer *pInBuffer;
1878 Buffer inBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08001879 bool outputBufferFull = false;
1880 inBuffer.frameCount = frames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001881 inBuffer.raw = data;
Eric Laurent81784c32012-11-19 14:55:58 -08001882
1883 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
1884
1885 if (!mActive && frames != 0) {
Andy Hung5bedff62015-01-16 11:05:32 -08001886 (void) start();
Eric Laurent81784c32012-11-19 14:55:58 -08001887 }
1888
1889 while (waitTimeLeftMs) {
1890 // First write pending buffers, then new data
1891 if (mBufferQueue.size()) {
1892 pInBuffer = mBufferQueue.itemAt(0);
1893 } else {
1894 pInBuffer = &inBuffer;
1895 }
1896
1897 if (pInBuffer->frameCount == 0) {
1898 break;
1899 }
1900
1901 if (mOutBuffer.frameCount == 0) {
1902 mOutBuffer.frameCount = pInBuffer->frameCount;
1903 nsecs_t startTime = systemTime();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001904 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001905 if (status != NO_ERROR && status != NOT_ENOUGH_DATA) {
Andy Hung9d84af52018-09-12 18:03:44 -07001906 ALOGV("%s(%d): thread %d no more output buffers; status %d",
1907 __func__, mId,
1908 (int)mThreadIoHandle, status);
Eric Laurent81784c32012-11-19 14:55:58 -08001909 outputBufferFull = true;
1910 break;
1911 }
1912 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
1913 if (waitTimeLeftMs >= waitTimeMs) {
1914 waitTimeLeftMs -= waitTimeMs;
1915 } else {
1916 waitTimeLeftMs = 0;
1917 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08001918 if (status == NOT_ENOUGH_DATA) {
1919 restartIfDisabled();
1920 continue;
1921 }
Eric Laurent81784c32012-11-19 14:55:58 -08001922 }
1923
1924 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount :
1925 pInBuffer->frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001926 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001927 Proxy::Buffer buf;
1928 buf.mFrameCount = outFrames;
1929 buf.mRaw = NULL;
1930 mClientProxy->releaseBuffer(&buf);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001931 restartIfDisabled();
Eric Laurent81784c32012-11-19 14:55:58 -08001932 pInBuffer->frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001933 pInBuffer->raw = (int8_t *)pInBuffer->raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001934 mOutBuffer.frameCount -= outFrames;
Andy Hungc25b84a2015-01-14 19:04:10 -08001935 mOutBuffer.raw = (int8_t *)mOutBuffer.raw + outFrames * mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001936
1937 if (pInBuffer->frameCount == 0) {
1938 if (mBufferQueue.size()) {
1939 mBufferQueue.removeAt(0);
Andy Hungc25b84a2015-01-14 19:04:10 -08001940 free(pInBuffer->mBuffer);
Yunlian Jiang8adc8082017-06-06 15:59:44 -07001941 if (pInBuffer != &inBuffer) {
1942 delete pInBuffer;
1943 }
Andy Hung9d84af52018-09-12 18:03:44 -07001944 ALOGV("%s(%d): thread %d released overflow buffer %zu",
1945 __func__, mId,
1946 (int)mThreadIoHandle, mBufferQueue.size());
Eric Laurent81784c32012-11-19 14:55:58 -08001947 } else {
1948 break;
1949 }
1950 }
1951 }
1952
1953 // If we could not write all frames, allocate a buffer and queue it for next time.
1954 if (inBuffer.frameCount) {
1955 sp<ThreadBase> thread = mThread.promote();
1956 if (thread != 0 && !thread->standby()) {
1957 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
1958 pInBuffer = new Buffer;
Andy Hungc25b84a2015-01-14 19:04:10 -08001959 pInBuffer->mBuffer = malloc(inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001960 pInBuffer->frameCount = inBuffer.frameCount;
Andy Hungc25b84a2015-01-14 19:04:10 -08001961 pInBuffer->raw = pInBuffer->mBuffer;
1962 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08001963 mBufferQueue.add(pInBuffer);
Andy Hung9d84af52018-09-12 18:03:44 -07001964 ALOGV("%s(%d): thread %d adding overflow buffer %zu", __func__, mId,
1965 (int)mThreadIoHandle, mBufferQueue.size());
Andy Hung1c86ebe2018-05-29 20:29:08 -07001966 // audio data is consumed (stored locally); set frameCount to 0.
1967 inBuffer.frameCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001968 } else {
Andy Hung9d84af52018-09-12 18:03:44 -07001969 ALOGW("%s(%d): thread %d no more overflow buffers",
1970 __func__, mId, (int)mThreadIoHandle);
Andy Hung1c86ebe2018-05-29 20:29:08 -07001971 // TODO: return error for this.
Eric Laurent81784c32012-11-19 14:55:58 -08001972 }
1973 }
1974 }
1975
Andy Hungc25b84a2015-01-14 19:04:10 -08001976 // Calling write() with a 0 length buffer means that no more data will be written:
1977 // We rely on stop() to set the appropriate flags to allow the remaining frames to play out.
1978 if (frames == 0 && mBufferQueue.size() == 0 && mActive) {
1979 stop();
Eric Laurent81784c32012-11-19 14:55:58 -08001980 }
1981
Andy Hung1c86ebe2018-05-29 20:29:08 -07001982 return frames - inBuffer.frameCount; // number of frames consumed.
Eric Laurent81784c32012-11-19 14:55:58 -08001983}
1984
Kevin Rocard12381092018-04-11 09:19:59 -07001985void AudioFlinger::PlaybackThread::OutputTrack::copyMetadataTo(MetadataInserter& backInserter) const
1986{
1987 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1988 backInserter = std::copy(mTrackMetadatas.begin(), mTrackMetadatas.end(), backInserter);
1989}
1990
1991void AudioFlinger::PlaybackThread::OutputTrack::setMetadatas(const SourceMetadatas& metadatas) {
1992 {
1993 std::lock_guard<std::mutex> lock(mTrackMetadatasMutex);
1994 mTrackMetadatas = metadatas;
1995 }
1996 // No need to adjust metadata track volumes as OutputTrack volumes are always 0dBFS.
1997 setMetadataHasChanged();
1998}
1999
Eric Laurent81784c32012-11-19 14:55:58 -08002000status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(
2001 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
2002{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002003 ClientProxy::Buffer buf;
2004 buf.mFrameCount = buffer->frameCount;
2005 struct timespec timeout;
2006 timeout.tv_sec = waitTimeMs / 1000;
2007 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000;
2008 status_t status = mClientProxy->obtainBuffer(&buf, &timeout);
2009 buffer->frameCount = buf.mFrameCount;
2010 buffer->raw = buf.mRaw;
2011 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002012}
2013
Eric Laurent81784c32012-11-19 14:55:58 -08002014void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
2015{
2016 size_t size = mBufferQueue.size();
2017
2018 for (size_t i = 0; i < size; i++) {
2019 Buffer *pBuffer = mBufferQueue.itemAt(i);
Andy Hungc25b84a2015-01-14 19:04:10 -08002020 free(pBuffer->mBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002021 delete pBuffer;
2022 }
2023 mBufferQueue.clear();
2024}
2025
Eric Laurent4d231dc2016-03-11 18:38:23 -08002026void AudioFlinger::PlaybackThread::OutputTrack::restartIfDisabled()
2027{
2028 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2029 if (mActive && (flags & CBLK_DISABLED)) {
2030 start();
2031 }
2032}
Eric Laurent81784c32012-11-19 14:55:58 -08002033
Andy Hung9d84af52018-09-12 18:03:44 -07002034// ----------------------------------------------------------------------------
2035#undef LOG_TAG
2036#define LOG_TAG "AF::PatchTrack"
2037
Eric Laurent83b88082014-06-20 18:31:16 -07002038AudioFlinger::PlaybackThread::PatchTrack::PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -07002039 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -07002040 uint32_t sampleRate,
2041 audio_channel_mask_t channelMask,
2042 audio_format_t format,
2043 size_t frameCount,
2044 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002045 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002046 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002047 const Timeout& timeout,
2048 size_t frameCountToBeReady)
Eric Laurent3bcf8592015-04-03 12:13:24 -07002049 : Track(playbackThread, NULL, streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002050 audio_attributes_t{} /* currently unused for patch track */,
Eric Laurent223fd5c2014-11-11 13:43:36 -08002051 sampleRate, format, channelMask, frameCount,
Andy Hung8fe68032017-06-05 16:17:51 -07002052 buffer, bufferSize, nullptr /* sharedBuffer */,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +01002053 AUDIO_SESSION_NONE, getpid(), AID_AUDIOSERVER, flags, TYPE_PATCH,
2054 AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
Kevin Rocard45986c72018-12-18 18:22:59 -08002055 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
2056 *playbackThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002057{
Andy Hung9d84af52018-09-12 18:03:44 -07002058 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2059 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002060 (int)mPeerTimeout.tv_sec,
2061 (int)(mPeerTimeout.tv_nsec / 1000000));
2062}
2063
2064AudioFlinger::PlaybackThread::PatchTrack::~PatchTrack()
2065{
Andy Hungabfab202019-03-07 19:45:54 -08002066 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002067}
2068
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002069size_t AudioFlinger::PlaybackThread::PatchTrack::framesReady() const
2070{
2071 if (mPeerProxy && mPeerProxy->producesBufferOnDemand()) {
2072 return std::numeric_limits<size_t>::max();
2073 } else {
2074 return Track::framesReady();
2075 }
2076}
2077
Eric Laurent4d231dc2016-03-11 18:38:23 -08002078status_t AudioFlinger::PlaybackThread::PatchTrack::start(AudioSystem::sync_event_t event,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002079 audio_session_t triggerSession)
Eric Laurent4d231dc2016-03-11 18:38:23 -08002080{
2081 status_t status = Track::start(event, triggerSession);
2082 if (status != NO_ERROR) {
2083 return status;
2084 }
2085 android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2086 return status;
2087}
2088
Eric Laurent83b88082014-06-20 18:31:16 -07002089// AudioBufferProvider interface
2090status_t AudioFlinger::PlaybackThread::PatchTrack::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002091 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002092{
Andy Hung9d84af52018-09-12 18:03:44 -07002093 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002094 Proxy::Buffer buf;
2095 buf.mFrameCount = buffer->frameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002096 if (ATRACE_ENABLED()) {
2097 std::string traceName("PTnReq");
2098 traceName += std::to_string(id());
2099 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2100 }
Eric Laurent83b88082014-06-20 18:31:16 -07002101 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
Andy Hung9d84af52018-09-12 18:03:44 -07002102 ALOGV_IF(status != NO_ERROR, "%s(%d): getNextBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002103 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002104 if (ATRACE_ENABLED()) {
2105 std::string traceName("PTnObt");
2106 traceName += std::to_string(id());
2107 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2108 }
Eric Laurent83b88082014-06-20 18:31:16 -07002109 if (buf.mFrameCount == 0) {
2110 return WOULD_BLOCK;
2111 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002112 status = Track::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002113 return status;
2114}
2115
2116void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2117{
Andy Hung9d84af52018-09-12 18:03:44 -07002118 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002119 Proxy::Buffer buf;
2120 buf.mFrameCount = buffer->frameCount;
2121 buf.mRaw = buffer->raw;
2122 mPeerProxy->releaseBuffer(&buf);
2123 TrackBase::releaseBuffer(buffer);
2124}
2125
2126status_t AudioFlinger::PlaybackThread::PatchTrack::obtainBuffer(Proxy::Buffer* buffer,
2127 const struct timespec *timeOut)
2128{
Eric Laurent4d231dc2016-03-11 18:38:23 -08002129 status_t status = NO_ERROR;
2130 static const int32_t kMaxTries = 5;
2131 int32_t tryCounter = kMaxTries;
Andy Hungf62e1a22018-05-08 18:32:11 -07002132 const size_t originalFrameCount = buffer->mFrameCount;
Eric Laurent4d231dc2016-03-11 18:38:23 -08002133 do {
2134 if (status == NOT_ENOUGH_DATA) {
2135 restartIfDisabled();
Andy Hungf62e1a22018-05-08 18:32:11 -07002136 buffer->mFrameCount = originalFrameCount; // cleared on error, must be restored.
Eric Laurent4d231dc2016-03-11 18:38:23 -08002137 }
2138 status = mProxy->obtainBuffer(buffer, timeOut);
2139 } while ((status == NOT_ENOUGH_DATA) && (tryCounter-- > 0));
2140 return status;
Eric Laurent83b88082014-06-20 18:31:16 -07002141}
2142
2143void AudioFlinger::PlaybackThread::PatchTrack::releaseBuffer(Proxy::Buffer* buffer)
2144{
2145 mProxy->releaseBuffer(buffer);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002146 restartIfDisabled();
naoki miyazuf37f9982019-11-28 11:18:18 +09002147
2148 // Check if the PatchTrack has enough data to write once in releaseBuffer().
2149 // If not, prevent an underrun from occurring by moving the track into FS_FILLING;
2150 // this logic avoids glitches when suspending A2DP with AudioPlaybackCapture.
2151 // TODO: perhaps underrun avoidance could be a track property checked in isReady() instead.
2152 if (mFillingUpStatus == FS_ACTIVE
2153 && audio_is_linear_pcm(mFormat)
2154 && !isOffloadedOrDirect()) {
2155 if (sp<ThreadBase> thread = mThread.promote();
2156 thread != 0) {
2157 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2158 const size_t frameCount = playbackThread->frameCount() * sampleRate()
2159 / playbackThread->sampleRate();
2160 if (framesReady() < frameCount) {
2161 ALOGD("%s(%d) Not enough data, wait for buffer to fill", __func__, mId);
2162 mFillingUpStatus = FS_FILLING;
2163 }
2164 }
2165 }
Eric Laurent4d231dc2016-03-11 18:38:23 -08002166}
2167
2168void AudioFlinger::PlaybackThread::PatchTrack::restartIfDisabled()
2169{
Eric Laurent83b88082014-06-20 18:31:16 -07002170 if (android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags) & CBLK_DISABLED) {
Andy Hung9d84af52018-09-12 18:03:44 -07002171 ALOGW("%s(%d): disabled due to previous underrun, restarting", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002172 start();
2173 }
Eric Laurent83b88082014-06-20 18:31:16 -07002174}
2175
Eric Laurent81784c32012-11-19 14:55:58 -08002176// ----------------------------------------------------------------------------
2177// Record
2178// ----------------------------------------------------------------------------
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002179
2180
2181// ----------------------------------------------------------------------------
2182// AppOp for audio recording
2183// -------------------------------
2184
2185#undef LOG_TAG
2186#define LOG_TAG "AF::OpRecordAudioMonitor"
2187
2188// static
2189sp<AudioFlinger::RecordThread::OpRecordAudioMonitor>
2190AudioFlinger::RecordThread::OpRecordAudioMonitor::createIfNeeded(
Eric Laurent58a0dd82019-10-24 12:42:17 -07002191 uid_t uid, const audio_attributes_t& attr, const String16& opPackageName)
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002192{
2193 if (isServiceUid(uid)) {
2194 ALOGV("not silencing record for service uid:%d pack:%s",
2195 uid, String8(opPackageName).string());
2196 return nullptr;
2197 }
2198
Eric Laurent58a0dd82019-10-24 12:42:17 -07002199 // Capturing from FM TUNER output is not controlled by OP_RECORD_AUDIO
2200 // because it does not affect users privacy as does capturing from an actual microphone.
2201 if (attr.source == AUDIO_SOURCE_FM_TUNER) {
2202 ALOGV("not muting FM TUNER capture for uid %d", uid);
2203 return nullptr;
2204 }
2205
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002206 if (opPackageName.size() == 0) {
2207 Vector<String16> packages;
2208 // no package name, happens with SL ES clients
2209 // query package manager to find one
2210 PermissionController permissionController;
2211 permissionController.getPackagesForUid(uid, packages);
2212 if (packages.isEmpty()) {
2213 return nullptr;
2214 } else {
2215 ALOGV("using pack:%s for uid:%d", String8(packages[0]).string(), uid);
2216 return new OpRecordAudioMonitor(uid, packages[0]);
2217 }
2218 }
2219
2220 return new OpRecordAudioMonitor(uid, opPackageName);
2221}
2222
2223AudioFlinger::RecordThread::OpRecordAudioMonitor::OpRecordAudioMonitor(
2224 uid_t uid, const String16& opPackageName)
2225 : mHasOpRecordAudio(true), mUid(uid), mPackage(opPackageName)
2226{
2227}
2228
2229AudioFlinger::RecordThread::OpRecordAudioMonitor::~OpRecordAudioMonitor()
2230{
2231 if (mOpCallback != 0) {
2232 mAppOpsManager.stopWatchingMode(mOpCallback);
2233 }
2234 mOpCallback.clear();
2235}
2236
2237void AudioFlinger::RecordThread::OpRecordAudioMonitor::onFirstRef()
2238{
2239 checkRecordAudio();
2240 mOpCallback = new RecordAudioOpCallback(this);
2241 ALOGV("start watching OP_RECORD_AUDIO for pack:%s", String8(mPackage).string());
2242 mAppOpsManager.startWatchingMode(AppOpsManager::OP_RECORD_AUDIO, mPackage, mOpCallback);
2243}
2244
2245bool AudioFlinger::RecordThread::OpRecordAudioMonitor::hasOpRecordAudio() const {
2246 return mHasOpRecordAudio.load();
2247}
2248
2249// Called by RecordAudioOpCallback when OP_RECORD_AUDIO is updated in AppOp callback
2250// and in onFirstRef()
2251// Note this method is never called (and never to be) for audio server / root track
2252// due to the UID in createIfNeeded(). As a result for those record track, it's:
2253// - not called from constructor,
2254// - not called from RecordAudioOpCallback because the callback is not installed in this case
2255void AudioFlinger::RecordThread::OpRecordAudioMonitor::checkRecordAudio()
2256{
2257 const int32_t mode = mAppOpsManager.checkOp(AppOpsManager::OP_RECORD_AUDIO,
2258 mUid, mPackage);
2259 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
2260 // verbose logging only log when appOp changed
2261 ALOGI_IF(hasIt != mHasOpRecordAudio.load(),
2262 "OP_RECORD_AUDIO missing, %ssilencing record uid%d pack:%s",
2263 hasIt ? "un" : "", mUid, String8(mPackage).string());
2264 mHasOpRecordAudio.store(hasIt);
2265}
2266
2267AudioFlinger::RecordThread::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
2268 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
2269{ }
2270
2271void AudioFlinger::RecordThread::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
2272 const String16& packageName) {
2273 UNUSED(packageName);
2274 if (op != AppOpsManager::OP_RECORD_AUDIO) {
2275 return;
2276 }
2277 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
2278 if (monitor != NULL) {
2279 monitor->checkRecordAudio();
2280 }
2281}
2282
2283
2284
Andy Hung9d84af52018-09-12 18:03:44 -07002285#undef LOG_TAG
2286#define LOG_TAG "AF::RecordHandle"
Eric Laurent81784c32012-11-19 14:55:58 -08002287
2288AudioFlinger::RecordHandle::RecordHandle(
2289 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
2290 : BnAudioRecord(),
2291 mRecordTrack(recordTrack)
2292{
2293}
2294
2295AudioFlinger::RecordHandle::~RecordHandle() {
2296 stop_nonvirtual();
2297 mRecordTrack->destroy();
2298}
2299
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002300binder::Status AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event,
2301 int /*audio_session_t*/ triggerSession) {
Andy Hung9d84af52018-09-12 18:03:44 -07002302 ALOGV("%s()", __func__);
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002303 return binder::Status::fromStatusT(
2304 mRecordTrack->start((AudioSystem::sync_event_t)event, (audio_session_t) triggerSession));
Eric Laurent81784c32012-11-19 14:55:58 -08002305}
2306
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002307binder::Status AudioFlinger::RecordHandle::stop() {
Eric Laurent81784c32012-11-19 14:55:58 -08002308 stop_nonvirtual();
Ivan Lozanoff6900d2017-08-01 15:47:38 -07002309 return binder::Status::ok();
Eric Laurent81784c32012-11-19 14:55:58 -08002310}
2311
2312void AudioFlinger::RecordHandle::stop_nonvirtual() {
Andy Hung9d84af52018-09-12 18:03:44 -07002313 ALOGV("%s()", __func__);
Eric Laurent81784c32012-11-19 14:55:58 -08002314 mRecordTrack->stop();
2315}
2316
jiabin653cc0a2018-01-17 17:54:10 -08002317binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
2318 std::vector<media::MicrophoneInfo>* activeMicrophones) {
Andy Hung9d84af52018-09-12 18:03:44 -07002319 ALOGV("%s()", __func__);
jiabin653cc0a2018-01-17 17:54:10 -08002320 return binder::Status::fromStatusT(
2321 mRecordTrack->getActiveMicrophones(activeMicrophones));
2322}
2323
Paul McLean12340082019-03-19 09:35:05 -06002324binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002325 int /*audio_microphone_direction_t*/ direction) {
2326 ALOGV("%s()", __func__);
Paul McLean12340082019-03-19 09:35:05 -06002327 return binder::Status::fromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002328 static_cast<audio_microphone_direction_t>(direction)));
2329}
2330
Paul McLean12340082019-03-19 09:35:05 -06002331binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002332 ALOGV("%s()", __func__);
Paul McLean12340082019-03-19 09:35:05 -06002333 return binder::Status::fromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
Paul McLean03a6e6a2018-12-04 10:54:13 -07002334}
2335
Eric Laurent81784c32012-11-19 14:55:58 -08002336// ----------------------------------------------------------------------------
Andy Hung9d84af52018-09-12 18:03:44 -07002337#undef LOG_TAG
2338#define LOG_TAG "AF::RecordTrack"
Eric Laurent81784c32012-11-19 14:55:58 -08002339
Glenn Kasten05997e22014-03-13 15:08:33 -07002340// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Eric Laurent81784c32012-11-19 14:55:58 -08002341AudioFlinger::RecordThread::RecordTrack::RecordTrack(
2342 RecordThread *thread,
2343 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002344 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -08002345 uint32_t sampleRate,
2346 audio_format_t format,
2347 audio_channel_mask_t channelMask,
2348 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -07002349 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002350 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -08002351 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002352 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -08002353 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07002354 audio_input_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002355 track_type type,
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002356 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002357 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002358 : TrackBase(thread, client, attr, sampleRate, format,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002359 channelMask, frameCount, buffer, bufferSize, sessionId,
2360 creatorPid, uid, false /*isOut*/,
Eric Laurent83b88082014-06-20 18:31:16 -07002361 (type == TYPE_DEFAULT) ?
Eric Laurent05067782016-06-01 18:27:28 -07002362 ((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
Eric Laurent83b88082014-06-20 18:31:16 -07002363 ((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
Andy Hungb68f5eb2019-12-03 16:49:17 -08002364 type, portId,
2365 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD) + std::to_string(portId)),
Andy Hung97a893e2015-03-29 01:03:07 -07002366 mOverflow(false),
Andy Hung4c6afaf2015-06-12 18:23:35 -07002367 mFramesToDrop(0),
2368 mResamplerBufferProvider(NULL), // initialize in case of early constructor exit
Eric Laurent05067782016-06-01 18:27:28 -07002369 mRecordBufferConverter(NULL),
jiabin9378eb92018-05-02 15:26:35 -07002370 mFlags(flags),
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002371 mSilenced(false),
Eric Laurent58a0dd82019-10-24 12:42:17 -07002372 mOpRecordAudioMonitor(OpRecordAudioMonitor::createIfNeeded(uid, attr, opPackageName))
Eric Laurent81784c32012-11-19 14:55:58 -08002373{
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07002374 if (mCblk == NULL) {
2375 return;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002376 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002377
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002378 if (!isDirect()) {
2379 mRecordBufferConverter = new RecordBufferConverter(
2380 thread->mChannelMask, thread->mFormat, thread->mSampleRate,
2381 channelMask, format, sampleRate);
2382 // Check if the RecordBufferConverter construction was successful.
2383 // If not, don't continue with construction.
2384 //
2385 // NOTE: It would be extremely rare that the record track cannot be created
2386 // for the current device, but a pending or future device change would make
2387 // the record track configuration valid.
2388 if (mRecordBufferConverter->initCheck() != NO_ERROR) {
Andy Hung9d84af52018-09-12 18:03:44 -07002389 ALOGE("%s(%d): RecordTrack unable to create record buffer converter", __func__, mId);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07002390 return;
2391 }
Andy Hung97a893e2015-03-29 01:03:07 -07002392 }
2393
Andy Hung6ae58432016-02-16 18:32:24 -08002394 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount,
Andy Hung3f0c9022016-01-15 17:49:46 -08002395 mFrameSize, !isExternalTrack());
Andy Hung3f0c9022016-01-15 17:49:46 -08002396
Andy Hung97a893e2015-03-29 01:03:07 -07002397 mResamplerBufferProvider = new ResamplerBufferProvider(this);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002398
Eric Laurent05067782016-06-01 18:27:28 -07002399 if (flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kastenc263ca02014-06-04 20:31:46 -07002400 ALOG_ASSERT(thread->mFastTrackAvail);
2401 thread->mFastTrackAvail = false;
Andy Hung000adb52018-06-01 15:43:26 -07002402 } else {
2403 // TODO: only Normal Record has timestamps (Fast Record does not).
Andy Hung5d3d9562018-10-04 19:27:26 -07002404 mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
Glenn Kastenc263ca02014-06-04 20:31:46 -07002405 }
Andy Hung8946a282018-04-19 20:04:56 -07002406#ifdef TEE_SINK
2407 mTee.setId(std::string("_") + std::to_string(mThreadIoHandle)
2408 + "_" + std::to_string(mId)
2409 + "_R");
2410#endif
Andy Hungb68f5eb2019-12-03 16:49:17 -08002411
2412 // Once this item is logged by the server, the client can add properties.
Andy Hungc2b11cb2020-04-22 09:04:01 -07002413 mTrackMetrics.logConstructor(creatorPid, uid);
Eric Laurent81784c32012-11-19 14:55:58 -08002414}
2415
2416AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
2417{
Andy Hung9d84af52018-09-12 18:03:44 -07002418 ALOGV("%s()", __func__);
Andy Hung97a893e2015-03-29 01:03:07 -07002419 delete mRecordBufferConverter;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002420 delete mResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08002421}
2422
Andy Hung97a893e2015-03-29 01:03:07 -07002423status_t AudioFlinger::RecordThread::RecordTrack::initCheck() const
2424{
2425 status_t status = TrackBase::initCheck();
2426 if (status == NO_ERROR && mServerProxy == 0) {
2427 status = BAD_VALUE;
2428 }
2429 return status;
2430}
2431
Eric Laurent81784c32012-11-19 14:55:58 -08002432// AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08002433status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08002434{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002435 ServerProxy::Buffer buf;
2436 buf.mFrameCount = buffer->frameCount;
2437 status_t status = mServerProxy->obtainBuffer(&buf);
2438 buffer->frameCount = buf.mFrameCount;
2439 buffer->raw = buf.mRaw;
2440 if (buf.mFrameCount == 0) {
2441 // FIXME also wake futex so that overrun is noticed more quickly
Glenn Kasten96f60d82013-07-12 10:21:18 -07002442 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags);
Eric Laurent81784c32012-11-19 14:55:58 -08002443 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002444 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002445}
2446
2447status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08002448 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08002449{
2450 sp<ThreadBase> thread = mThread.promote();
2451 if (thread != 0) {
2452 RecordThread *recordThread = (RecordThread *)thread.get();
2453 return recordThread->start(this, event, triggerSession);
2454 } else {
Eric Laurent717bc282020-08-21 17:10:39 -07002455 ALOGW("%s track %d: thread was destroyed", __func__, portId());
2456 return DEAD_OBJECT;
Eric Laurent81784c32012-11-19 14:55:58 -08002457 }
2458}
2459
2460void AudioFlinger::RecordThread::RecordTrack::stop()
2461{
2462 sp<ThreadBase> thread = mThread.promote();
2463 if (thread != 0) {
2464 RecordThread *recordThread = (RecordThread *)thread.get();
Eric Laurent83b88082014-06-20 18:31:16 -07002465 if (recordThread->stop(this) && isExternalTrack()) {
Eric Laurentfee19762018-01-29 18:44:13 -08002466 AudioSystem::stopInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002467 }
2468 }
2469}
2470
2471void AudioFlinger::RecordThread::RecordTrack::destroy()
2472{
2473 // see comments at AudioFlinger::PlaybackThread::Track::destroy()
2474 sp<RecordTrack> keep(this);
2475 {
Andy Hungce685402018-10-05 17:23:27 -07002476 track_state priorState = mState;
Eric Laurent81784c32012-11-19 14:55:58 -08002477 sp<ThreadBase> thread = mThread.promote();
2478 if (thread != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08002479 Mutex::Autolock _l(thread->mLock);
2480 RecordThread *recordThread = (RecordThread *) thread.get();
Andy Hungce685402018-10-05 17:23:27 -07002481 priorState = mState;
2482 recordThread->destroyTrack_l(this); // move mState to STOPPED, terminate
2483 }
2484 // APM portid/client management done outside of lock.
2485 // NOTE: if thread doesn't exist, the input descriptor probably doesn't either.
2486 if (isExternalTrack()) {
2487 switch (priorState) {
2488 case ACTIVE: // invalidated while still active
2489 case STARTING_2: // invalidated/start-aborted after startInput successfully called
2490 case PAUSING: // invalidated while in the middle of stop() pausing (still active)
2491 AudioSystem::stopInput(mPortId);
2492 break;
2493
2494 case STARTING_1: // invalidated/start-aborted and startInput not successful
2495 case PAUSED: // OK, not active
2496 case IDLE: // OK, not active
2497 break;
2498
2499 case STOPPED: // unexpected (destroyed)
2500 default:
2501 LOG_ALWAYS_FATAL("%s(%d): invalid prior state: %d", __func__, mId, priorState);
2502 }
2503 AudioSystem::releaseInput(mPortId);
Eric Laurent81784c32012-11-19 14:55:58 -08002504 }
2505 }
2506}
2507
Eric Laurent9a54bc22013-09-09 09:08:44 -07002508void AudioFlinger::RecordThread::RecordTrack::invalidate()
2509{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002510 TrackBase::invalidate();
Eric Laurent9a54bc22013-09-09 09:08:44 -07002511 // FIXME should use proxy, and needs work
2512 audio_track_cblk_t* cblk = mCblk;
2513 android_atomic_or(CBLK_INVALID, &cblk->mFlags);
2514 android_atomic_release_store(0x40000000, &cblk->mFutex);
2515 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE
Elliott Hughesee499292014-05-21 17:55:51 -07002516 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX);
Eric Laurent9a54bc22013-09-09 09:08:44 -07002517}
2518
Eric Laurent81784c32012-11-19 14:55:58 -08002519
Andy Hung000adb52018-06-01 15:43:26 -07002520void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result)
Eric Laurent81784c32012-11-19 14:55:58 -08002521{
Eric Laurent973db022018-11-20 14:54:31 -08002522 result.appendFormat("Active Id Client Session Port Id S Flags "
Andy Hung9d84af52018-09-12 18:03:44 -07002523 " Format Chn mask SRate Source "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002524 " Server FrmCnt FrmRdy Sil%s\n",
2525 isServerLatencySupported() ? " Latency" : "");
Eric Laurent81784c32012-11-19 14:55:58 -08002526}
2527
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002528void AudioFlinger::RecordThread::RecordTrack::appendDump(String8& result, bool active)
Eric Laurent81784c32012-11-19 14:55:58 -08002529{
Eric Laurent973db022018-11-20 14:54:31 -08002530 result.appendFormat("%c%5s %6d %6u %7u %7u %2s 0x%03X "
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002531 "%08X %08X %6u %6X "
Andy Hung000adb52018-06-01 15:43:26 -07002532 "%08X %6zu %6zu %3c",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002533 isFastTrack() ? 'F' : ' ',
Marco Nelissenb2208842014-02-07 14:00:50 -08002534 active ? "yes" : "no",
Andy Hung9d84af52018-09-12 18:03:44 -07002535 mId,
Andy Hung4ef19fa2018-05-15 19:35:29 -07002536 (mClient == 0) ? getpid() : mClient->pid(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002537 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08002538 mPortId,
Andy Hunge2e830f2019-12-03 12:54:46 -08002539 getTrackStateAsCodedString(),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002540 mCblk->mFlags,
2541
Eric Laurent81784c32012-11-19 14:55:58 -08002542 mFormat,
2543 mChannelMask,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002544 mSampleRate,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002545 mAttr.source,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002546
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002547 mCblk->mServer,
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002548 mFrameCount,
Andy Hung000adb52018-06-01 15:43:26 -07002549 mServerProxy->framesReadySafe(),
Jean-Michel Trivi7d665ab2018-04-11 17:26:51 -07002550 isSilenced() ? 's' : 'n'
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002551 );
Andy Hung000adb52018-06-01 15:43:26 -07002552 if (isServerLatencySupported()) {
2553 double latencyMs;
2554 bool fromTrack;
2555 if (getTrackLatencyMs(&latencyMs, &fromTrack) == OK) {
2556 // Show latency in msec, followed by 't' if from track timestamp (the most accurate)
2557 // or 'k' if estimated from kernel (usually for debugging).
2558 result.appendFormat(" %7.2lf %c", latencyMs, fromTrack ? 't' : 'k');
2559 } else {
2560 result.appendFormat("%10s", mCblk->mServer != 0 ? "unavail" : "new");
2561 }
2562 }
2563 result.append("\n");
Eric Laurent81784c32012-11-19 14:55:58 -08002564}
2565
Glenn Kasten25f4aa82014-02-07 10:50:43 -08002566void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event)
2567{
2568 if (event == mSyncStartEvent) {
2569 ssize_t framesToDrop = 0;
2570 sp<ThreadBase> threadBase = mThread.promote();
2571 if (threadBase != 0) {
2572 // TODO: use actual buffer filling status instead of 2 buffers when info is available
2573 // from audio HAL
2574 framesToDrop = threadBase->mFrameCount * 2;
2575 }
2576 mFramesToDrop = framesToDrop;
2577 }
2578}
2579
2580void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent()
2581{
2582 if (mSyncStartEvent != 0) {
2583 mSyncStartEvent->cancel();
2584 mSyncStartEvent.clear();
2585 }
2586 mFramesToDrop = 0;
2587}
2588
Andy Hung3f0c9022016-01-15 17:49:46 -08002589void AudioFlinger::RecordThread::RecordTrack::updateTrackFrameInfo(
2590 int64_t trackFramesReleased, int64_t sourceFramesRead,
2591 uint32_t halSampleRate, const ExtendedTimestamp &timestamp)
2592{
Andy Hung30282562018-08-08 18:27:03 -07002593 // Make the kernel frametime available.
2594 const FrameTime ft{
2595 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
2596 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]};
2597 // ALOGD("FrameTime: %lld %lld", (long long)ft.frames, (long long)ft.timeNs);
2598 mKernelFrameTime.store(ft);
2599 if (!audio_is_linear_pcm(mFormat)) {
2600 return;
2601 }
2602
Andy Hung3f0c9022016-01-15 17:49:46 -08002603 ExtendedTimestamp local = timestamp;
2604
2605 // Convert HAL frames to server-side track frames at track sample rate.
2606 // We use trackFramesReleased and sourceFramesRead as an anchor point.
2607 for (int i = ExtendedTimestamp::LOCATION_SERVER; i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2608 if (local.mTimeNs[i] != 0) {
2609 const int64_t relativeServerFrames = local.mPosition[i] - sourceFramesRead;
2610 const int64_t relativeTrackFrames = relativeServerFrames
2611 * mSampleRate / halSampleRate; // TODO: potential computation overflow
2612 local.mPosition[i] = relativeTrackFrames + trackFramesReleased;
2613 }
2614 }
Andy Hung6ae58432016-02-16 18:32:24 -08002615 mServerProxy->setTimestamp(local);
Andy Hung000adb52018-06-01 15:43:26 -07002616
2617 // Compute latency info.
2618 const bool useTrackTimestamp = true; // use track unless debugging.
2619 const double latencyMs = - (useTrackTimestamp
2620 ? local.getOutputServerLatencyMs(sampleRate())
2621 : timestamp.getOutputServerLatencyMs(halSampleRate));
2622
2623 mServerLatencyFromTrack.store(useTrackTimestamp);
2624 mServerLatencyMs.store(latencyMs);
Andy Hung3f0c9022016-01-15 17:49:46 -08002625}
Eric Laurent83b88082014-06-20 18:31:16 -07002626
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002627bool AudioFlinger::RecordThread::RecordTrack::isSilenced() const {
2628 if (mSilenced) {
2629 return true;
2630 }
2631 // The monitor is only created for record tracks that can be silenced.
2632 return mOpRecordAudioMonitor ? !mOpRecordAudioMonitor->hasOpRecordAudio() : false;
2633}
2634
jiabin653cc0a2018-01-17 17:54:10 -08002635status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
2636 std::vector<media::MicrophoneInfo>* activeMicrophones)
2637{
2638 sp<ThreadBase> thread = mThread.promote();
2639 if (thread != 0) {
2640 RecordThread *recordThread = (RecordThread *)thread.get();
2641 return recordThread->getActiveMicrophones(activeMicrophones);
2642 } else {
2643 return BAD_VALUE;
2644 }
2645}
2646
Paul McLean12340082019-03-19 09:35:05 -06002647status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -07002648 audio_microphone_direction_t direction) {
2649 sp<ThreadBase> thread = mThread.promote();
2650 if (thread != 0) {
2651 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002652 return recordThread->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002653 } else {
2654 return BAD_VALUE;
2655 }
2656}
2657
Paul McLean12340082019-03-19 09:35:05 -06002658status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
Paul McLean03a6e6a2018-12-04 10:54:13 -07002659 sp<ThreadBase> thread = mThread.promote();
2660 if (thread != 0) {
2661 RecordThread *recordThread = (RecordThread *)thread.get();
Paul McLean12340082019-03-19 09:35:05 -06002662 return recordThread->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002663 } else {
2664 return BAD_VALUE;
2665 }
2666}
2667
Andy Hung9d84af52018-09-12 18:03:44 -07002668// ----------------------------------------------------------------------------
2669#undef LOG_TAG
2670#define LOG_TAG "AF::PatchRecord"
2671
Eric Laurent83b88082014-06-20 18:31:16 -07002672AudioFlinger::RecordThread::PatchRecord::PatchRecord(RecordThread *recordThread,
2673 uint32_t sampleRate,
2674 audio_channel_mask_t channelMask,
2675 audio_format_t format,
2676 size_t frameCount,
2677 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -07002678 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -08002679 audio_input_flags_t flags,
2680 const Timeout& timeout)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002681 : RecordTrack(recordThread, NULL,
2682 audio_attributes_t{} /* currently unused for patch track */,
2683 sampleRate, format, channelMask, frameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002684 buffer, bufferSize, AUDIO_SESSION_NONE, getpid(), AID_AUDIOSERVER,
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07002685 flags, TYPE_PATCH, String16()),
Kevin Rocard45986c72018-12-18 18:22:59 -08002686 PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
2687 *recordThread, timeout)
Eric Laurent83b88082014-06-20 18:31:16 -07002688{
Andy Hung9d84af52018-09-12 18:03:44 -07002689 ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
2690 __func__, mId, sampleRate,
Eric Laurent83b88082014-06-20 18:31:16 -07002691 (int)mPeerTimeout.tv_sec,
2692 (int)(mPeerTimeout.tv_nsec / 1000000));
2693}
2694
2695AudioFlinger::RecordThread::PatchRecord::~PatchRecord()
2696{
Andy Hungabfab202019-03-07 19:45:54 -08002697 ALOGV("%s(%d)", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002698}
2699
Mikhail Naganov8296c252019-09-25 14:59:54 -07002700static size_t writeFramesHelper(
2701 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2702{
2703 AudioBufferProvider::Buffer patchBuffer;
2704 patchBuffer.frameCount = frameCount;
2705 auto status = dest->getNextBuffer(&patchBuffer);
2706 if (status != NO_ERROR) {
2707 ALOGW("%s PathRecord getNextBuffer failed with error %d: %s",
2708 __func__, status, strerror(-status));
2709 return 0;
2710 }
2711 ALOG_ASSERT(patchBuffer.frameCount <= frameCount);
2712 memcpy(patchBuffer.raw, src, patchBuffer.frameCount * frameSize);
2713 size_t framesWritten = patchBuffer.frameCount;
2714 dest->releaseBuffer(&patchBuffer);
2715 return framesWritten;
2716}
2717
2718// static
2719size_t AudioFlinger::RecordThread::PatchRecord::writeFrames(
2720 AudioBufferProvider* dest, const void* src, size_t frameCount, size_t frameSize)
2721{
2722 size_t framesWritten = writeFramesHelper(dest, src, frameCount, frameSize);
2723 // On buffer wrap, the buffer frame count will be less than requested,
2724 // when this happens a second buffer needs to be used to write the leftover audio
2725 const size_t framesLeft = frameCount - framesWritten;
2726 if (framesWritten != 0 && framesLeft != 0) {
2727 framesWritten += writeFramesHelper(dest, (const char*)src + framesWritten * frameSize,
2728 framesLeft, frameSize);
2729 }
2730 return framesWritten;
2731}
2732
Eric Laurent83b88082014-06-20 18:31:16 -07002733// AudioBufferProvider interface
2734status_t AudioFlinger::RecordThread::PatchRecord::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08002735 AudioBufferProvider::Buffer* buffer)
Eric Laurent83b88082014-06-20 18:31:16 -07002736{
Andy Hung9d84af52018-09-12 18:03:44 -07002737 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002738 Proxy::Buffer buf;
2739 buf.mFrameCount = buffer->frameCount;
2740 status_t status = mPeerProxy->obtainBuffer(&buf, &mPeerTimeout);
2741 ALOGV_IF(status != NO_ERROR,
Andy Hung9d84af52018-09-12 18:03:44 -07002742 "%s(%d): mPeerProxy->obtainBuffer status %d", __func__, mId, status);
Eric Laurentc2730ba2014-07-20 15:47:07 -07002743 buffer->frameCount = buf.mFrameCount;
Mikhail Naganov938be412019-09-04 11:38:47 -07002744 if (ATRACE_ENABLED()) {
2745 std::string traceName("PRnObt");
2746 traceName += std::to_string(id());
2747 ATRACE_INT(traceName.c_str(), buf.mFrameCount);
2748 }
Eric Laurent83b88082014-06-20 18:31:16 -07002749 if (buf.mFrameCount == 0) {
2750 return WOULD_BLOCK;
2751 }
Glenn Kastend79072e2016-01-06 08:41:20 -08002752 status = RecordTrack::getNextBuffer(buffer);
Eric Laurent83b88082014-06-20 18:31:16 -07002753 return status;
2754}
2755
2756void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(AudioBufferProvider::Buffer* buffer)
2757{
Andy Hung9d84af52018-09-12 18:03:44 -07002758 ALOG_ASSERT(mPeerProxy != 0, "%s(%d): called without peer proxy", __func__, mId);
Eric Laurent83b88082014-06-20 18:31:16 -07002759 Proxy::Buffer buf;
2760 buf.mFrameCount = buffer->frameCount;
2761 buf.mRaw = buffer->raw;
2762 mPeerProxy->releaseBuffer(&buf);
2763 TrackBase::releaseBuffer(buffer);
2764}
2765
2766status_t AudioFlinger::RecordThread::PatchRecord::obtainBuffer(Proxy::Buffer* buffer,
2767 const struct timespec *timeOut)
2768{
2769 return mProxy->obtainBuffer(buffer, timeOut);
2770}
2771
2772void AudioFlinger::RecordThread::PatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2773{
2774 mProxy->releaseBuffer(buffer);
2775}
2776
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002777#undef LOG_TAG
2778#define LOG_TAG "AF::PthrPatchRecord"
2779
2780static std::unique_ptr<void, decltype(free)*> allocAligned(size_t alignment, size_t size)
2781{
2782 void *ptr = nullptr;
2783 (void)posix_memalign(&ptr, alignment, size);
2784 return std::unique_ptr<void, decltype(free)*>(ptr, free);
2785}
2786
2787AudioFlinger::RecordThread::PassthruPatchRecord::PassthruPatchRecord(
2788 RecordThread *recordThread,
2789 uint32_t sampleRate,
2790 audio_channel_mask_t channelMask,
2791 audio_format_t format,
2792 size_t frameCount,
2793 audio_input_flags_t flags)
2794 : PatchRecord(recordThread, sampleRate, channelMask, format, frameCount,
2795 nullptr /*buffer*/, 0 /*bufferSize*/, flags),
2796 mPatchRecordAudioBufferProvider(*this),
2797 mSinkBuffer(allocAligned(32, mFrameCount * mFrameSize)),
2798 mStubBuffer(allocAligned(32, mFrameCount * mFrameSize))
2799{
2800 memset(mStubBuffer.get(), 0, mFrameCount * mFrameSize);
2801}
2802
2803sp<StreamInHalInterface> AudioFlinger::RecordThread::PassthruPatchRecord::obtainStream(
2804 sp<ThreadBase>* thread)
2805{
2806 *thread = mThread.promote();
2807 if (!*thread) return nullptr;
2808 RecordThread *recordThread = static_cast<RecordThread*>((*thread).get());
2809 Mutex::Autolock _l(recordThread->mLock);
2810 return recordThread->mInput ? recordThread->mInput->stream : nullptr;
2811}
2812
2813// PatchProxyBufferProvider methods are called on DirectOutputThread
2814status_t AudioFlinger::RecordThread::PassthruPatchRecord::obtainBuffer(
2815 Proxy::Buffer* buffer, const struct timespec* timeOut)
2816{
2817 if (mUnconsumedFrames) {
2818 buffer->mFrameCount = std::min(buffer->mFrameCount, mUnconsumedFrames);
2819 // mUnconsumedFrames is decreased in releaseBuffer to use actual frame consumption figure.
2820 return PatchRecord::obtainBuffer(buffer, timeOut);
2821 }
2822
2823 // Otherwise, execute a read from HAL and write into the buffer.
2824 nsecs_t startTimeNs = 0;
2825 if (timeOut && (timeOut->tv_sec != 0 || timeOut->tv_nsec != 0) && timeOut->tv_sec != INT_MAX) {
2826 // Will need to correct timeOut by elapsed time.
2827 startTimeNs = systemTime();
2828 }
2829 const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
2830 buffer->mFrameCount = 0;
2831 buffer->mRaw = nullptr;
2832 sp<ThreadBase> thread;
2833 sp<StreamInHalInterface> stream = obtainStream(&thread);
2834 if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
2835
2836 status_t result = NO_ERROR;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002837 size_t bytesRead = 0;
2838 {
2839 ATRACE_NAME("read");
2840 result = stream->read(mSinkBuffer.get(), framesToRead * mFrameSize, &bytesRead);
2841 if (result != NO_ERROR) goto stream_error;
2842 if (bytesRead == 0) return NO_ERROR;
2843 }
2844
2845 {
2846 std::lock_guard<std::mutex> lock(mReadLock);
2847 mReadBytes += bytesRead;
2848 mReadError = NO_ERROR;
2849 }
2850 mReadCV.notify_one();
2851 // writeFrames handles wraparound and should write all the provided frames.
2852 // If it couldn't, there is something wrong with the client/server buffer of the software patch.
2853 buffer->mFrameCount = writeFrames(
2854 &mPatchRecordAudioBufferProvider,
2855 mSinkBuffer.get(), bytesRead / mFrameSize, mFrameSize);
2856 ALOGW_IF(buffer->mFrameCount < bytesRead / mFrameSize,
2857 "Lost %zu frames obtained from HAL", bytesRead / mFrameSize - buffer->mFrameCount);
2858 mUnconsumedFrames = buffer->mFrameCount;
Mikhail Naganov4de49972019-10-07 09:53:58 -07002859 struct timespec newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002860 if (startTimeNs) {
Mikhail Naganov4de49972019-10-07 09:53:58 -07002861 // Correct the timeout by elapsed time.
2862 nsecs_t newTimeOutNs = audio_utils_ns_from_timespec(timeOut) - (systemTime() - startTimeNs);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002863 if (newTimeOutNs < 0) newTimeOutNs = 0;
2864 newTimeOut.tv_sec = newTimeOutNs / NANOS_PER_SECOND;
2865 newTimeOut.tv_nsec = newTimeOutNs - newTimeOut.tv_sec * NANOS_PER_SECOND;
Mikhail Naganov4de49972019-10-07 09:53:58 -07002866 timeOut = &newTimeOut;
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002867 }
Mikhail Naganov4de49972019-10-07 09:53:58 -07002868 return PatchRecord::obtainBuffer(buffer, timeOut);
Mikhail Naganovcaf59942019-09-25 14:05:29 -07002869
2870stream_error:
2871 stream->standby();
2872 {
2873 std::lock_guard<std::mutex> lock(mReadLock);
2874 mReadError = result;
2875 }
2876 mReadCV.notify_one();
2877 return result;
2878}
2879
2880void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(Proxy::Buffer* buffer)
2881{
2882 if (buffer->mFrameCount <= mUnconsumedFrames) {
2883 mUnconsumedFrames -= buffer->mFrameCount;
2884 } else {
2885 ALOGW("Write side has consumed more frames than we had: %zu > %zu",
2886 buffer->mFrameCount, mUnconsumedFrames);
2887 mUnconsumedFrames = 0;
2888 }
2889 PatchRecord::releaseBuffer(buffer);
2890}
2891
2892// AudioBufferProvider and Source methods are called on RecordThread
2893// 'read' emulates actual audio data with 0's. This is OK as 'getNextBuffer'
2894// and 'releaseBuffer' are stubbed out and ignore their input.
2895// It's not possible to retrieve actual data here w/o blocking 'obtainBuffer'
2896// until we copy it.
2897status_t AudioFlinger::RecordThread::PassthruPatchRecord::read(
2898 void* buffer, size_t bytes, size_t* read)
2899{
2900 bytes = std::min(bytes, mFrameCount * mFrameSize);
2901 {
2902 std::unique_lock<std::mutex> lock(mReadLock);
2903 mReadCV.wait(lock, [&]{ return mReadError != NO_ERROR || mReadBytes != 0; });
2904 if (mReadError != NO_ERROR) {
2905 mLastReadFrames = 0;
2906 return mReadError;
2907 }
2908 *read = std::min(bytes, mReadBytes);
2909 mReadBytes -= *read;
2910 }
2911 mLastReadFrames = *read / mFrameSize;
2912 memset(buffer, 0, *read);
2913 return 0;
2914}
2915
2916status_t AudioFlinger::RecordThread::PassthruPatchRecord::getCapturePosition(
2917 int64_t* frames, int64_t* time)
2918{
2919 sp<ThreadBase> thread;
2920 sp<StreamInHalInterface> stream = obtainStream(&thread);
2921 return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
2922}
2923
2924status_t AudioFlinger::RecordThread::PassthruPatchRecord::standby()
2925{
2926 // RecordThread issues 'standby' command in two major cases:
2927 // 1. Error on read--this case is handled in 'obtainBuffer'.
2928 // 2. Track is stopping--as PassthruPatchRecord assumes continuous
2929 // output, this can only happen when the software patch
2930 // is being torn down. In this case, the RecordThread
2931 // will terminate and close the HAL stream.
2932 return 0;
2933}
2934
2935// As the buffer gets filled in obtainBuffer, here we only simulate data consumption.
2936status_t AudioFlinger::RecordThread::PassthruPatchRecord::getNextBuffer(
2937 AudioBufferProvider::Buffer* buffer)
2938{
2939 buffer->frameCount = mLastReadFrames;
2940 buffer->raw = buffer->frameCount != 0 ? mStubBuffer.get() : nullptr;
2941 return NO_ERROR;
2942}
2943
2944void AudioFlinger::RecordThread::PassthruPatchRecord::releaseBuffer(
2945 AudioBufferProvider::Buffer* buffer)
2946{
2947 buffer->frameCount = 0;
2948 buffer->raw = nullptr;
2949}
2950
Andy Hung9d84af52018-09-12 18:03:44 -07002951// ----------------------------------------------------------------------------
2952#undef LOG_TAG
2953#define LOG_TAG "AF::MmapTrack"
Eric Laurent6acd1d42017-01-04 14:23:29 -08002954
2955AudioFlinger::MmapThread::MmapTrack::MmapTrack(ThreadBase *thread,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002956 const audio_attributes_t& attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002957 uint32_t sampleRate,
2958 audio_format_t format,
2959 audio_channel_mask_t channelMask,
2960 audio_session_t sessionId,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002961 bool isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002962 uid_t uid,
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002963 pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002964 pid_t creatorPid,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002965 audio_port_handle_t portId)
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002966 : TrackBase(thread, NULL, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002967 channelMask, (size_t)0 /* frameCount */,
2968 nullptr /* buffer */, (size_t)0 /* bufferSize */,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002969 sessionId, creatorPid, uid, isOut,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002970 ALLOC_NONE,
Andy Hungc2b11cb2020-04-22 09:04:01 -07002971 TYPE_DEFAULT, portId,
2972 std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
Eric Laurent331679c2018-04-16 17:03:16 -07002973 mPid(pid), mSilenced(false), mSilencedNotified(false)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002974{
Andy Hungc2b11cb2020-04-22 09:04:01 -07002975 // Once this item is logged by the server, the client can add properties.
2976 mTrackMetrics.logConstructor(creatorPid, uid);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002977}
2978
2979AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
2980{
2981}
2982
2983status_t AudioFlinger::MmapThread::MmapTrack::initCheck() const
2984{
2985 return NO_ERROR;
2986}
2987
2988status_t AudioFlinger::MmapThread::MmapTrack::start(AudioSystem::sync_event_t event __unused,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07002989 audio_session_t triggerSession __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08002990{
2991 return NO_ERROR;
2992}
2993
2994void AudioFlinger::MmapThread::MmapTrack::stop()
2995{
2996}
2997
2998// AudioBufferProvider interface
2999status_t AudioFlinger::MmapThread::MmapTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3000{
3001 buffer->frameCount = 0;
3002 buffer->raw = nullptr;
3003 return INVALID_OPERATION;
3004}
3005
3006// ExtendedAudioBufferProvider interface
3007size_t AudioFlinger::MmapThread::MmapTrack::framesReady() const {
3008 return 0;
3009}
3010
3011int64_t AudioFlinger::MmapThread::MmapTrack::framesReleased() const
3012{
3013 return 0;
3014}
3015
3016void AudioFlinger::MmapThread::MmapTrack::onTimestamp(const ExtendedTimestamp &timestamp __unused)
3017{
3018}
3019
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003020void AudioFlinger::MmapThread::MmapTrack::appendDumpHeader(String8& result)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003021{
Eric Laurent973db022018-11-20 14:54:31 -08003022 result.appendFormat("Client Session Port Id Format Chn mask SRate Flags %s\n",
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003023 isOut() ? "Usg CT": "Source");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003024}
3025
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003026void AudioFlinger::MmapThread::MmapTrack::appendDump(String8& result, bool active __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08003027{
Eric Laurent973db022018-11-20 14:54:31 -08003028 result.appendFormat("%6u %7u %7u %08X %08X %6u 0x%03X ",
Andy Hung2c6c3bb2017-06-16 14:01:45 -07003029 mPid,
3030 mSessionId,
Eric Laurent973db022018-11-20 14:54:31 -08003031 mPortId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08003032 mFormat,
3033 mChannelMask,
Kevin Rocard5f2136e2018-05-11 22:03:00 -07003034 mSampleRate,
3035 mAttr.flags);
3036 if (isOut()) {
3037 result.appendFormat("%3x %2x", mAttr.usage, mAttr.content_type);
3038 } else {
3039 result.appendFormat("%6x", mAttr.source);
3040 }
3041 result.append("\n");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003042}
3043
Glenn Kasten63238ef2015-03-02 15:50:29 -08003044} // namespace android