blob: 06db915f5508b9a8c2a7acb974cef4a1a62c258a [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"
Vlad Popab042ee62022-10-20 18:05:00 +020020// #define LOG_NDEBUG 0
Alex Ray371eb972012-11-30 11:11:54 -080021#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"
Eric Laurent81784c32012-11-19 14:55:58 -080024#include <math.h>
25#include <fcntl.h>
Eric Tan7b651152018-07-13 10:17:19 -070026#include <memory>
Andy Hungb68f5eb2019-12-03 16:49:17 -080027#include <sstream>
Eric Tan7b651152018-07-13 10:17:19 -070028#include <string>
Glenn Kastenad8510a2015-02-17 16:24:07 -080029#include <linux/futex.h>
Eric Laurent81784c32012-11-19 14:55:58 -080030#include <sys/stat.h>
Glenn Kastenad8510a2015-02-17 16:24:07 -080031#include <sys/syscall.h>
Glenn Kastenc9a23672020-06-30 12:12:42 -070032#include <cutils/bitops.h>
Eric Laurent81784c32012-11-19 14:55:58 -080033#include <cutils/properties.h>
Vlad Popae8d99472022-06-30 16:02:48 +020034#include <binder/PersistableBundle.h>
jiabinc52b1ff2019-10-31 17:20:42 -070035#include <media/AudioContainers.h>
36#include <media/AudioDeviceTypeAddr.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070037#include <media/AudioParameter.h>
Andy Hungcd044842014-08-07 11:04:34 -070038#include <media/AudioResamplerPublic.h>
Andy Hung89816052017-01-11 17:08:23 -080039#include <media/RecordBufferConverter.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070040#include <media/TypeConverter.h>
Eric Laurent81784c32012-11-19 14:55:58 -080041#include <utils/Log.h>
Alex Ray371eb972012-11-30 11:11:54 -080042#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080043
44#include <private/media/AudioTrackShared.h>
Wei Jiaf2ae3e12016-10-27 17:10:59 -070045#include <private/android_filesystem_config.h>
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +010046#include <audio_utils/Balance.h>
Vlad Popab042ee62022-10-20 18:05:00 +020047#include <audio_utils/MelProcessor.h>
jiabinf6eb4c32020-02-25 14:06:25 -080048#include <audio_utils/Metadata.h>
jiabin245cdd92018-12-07 17:55:15 -080049#include <audio_utils/channels.h>
Glenn Kasten6bf707f2017-02-23 16:53:58 -080050#include <audio_utils/mono_blend.h>
Eric Laurent81784c32012-11-19 14:55:58 -080051#include <audio_utils/primitives.h>
Andy Hung98ef9782014-03-04 14:46:50 -080052#include <audio_utils/format.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070053#include <audio_utils/minifloat.h>
Hongwei Wang95e37682019-04-12 11:13:36 -070054#include <audio_utils/safe_math.h>
Mikhail Naganov9fe94012016-10-14 14:57:40 -070055#include <system/audio_effects/effect_aec.h>
Eric Laurentb3f315a2021-07-13 15:09:05 +020056#include <system/audio_effects/effect_downmix.h>
57#include <system/audio_effects/effect_ns.h>
Eric Laurent1c5e2e32021-08-18 18:50:28 +020058#include <system/audio_effects/effect_spatializer.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070059#include <system/audio.h>
Eric Laurent81784c32012-11-19 14:55:58 -080060
61// NBAIO implementations
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070062#include <media/nbaio/AudioStreamInSource.h>
Eric Laurent81784c32012-11-19 14:55:58 -080063#include <media/nbaio/AudioStreamOutSink.h>
64#include <media/nbaio/MonoPipe.h>
65#include <media/nbaio/MonoPipeReader.h>
66#include <media/nbaio/Pipe.h>
67#include <media/nbaio/PipeReader.h>
68#include <media/nbaio/SourceAudioBufferProvider.h>
Wei Jia3f273d12015-11-24 09:06:49 -080069#include <mediautils/BatteryNotifier.h>
Andy Hungafc51db2022-04-08 17:33:40 -070070#include <mediautils/Process.h>
Eric Laurent81784c32012-11-19 14:55:58 -080071
Mikhail Naganov2996f672019-04-18 12:29:59 -070072#include <audiomanager/AudioManager.h>
Eric Laurent81784c32012-11-19 14:55:58 -080073#include <powermanager/PowerManager.h>
74
Kevin Rocard7588ff42018-01-08 11:11:30 -080075#include <media/audiohal/EffectsFactoryHalInterface.h>
Kevin Rocard069c2712018-03-29 19:09:14 -070076#include <media/audiohal/StreamHalInterface.h>
Kevin Rocard7588ff42018-01-08 11:11:30 -080077
Eric Laurent81784c32012-11-19 14:55:58 -080078#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080079#include "FastMixer.h"
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070080#include "FastCapture.h"
Andy Hungab7ef302018-05-15 19:35:29 -070081#include <mediautils/SchedulingPolicyService.h>
82#include <mediautils/ServiceUtilities.h>
Eric Laurent81784c32012-11-19 14:55:58 -080083
Eric Laurent81784c32012-11-19 14:55:58 -080084#ifdef ADD_BATTERY_DATA
85#include <media/IMediaPlayerService.h>
86#include <media/IMediaDeathNotifier.h>
87#endif
88
Eric Laurent81784c32012-11-19 14:55:58 -080089#ifdef DEBUG_CPU_USAGE
Eric Tan5b13ff82018-07-27 11:20:17 -070090#include <audio_utils/Statistics.h>
Eric Laurent81784c32012-11-19 14:55:58 -080091#include <cpustats/ThreadCpuUsage.h>
92#endif
93
Glenn Kastenc05b8d72016-03-24 09:48:17 -070094#include "AutoPark.h"
95
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080096#include <pthread.h>
97#include "TypedLogger.h"
98
Eric Laurent81784c32012-11-19 14:55:58 -080099// ----------------------------------------------------------------------------
100
101// Note: the following macro is used for extremely verbose logging message. In
102// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
103// 0; but one side effect of this is to turn all LOGV's as well. Some messages
104// are so verbose that we want to suppress them even when we have ALOG_ASSERT
105// turned on. Do not uncomment the #def below unless you really know what you
106// are doing and want to see all of the extremely verbose messages.
107//#define VERY_VERY_VERBOSE_LOGGING
108#ifdef VERY_VERY_VERBOSE_LOGGING
109#define ALOGVV ALOGV
110#else
111#define ALOGVV(a...) do { } while(0)
112#endif
113
Andy Hung6770c6f2015-04-07 13:43:36 -0700114// TODO: Move these macro/inlines to a header file.
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700115#define max(a, b) ((a) > (b) ? (a) : (b))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700116
Andy Hung6770c6f2015-04-07 13:43:36 -0700117template <typename T>
118static inline T min(const T& a, const T& b)
119{
120 return a < b ? a : b;
121}
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700122
Eric Laurent81784c32012-11-19 14:55:58 -0800123namespace android {
124
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700125using media::IEffectClient;
Svet Ganov33761132021-05-13 22:51:08 +0000126using content::AttributionSourceState;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700127
Eric Laurent81784c32012-11-19 14:55:58 -0800128// retry counts for buffer fill timeout
129// 50 * ~20msecs = 1 second
130static const int8_t kMaxTrackRetries = 50;
131static const int8_t kMaxTrackStartupRetries = 50;
Andy Hung455982f2021-04-27 17:46:12 -0700132
Eric Laurent81784c32012-11-19 14:55:58 -0800133// allow less retry attempts on direct output thread.
134// direct outputs can be a scarce resource in audio hardware and should
135// be released as quickly as possible.
Andy Hung455982f2021-04-27 17:46:12 -0700136// Notes:
137// 1) The retry duration kMaxTrackRetriesDirectMs may be increased
138// in case the data write is bursty for the AudioTrack. The application
139// should endeavor to write at least once every kMaxTrackRetriesDirectMs
140// to prevent an underrun situation. If the data is bursty, then
141// the application can also throttle the data sent to be even.
142// 2) For compressed audio data, any data present in the AudioTrack buffer
143// will be sent and reset the retry count. This delivers data as
144// it arrives, with approximately kDirectMinSleepTimeUs = 10ms checking interval.
145// 3) For linear PCM or proportional PCM, we wait one period for a period's worth
146// of data to be available, then any remaining data is delivered.
147// This is required to ensure the last bit of data is delivered before underrun.
148//
149// Sleep time per cycle is kDirectMinSleepTimeUs for compressed tracks
150// or the size of the HAL period for proportional / linear PCM tracks.
151static const int32_t kMaxTrackRetriesDirectMs = 200;
Eric Laurent81784c32012-11-19 14:55:58 -0800152
153// don't warn about blocked writes or record buffer overflows more often than this
154static const nsecs_t kWarningThrottleNs = seconds(5);
155
156// RecordThread loop sleep time upon application overrun or audio HAL read error
157static const int kRecordThreadSleepUs = 5000;
158
Eric Laurent10351942014-05-08 18:49:52 -0700159// maximum time to wait in sendConfigEvent_l() for a status to be received
160static const nsecs_t kConfigEventTimeoutNs = seconds(2);
Eric Laurent81784c32012-11-19 14:55:58 -0800161
162// minimum sleep time for the mixer thread loop when tracks are active but in underrun
163static const uint32_t kMinThreadSleepTimeUs = 5000;
164// maximum divider applied to the active sleep time in the mixer thread loop
165static const uint32_t kMaxThreadSleepTimeShift = 2;
166
Andy Hung09a50072014-02-27 14:30:47 -0800167// minimum normal sink buffer size, expressed in milliseconds rather than frames
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700168// FIXME This should be based on experimentally observed scheduling jitter
Andy Hung09a50072014-02-27 14:30:47 -0800169static const uint32_t kMinNormalSinkBufferSizeMs = 20;
170// maximum normal sink buffer size
171static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
Eric Laurent81784c32012-11-19 14:55:58 -0800172
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700173// minimum capture buffer size in milliseconds to _not_ need a fast capture thread
174// FIXME This should be based on experimentally observed scheduling jitter
175static const uint32_t kMinNormalCaptureBufferSizeMs = 12;
176
Eric Laurent972a1732013-09-04 09:42:59 -0700177// Offloaded output thread standby delay: allows track transition without going to standby
178static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
179
Eric Laurent51716182016-02-29 18:00:56 -0800180// Direct output thread minimum sleep time in idle or active(underrun) state
181static const nsecs_t kDirectMinSleepTimeUs = 10000;
182
Brian Lindahl65e90012022-07-27 18:01:07 +0200183// Minimum amount of time between checking to see if the timestamp is advancing
184// for underrun detection. If we check too frequently, we may not detect a
185// timestamp update and will falsely detect underrun.
186static const nsecs_t kMinimumTimeBetweenTimestampChecksNs = 150 /* ms */ * 1000;
187
Glenn Kasten1b291842016-07-18 14:55:21 -0700188// The universal constant for ubiquitous 20ms value. The value of 20ms seems to provide a good
189// balance between power consumption and latency, and allows threads to be scheduled reliably
190// by the CFS scheduler.
191// FIXME Express other hardcoded references to 20ms with references to this constant and move
192// it appropriately.
193#define FMS_20 20
Eric Laurent51716182016-02-29 18:00:56 -0800194
Eric Laurent81784c32012-11-19 14:55:58 -0800195// Whether to use fast mixer
196static const enum {
197 FastMixer_Never, // never initialize or use: for debugging only
198 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
199 // normal mixer multiplier is 1
200 FastMixer_Static, // initialize if needed, then use all the time if initialized,
201 // multiplier is calculated based on min & max normal mixer buffer size
202 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
203 // multiplier is calculated based on min & max normal mixer buffer size
204 // FIXME for FastMixer_Dynamic:
205 // Supporting this option will require fixing HALs that can't handle large writes.
206 // For example, one HAL implementation returns an error from a large write,
207 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
208 // We could either fix the HAL implementations, or provide a wrapper that breaks
209 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
210} kUseFastMixer = FastMixer_Static;
211
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700212// Whether to use fast capture
213static const enum {
214 FastCapture_Never, // never initialize or use: for debugging only
215 FastCapture_Always, // always initialize and use, even if not needed: for debugging only
216 FastCapture_Static, // initialize if needed, then use all the time if initialized
217} kUseFastCapture = FastCapture_Static;
218
Eric Laurent81784c32012-11-19 14:55:58 -0800219// Priorities for requestPriority
220static const int kPriorityAudioApp = 2;
221static const int kPriorityFastMixer = 3;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700222static const int kPriorityFastCapture = 3;
Eric Laurent81784c32012-11-19 14:55:58 -0800223
Glenn Kastenea38ee72016-04-18 11:08:01 -0700224// IAudioFlinger::createTrack() has an in/out parameter 'pFrameCount' for the total size of the
225// track buffer in shared memory. Zero on input means to use a default value. For fast tracks,
226// AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
Glenn Kasten03490092014-05-27 12:30:54 -0700227
228// This is the default value, if not specified by property.
Glenn Kastenb5fed682013-12-03 09:06:43 -0800229static const int kFastTrackMultiplier = 2;
Eric Laurent81784c32012-11-19 14:55:58 -0800230
Glenn Kasten03490092014-05-27 12:30:54 -0700231// The minimum and maximum allowed values
232static const int kFastTrackMultiplierMin = 1;
233static const int kFastTrackMultiplierMax = 2;
234
235// The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
236static int sFastTrackMultiplier = kFastTrackMultiplier;
237
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700238// See Thread::readOnlyHeap().
239// Initially this heap is used to allocate client buffers for "fast" AudioRecord.
240// Eventually it will be the single buffer that FastCapture writes into via HAL read(),
241// and that all "fast" AudioRecord clients read from. In either case, the size can be small.
Mikhail Naganov79a77822018-05-10 15:57:25 -0700242static const size_t kRecordThreadReadOnlyHeapSize = 0xD000;
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700243
Eric Laurent81784c32012-11-19 14:55:58 -0800244// ----------------------------------------------------------------------------
245
Andy Hungb68f5eb2019-12-03 16:49:17 -0800246// TODO: move all toString helpers to audio.h
247// under #ifdef __cplusplus #endif
248static std::string patchSinksToString(const struct audio_patch *patch)
249{
250 std::stringstream ss;
251 for (size_t i = 0; i < patch->num_sinks; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700252 if (i > 0) {
253 ss << "|";
254 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800255 ss << "(" << toString(patch->sinks[i].ext.device.type)
256 << ", " << patch->sinks[i].ext.device.address << ")";
257 }
258 return ss.str();
259}
260
261static std::string patchSourcesToString(const struct audio_patch *patch)
262{
263 std::stringstream ss;
264 for (size_t i = 0; i < patch->num_sources; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700265 if (i > 0) {
266 ss << "|";
267 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800268 ss << "(" << toString(patch->sources[i].ext.device.type)
269 << ", " << patch->sources[i].ext.device.address << ")";
270 }
271 return ss.str();
272}
273
Andy Hung4bd53e72022-11-17 17:21:45 -0800274static std::string toString(audio_latency_mode_t mode) {
275 // We convert to the AIDL type to print (eventually the legacy type will be removed).
Mikhail Naganovf53e1822022-12-18 02:48:14 +0000276 const auto result = legacy2aidl_audio_latency_mode_t_AudioLatencyMode(mode);
277 return result.has_value() ? media::audio::common::toString(*result) : "UNKNOWN";
Andy Hung4bd53e72022-11-17 17:21:45 -0800278}
279
280// Could be made a template, but other toString overloads for std::vector are confused.
281static std::string toString(const std::vector<audio_latency_mode_t>& elements) {
282 std::string s("{ ");
283 for (const auto& e : elements) {
284 s.append(toString(e));
285 s.append(" ");
286 }
287 s.append("}");
288 return s;
289}
290
Glenn Kasten03490092014-05-27 12:30:54 -0700291static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
292
293static void sFastTrackMultiplierInit()
294{
295 char value[PROPERTY_VALUE_MAX];
296 if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
297 char *endptr;
298 unsigned long ul = strtoul(value, &endptr, 0);
299 if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
300 sFastTrackMultiplier = (int) ul;
301 }
302 }
303}
304
305// ----------------------------------------------------------------------------
306
Eric Laurent81784c32012-11-19 14:55:58 -0800307#ifdef ADD_BATTERY_DATA
308// To collect the amplifier usage
309static void addBatteryData(uint32_t params) {
310 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
311 if (service == NULL) {
312 // it already logged
313 return;
314 }
315
316 service->addBatteryData(params);
317}
318#endif
319
Andy Hung3f0c9022016-01-15 17:49:46 -0800320// Track the CLOCK_BOOTTIME versus CLOCK_MONOTONIC timebase offset
321struct {
322 // call when you acquire a partial wakelock
323 void acquire(const sp<IBinder> &wakeLockToken) {
324 pthread_mutex_lock(&mLock);
325 if (wakeLockToken.get() == nullptr) {
326 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
327 } else {
328 if (mCount == 0) {
329 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
330 }
331 ++mCount;
332 }
333 pthread_mutex_unlock(&mLock);
334 }
335
336 // call when you release a partial wakelock.
337 void release(const sp<IBinder> &wakeLockToken) {
338 if (wakeLockToken.get() == nullptr) {
339 return;
340 }
341 pthread_mutex_lock(&mLock);
342 if (--mCount < 0) {
343 ALOGE("negative wakelock count");
344 mCount = 0;
345 }
346 pthread_mutex_unlock(&mLock);
347 }
348
349 // retrieves the boottime timebase offset from monotonic.
350 int64_t getBoottimeOffset() {
351 pthread_mutex_lock(&mLock);
352 int64_t boottimeOffset = mBoottimeOffset;
353 pthread_mutex_unlock(&mLock);
354 return boottimeOffset;
355 }
356
357 // Adjusts the timebase offset between TIMEBASE_MONOTONIC
358 // and the selected timebase.
359 // Currently only TIMEBASE_BOOTTIME is allowed.
360 //
361 // This only needs to be called upon acquiring the first partial wakelock
362 // after all other partial wakelocks are released.
363 //
364 // We do an empirical measurement of the offset rather than parsing
365 // /proc/timer_list since the latter is not a formal kernel ABI.
366 static void adjustTimebaseOffset(int64_t *offset, ExtendedTimestamp::Timebase timebase) {
367 int clockbase;
368 switch (timebase) {
369 case ExtendedTimestamp::TIMEBASE_BOOTTIME:
370 clockbase = SYSTEM_TIME_BOOTTIME;
371 break;
372 default:
373 LOG_ALWAYS_FATAL("invalid timebase %d", timebase);
374 break;
375 }
376 // try three times to get the clock offset, choose the one
377 // with the minimum gap in measurements.
378 const int tries = 3;
Andy Hung920f6572022-10-06 12:09:49 -0700379 nsecs_t bestGap = 0, measured = 0; // not required, initialized for clang-tidy
Andy Hung3f0c9022016-01-15 17:49:46 -0800380 for (int i = 0; i < tries; ++i) {
381 const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
382 const nsecs_t tbase = systemTime(clockbase);
383 const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
384 const nsecs_t gap = tmono2 - tmono;
385 if (i == 0 || gap < bestGap) {
386 bestGap = gap;
387 measured = tbase - ((tmono + tmono2) >> 1);
388 }
389 }
390
391 // to avoid micro-adjusting, we don't change the timebase
392 // unless it is significantly different.
393 //
394 // Assumption: It probably takes more than toleranceNs to
395 // suspend and resume the device.
396 static int64_t toleranceNs = 10000; // 10 us
397 if (llabs(*offset - measured) > toleranceNs) {
398 ALOGV("Adjusting timebase offset old: %lld new: %lld",
399 (long long)*offset, (long long)measured);
400 *offset = measured;
401 }
402 }
403
404 pthread_mutex_t mLock;
405 int32_t mCount;
406 int64_t mBoottimeOffset;
407} gBoottime = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; // static, so use POD initialization
Eric Laurent81784c32012-11-19 14:55:58 -0800408
409// ----------------------------------------------------------------------------
410// CPU Stats
411// ----------------------------------------------------------------------------
412
413class CpuStats {
414public:
415 CpuStats();
416 void sample(const String8 &title);
417#ifdef DEBUG_CPU_USAGE
418private:
419 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
Andy Hung16698b82018-08-01 10:48:38 -0700420 audio_utils::Statistics<double> mWcStats; // statistics on thread CPU usage in wall clock ns
Eric Laurent81784c32012-11-19 14:55:58 -0800421
Andy Hung16698b82018-08-01 10:48:38 -0700422 audio_utils::Statistics<double> mHzStats; // statistics on thread CPU usage in cycles
Eric Laurent81784c32012-11-19 14:55:58 -0800423
424 int mCpuNum; // thread's current CPU number
425 int mCpukHz; // frequency of thread's current CPU in kHz
426#endif
427};
428
429CpuStats::CpuStats()
430#ifdef DEBUG_CPU_USAGE
431 : mCpuNum(-1), mCpukHz(-1)
432#endif
433{
434}
435
Glenn Kasten0f11b512014-01-31 16:18:54 -0800436void CpuStats::sample(const String8 &title
437#ifndef DEBUG_CPU_USAGE
438 __unused
439#endif
440 ) {
Eric Laurent81784c32012-11-19 14:55:58 -0800441#ifdef DEBUG_CPU_USAGE
442 // get current thread's delta CPU time in wall clock ns
443 double wcNs;
444 bool valid = mCpuUsage.sampleAndEnable(wcNs);
445
446 // record sample for wall clock statistics
447 if (valid) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700448 mWcStats.add(wcNs);
Eric Laurent81784c32012-11-19 14:55:58 -0800449 }
450
451 // get the current CPU number
452 int cpuNum = sched_getcpu();
453
454 // get the current CPU frequency in kHz
455 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
456
457 // check if either CPU number or frequency changed
458 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
459 mCpuNum = cpuNum;
460 mCpukHz = cpukHz;
461 // ignore sample for purposes of cycles
462 valid = false;
463 }
464
465 // if no change in CPU number or frequency, then record sample for cycle statistics
466 if (valid && mCpukHz > 0) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700467 const double cycles = wcNs * cpukHz * 0.000001;
468 mHzStats.add(cycles);
Eric Laurent81784c32012-11-19 14:55:58 -0800469 }
470
Eric Tan5b13ff82018-07-27 11:20:17 -0700471 const unsigned n = mWcStats.getN();
Eric Laurent81784c32012-11-19 14:55:58 -0800472 // mCpuUsage.elapsed() is expensive, so don't call it every loop
473 if ((n & 127) == 1) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700474 const long long elapsed = mCpuUsage.elapsed();
Eric Laurent81784c32012-11-19 14:55:58 -0800475 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700476 const double perLoop = elapsed / (double) n;
477 const double perLoop100 = perLoop * 0.01;
478 const double perLoop1k = perLoop * 0.001;
479 const double mean = mWcStats.getMean();
480 const double stddev = mWcStats.getStdDev();
481 const double minimum = mWcStats.getMin();
482 const double maximum = mWcStats.getMax();
483 const double meanCycles = mHzStats.getMean();
484 const double stddevCycles = mHzStats.getStdDev();
485 const double minCycles = mHzStats.getMin();
486 const double maxCycles = mHzStats.getMax();
Eric Laurent81784c32012-11-19 14:55:58 -0800487 mCpuUsage.resetElapsed();
488 mWcStats.reset();
489 mHzStats.reset();
490 ALOGD("CPU usage for %s over past %.1f secs\n"
491 " (%u mixer loops at %.1f mean ms per loop):\n"
492 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
493 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
494 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
495 title.string(),
496 elapsed * .000000001, n, perLoop * .000001,
497 mean * .001,
498 stddev * .001,
499 minimum * .001,
500 maximum * .001,
501 mean / perLoop100,
502 stddev / perLoop100,
503 minimum / perLoop100,
504 maximum / perLoop100,
505 meanCycles / perLoop1k,
506 stddevCycles / perLoop1k,
507 minCycles / perLoop1k,
508 maxCycles / perLoop1k);
509
510 }
511 }
512#endif
513};
514
515// ----------------------------------------------------------------------------
516// ThreadBase
517// ----------------------------------------------------------------------------
518
Glenn Kasten97b7b752014-09-28 13:04:24 -0700519// static
520const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
521{
522 switch (type) {
523 case MIXER:
524 return "MIXER";
525 case DIRECT:
526 return "DIRECT";
527 case DUPLICATING:
528 return "DUPLICATING";
529 case RECORD:
530 return "RECORD";
531 case OFFLOAD:
532 return "OFFLOAD";
Andy Hungea840382020-05-05 21:50:17 -0700533 case MMAP_PLAYBACK:
534 return "MMAP_PLAYBACK";
535 case MMAP_CAPTURE:
536 return "MMAP_CAPTURE";
Eric Laurent1c5e2e32021-08-18 18:50:28 +0200537 case SPATIALIZER:
538 return "SPATIALIZER";
jiabinc658e452022-10-21 20:52:21 +0000539 case BIT_PERFECT:
540 return "BIT_PERFECT";
Glenn Kasten97b7b752014-09-28 13:04:24 -0700541 default:
542 return "unknown";
543 }
544}
545
Eric Laurent81784c32012-11-19 14:55:58 -0800546AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -0700547 type_t type, bool systemReady, bool isOut)
Eric Laurent81784c32012-11-19 14:55:58 -0800548 : Thread(false /*canCallJava*/),
549 mType(type),
Glenn Kasten9b58f632013-07-16 11:37:48 -0700550 mAudioFlinger(audioFlinger),
Andy Hungcf10d742020-04-28 15:38:24 -0700551 mThreadMetrics(std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_THREAD) + std::to_string(id),
552 isOut),
553 mIsOut(isOut),
Glenn Kasten70949c42013-08-06 07:40:12 -0700554 // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800555 // are set by PlaybackThread::readOutputParameters_l() or
556 // RecordThread::readInputParameters_l()
Eric Laurentfd477972013-10-25 18:10:40 -0700557 //FIXME: mStandby should be true here. Is this some kind of hack?
jiabinc52b1ff2019-10-31 17:20:42 -0700558 mStandby(false),
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700559 mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
Eric Laurent81784c32012-11-19 14:55:58 -0800560 // mName will be set by concrete (non-virtual) subclass
Eric Laurent72e3f392015-05-20 14:43:50 -0700561 mDeathRecipient(new PMDeathRecipient(this)),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800562 mSystemReady(systemReady),
563 mSignalPending(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800564{
Andy Hungcf10d742020-04-28 15:38:24 -0700565 mThreadMetrics.logConstructor(getpid(), threadTypeToString(type), id);
Eric Laurent296fb132015-05-01 11:38:42 -0700566 memset(&mPatch, 0, sizeof(struct audio_patch));
Eric Laurent81784c32012-11-19 14:55:58 -0800567}
568
569AudioFlinger::ThreadBase::~ThreadBase()
570{
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700571 // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700572 mConfigEvents.clear();
573
Eric Laurent81784c32012-11-19 14:55:58 -0800574 // do not lock the mutex in destructor
575 releaseWakeLock_l();
576 if (mPowerManager != 0) {
Marco Nelissen06b46062014-11-14 07:58:25 -0800577 sp<IBinder> binder = IInterface::asBinder(mPowerManager);
Eric Laurent81784c32012-11-19 14:55:58 -0800578 binder->unlinkToDeath(mDeathRecipient);
579 }
Andy Hungd0979812019-02-21 15:51:44 -0800580
581 sendStatistics(true /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -0800582}
583
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700584status_t AudioFlinger::ThreadBase::readyToRun()
585{
586 status_t status = initCheck();
587 if (status == NO_ERROR) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800588 ALOGI("AudioFlinger's thread %p tid=%d ready to run", this, getTid());
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700589 } else {
590 ALOGE("No working audio driver found.");
591 }
592 return status;
593}
594
Eric Laurent81784c32012-11-19 14:55:58 -0800595void AudioFlinger::ThreadBase::exit()
596{
597 ALOGV("ThreadBase::exit");
598 // do any cleanup required for exit to succeed
599 preExit();
600 {
601 // This lock prevents the following race in thread (uniprocessor for illustration):
602 // if (!exitPending()) {
603 // // context switch from here to exit()
604 // // exit() calls requestExit(), what exitPending() observes
605 // // exit() calls signal(), which is dropped since no waiters
606 // // context switch back from exit() to here
607 // mWaitWorkCV.wait(...);
608 // // now thread is hung
609 // }
610 AutoMutex lock(mLock);
611 requestExit();
612 mWaitWorkCV.broadcast();
613 }
614 // When Thread::requestExitAndWait is made virtual and this method is renamed to
615 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
616 requestExitAndWait();
617}
618
619status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
620{
Eric Laurent81784c32012-11-19 14:55:58 -0800621 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
622 Mutex::Autolock _l(mLock);
623
Eric Laurent10351942014-05-08 18:49:52 -0700624 return sendSetParameterConfigEvent_l(keyValuePairs);
625}
626
627// sendConfigEvent_l() must be called with ThreadBase::mLock held
628// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
629status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
Andy Hung920f6572022-10-06 12:09:49 -0700630NO_THREAD_SAFETY_ANALYSIS // condition variable
Eric Laurent10351942014-05-08 18:49:52 -0700631{
632 status_t status = NO_ERROR;
633
Eric Laurent72e3f392015-05-20 14:43:50 -0700634 if (event->mRequiresSystemReady && !mSystemReady) {
635 event->mWaitStatus = false;
636 mPendingConfigEvents.add(event);
637 return status;
638 }
Eric Laurent10351942014-05-08 18:49:52 -0700639 mConfigEvents.add(event);
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700640 ALOGV("sendConfigEvent_l() num events %zu event %d", mConfigEvents.size(), event->mType);
Eric Laurent81784c32012-11-19 14:55:58 -0800641 mWaitWorkCV.signal();
Eric Laurent10351942014-05-08 18:49:52 -0700642 mLock.unlock();
643 {
644 Mutex::Autolock _l(event->mLock);
645 while (event->mWaitStatus) {
646 if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
647 event->mStatus = TIMED_OUT;
648 event->mWaitStatus = false;
649 }
650 }
651 status = event->mStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800652 }
Eric Laurent10351942014-05-08 18:49:52 -0700653 mLock.lock();
Eric Laurent81784c32012-11-19 14:55:58 -0800654 return status;
655}
656
Mikhail Naganov88536df2021-07-26 17:30:29 -0700657void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700658 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800659{
660 Mutex::Autolock _l(mLock);
Eric Laurent09f1ed22019-04-24 17:45:17 -0700661 sendIoConfigEvent_l(event, pid, portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800662}
663
664// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
Mikhail Naganov88536df2021-07-26 17:30:29 -0700665void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700666 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800667{
Andy Hungd0979812019-02-21 15:51:44 -0800668 // The audio statistics history is exponentially weighted to forget events
669 // about five or more seconds in the past. In order to have
670 // crisper statistics for mediametrics, we reset the statistics on
671 // an IoConfigEvent, to reflect different properties for a new device.
672 mIoJitterMs.reset();
673 mLatencyMs.reset();
674 mProcessTimeMs.reset();
Robert Wu06db0a32021-08-10 19:05:34 +0000675 mMonopipePipeDepthStats.reset();
Dean Wheatley12473e92021-03-18 23:00:55 +1100676 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS);
Andy Hungd0979812019-02-21 15:51:44 -0800677
Eric Laurent09f1ed22019-04-24 17:45:17 -0700678 sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700679 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800680}
681
Mikhail Naganov83f04272017-02-07 10:45:09 -0800682void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent72e3f392015-05-20 14:43:50 -0700683{
684 Mutex::Autolock _l(mLock);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800685 sendPrioConfigEvent_l(pid, tid, prio, forApp);
Eric Laurent72e3f392015-05-20 14:43:50 -0700686}
687
Eric Laurent81784c32012-11-19 14:55:58 -0800688// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
Mikhail Naganov83f04272017-02-07 10:45:09 -0800689void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(
690 pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent81784c32012-11-19 14:55:58 -0800691{
Mikhail Naganov83f04272017-02-07 10:45:09 -0800692 sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700693 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800694}
695
Eric Laurent10351942014-05-08 18:49:52 -0700696// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
697status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
Eric Laurent81784c32012-11-19 14:55:58 -0800698{
Andy Hung2ddee192015-12-18 17:34:44 -0800699 sp<ConfigEvent> configEvent;
700 AudioParameter param(keyValuePair);
701 int value;
Mikhail Naganov00260b52016-10-13 12:54:24 -0700702 if (param.getInt(String8(AudioParameter::keyMonoOutput), value) == NO_ERROR) {
Andy Hung2ddee192015-12-18 17:34:44 -0800703 setMasterMono_l(value != 0);
704 if (param.size() == 1) {
705 return NO_ERROR; // should be a solo parameter - we don't pass down
706 }
Mikhail Naganov00260b52016-10-13 12:54:24 -0700707 param.remove(String8(AudioParameter::keyMonoOutput));
Andy Hung2ddee192015-12-18 17:34:44 -0800708 configEvent = new SetParameterConfigEvent(param.toString());
709 } else {
710 configEvent = new SetParameterConfigEvent(keyValuePair);
711 }
Eric Laurent10351942014-05-08 18:49:52 -0700712 return sendConfigEvent_l(configEvent);
Glenn Kastenf7773312013-08-13 16:00:42 -0700713}
714
Eric Laurent1c333e22014-05-20 10:48:17 -0700715status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
716 const struct audio_patch *patch,
717 audio_patch_handle_t *handle)
718{
719 Mutex::Autolock _l(mLock);
720 sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
721 status_t status = sendConfigEvent_l(configEvent);
722 if (status == NO_ERROR) {
723 CreateAudioPatchConfigEventData *data =
724 (CreateAudioPatchConfigEventData *)configEvent->mData.get();
725 *handle = data->mHandle;
726 }
727 return status;
728}
729
730status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
731 const audio_patch_handle_t handle)
732{
733 Mutex::Autolock _l(mLock);
734 sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
735 return sendConfigEvent_l(configEvent);
736}
737
jiabinc52b1ff2019-10-31 17:20:42 -0700738status_t AudioFlinger::ThreadBase::sendUpdateOutDeviceConfigEvent(
739 const DeviceDescriptorBaseVector& outDevices)
740{
741 if (type() != RECORD) {
742 // The update out device operation is only for record thread.
743 return INVALID_OPERATION;
744 }
745 Mutex::Autolock _l(mLock);
746 sp<ConfigEvent> configEvent = (ConfigEvent *)new UpdateOutDevicesConfigEvent(outDevices);
747 return sendConfigEvent_l(configEvent);
748}
749
Eric Laurentec376dc2021-04-08 20:41:22 +0200750void AudioFlinger::ThreadBase::sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs)
751{
752 ALOG_ASSERT(type() == RECORD, "sendResizeBufferConfigEvent_l() called on non record thread");
753 sp<ConfigEvent> configEvent =
754 (ConfigEvent *)new ResizeBufferConfigEvent(maxSharedAudioHistoryMs);
755 sendConfigEvent_l(configEvent);
756}
Eric Laurent1c333e22014-05-20 10:48:17 -0700757
Eric Laurentb3f315a2021-07-13 15:09:05 +0200758void AudioFlinger::ThreadBase::sendCheckOutputStageEffectsEvent()
759{
760 Mutex::Autolock _l(mLock);
761 sendCheckOutputStageEffectsEvent_l();
762}
763
764void AudioFlinger::ThreadBase::sendCheckOutputStageEffectsEvent_l()
765{
766 sp<ConfigEvent> configEvent =
767 (ConfigEvent *)new CheckOutputStageEffectsEvent();
768 sendConfigEvent_l(configEvent);
769}
770
Eric Laurent68a40a82022-05-03 18:15:04 +0200771void AudioFlinger::ThreadBase::sendHalLatencyModesChangedEvent_l()
772{
773 sp<ConfigEvent> configEvent = sp<HalLatencyModesChangedEvent>::make();
774 sendConfigEvent_l(configEvent);
775}
776
Glenn Kasten2cfbf882013-08-14 13:12:11 -0700777// post condition: mConfigEvents.isEmpty()
Eric Laurent021cf962014-05-13 10:18:14 -0700778void AudioFlinger::ThreadBase::processConfigEvents_l()
Glenn Kastenf7773312013-08-13 16:00:42 -0700779{
Eric Laurent10351942014-05-08 18:49:52 -0700780 bool configChanged = false;
781
Eric Laurent81784c32012-11-19 14:55:58 -0800782 while (!mConfigEvents.isEmpty()) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700783 ALOGV("processConfigEvents_l() remaining events %zu", mConfigEvents.size());
Eric Laurent10351942014-05-08 18:49:52 -0700784 sp<ConfigEvent> event = mConfigEvents[0];
Eric Laurent81784c32012-11-19 14:55:58 -0800785 mConfigEvents.removeAt(0);
Eric Laurent10351942014-05-08 18:49:52 -0700786 switch (event->mType) {
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700787 case CFG_EVENT_PRIO: {
Eric Laurent10351942014-05-08 18:49:52 -0700788 PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
789 // FIXME Need to understand why this has to be done asynchronously
Mikhail Naganov83f04272017-02-07 10:45:09 -0800790 int err = requestPriority(data->mPid, data->mTid, data->mPrio, data->mForApp,
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700791 true /*asynchronous*/);
792 if (err != 0) {
793 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
Eric Laurent10351942014-05-08 18:49:52 -0700794 data->mPrio, data->mPid, data->mTid, err);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700795 }
796 } break;
797 case CFG_EVENT_IO: {
Eric Laurent10351942014-05-08 18:49:52 -0700798 IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
Eric Laurent09f1ed22019-04-24 17:45:17 -0700799 ioConfigChanged(data->mEvent, data->mPid, data->mPortId);
Eric Laurent10351942014-05-08 18:49:52 -0700800 } break;
801 case CFG_EVENT_SET_PARAMETER: {
802 SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
803 if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
804 configChanged = true;
Andy Hung293558a2017-03-21 12:19:20 -0700805 mLocalLog.log("CFG_EVENT_SET_PARAMETER: (%s) configuration changed",
806 data->mKeyValuePairs.string());
Glenn Kastend5418eb2013-08-14 13:11:06 -0700807 }
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700808 } break;
Eric Laurent1c333e22014-05-20 10:48:17 -0700809 case CFG_EVENT_CREATE_AUDIO_PATCH: {
jiabinc52b1ff2019-10-31 17:20:42 -0700810 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700811 CreateAudioPatchConfigEventData *data =
812 (CreateAudioPatchConfigEventData *)event->mData.get();
813 event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
jiabinc52b1ff2019-10-31 17:20:42 -0700814 const DeviceTypeSet newDevices = getDeviceTypes();
Eric Laurent52568142022-10-28 11:23:28 +0200815 configChanged = oldDevices != newDevices;
jiabinc52b1ff2019-10-31 17:20:42 -0700816 mLocalLog.log("CFG_EVENT_CREATE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
817 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
818 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -0700819 } break;
820 case CFG_EVENT_RELEASE_AUDIO_PATCH: {
jiabinc52b1ff2019-10-31 17:20:42 -0700821 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700822 ReleaseAudioPatchConfigEventData *data =
823 (ReleaseAudioPatchConfigEventData *)event->mData.get();
824 event->mStatus = releaseAudioPatch_l(data->mHandle);
jiabinc52b1ff2019-10-31 17:20:42 -0700825 const DeviceTypeSet newDevices = getDeviceTypes();
Eric Laurent52568142022-10-28 11:23:28 +0200826 configChanged = oldDevices != newDevices;
jiabinc52b1ff2019-10-31 17:20:42 -0700827 mLocalLog.log("CFG_EVENT_RELEASE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
828 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
829 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
830 } break;
831 case CFG_EVENT_UPDATE_OUT_DEVICE: {
832 UpdateOutDevicesConfigEventData *data =
833 (UpdateOutDevicesConfigEventData *)event->mData.get();
834 updateOutDevices(data->mOutDevices);
Eric Laurent1c333e22014-05-20 10:48:17 -0700835 } break;
Eric Laurentec376dc2021-04-08 20:41:22 +0200836 case CFG_EVENT_RESIZE_BUFFER: {
837 ResizeBufferConfigEventData *data =
838 (ResizeBufferConfigEventData *)event->mData.get();
839 resizeInputBuffer_l(data->mMaxSharedAudioHistoryMs);
840 } break;
Eric Laurentb3f315a2021-07-13 15:09:05 +0200841
842 case CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS: {
843 setCheckOutputStageEffects();
844 } break;
845
Eric Laurent68a40a82022-05-03 18:15:04 +0200846 case CFG_EVENT_HAL_LATENCY_MODES_CHANGED: {
847 onHalLatencyModesChanged_l();
848 } break;
849
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700850 default:
Eric Laurent10351942014-05-08 18:49:52 -0700851 ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700852 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800853 }
Eric Laurent10351942014-05-08 18:49:52 -0700854 {
855 Mutex::Autolock _l(event->mLock);
856 if (event->mWaitStatus) {
857 event->mWaitStatus = false;
858 event->mCond.signal();
859 }
860 }
861 ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
862 }
863
864 if (configChanged) {
865 cacheParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800866 }
Eric Laurent81784c32012-11-19 14:55:58 -0800867}
868
Marco Nelissenb2208842014-02-07 14:00:50 -0800869String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
870 String8 s;
Glenn Kastene1635ec2015-06-08 15:46:49 -0700871 const audio_channel_representation_t representation =
872 audio_channel_mask_get_representation(mask);
Andy Hungf98ec8d2015-05-19 12:53:24 -0700873
874 switch (representation) {
jiabin245cdd92018-12-07 17:55:15 -0800875 // Travel all single bit channel mask to convert channel mask to string.
Andy Hungf98ec8d2015-05-19 12:53:24 -0700876 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
877 if (output) {
878 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
879 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
880 if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
Andy Hungfba71252021-05-07 11:58:32 -0700881 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low-frequency, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700882 if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
883 if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
884 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
885 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
886 if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
887 if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
888 if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
889 if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
890 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
891 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
892 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
893 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700894 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, ");
895 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, ");
896 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT) s.append("top-side-left, ");
897 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT) s.append("top-side-right, ");
898 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_LEFT) s.append("bottom-front-left, ");
899 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_CENTER) s.append("bottom-front-center, ");
900 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_RIGHT) s.append("bottom-front-right, ");
Andy Hungfba71252021-05-07 11:58:32 -0700901 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY_2) s.append("low-frequency-2, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700902 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_B) s.append("haptic-B, ");
903 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_A) s.append("haptic-A, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700904 if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown, ");
905 } else {
906 if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
907 if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
908 if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
909 if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
910 if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
911 if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
912 if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
913 if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
914 if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
915 if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
916 if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
917 if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
Mikhail Naganovc9948492018-05-10 17:25:28 -0700918 if (mask & AUDIO_CHANNEL_IN_BACK_LEFT) s.append("back-left, ");
919 if (mask & AUDIO_CHANNEL_IN_BACK_RIGHT) s.append("back-right, ");
920 if (mask & AUDIO_CHANNEL_IN_CENTER) s.append("center, ");
Andy Hungfba71252021-05-07 11:58:32 -0700921 if (mask & AUDIO_CHANNEL_IN_LOW_FREQUENCY) s.append("low-frequency, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700922 if (mask & AUDIO_CHANNEL_IN_TOP_LEFT) s.append("top-left, ");
923 if (mask & AUDIO_CHANNEL_IN_TOP_RIGHT) s.append("top-right, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700924 if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
925 if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
926 if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown, ");
927 }
928 const int len = s.length();
929 if (len > 2) {
Glenn Kasten57c4e6f2016-03-18 14:54:07 -0700930 (void) s.lockBuffer(len); // needed?
Andy Hungf98ec8d2015-05-19 12:53:24 -0700931 s.unlockBuffer(len - 2); // remove trailing ", "
932 }
933 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800934 }
Andy Hungf98ec8d2015-05-19 12:53:24 -0700935 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
936 s.appendFormat("index mask, bits:%#x", audio_channel_mask_get_bits(mask));
937 return s;
938 default:
939 s.appendFormat("unknown mask, representation:%d bits:%#x",
940 representation, audio_channel_mask_get_bits(mask));
941 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800942 }
Marco Nelissenb2208842014-02-07 14:00:50 -0800943}
944
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700945void AudioFlinger::ThreadBase::dump(int fd, const Vector<String16>& args)
Andy Hung920f6572022-10-06 12:09:49 -0700946NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Eric Laurent81784c32012-11-19 14:55:58 -0800947{
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800948 dprintf(fd, "\n%s thread %p, name %s, tid %d, type %d (%s):\n", isOutput() ? "Output" : "Input",
949 this, mThreadName, getTid(), type(), threadTypeToString(type()));
950
Eric Laurent81784c32012-11-19 14:55:58 -0800951 bool locked = AudioFlinger::dumpTryLock(mLock);
952 if (!locked) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800953 dprintf(fd, " Thread may be deadlocked\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800954 }
955
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700956 dumpBase_l(fd, args);
957 dumpInternals_l(fd, args);
958 dumpTracks_l(fd, args);
959 dumpEffectChains_l(fd, args);
960
961 if (locked) {
962 mLock.unlock();
963 }
964
965 dprintf(fd, " Local log:\n");
966 mLocalLog.dump(fd, " " /* prefix */, 40 /* lines */);
Andy Hungafc51db2022-04-08 17:33:40 -0700967
968 // --all does the statistics
969 bool dumpAll = false;
970 for (const auto &arg : args) {
971 if (arg == String16("--all")) {
972 dumpAll = true;
973 }
974 }
975 if (dumpAll || type() == SPATIALIZER) {
Andy Hung44d648b2022-04-08 17:33:40 -0700976 const std::string sched = mThreadSnapshot.toString();
Andy Hungafc51db2022-04-08 17:33:40 -0700977 if (!sched.empty()) {
978 (void)write(fd, sched.c_str(), sched.size());
979 }
980 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700981}
982
983void AudioFlinger::ThreadBase::dumpBase_l(int fd, const Vector<String16>& args __unused)
984{
Elliott Hughes87cebad2014-05-22 10:14:43 -0700985 dprintf(fd, " I/O handle: %d\n", mId);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700986 dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
Glenn Kasten97b7b752014-09-28 13:04:24 -0700987 dprintf(fd, " Sample rate: %u Hz\n", mSampleRate);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700988 dprintf(fd, " HAL frame count: %zu\n", mFrameCount);
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700989 dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat).c_str());
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700990 dprintf(fd, " HAL buffer size: %zu bytes\n", mBufferSize);
Glenn Kasten97b7b752014-09-28 13:04:24 -0700991 dprintf(fd, " Channel count: %u\n", mChannelCount);
992 dprintf(fd, " Channel mask: 0x%08x (%s)\n", mChannelMask,
Marco Nelissenb2208842014-02-07 14:00:50 -0800993 channelMaskToString(mChannelMask, mType != RECORD).string());
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700994 dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat).c_str());
Glenn Kastenf87c2f52015-08-21 08:03:57 -0700995 dprintf(fd, " Processing frame size: %zu bytes\n", mFrameSize);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700996 dprintf(fd, " Pending config events:");
Marco Nelissenb2208842014-02-07 14:00:50 -0800997 size_t numConfig = mConfigEvents.size();
998 if (numConfig) {
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700999 const size_t SIZE = 256;
1000 char buffer[SIZE];
Marco Nelissenb2208842014-02-07 14:00:50 -08001001 for (size_t i = 0; i < numConfig; i++) {
1002 mConfigEvents[i]->dump(buffer, SIZE);
Elliott Hughes87cebad2014-05-22 10:14:43 -07001003 dprintf(fd, "\n %s", buffer);
Marco Nelissenb2208842014-02-07 14:00:50 -08001004 }
Elliott Hughes87cebad2014-05-22 10:14:43 -07001005 dprintf(fd, "\n");
Marco Nelissenb2208842014-02-07 14:00:50 -08001006 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -07001007 dprintf(fd, " none\n");
Eric Laurent81784c32012-11-19 14:55:58 -08001008 }
Andy Hung293558a2017-03-21 12:19:20 -07001009 // Note: output device may be used by capture threads for effects such as AEC.
jiabinc52b1ff2019-10-31 17:20:42 -07001010 dprintf(fd, " Output devices: %s (%s)\n",
1011 dumpDeviceTypes(outDeviceTypes()).c_str(), toString(outDeviceTypes()).c_str());
1012 dprintf(fd, " Input device: %#x (%s)\n",
1013 inDeviceType(), toString(inDeviceType()).c_str());
Andy Hung9b181952019-02-25 14:53:36 -08001014 dprintf(fd, " Audio source: %d (%s)\n", mAudioSource, toString(mAudioSource).c_str());
Eric Laurent81784c32012-11-19 14:55:58 -08001015
Andy Hung2e2c0bb2018-06-11 19:13:11 -07001016 // Dump timestamp statistics for the Thread types that support it.
1017 if (mType == RECORD
1018 || mType == MIXER
1019 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -07001020 || mType == DIRECT
Andy Hung4b7f54f2022-04-28 17:45:28 -07001021 || mType == OFFLOAD
1022 || mType == SPATIALIZER) {
Andy Hung2e2c0bb2018-06-11 19:13:11 -07001023 dprintf(fd, " Timestamp stats: %s\n", mTimestampVerifier.toString().c_str());
Andy Hungc8fddf32018-08-08 18:32:37 -07001024 dprintf(fd, " Timestamp corrected: %s\n", isTimestampCorrectionEnabled() ? "yes" : "no");
Andy Hung2e2c0bb2018-06-11 19:13:11 -07001025 }
1026
Andy Hung446f4df2019-02-21 12:26:41 -08001027 if (mLastIoBeginNs > 0) { // MMAP may not set this
1028 dprintf(fd, " Last %s occurred (msecs): %lld\n",
1029 isOutput() ? "write" : "read",
1030 (long long) (systemTime() - mLastIoBeginNs) / NANOS_PER_MILLISECOND);
1031 }
1032
1033 if (mProcessTimeMs.getN() > 0) {
1034 dprintf(fd, " Process time ms stats: %s\n", mProcessTimeMs.toString().c_str());
1035 }
1036
1037 if (mIoJitterMs.getN() > 0) {
1038 dprintf(fd, " Hal %s jitter ms stats: %s\n",
1039 isOutput() ? "write" : "read",
1040 mIoJitterMs.toString().c_str());
1041 }
1042
Andy Hunge6c37112019-02-26 17:38:10 -08001043 if (mLatencyMs.getN() > 0) {
1044 dprintf(fd, " Threadloop %s latency stats: %s\n",
1045 isOutput() ? "write" : "read",
1046 mLatencyMs.toString().c_str());
1047 }
Robert Wu06db0a32021-08-10 19:05:34 +00001048
1049 if (mMonopipePipeDepthStats.getN() > 0) {
1050 dprintf(fd, " Monopipe %s pipe depth stats: %s\n",
1051 isOutput() ? "write" : "read",
1052 mMonopipePipeDepthStats.toString().c_str());
1053 }
Eric Laurent81784c32012-11-19 14:55:58 -08001054}
1055
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001056void AudioFlinger::ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08001057{
1058 const size_t SIZE = 256;
1059 char buffer[SIZE];
Eric Laurent81784c32012-11-19 14:55:58 -08001060
Marco Nelissenb2208842014-02-07 14:00:50 -08001061 size_t numEffectChains = mEffectChains.size();
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +00001062 snprintf(buffer, SIZE, " %zu Effect Chains\n", numEffectChains);
Eric Laurent81784c32012-11-19 14:55:58 -08001063 write(fd, buffer, strlen(buffer));
1064
Marco Nelissenb2208842014-02-07 14:00:50 -08001065 for (size_t i = 0; i < numEffectChains; ++i) {
Eric Laurent81784c32012-11-19 14:55:58 -08001066 sp<EffectChain> chain = mEffectChains[i];
1067 if (chain != 0) {
1068 chain->dump(fd, args);
1069 }
1070 }
1071}
1072
Andy Hungdae27702016-10-31 14:01:16 -07001073void AudioFlinger::ThreadBase::acquireWakeLock()
Eric Laurent81784c32012-11-19 14:55:58 -08001074{
1075 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -07001076 acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001077}
1078
Narayan Kamath014e7fa2013-10-14 15:03:38 +01001079String16 AudioFlinger::ThreadBase::getWakeLockTag()
1080{
1081 switch (mType) {
Glenn Kastenbcb14862015-03-05 17:11:21 -08001082 case MIXER:
1083 return String16("AudioMix");
1084 case DIRECT:
1085 return String16("AudioDirectOut");
1086 case DUPLICATING:
1087 return String16("AudioDup");
1088 case RECORD:
1089 return String16("AudioIn");
1090 case OFFLOAD:
1091 return String16("AudioOffload");
Andy Hungea840382020-05-05 21:50:17 -07001092 case MMAP_PLAYBACK:
1093 return String16("MmapPlayback");
1094 case MMAP_CAPTURE:
1095 return String16("MmapCapture");
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001096 case SPATIALIZER:
1097 return String16("AudioSpatial");
Glenn Kastenbcb14862015-03-05 17:11:21 -08001098 default:
1099 ALOG_ASSERT(false);
1100 return String16("AudioUnknown");
Narayan Kamath014e7fa2013-10-14 15:03:38 +01001101 }
1102}
1103
Andy Hungdae27702016-10-31 14:01:16 -07001104void AudioFlinger::ThreadBase::acquireWakeLock_l()
Eric Laurent81784c32012-11-19 14:55:58 -08001105{
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001106 getPowerManager_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001107 if (mPowerManager != 0) {
1108 sp<IBinder> binder = new BBinder();
Andy Hungdae27702016-10-31 14:01:16 -07001109 // Uses AID_AUDIOSERVER for wakelock. updateWakeLockUids_l() updates with client uids.
Chris Ye6597d732020-02-28 22:38:25 -08001110 binder::Status status = mPowerManager->acquireWakeLockAsync(binder,
1111 POWERMANAGER_PARTIAL_WAKE_LOCK,
Narayan Kamath014e7fa2013-10-14 15:03:38 +01001112 getWakeLockTag(),
Marco Nelissendcb346b2015-09-09 10:47:29 -07001113 String16("audioserver"),
Chris Ye6597d732020-02-28 22:38:25 -08001114 {} /* workSource */,
1115 {} /* historyTag */);
1116 if (status.isOk()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001117 mWakeLockToken = binder;
1118 }
Chris Ye6597d732020-02-28 22:38:25 -08001119 ALOGV("acquireWakeLock_l() %s status %d", mThreadName, status.exceptionCode());
Eric Laurent81784c32012-11-19 14:55:58 -08001120 }
Wei Jia3f273d12015-11-24 09:06:49 -08001121
Andy Hung3f0c9022016-01-15 17:49:46 -08001122 gBoottime.acquire(mWakeLockToken);
Andy Hung818e7a32016-02-16 18:08:07 -08001123 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
1124 gBoottime.getBoottimeOffset();
Eric Laurent81784c32012-11-19 14:55:58 -08001125}
1126
1127void AudioFlinger::ThreadBase::releaseWakeLock()
1128{
1129 Mutex::Autolock _l(mLock);
1130 releaseWakeLock_l();
1131}
1132
1133void AudioFlinger::ThreadBase::releaseWakeLock_l()
1134{
Andy Hung3f0c9022016-01-15 17:49:46 -08001135 gBoottime.release(mWakeLockToken);
Eric Laurent81784c32012-11-19 14:55:58 -08001136 if (mWakeLockToken != 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001137 ALOGV("releaseWakeLock_l() %s", mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001138 if (mPowerManager != 0) {
Chris Ye6597d732020-02-28 22:38:25 -08001139 mPowerManager->releaseWakeLockAsync(mWakeLockToken, 0);
Eric Laurent81784c32012-11-19 14:55:58 -08001140 }
1141 mWakeLockToken.clear();
1142 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001143}
1144
1145void AudioFlinger::ThreadBase::getPowerManager_l() {
Eric Laurent72e3f392015-05-20 14:43:50 -07001146 if (mSystemReady && mPowerManager == 0) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001147 // use checkService() to avoid blocking if power service is not up yet
1148 sp<IBinder> binder =
1149 defaultServiceManager()->checkService(String16("power"));
1150 if (binder == 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001151 ALOGW("Thread %s cannot connect to the power manager service", mThreadName);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001152 } else {
Chris Ye6597d732020-02-28 22:38:25 -08001153 mPowerManager = interface_cast<os::IPowerManager>(binder);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001154 binder->linkToDeath(mDeathRecipient);
1155 }
1156 }
1157}
1158
Andy Hungd01b0f12016-11-07 16:10:30 -08001159void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t> &uids) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001160 getPowerManager_l();
Andy Hungdae27702016-10-31 14:01:16 -07001161
1162#if !LOG_NDEBUG
1163 std::stringstream s;
Andy Hungd01b0f12016-11-07 16:10:30 -08001164 for (uid_t uid : uids) {
Andy Hungdae27702016-10-31 14:01:16 -07001165 s << uid << " ";
1166 }
1167 ALOGD("updateWakeLockUids_l %s uids:%s", mThreadName, s.str().c_str());
1168#endif
1169
Andy Hung438e7572015-12-14 15:51:17 -08001170 if (mWakeLockToken == NULL) { // token may be NULL if AudioFlinger::systemReady() not called.
1171 if (mSystemReady) {
1172 ALOGE("no wake lock to update, but system ready!");
1173 } else {
1174 ALOGW("no wake lock to update, system not ready yet");
1175 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001176 return;
1177 }
1178 if (mPowerManager != 0) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08001179 std::vector<int> uidsAsInt(uids.begin(), uids.end()); // powermanager expects uids as ints
Chris Ye6597d732020-02-28 22:38:25 -08001180 binder::Status status = mPowerManager->updateWakeLockUidsAsync(
1181 mWakeLockToken, uidsAsInt);
1182 ALOGV("updateWakeLockUids_l() %s status %d", mThreadName, status.exceptionCode());
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001183 }
1184}
1185
Eric Laurent81784c32012-11-19 14:55:58 -08001186void AudioFlinger::ThreadBase::clearPowerManager()
1187{
1188 Mutex::Autolock _l(mLock);
1189 releaseWakeLock_l();
1190 mPowerManager.clear();
1191}
1192
jiabinc52b1ff2019-10-31 17:20:42 -07001193void AudioFlinger::ThreadBase::updateOutDevices(
1194 const DeviceDescriptorBaseVector& outDevices __unused)
1195{
1196 ALOGE("%s should only be called in RecordThread", __func__);
1197}
1198
Eric Laurentec376dc2021-04-08 20:41:22 +02001199void AudioFlinger::ThreadBase::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs __unused)
1200{
1201 ALOGE("%s should only be called in RecordThread", __func__);
1202}
1203
Glenn Kasten0f11b512014-01-31 16:18:54 -08001204void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001205{
1206 sp<ThreadBase> thread = mThread.promote();
1207 if (thread != 0) {
1208 thread->clearPowerManager();
1209 }
1210 ALOGW("power manager service died !!!");
1211}
1212
Eric Laurent81784c32012-11-19 14:55:58 -08001213void AudioFlinger::ThreadBase::setEffectSuspended_l(
Glenn Kastend848eb42016-03-08 13:42:11 -08001214 const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001215{
1216 sp<EffectChain> chain = getEffectChain_l(sessionId);
1217 if (chain != 0) {
1218 if (type != NULL) {
1219 chain->setEffectSuspended_l(type, suspend);
1220 } else {
1221 chain->setEffectSuspendedAll_l(suspend);
1222 }
1223 }
1224
1225 updateSuspendedSessions_l(type, suspend, sessionId);
1226}
1227
1228void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1229{
1230 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
1231 if (index < 0) {
1232 return;
1233 }
1234
1235 const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
1236 mSuspendedSessions.valueAt(index);
1237
1238 for (size_t i = 0; i < sessionEffects.size(); i++) {
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001239 const sp<SuspendedSessionDesc>& desc = sessionEffects.valueAt(i);
Eric Laurent81784c32012-11-19 14:55:58 -08001240 for (int j = 0; j < desc->mRefCount; j++) {
1241 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1242 chain->setEffectSuspendedAll_l(true);
1243 } else {
1244 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1245 desc->mType.timeLow);
1246 chain->setEffectSuspended_l(&desc->mType, true);
1247 }
1248 }
1249 }
1250}
1251
1252void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1253 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -08001254 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001255{
1256 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
1257
1258 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1259
1260 if (suspend) {
1261 if (index >= 0) {
1262 sessionEffects = mSuspendedSessions.valueAt(index);
1263 } else {
1264 mSuspendedSessions.add(sessionId, sessionEffects);
1265 }
1266 } else {
1267 if (index < 0) {
1268 return;
1269 }
1270 sessionEffects = mSuspendedSessions.valueAt(index);
1271 }
1272
1273
1274 int key = EffectChain::kKeyForSuspendAll;
1275 if (type != NULL) {
1276 key = type->timeLow;
1277 }
1278 index = sessionEffects.indexOfKey(key);
1279
1280 sp<SuspendedSessionDesc> desc;
1281 if (suspend) {
1282 if (index >= 0) {
1283 desc = sessionEffects.valueAt(index);
1284 } else {
1285 desc = new SuspendedSessionDesc();
1286 if (type != NULL) {
1287 desc->mType = *type;
1288 }
1289 sessionEffects.add(key, desc);
1290 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1291 }
1292 desc->mRefCount++;
1293 } else {
1294 if (index < 0) {
1295 return;
1296 }
1297 desc = sessionEffects.valueAt(index);
1298 if (--desc->mRefCount == 0) {
1299 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1300 sessionEffects.removeItemsAt(index);
1301 if (sessionEffects.isEmpty()) {
1302 ALOGV("updateSuspendedSessions_l() restore removing session %d",
1303 sessionId);
1304 mSuspendedSessions.removeItem(sessionId);
1305 }
1306 }
1307 }
1308 if (!sessionEffects.isEmpty()) {
1309 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1310 }
1311}
1312
Eric Laurent6b446ce2019-12-13 10:56:31 -08001313void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
1314 audio_session_t sessionId,
Andy Hung920f6572022-10-06 12:09:49 -07001315 bool threadLocked)
1316NO_THREAD_SAFETY_ANALYSIS // manual locking
1317{
Eric Laurent6b446ce2019-12-13 10:56:31 -08001318 if (!threadLocked) {
1319 mLock.lock();
1320 }
Eric Laurent81784c32012-11-19 14:55:58 -08001321
Eric Laurent81784c32012-11-19 14:55:58 -08001322 if (mType != RECORD) {
1323 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1324 // another session. This gives the priority to well behaved effect control panels
1325 // and applications not using global effects.
1326 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1327 // global effects
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001328 if (!audio_is_global_session(sessionId)) {
Eric Laurent81784c32012-11-19 14:55:58 -08001329 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1330 }
1331 }
1332
Eric Laurent6b446ce2019-12-13 10:56:31 -08001333 if (!threadLocked) {
1334 mLock.unlock();
Eric Laurent81784c32012-11-19 14:55:58 -08001335 }
1336}
1337
Eric Laurent4c415062016-06-17 16:14:16 -07001338// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1339status_t AudioFlinger::RecordThread::checkEffectCompatibility_l(
1340 const effect_descriptor_t *desc, audio_session_t sessionId)
1341{
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001342 // No global output effect sessions on record threads
1343 if (sessionId == AUDIO_SESSION_OUTPUT_MIX
1344 || sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Eric Laurent4c415062016-06-17 16:14:16 -07001345 ALOGW("checkEffectCompatibility_l(): global effect %s on record thread %s",
1346 desc->name, mThreadName);
1347 return BAD_VALUE;
1348 }
1349 // only pre processing effects on record thread
1350 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) {
1351 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on record thread %s",
1352 desc->name, mThreadName);
1353 return BAD_VALUE;
1354 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001355
1356 // always allow effects without processing load or latency
1357 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1358 return NO_ERROR;
1359 }
1360
Eric Laurent4c415062016-06-17 16:14:16 -07001361 audio_input_flags_t flags = mInput->flags;
1362 if (hasFastCapture() || (flags & AUDIO_INPUT_FLAG_FAST)) {
1363 if (flags & AUDIO_INPUT_FLAG_RAW) {
1364 ALOGW("checkEffectCompatibility_l(): effect %s on record thread %s in raw mode",
1365 desc->name, mThreadName);
1366 return BAD_VALUE;
1367 }
1368 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1369 ALOGW("checkEffectCompatibility_l(): non HW effect %s on record thread %s in fast mode",
1370 desc->name, mThreadName);
1371 return BAD_VALUE;
1372 }
1373 }
jiabineb3bda02020-06-30 14:07:03 -07001374
1375 if (EffectModule::isHapticGenerator(&desc->type)) {
1376 ALOGE("%s(): HapticGenerator is not supported in RecordThread", __func__);
1377 return BAD_VALUE;
1378 }
Eric Laurent4c415062016-06-17 16:14:16 -07001379 return NO_ERROR;
1380}
1381
1382// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1383status_t AudioFlinger::PlaybackThread::checkEffectCompatibility_l(
1384 const effect_descriptor_t *desc, audio_session_t sessionId)
1385{
1386 // no preprocessing on playback threads
1387 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001388 ALOGW("%s: pre processing effect %s created on playback"
1389 " thread %s", __func__, desc->name, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001390 return BAD_VALUE;
1391 }
1392
Eric Laurent3e4de772017-07-16 16:55:08 -07001393 // always allow effects without processing load or latency
1394 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1395 return NO_ERROR;
1396 }
1397
jiabineb3bda02020-06-30 14:07:03 -07001398 if (EffectModule::isHapticGenerator(&desc->type) && mHapticChannelCount == 0) {
1399 ALOGW("%s: thread doesn't support haptic playback while the effect is HapticGenerator",
1400 __func__);
1401 return BAD_VALUE;
1402 }
1403
Eric Laurentf690c462021-09-17 14:47:03 +02001404 if (memcmp(&desc->type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0
1405 && mType != SPATIALIZER) {
1406 ALOGW("%s: attempt to create a spatializer effect on a thread of type %d",
1407 __func__, mType);
1408 return BAD_VALUE;
1409 }
1410
Eric Laurent4c415062016-06-17 16:14:16 -07001411 switch (mType) {
1412 case MIXER: {
Andy Hung9aad48c2017-11-29 10:29:19 -08001413#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001414 // Reject any effect on mixer multichannel sinks.
1415 // TODO: fix both format and multichannel issues with effects.
1416 if (mChannelCount != FCC_2) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001417 ALOGW("%s: effect %s for multichannel(%d) on MIXER thread %s",
1418 __func__, desc->name, mChannelCount, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001419 return BAD_VALUE;
1420 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001421#endif
Eric Laurent4c415062016-06-17 16:14:16 -07001422 audio_output_flags_t flags = mOutput->flags;
1423 if (hasFastMixer() || (flags & AUDIO_OUTPUT_FLAG_FAST)) {
1424 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1425 // global effects are applied only to non fast tracks if they are SW
1426 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1427 break;
1428 }
1429 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1430 // only post processing on output stage session
1431 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001432 ALOGW("%s: non post processing effect %s not allowed on output stage session",
1433 __func__, desc->name);
Eric Laurent4c415062016-06-17 16:14:16 -07001434 return BAD_VALUE;
1435 }
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001436 } else if (sessionId == AUDIO_SESSION_DEVICE) {
1437 // only post processing on output stage session
1438 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001439 ALOGW("%s: non post processing effect %s not allowed on device session",
1440 __func__, desc->name);
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001441 return BAD_VALUE;
1442 }
Eric Laurent4c415062016-06-17 16:14:16 -07001443 } else {
1444 // no restriction on effects applied on non fast tracks
1445 if ((hasAudioSession_l(sessionId) & ThreadBase::FAST_SESSION) == 0) {
1446 break;
1447 }
1448 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001449
Eric Laurent4c415062016-06-17 16:14:16 -07001450 if (flags & AUDIO_OUTPUT_FLAG_RAW) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001451 ALOGW("%s: effect %s on playback thread in raw mode", __func__, desc->name);
Eric Laurent4c415062016-06-17 16:14:16 -07001452 return BAD_VALUE;
1453 }
1454 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001455 ALOGW("%s: non HW effect %s on playback thread in fast mode",
1456 __func__, desc->name);
Eric Laurent4c415062016-06-17 16:14:16 -07001457 return BAD_VALUE;
1458 }
1459 }
1460 } break;
1461 case OFFLOAD:
Jean-Michel Trivi773ee952016-07-11 16:53:18 -07001462 // nothing actionable on offload threads, if the effect:
1463 // - is offloadable: the effect can be created
1464 // - is NOT offloadable: the effect should still be created, but EffectHandle::enable()
1465 // will take care of invalidating the tracks of the thread
Eric Laurent4c415062016-06-17 16:14:16 -07001466 break;
1467 case DIRECT:
1468 // Reject any effect on Direct output threads for now, since the format of
1469 // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
Eric Laurentb62d0362021-10-26 17:40:18 +02001470 ALOGW("%s: effect %s on DIRECT output thread %s",
1471 __func__, desc->name, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001472 return BAD_VALUE;
1473 case DUPLICATING:
Andy Hung9aad48c2017-11-29 10:29:19 -08001474#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001475 // Reject any effect on mixer multichannel sinks.
1476 // TODO: fix both format and multichannel issues with effects.
1477 if (mChannelCount != FCC_2) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001478 ALOGW("%s: effect %s for multichannel(%d) on DUPLICATING thread %s",
1479 __func__, desc->name, mChannelCount, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001480 return BAD_VALUE;
1481 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001482#endif
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001483 if (audio_is_global_session(sessionId)) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001484 ALOGW("%s: global effect %s on DUPLICATING thread %s",
1485 __func__, desc->name, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001486 return BAD_VALUE;
1487 }
1488 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001489 ALOGW("%s: post processing effect %s on DUPLICATING thread %s",
1490 __func__, desc->name, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001491 return BAD_VALUE;
1492 }
1493 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) != 0) {
Eric Laurentb62d0362021-10-26 17:40:18 +02001494 ALOGW("%s: HW tunneled effect %s on DUPLICATING thread %s",
1495 __func__, desc->name, mThreadName);
Eric Laurent4c415062016-06-17 16:14:16 -07001496 return BAD_VALUE;
1497 }
1498 break;
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001499 case SPATIALIZER:
Eric Laurentb62d0362021-10-26 17:40:18 +02001500 // Global effects (AUDIO_SESSION_OUTPUT_MIX) are not supported on spatializer mixer
1501 // as there is no common accumulation buffer for sptialized and non sptialized tracks.
1502 // Post processing effects (AUDIO_SESSION_OUTPUT_STAGE or AUDIO_SESSION_DEVICE)
1503 // are supported and added after the spatializer.
1504 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1505 ALOGW("%s: global effect %s not supported on spatializer thread %s",
1506 __func__, desc->name, mThreadName);
Eric Laurentb3f315a2021-07-13 15:09:05 +02001507 return BAD_VALUE;
Eric Laurentb62d0362021-10-26 17:40:18 +02001508 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1509 // only post processing , downmixer or spatializer effects on output stage session
1510 if (memcmp(&desc->type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0
1511 || memcmp(&desc->type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0) {
1512 break;
1513 }
1514 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1515 ALOGW("%s: non post processing effect %s not allowed on output stage session",
1516 __func__, desc->name);
1517 return BAD_VALUE;
1518 }
1519 } else if (sessionId == AUDIO_SESSION_DEVICE) {
1520 // only post processing on output stage session
1521 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1522 ALOGW("%s: non post processing effect %s not allowed on device session",
1523 __func__, desc->name);
1524 return BAD_VALUE;
1525 }
Eric Laurentb3f315a2021-07-13 15:09:05 +02001526 }
1527 break;
jiabinc658e452022-10-21 20:52:21 +00001528 case BIT_PERFECT:
1529 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) != 0) {
1530 // Allow HW accelerated effects of tunnel type
1531 break;
1532 }
1533 // As bit-perfect tracks will not be allowed to apply audio effect that will touch the audio
1534 // data, effects will not be allowed on 1) global effects (AUDIO_SESSION_OUTPUT_MIX),
1535 // 2) post-processing effects (AUDIO_SESSION_OUTPUT_STAGE or AUDIO_SESSION_DEVICE) and
1536 // 3) there is any bit-perfect track with the given session id.
1537 if (sessionId == AUDIO_SESSION_OUTPUT_MIX || sessionId == AUDIO_SESSION_OUTPUT_STAGE ||
1538 sessionId == AUDIO_SESSION_DEVICE) {
1539 ALOGW("%s: effect %s not supported on bit-perfect thread %s",
1540 __func__, desc->name, mThreadName);
1541 return BAD_VALUE;
1542 } else if ((hasAudioSession_l(sessionId) & ThreadBase::BIT_PERFECT_SESSION) != 0) {
1543 ALOGW("%s: effect %s not supported as there is a bit-perfect track with session as %d",
1544 __func__, desc->name, sessionId);
1545 return BAD_VALUE;
1546 }
1547 break;
Eric Laurent4c415062016-06-17 16:14:16 -07001548 default:
1549 LOG_ALWAYS_FATAL("checkEffectCompatibility_l(): wrong thread type %d", mType);
1550 }
1551
1552 return NO_ERROR;
1553}
1554
Eric Laurent81784c32012-11-19 14:55:58 -08001555// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
1556sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
1557 const sp<AudioFlinger::Client>& client,
1558 const sp<IEffectClient>& effectClient,
1559 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -08001560 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -08001561 effect_descriptor_t *desc,
1562 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001563 status_t *status,
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001564 bool pinned,
Eric Laurentde8caf42021-08-11 17:19:25 +02001565 bool probe,
1566 bool notifyFramesProcessed)
Eric Laurent81784c32012-11-19 14:55:58 -08001567{
1568 sp<EffectModule> effect;
1569 sp<EffectHandle> handle;
1570 status_t lStatus;
1571 sp<EffectChain> chain;
1572 bool chainCreated = false;
1573 bool effectCreated = false;
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001574 audio_unique_id_t effectId = AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
Eric Laurent81784c32012-11-19 14:55:58 -08001575
1576 lStatus = initCheck();
1577 if (lStatus != NO_ERROR) {
1578 ALOGW("createEffect_l() Audio driver not initialized.");
1579 goto Exit;
1580 }
1581
Eric Laurent81784c32012-11-19 14:55:58 -08001582 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
1583
1584 { // scope for mLock
1585 Mutex::Autolock _l(mLock);
1586
Eric Laurent4c415062016-06-17 16:14:16 -07001587 lStatus = checkEffectCompatibility_l(desc, sessionId);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001588 if (probe || lStatus != NO_ERROR) {
Eric Laurent4c415062016-06-17 16:14:16 -07001589 goto Exit;
1590 }
1591
Eric Laurent81784c32012-11-19 14:55:58 -08001592 // check for existing effect chain with the requested audio session
1593 chain = getEffectChain_l(sessionId);
1594 if (chain == 0) {
1595 // create a new chain for this session
1596 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
1597 chain = new EffectChain(this, sessionId);
1598 addEffectChain_l(chain);
1599 chain->setStrategy(getStrategyForSession_l(sessionId));
1600 chainCreated = true;
1601 } else {
1602 effect = chain->getEffectFromDesc_l(desc);
1603 }
1604
1605 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
1606
1607 if (effect == 0) {
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001608 effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
Eric Laurent81784c32012-11-19 14:55:58 -08001609 // create a new effect module if none present in the chain
Eric Laurent6b446ce2019-12-13 10:56:31 -08001610 lStatus = chain->createEffect_l(effect, desc, effectId, sessionId, pinned);
Eric Laurent81784c32012-11-19 14:55:58 -08001611 if (lStatus != NO_ERROR) {
1612 goto Exit;
1613 }
1614 effectCreated = true;
1615
jiabinc52b1ff2019-10-31 17:20:42 -07001616 // FIXME: use vector of device and address when effect interface is ready.
jiabin8f278ee2019-11-11 12:16:27 -08001617 effect->setDevices(outDeviceTypeAddrs());
1618 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001619 effect->setMode(mAudioFlinger->getMode());
1620 effect->setAudioSource(mAudioSource);
1621 }
jiabin1319f5a2021-03-30 22:21:24 +00001622 if (effect->isHapticGenerator()) {
1623 // TODO(b/184194057): Use the vibrator information from the vibrator that will be used
1624 // for the HapticGenerator.
Lais Andradebc3f37a2021-07-02 00:13:19 +01001625 const std::optional<media::AudioVibratorInfo> defaultVibratorInfo =
1626 std::move(mAudioFlinger->getDefaultVibratorInfo_l());
1627 if (defaultVibratorInfo) {
jiabin1319f5a2021-03-30 22:21:24 +00001628 // Only set the vibrator info when it is a valid one.
Lais Andradebc3f37a2021-07-02 00:13:19 +01001629 effect->setVibratorInfo(*defaultVibratorInfo);
jiabin1319f5a2021-03-30 22:21:24 +00001630 }
1631 }
Eric Laurent81784c32012-11-19 14:55:58 -08001632 // create effect handle and connect it to effect module
Eric Laurentde8caf42021-08-11 17:19:25 +02001633 handle = new EffectHandle(effect, client, effectClient, priority, notifyFramesProcessed);
Glenn Kastene75da402013-11-20 13:54:52 -08001634 lStatus = handle->initCheck();
1635 if (lStatus == OK) {
1636 lStatus = effect->addHandle(handle.get());
Eric Laurentb3f315a2021-07-13 15:09:05 +02001637 sendCheckOutputStageEffectsEvent_l();
Glenn Kastene75da402013-11-20 13:54:52 -08001638 }
Eric Laurent81784c32012-11-19 14:55:58 -08001639 if (enabled != NULL) {
1640 *enabled = (int)effect->isEnabled();
1641 }
1642 }
1643
1644Exit:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001645 if (!probe && lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurent81784c32012-11-19 14:55:58 -08001646 Mutex::Autolock _l(mLock);
1647 if (effectCreated) {
1648 chain->removeEffect_l(effect);
1649 }
Eric Laurent81784c32012-11-19 14:55:58 -08001650 if (chainCreated) {
1651 removeEffectChain_l(chain);
1652 }
haobo101735295ff7b0d2017-03-17 17:44:03 +08001653 // handle must be cleared by caller to avoid deadlock.
Eric Laurent81784c32012-11-19 14:55:58 -08001654 }
1655
Glenn Kasten9156ef32013-08-06 15:39:08 -07001656 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08001657 return handle;
1658}
1659
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001660void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
1661 bool unpinIfLast)
1662{
1663 bool remove = false;
1664 sp<EffectModule> effect;
1665 {
1666 Mutex::Autolock _l(mLock);
Eric Laurent41709552019-12-16 19:34:05 -08001667 sp<EffectBase> effectBase = handle->effect().promote();
1668 if (effectBase == nullptr) {
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001669 return;
1670 }
Eric Laurentb82e6b72019-11-22 17:25:04 -08001671 effect = effectBase->asEffectModule();
1672 if (effect == nullptr) {
1673 return;
1674 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001675 // restore suspended effects if the disconnected handle was enabled and the last one.
1676 remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
1677 if (remove) {
1678 removeEffect_l(effect, true);
1679 }
Eric Laurentb3f315a2021-07-13 15:09:05 +02001680 sendCheckOutputStageEffectsEvent_l();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001681 }
1682 if (remove) {
1683 mAudioFlinger->updateOrphanEffectChains(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001684 if (handle->enabled()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001685 effect->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001686 }
1687 }
1688}
1689
Eric Laurent6b446ce2019-12-13 10:56:31 -08001690void AudioFlinger::ThreadBase::onEffectEnable(const sp<EffectModule>& effect) {
Andy Hungea840382020-05-05 21:50:17 -07001691 if (isOffloadOrMmap()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001692 Mutex::Autolock _l(mLock);
1693 broadcast_l();
1694 }
1695 if (!effect->isOffloadable()) {
1696 if (mType == ThreadBase::OFFLOAD) {
1697 PlaybackThread *t = (PlaybackThread *)this;
1698 t->invalidateTracks(AUDIO_STREAM_MUSIC);
1699 }
1700 if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
1701 mAudioFlinger->onNonOffloadableGlobalEffectEnable();
1702 }
1703 }
1704}
1705
1706void AudioFlinger::ThreadBase::onEffectDisable() {
Andy Hungea840382020-05-05 21:50:17 -07001707 if (isOffloadOrMmap()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001708 Mutex::Autolock _l(mLock);
1709 broadcast_l();
1710 }
1711}
1712
Glenn Kastend848eb42016-03-08 13:42:11 -08001713sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
1714 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001715{
1716 Mutex::Autolock _l(mLock);
1717 return getEffect_l(sessionId, effectId);
1718}
1719
Glenn Kastend848eb42016-03-08 13:42:11 -08001720sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
1721 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001722{
1723 sp<EffectChain> chain = getEffectChain_l(sessionId);
1724 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
1725}
1726
Eric Laurent6c796322019-04-09 14:13:17 -07001727std::vector<int> AudioFlinger::ThreadBase::getEffectIds_l(audio_session_t sessionId)
1728{
1729 sp<EffectChain> chain = getEffectChain_l(sessionId);
1730 return chain != nullptr ? chain->getEffectIds() : std::vector<int>{};
1731}
1732
Eric Laurent81784c32012-11-19 14:55:58 -08001733// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
1734// PlaybackThread::mLock held
1735status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
1736{
1737 // check for existing effect chain with the requested audio session
Glenn Kastend848eb42016-03-08 13:42:11 -08001738 audio_session_t sessionId = effect->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08001739 sp<EffectChain> chain = getEffectChain_l(sessionId);
1740 bool chainCreated = false;
1741
Eric Laurent5baf2af2013-09-12 17:37:00 -07001742 ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001743 "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %#x",
Eric Laurent5baf2af2013-09-12 17:37:00 -07001744 this, effect->desc().name, effect->desc().flags);
1745
Eric Laurent81784c32012-11-19 14:55:58 -08001746 if (chain == 0) {
1747 // create a new chain for this session
1748 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
1749 chain = new EffectChain(this, sessionId);
1750 addEffectChain_l(chain);
1751 chain->setStrategy(getStrategyForSession_l(sessionId));
1752 chainCreated = true;
1753 }
1754 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
1755
1756 if (chain->getEffectFromId_l(effect->id()) != 0) {
1757 ALOGW("addEffect_l() %p effect %s already present in chain %p",
1758 this, effect->desc().name, chain.get());
1759 return BAD_VALUE;
1760 }
1761
Eric Laurent5baf2af2013-09-12 17:37:00 -07001762 effect->setOffloaded(mType == OFFLOAD, mId);
1763
Eric Laurent81784c32012-11-19 14:55:58 -08001764 status_t status = chain->addEffect_l(effect);
1765 if (status != NO_ERROR) {
1766 if (chainCreated) {
1767 removeEffectChain_l(chain);
1768 }
1769 return status;
1770 }
1771
jiabin8f278ee2019-11-11 12:16:27 -08001772 effect->setDevices(outDeviceTypeAddrs());
1773 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001774 effect->setMode(mAudioFlinger->getMode());
1775 effect->setAudioSource(mAudioSource);
Eric Laurentd8365c52017-07-16 15:27:05 -07001776
Eric Laurent81784c32012-11-19 14:55:58 -08001777 return NO_ERROR;
1778}
1779
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001780void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect, bool release) {
Eric Laurent81784c32012-11-19 14:55:58 -08001781
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001782 ALOGV("%s %p effect %p", __FUNCTION__, this, effect.get());
Eric Laurent81784c32012-11-19 14:55:58 -08001783 effect_descriptor_t desc = effect->desc();
1784 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1785 detachAuxEffect_l(effect->id());
1786 }
1787
Andy Hungfda44002021-06-03 17:23:16 -07001788 sp<EffectChain> chain = effect->getCallback()->chain().promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001789 if (chain != 0) {
1790 // remove effect chain if removing last effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001791 if (chain->removeEffect_l(effect, release) == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001792 removeEffectChain_l(chain);
1793 }
1794 } else {
1795 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
1796 }
1797}
1798
1799void AudioFlinger::ThreadBase::lockEffectChains_l(
1800 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
Andy Hung920f6572022-10-06 12:09:49 -07001801NO_THREAD_SAFETY_ANALYSIS // calls EffectChain::lock()
Eric Laurent81784c32012-11-19 14:55:58 -08001802{
1803 effectChains = mEffectChains;
1804 for (size_t i = 0; i < mEffectChains.size(); i++) {
1805 mEffectChains[i]->lock();
1806 }
1807}
1808
1809void AudioFlinger::ThreadBase::unlockEffectChains(
1810 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
Andy Hung920f6572022-10-06 12:09:49 -07001811NO_THREAD_SAFETY_ANALYSIS // calls EffectChain::unlock()
Eric Laurent81784c32012-11-19 14:55:58 -08001812{
1813 for (size_t i = 0; i < effectChains.size(); i++) {
1814 effectChains[i]->unlock();
1815 }
1816}
1817
Glenn Kastend848eb42016-03-08 13:42:11 -08001818sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001819{
1820 Mutex::Autolock _l(mLock);
1821 return getEffectChain_l(sessionId);
1822}
1823
Glenn Kastend848eb42016-03-08 13:42:11 -08001824sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
1825 const
Eric Laurent81784c32012-11-19 14:55:58 -08001826{
1827 size_t size = mEffectChains.size();
1828 for (size_t i = 0; i < size; i++) {
1829 if (mEffectChains[i]->sessionId() == sessionId) {
1830 return mEffectChains[i];
1831 }
1832 }
1833 return 0;
1834}
1835
1836void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
1837{
1838 Mutex::Autolock _l(mLock);
1839 size_t size = mEffectChains.size();
1840 for (size_t i = 0; i < size; i++) {
1841 mEffectChains[i]->setMode_l(mode);
1842 }
1843}
1844
Mikhail Naganovdc769682018-05-04 15:34:08 -07001845void AudioFlinger::ThreadBase::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07001846{
1847 config->type = AUDIO_PORT_TYPE_MIX;
1848 config->ext.mix.handle = mId;
1849 config->sample_rate = mSampleRate;
1850 config->format = mFormat;
1851 config->channel_mask = mChannelMask;
1852 config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
1853 AUDIO_PORT_CONFIG_FORMAT;
1854}
1855
Eric Laurent72e3f392015-05-20 14:43:50 -07001856void AudioFlinger::ThreadBase::systemReady()
1857{
1858 Mutex::Autolock _l(mLock);
1859 if (mSystemReady) {
1860 return;
1861 }
1862 mSystemReady = true;
1863
1864 for (size_t i = 0; i < mPendingConfigEvents.size(); i++) {
1865 sendConfigEvent_l(mPendingConfigEvents.editItemAt(i));
1866 }
1867 mPendingConfigEvents.clear();
1868}
1869
Andy Hungdae27702016-10-31 14:01:16 -07001870template <typename T>
1871ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::add(const sp<T> &track) {
1872 ssize_t index = mActiveTracks.indexOf(track);
1873 if (index >= 0) {
1874 ALOGW("ActiveTracks<T>::add track %p already there", track.get());
1875 return index;
1876 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001877 logTrack("add", track);
Andy Hungdae27702016-10-31 14:01:16 -07001878 mActiveTracksGeneration++;
1879 mLatestActiveTrack = track;
1880 ++mBatteryCounter[track->uid()].second;
Kevin Rocard069c2712018-03-29 19:09:14 -07001881 mHasChanged = true;
Andy Hungdae27702016-10-31 14:01:16 -07001882 return mActiveTracks.add(track);
1883}
1884
1885template <typename T>
1886ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::remove(const sp<T> &track) {
1887 ssize_t index = mActiveTracks.remove(track);
1888 if (index < 0) {
1889 ALOGW("ActiveTracks<T>::remove nonexistent track %p", track.get());
1890 return index;
1891 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001892 logTrack("remove", track);
Andy Hungdae27702016-10-31 14:01:16 -07001893 mActiveTracksGeneration++;
1894 --mBatteryCounter[track->uid()].second;
1895 // mLatestActiveTrack is not cleared even if is the same as track.
Kevin Rocard069c2712018-03-29 19:09:14 -07001896 mHasChanged = true;
Andy Hung8946a282018-04-19 20:04:56 -07001897#ifdef TEE_SINK
1898 track->dumpTee(-1 /* fd */, "_REMOVE");
1899#endif
Andy Hungc2b11cb2020-04-22 09:04:01 -07001900 track->logEndInterval(); // log to MediaMetrics
Andy Hungdae27702016-10-31 14:01:16 -07001901 return index;
1902}
1903
1904template <typename T>
1905void AudioFlinger::ThreadBase::ActiveTracks<T>::clear() {
1906 for (const sp<T> &track : mActiveTracks) {
1907 BatteryNotifier::getInstance().noteStopAudio(track->uid());
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001908 logTrack("clear", track);
Andy Hungdae27702016-10-31 14:01:16 -07001909 }
1910 mLastActiveTracksGeneration = mActiveTracksGeneration;
Kevin Rocard069c2712018-03-29 19:09:14 -07001911 if (!mActiveTracks.empty()) { mHasChanged = true; }
Andy Hungdae27702016-10-31 14:01:16 -07001912 mActiveTracks.clear();
1913 mLatestActiveTrack.clear();
1914 mBatteryCounter.clear();
1915}
1916
1917template <typename T>
1918void AudioFlinger::ThreadBase::ActiveTracks<T>::updatePowerState(
Andy Hung920f6572022-10-06 12:09:49 -07001919 const sp<ThreadBase>& thread, bool force) {
Andy Hungdae27702016-10-31 14:01:16 -07001920 // Updates ActiveTracks client uids to the thread wakelock.
1921 if (mActiveTracksGeneration != mLastActiveTracksGeneration || force) {
1922 thread->updateWakeLockUids_l(getWakeLockUids());
1923 mLastActiveTracksGeneration = mActiveTracksGeneration;
1924 }
1925
1926 // Updates BatteryNotifier uids
1927 for (auto it = mBatteryCounter.begin(); it != mBatteryCounter.end();) {
1928 const uid_t uid = it->first;
1929 ssize_t &previous = it->second.first;
1930 ssize_t &current = it->second.second;
1931 if (current > 0) {
1932 if (previous == 0) {
1933 BatteryNotifier::getInstance().noteStartAudio(uid);
1934 }
1935 previous = current;
1936 ++it;
1937 } else if (current == 0) {
1938 if (previous > 0) {
1939 BatteryNotifier::getInstance().noteStopAudio(uid);
1940 }
1941 it = mBatteryCounter.erase(it); // std::map<> is stable on iterator erase.
1942 } else /* (current < 0) */ {
1943 LOG_ALWAYS_FATAL("negative battery count %zd", current);
1944 }
1945 }
1946}
Eric Laurent83b88082014-06-20 18:31:16 -07001947
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001948template <typename T>
Kevin Rocard069c2712018-03-29 19:09:14 -07001949bool AudioFlinger::ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001950 bool hasChanged = mHasChanged;
Kevin Rocard069c2712018-03-29 19:09:14 -07001951 mHasChanged = false;
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001952
1953 for (const sp<T> &track : mActiveTracks) {
1954 // Do not short-circuit as all hasChanged states must be reset
1955 // as all the metadata are going to be sent
1956 hasChanged |= track->readAndClearHasChanged();
1957 }
Kevin Rocard069c2712018-03-29 19:09:14 -07001958 return hasChanged;
1959}
1960
1961template <typename T>
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001962void AudioFlinger::ThreadBase::ActiveTracks<T>::logTrack(
1963 const char *funcName, const sp<T> &track) const {
1964 if (mLocalLog != nullptr) {
1965 String8 result;
1966 track->appendDump(result, false /* active */);
1967 mLocalLog->log("AT::%-10s(%p) %s", funcName, track.get(), result.string());
1968 }
1969}
1970
Eric Laurent6acd1d42017-01-04 14:23:29 -08001971void AudioFlinger::ThreadBase::broadcast_l()
1972{
1973 // Thread could be blocked waiting for async
1974 // so signal it to handle state changes immediately
1975 // If threadLoop is currently unlocked a signal of mWaitWorkCV will
1976 // be lost so we also flag to prevent it blocking on mWaitWorkCV
1977 mSignalPending = true;
1978 mWaitWorkCV.broadcast();
1979}
1980
Andy Hungd0979812019-02-21 15:51:44 -08001981// Call only from threadLoop() or when it is idle.
1982// Do not call from high performance code as this may do binder rpc to the MediaMetrics service.
1983void AudioFlinger::ThreadBase::sendStatistics(bool force)
1984{
1985 // Do not log if we have no stats.
1986 // We choose the timestamp verifier because it is the most likely item to be present.
1987 const int64_t nstats = mTimestampVerifier.getN() - mLastRecordedTimestampVerifierN;
1988 if (nstats == 0) {
1989 return;
1990 }
1991
1992 // Don't log more frequently than once per 12 hours.
1993 // We use BOOTTIME to include suspend time.
1994 const int64_t timeNs = systemTime(SYSTEM_TIME_BOOTTIME);
1995 const int64_t sinceNs = timeNs - mLastRecordedTimeNs; // ok if mLastRecordedTimeNs = 0
1996 if (!force && sinceNs <= 12 * NANOS_PER_HOUR) {
1997 return;
1998 }
1999
2000 mLastRecordedTimestampVerifierN = mTimestampVerifier.getN();
2001 mLastRecordedTimeNs = timeNs;
2002
Ray Essickf27e9872019-12-07 06:28:46 -08002003 std::unique_ptr<mediametrics::Item> item(mediametrics::Item::create("audiothread"));
Andy Hungd0979812019-02-21 15:51:44 -08002004
2005#define MM_PREFIX "android.media.audiothread." // avoid cut-n-paste errors.
2006
2007 // thread configuration
2008 item->setInt32(MM_PREFIX "id", (int32_t)mId); // IO handle
2009 // item->setInt32(MM_PREFIX "portId", (int32_t)mPortId);
2010 item->setCString(MM_PREFIX "type", threadTypeToString(mType));
2011 item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
2012 item->setInt64(MM_PREFIX "channelMask", (int64_t)mChannelMask);
2013 item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
2014 item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
jiabinc52b1ff2019-10-31 17:20:42 -07002015 item->setCString(MM_PREFIX "outDevice", toString(outDeviceTypes()).c_str());
2016 item->setCString(MM_PREFIX "inDevice", toString(inDeviceType()).c_str());
Andy Hungd0979812019-02-21 15:51:44 -08002017
2018 // thread statistics
2019 if (mIoJitterMs.getN() > 0) {
2020 item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
2021 item->setDouble(MM_PREFIX "ioJitterMs.std", mIoJitterMs.getStdDev());
2022 }
2023 if (mProcessTimeMs.getN() > 0) {
2024 item->setDouble(MM_PREFIX "processTimeMs.mean", mProcessTimeMs.getMean());
2025 item->setDouble(MM_PREFIX "processTimeMs.std", mProcessTimeMs.getStdDev());
2026 }
2027 const auto tsjitter = mTimestampVerifier.getJitterMs();
2028 if (tsjitter.getN() > 0) {
2029 item->setDouble(MM_PREFIX "timestampJitterMs.mean", tsjitter.getMean());
2030 item->setDouble(MM_PREFIX "timestampJitterMs.std", tsjitter.getStdDev());
2031 }
2032 if (mLatencyMs.getN() > 0) {
2033 item->setDouble(MM_PREFIX "latencyMs.mean", mLatencyMs.getMean());
2034 item->setDouble(MM_PREFIX "latencyMs.std", mLatencyMs.getStdDev());
2035 }
Robert Wu06db0a32021-08-10 19:05:34 +00002036 if (mMonopipePipeDepthStats.getN() > 0) {
2037 item->setDouble(MM_PREFIX "monopipePipeDepthStats.mean",
2038 mMonopipePipeDepthStats.getMean());
2039 item->setDouble(MM_PREFIX "monopipePipeDepthStats.std",
2040 mMonopipePipeDepthStats.getStdDev());
2041 }
Andy Hungd0979812019-02-21 15:51:44 -08002042
2043 item->selfrecord();
2044}
2045
Eric Laurentd66d7a12021-07-13 13:35:32 +02002046product_strategy_t AudioFlinger::ThreadBase::getStrategyForStream(audio_stream_type_t stream) const
2047{
2048 if (!mAudioFlinger->isAudioPolicyReady()) {
2049 return PRODUCT_STRATEGY_NONE;
2050 }
2051 return AudioSystem::getStrategyForStream(stream);
2052}
2053
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01002054// startMelComputation_l() must be called with AudioFlinger::mLock held
2055void AudioFlinger::ThreadBase::startMelComputation_l(
2056 const sp<audio_utils::MelProcessor>& /*processor*/)
2057{
2058 // Do nothing
2059 ALOGW("%s: ThreadBase does not support CSD", __func__);
2060}
2061
2062// stopMelComputation_l() must be called with AudioFlinger::mLock held
2063void AudioFlinger::ThreadBase::stopMelComputation_l()
2064{
2065 // Do nothing
2066 ALOGW("%s: ThreadBase does not support CSD", __func__);
2067}
2068
Eric Laurent81784c32012-11-19 14:55:58 -08002069// ----------------------------------------------------------------------------
2070// Playback
2071// ----------------------------------------------------------------------------
2072
2073AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
2074 AudioStreamOut* output,
2075 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07002076 type_t type,
Eric Laurentf1f22e72021-07-13 14:04:14 +02002077 bool systemReady,
2078 audio_config_base_t *mixerConfig)
Andy Hungcf10d742020-04-28 15:38:24 -07002079 : ThreadBase(audioFlinger, id, type, systemReady, true /* isOut */),
Andy Hung2098f272014-02-27 14:00:06 -08002080 mNormalFrameCount(0), mSinkBuffer(NULL),
Eric Laurent1c5e2e32021-08-18 18:50:28 +02002081 mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision || type == SPATIALIZER),
Andy Hung69aed5f2014-02-25 17:24:40 -08002082 mMixerBuffer(NULL),
2083 mMixerBufferSize(0),
2084 mMixerBufferFormat(AUDIO_FORMAT_INVALID),
2085 mMixerBufferValid(false),
Eric Laurent1c5e2e32021-08-18 18:50:28 +02002086 mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision || type == SPATIALIZER),
Andy Hung98ef9782014-03-04 14:46:50 -08002087 mEffectBuffer(NULL),
2088 mEffectBufferSize(0),
2089 mEffectBufferFormat(AUDIO_FORMAT_INVALID),
2090 mEffectBufferValid(false),
Glenn Kastenc1fac192013-08-06 07:41:36 -07002091 mSuspended(0), mBytesWritten(0),
Andy Hungc54b1ff2016-02-23 14:07:07 -08002092 mFramesWritten(0),
Andy Hung238fa3d2016-07-28 10:53:22 -07002093 mSuspendedFrames(0),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002094 mActiveTracks(&this->mLocalLog),
Eric Laurent81784c32012-11-19 14:55:58 -08002095 // mStreamTypes[] initialized in constructor body
Andy Hung1bc088a2018-02-09 15:57:31 -08002096 mTracks(type == MIXER),
Eric Laurent81784c32012-11-19 14:55:58 -08002097 mOutput(output),
Andy Hung446f4df2019-02-21 12:26:41 -08002098 mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
Eric Laurent81784c32012-11-19 14:55:58 -08002099 mMixerStatus(MIXER_IDLE),
2100 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
Eric Laurentad9cb8b2015-05-26 16:38:19 -07002101 mStandbyDelayNs(AudioFlinger::mStandbyTimeInNsecs),
Eric Laurentbfb1b832013-01-07 09:53:42 -08002102 mBytesRemaining(0),
2103 mCurrentWriteLength(0),
2104 mUseAsyncWrite(false),
Eric Laurent3b4529e2013-09-05 18:09:19 -07002105 mWriteAckSequence(0),
2106 mDrainSequence(0),
Eric Laurent81784c32012-11-19 14:55:58 -08002107 mScreenState(AudioFlinger::mScreenState),
2108 // index 0 is reserved for normal mixer's submix
Glenn Kastendc2c50b2016-04-21 08:13:14 -07002109 mFastTrackAvailMask(((1 << FastMixerState::sMaxFastTracks) - 1) & ~1),
Eric Laurent7c29ec92017-09-20 17:54:22 -07002110 mHwSupportsPause(false), mHwPaused(false), mFlushPending(false),
Eric Laurent74c38dc2020-12-23 18:19:44 +01002111 mLeftVolFloat(-1.0), mRightVolFloat(-1.0),
Brian Lindahl65e90012022-07-27 18:01:07 +02002112 mDownStreamPatch{},
Eric Laurentb0463942022-12-20 16:31:10 +01002113 mIsTimestampAdvancing(kMinimumTimeBetweenTimestampChecksNs)
Eric Laurent81784c32012-11-19 14:55:58 -08002114{
Glenn Kastend7dca052015-03-05 16:05:54 -08002115 snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
2116 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08002117
2118 // Assumes constructor is called by AudioFlinger with it's mLock held, but
2119 // it would be safer to explicitly pass initial masterVolume/masterMute as
2120 // parameter.
2121 //
2122 // If the HAL we are using has support for master volume or master mute,
2123 // then do not attenuate or mute during mixing (just leave the volume at 1.0
2124 // and the mute set to false).
2125 mMasterVolume = audioFlinger->masterVolume_l();
2126 mMasterMute = audioFlinger->masterMute_l();
George Burgess IV5e4d86f2020-02-18 12:55:36 -08002127 if (mOutput->audioHwDev) {
Eric Laurent81784c32012-11-19 14:55:58 -08002128 if (mOutput->audioHwDev->canSetMasterVolume()) {
2129 mMasterVolume = 1.0;
2130 }
2131
2132 if (mOutput->audioHwDev->canSetMasterMute()) {
2133 mMasterMute = false;
2134 }
Andy Hungc8fddf32018-08-08 18:32:37 -07002135 mIsMsdDevice = strcmp(
2136 mOutput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002137 }
2138
Eric Laurentf1f22e72021-07-13 14:04:14 +02002139 if (mixerConfig != nullptr && mixerConfig->channel_mask != AUDIO_CHANNEL_NONE) {
2140 mMixerChannelMask = mixerConfig->channel_mask;
2141 }
2142
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002143 readOutputParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002144
Eric Laurent1c5e2e32021-08-18 18:50:28 +02002145 if (mType != SPATIALIZER
Eric Laurentb3f315a2021-07-13 15:09:05 +02002146 && mMixerChannelMask != mChannelMask) {
2147 LOG_ALWAYS_FATAL("HAL channel mask %#x does not match mixer channel mask %#x",
2148 mChannelMask, mMixerChannelMask);
2149 }
2150
Andy Hungc8fddf32018-08-08 18:32:37 -07002151 // TODO: We may also match on address as well as device type for
2152 // AUDIO_DEVICE_OUT_BUS, AUDIO_DEVICE_OUT_ALL_A2DP, AUDIO_DEVICE_OUT_REMOTE_SUBMIX
Dean Wheatleyf8726f02019-12-02 14:12:01 +11002153 if (type == MIXER || type == DIRECT || type == OFFLOAD) {
jiabinc52b1ff2019-10-31 17:20:42 -07002154 // TODO: This property should be ensure that only contains one single device type.
2155 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
2156 "audio.timestamp.corrected_output_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07002157 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_OUT_BUS // turn on by default for MSD
2158 : AUDIO_DEVICE_NONE));
2159 }
2160
Mikhail Naganovf33115d2020-09-25 23:03:05 +00002161 for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
2162 const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
Eric Laurent98e38192018-02-15 18:31:53 -08002163 mStreamTypes[stream].volume = 0.0f;
Eric Laurent81784c32012-11-19 14:55:58 -08002164 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
2165 }
Eric Laurent35f8c7c2020-02-08 11:42:35 -08002166 // Audio patch and call assistant volume are always max
Eric Laurent98e38192018-02-15 18:31:53 -08002167 mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
2168 mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
Eric Laurent35f8c7c2020-02-08 11:42:35 -08002169 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].volume = 1.0f;
2170 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
Eric Laurent81784c32012-11-19 14:55:58 -08002171}
2172
2173AudioFlinger::PlaybackThread::~PlaybackThread()
2174{
Glenn Kasten9e58b552013-01-18 15:09:48 -08002175 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung010a1a12014-03-13 13:57:33 -07002176 free(mSinkBuffer);
Andy Hung69aed5f2014-02-25 17:24:40 -08002177 free(mMixerBuffer);
Andy Hung98ef9782014-03-04 14:46:50 -08002178 free(mEffectBuffer);
Eric Laurentb62d0362021-10-26 17:40:18 +02002179 free(mPostSpatializerBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08002180}
2181
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002182// Thread virtuals
2183
2184void AudioFlinger::PlaybackThread::onFirstRef()
Eric Laurent81784c32012-11-19 14:55:58 -08002185{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002186 if (!isStreamInitialized()) {
jiabinf6eb4c32020-02-25 14:06:25 -08002187 ALOGE("The stream is not open yet"); // This should not happen.
2188 } else {
Mikhail Naganovaec565e2023-02-22 16:31:28 -08002189 // Callbacks take strong or weak pointers as a parameter.
2190 // Since PlaybackThread passes itself as a callback handler, it can only
2191 // be done outside of the constructor. Creating weak and especially strong
2192 // pointers to a refcounted object in its own constructor is strongly
2193 // discouraged, see comments in system/core/libutils/include/utils/RefBase.h.
2194 // Even if a function takes a weak pointer, it is possible that it will
2195 // need to convert it to a strong pointer down the line.
2196 if (mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING &&
2197 mOutput->stream->setCallback(this) == OK) {
2198 mUseAsyncWrite = true;
2199 mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
2200 }
2201
jiabinf6eb4c32020-02-25 14:06:25 -08002202 if (mOutput->stream->setEventCallback(this) != OK) {
jiabinf1a36052020-08-19 14:33:31 -07002203 ALOGD("Failed to add event callback");
jiabinf6eb4c32020-02-25 14:06:25 -08002204 }
2205 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002206 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
Andy Hung44d648b2022-04-08 17:33:40 -07002207 mThreadSnapshot.setTid(getTid());
Eric Laurent81784c32012-11-19 14:55:58 -08002208}
2209
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002210// ThreadBase virtuals
2211void AudioFlinger::PlaybackThread::preExit()
2212{
2213 ALOGV(" preExit()");
Ytai Ben-Tsvi7e0183f2022-02-04 10:49:54 -08002214 status_t result = mOutput->stream->exit();
2215 ALOGE_IF(result != OK, "Error when calling exit(): %d", result);
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002216}
2217
2218void AudioFlinger::PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08002219{
Eric Laurent81784c32012-11-19 14:55:58 -08002220 String8 result;
2221
Marco Nelissenb2208842014-02-07 14:00:50 -08002222 result.appendFormat(" Stream volumes in dB: ");
Eric Laurent81784c32012-11-19 14:55:58 -08002223 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
2224 const stream_type_t *st = &mStreamTypes[i];
2225 if (i > 0) {
2226 result.appendFormat(", ");
2227 }
2228 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
2229 if (st->mute) {
2230 result.append("M");
2231 }
2232 }
2233 result.append("\n");
2234 write(fd, result.string(), result.length());
2235 result.clear();
2236
Eric Laurent81784c32012-11-19 14:55:58 -08002237 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
2238 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
Elliott Hughes87cebad2014-05-22 10:14:43 -07002239 dprintf(fd, " Normal mixer raw underrun counters: partial=%u empty=%u\n",
Eric Laurent81784c32012-11-19 14:55:58 -08002240 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
Marco Nelissenb2208842014-02-07 14:00:50 -08002241
2242 size_t numtracks = mTracks.size();
2243 size_t numactive = mActiveTracks.size();
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002244 dprintf(fd, " %zu Tracks", numtracks);
Marco Nelissenb2208842014-02-07 14:00:50 -08002245 size_t numactiveseen = 0;
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002246 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08002247 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002248 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002249 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07002250 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08002251 for (size_t i = 0; i < numtracks; ++i) {
2252 sp<Track> track = mTracks[i];
2253 if (track != 0) {
2254 bool active = mActiveTracks.indexOf(track) >= 0;
2255 if (active) {
2256 numactiveseen++;
2257 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002258 result.append(prefix);
2259 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08002260 }
2261 }
2262 } else {
2263 result.append("\n");
2264 }
2265 if (numactiveseen != numactive) {
2266 // some tracks in the active list were not in the tracks list
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002267 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08002268 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002269 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07002270 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08002271 for (size_t i = 0; i < numactive; ++i) {
Andy Hungdae27702016-10-31 14:01:16 -07002272 sp<Track> track = mActiveTracks[i];
2273 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002274 result.append(prefix);
2275 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08002276 }
2277 }
2278 }
2279
2280 write(fd, result.string(), result.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002281}
2282
Andy Hung61589a42021-06-16 09:37:53 -07002283void AudioFlinger::PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08002284{
Andy Hung04cb8f72020-03-20 13:44:33 -07002285 dprintf(fd, " Master volume: %f\n", mMasterVolume);
Mikhail Naganovdfb411f2018-09-11 13:39:56 -07002286 dprintf(fd, " Master mute: %s\n", mMasterMute ? "on" : "off");
Eric Laurentf1f22e72021-07-13 14:04:14 +02002287 dprintf(fd, " Mixer channel Mask: %#x (%s)\n",
2288 mMixerChannelMask, channelMaskToString(mMixerChannelMask, true /* output */).c_str());
jiabin245cdd92018-12-07 17:55:15 -08002289 if (mHapticChannelMask != AUDIO_CHANNEL_NONE) {
2290 dprintf(fd, " Haptic channel mask: %#x (%s)\n", mHapticChannelMask,
2291 channelMaskToString(mHapticChannelMask, true /* output */).c_str());
2292 }
Elliott Hughes87cebad2014-05-22 10:14:43 -07002293 dprintf(fd, " Normal frame count: %zu\n", mNormalFrameCount);
Elliott Hughes87cebad2014-05-22 10:14:43 -07002294 dprintf(fd, " Total writes: %d\n", mNumWrites);
2295 dprintf(fd, " Delayed writes: %d\n", mNumDelayedWrites);
2296 dprintf(fd, " Blocked in write: %s\n", mInWrite ? "yes" : "no");
2297 dprintf(fd, " Suspend count: %d\n", mSuspended);
2298 dprintf(fd, " Sink buffer : %p\n", mSinkBuffer);
2299 dprintf(fd, " Mixer buffer: %p\n", mMixerBuffer);
2300 dprintf(fd, " Effect buffer: %p\n", mEffectBuffer);
2301 dprintf(fd, " Fast track availMask=%#x\n", mFastTrackAvailMask);
Eric Laurent42537be2016-01-08 17:16:42 -08002302 dprintf(fd, " Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
Glenn Kasten97b7b752014-09-28 13:04:24 -07002303 AudioStreamOut *output = mOutput;
2304 audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
Mikhail Naganov913d06c2016-11-01 12:49:22 -07002305 dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08002306 output, flags, toString(flags).c_str());
Andy Hungb54c8542016-09-21 12:55:15 -07002307 dprintf(fd, " Frames written: %lld\n", (long long)mFramesWritten);
2308 dprintf(fd, " Suspended frames: %lld\n", (long long)mSuspendedFrames);
2309 if (mPipeSink.get() != nullptr) {
2310 dprintf(fd, " PipeSink frames written: %lld\n", (long long)mPipeSink->framesWritten());
2311 }
2312 if (output != nullptr) {
2313 dprintf(fd, " Hal stream dump:\n");
Andy Hung61589a42021-06-16 09:37:53 -07002314 (void)output->stream->dump(fd, args);
Andy Hungb54c8542016-09-21 12:55:15 -07002315 }
Eric Laurent81784c32012-11-19 14:55:58 -08002316}
2317
Eric Laurent81784c32012-11-19 14:55:58 -08002318// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
2319sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
2320 const sp<AudioFlinger::Client>& client,
2321 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002322 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -08002323 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08002324 audio_format_t format,
2325 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08002326 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -08002327 size_t *pNotificationFrameCount,
2328 uint32_t notificationsPerBuffer,
2329 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -08002330 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -08002331 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -07002332 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002333 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002334 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -08002335 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002336 status_t *status,
jiabinf6eb4c32020-02-25 14:06:25 -08002337 audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02002338 const sp<media::IAudioTrackCallback>& callback,
jiabinc658e452022-10-21 20:52:21 +00002339 bool isSpatialized,
2340 bool isBitPerfect)
Eric Laurent81784c32012-11-19 14:55:58 -08002341{
Glenn Kasten74935e42013-12-19 08:56:45 -08002342 size_t frameCount = *pFrameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002343 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002344 sp<Track> track;
2345 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07002346 audio_output_flags_t outputFlags = mOutput->flags;
Eric Laurent21da6472017-11-09 16:29:26 -08002347 audio_output_flags_t requestedFlags = *flags;
Eric Laurent9b11c022018-06-06 19:19:22 -07002348 uint32_t sampleRate;
2349
2350 if (sharedBuffer != 0 && checkIMemory(sharedBuffer) != NO_ERROR) {
2351 lStatus = BAD_VALUE;
2352 goto Exit;
2353 }
Eric Laurent21da6472017-11-09 16:29:26 -08002354
2355 if (*pSampleRate == 0) {
2356 *pSampleRate = mSampleRate;
2357 }
Eric Laurent9b11c022018-06-06 19:19:22 -07002358 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07002359
2360 // special case for FAST flag considered OK if fast mixer is present
2361 if (hasFastMixer()) {
2362 outputFlags = (audio_output_flags_t)(outputFlags | AUDIO_OUTPUT_FLAG_FAST);
2363 }
2364
2365 // Check if requested flags are compatible with output stream flags
2366 if ((*flags & outputFlags) != *flags) {
2367 ALOGW("createTrack_l(): mismatch between requested flags (%08x) and output flags (%08x)",
2368 *flags, outputFlags);
2369 *flags = (audio_output_flags_t)(*flags & outputFlags);
2370 }
Eric Laurent81784c32012-11-19 14:55:58 -08002371
jiabinc658e452022-10-21 20:52:21 +00002372 if (isBitPerfect) {
2373 sp<EffectChain> chain = getEffectChain_l(sessionId);
2374 if (chain.get() != nullptr) {
2375 // Bit-perfect is required according to the configuration and preferred mixer
2376 // attributes, but it is not in the output flag from the client's request. Explicitly
2377 // adding bit-perfect flag to check the compatibility
2378 audio_output_flags_t flagsToCheck =
2379 (audio_output_flags_t)(*flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT);
2380 chain->checkOutputFlagCompatibility(&flagsToCheck);
2381 if ((flagsToCheck & AUDIO_OUTPUT_FLAG_BIT_PERFECT) == AUDIO_OUTPUT_FLAG_NONE) {
2382 ALOGE("%s cannot create track as there is data-processing effect attached to "
2383 "given session id(%d)", __func__, sessionId);
2384 lStatus = BAD_VALUE;
2385 goto Exit;
2386 }
2387 *flags = flagsToCheck;
2388 }
2389 }
2390
Eric Laurent81784c32012-11-19 14:55:58 -08002391 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07002392 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent81784c32012-11-19 14:55:58 -08002393 if (
Eric Laurent81784c32012-11-19 14:55:58 -08002394 // PCM data
2395 audio_is_linear_pcm(format) &&
Andy Hung1f439e12015-05-19 12:57:41 -07002396 // TODO: extract as a data library function that checks that a computationally
2397 // expensive downmixer is not required: isFastOutputChannelConversion()
jiabin245cdd92018-12-07 17:55:15 -08002398 (channelMask == (mChannelMask | mHapticChannelMask) ||
Andy Hung1f439e12015-05-19 12:57:41 -07002399 mChannelMask != AUDIO_CHANNEL_OUT_STEREO ||
2400 (channelMask == AUDIO_CHANNEL_OUT_MONO
2401 /* && mChannelMask == AUDIO_CHANNEL_OUT_STEREO */)) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002402 // hardware sample rate
2403 (sampleRate == mSampleRate) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002404 // normal mixer has an associated fast mixer
2405 hasFastMixer() &&
2406 // there are sufficient fast track slots available
2407 (mFastTrackAvailMask != 0)
2408 // FIXME test that MixerThread for this fast track has a capable output HAL
2409 // FIXME add a permission test also?
2410 ) {
Andy Hunge0a269a2016-03-23 15:13:42 -07002411 // static tracks can have any nonzero framecount, streaming tracks check against minimum.
2412 if (sharedBuffer == 0) {
Glenn Kasten03490092014-05-27 12:30:54 -07002413 // read the fast track multiplier property the first time it is needed
2414 int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
2415 if (ok != 0) {
2416 ALOGE("%s pthread_once failed: %d", __func__, ok);
2417 }
Andy Hunge0a269a2016-03-23 15:13:42 -07002418 frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
Eric Laurent81784c32012-11-19 14:55:58 -08002419 }
Eric Laurent4c415062016-06-17 16:14:16 -07002420
2421 // check compatibility with audio effects.
2422 { // scope for mLock
2423 Mutex::Autolock _l(mLock);
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002424 for (audio_session_t session : {
Eric Laurent3f75a5b2019-11-12 15:55:51 -08002425 AUDIO_SESSION_DEVICE,
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002426 AUDIO_SESSION_OUTPUT_STAGE,
2427 AUDIO_SESSION_OUTPUT_MIX,
2428 sessionId,
2429 }) {
2430 sp<EffectChain> chain = getEffectChain_l(session);
2431 if (chain.get() != nullptr) {
2432 audio_output_flags_t old = *flags;
2433 chain->checkOutputFlagCompatibility(flags);
2434 if (old != *flags) {
2435 ALOGV("AUDIO_OUTPUT_FLAGS denied by effect, session=%d old=%#x new=%#x",
2436 (int)session, (int)old, (int)*flags);
2437 }
Eric Laurent4c415062016-06-17 16:14:16 -07002438 }
2439 }
2440 }
Eric Laurent122f7e72016-06-29 11:53:29 -07002441 ALOGV_IF((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0,
Eric Laurent4c415062016-06-17 16:14:16 -07002442 "AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
2443 frameCount, mFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08002444 } else {
Robert Wu4c7bb7d2021-08-12 18:50:13 +00002445 ALOGD("AUDIO_OUTPUT_FLAG_FAST denied: sharedBuffer=%p frameCount=%zu "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002446 "mFrameCount=%zu format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
Andy Hung6146c082014-03-18 11:56:15 -07002447 "sampleRate=%u mSampleRate=%u "
Eric Laurent81784c32012-11-19 14:55:58 -08002448 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
Glenn Kastend79072e2016-01-06 08:41:20 -08002449 sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002450 audio_is_linear_pcm(format), channelMask, sampleRate,
2451 mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
Eric Laurent4c415062016-06-17 16:14:16 -07002452 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
Andy Hung0e48d252015-01-26 11:43:15 -08002453 }
2454 }
Eric Laurent21da6472017-11-09 16:29:26 -08002455
2456 if (!audio_has_proportional_frames(format)) {
2457 if (sharedBuffer != 0) {
2458 // Same comment as below about ignoring frameCount parameter for set()
2459 frameCount = sharedBuffer->size();
2460 } else if (frameCount == 0) {
2461 frameCount = mNormalFrameCount;
2462 }
2463 if (notificationFrameCount != frameCount) {
2464 notificationFrameCount = frameCount;
2465 }
2466 } else if (sharedBuffer != 0) {
2467 // FIXME: Ensure client side memory buffers need
2468 // not have additional alignment beyond sample
2469 // (e.g. 16 bit stereo accessed as 32 bit frame).
2470 size_t alignment = audio_bytes_per_sample(format);
2471 if (alignment & 1) {
2472 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
2473 alignment = 1;
2474 }
2475 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
2476 size_t frameSize = channelCount * audio_bytes_per_sample(format);
2477 if (channelCount > 1) {
2478 // More than 2 channels does not require stronger alignment than stereo
2479 alignment <<= 1;
2480 }
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002481 if (((uintptr_t)sharedBuffer->unsecurePointer() & (alignment - 1)) != 0) {
Eric Laurent21da6472017-11-09 16:29:26 -08002482 ALOGE("Invalid buffer alignment: address %p, channel count %u",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002483 sharedBuffer->unsecurePointer(), channelCount);
Eric Laurent21da6472017-11-09 16:29:26 -08002484 lStatus = BAD_VALUE;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002485 goto Exit;
2486 }
Eric Laurent21da6472017-11-09 16:29:26 -08002487
2488 // When initializing a shared buffer AudioTrack via constructors,
2489 // there's no frameCount parameter.
2490 // But when initializing a shared buffer AudioTrack via set(),
2491 // there _is_ a frameCount parameter. We silently ignore it.
2492 frameCount = sharedBuffer->size() / frameSize;
2493 } else {
2494 size_t minFrameCount = 0;
2495 // For fast tracks we try to respect the application's request for notifications per buffer.
2496 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2497 if (notificationsPerBuffer > 0) {
2498 // Avoid possible arithmetic overflow during multiplication.
2499 if (notificationsPerBuffer > SIZE_MAX / mFrameCount) {
2500 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
2501 notificationsPerBuffer, mFrameCount);
2502 } else {
2503 minFrameCount = mFrameCount * notificationsPerBuffer;
2504 }
2505 }
2506 } else {
2507 // For normal PCM streaming tracks, update minimum frame count.
2508 // Buffer depth is forced to be at least 2 x the normal mixer frame count and
2509 // cover audio hardware latency.
2510 // This is probably too conservative, but legacy application code may depend on it.
2511 // If you change this calculation, also review the start threshold which is related.
2512 uint32_t latencyMs = latency_l();
2513 if (latencyMs == 0) {
2514 ALOGE("Error when retrieving output stream latency");
2515 lStatus = UNKNOWN_ERROR;
2516 goto Exit;
2517 }
2518
2519 minFrameCount = AudioSystem::calculateMinFrameCount(latencyMs, mNormalFrameCount,
2520 mSampleRate, sampleRate, speed /*, 0 mNotificationsPerBufferReq*/);
2521
Eric Laurent81784c32012-11-19 14:55:58 -08002522 }
Eric Laurent21da6472017-11-09 16:29:26 -08002523 if (frameCount < minFrameCount) {
Eric Laurent81784c32012-11-19 14:55:58 -08002524 frameCount = minFrameCount;
2525 }
Eric Laurent81784c32012-11-19 14:55:58 -08002526 }
Eric Laurent21da6472017-11-09 16:29:26 -08002527
2528 // Make sure that application is notified with sufficient margin before underrun.
2529 // The client can divide the AudioTrack buffer into sub-buffers,
2530 // and expresses its desire to server as the notification frame count.
2531 if (sharedBuffer == 0 && audio_is_linear_pcm(format)) {
2532 size_t maxNotificationFrames;
2533 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2534 // notify every HAL buffer, regardless of the size of the track buffer
2535 maxNotificationFrames = mFrameCount;
2536 } else {
Andy Hungfa117802019-04-12 13:50:39 -07002537 // Triple buffer the notification period for a triple buffered mixer period;
2538 // otherwise, double buffering for the notification period is fine.
2539 //
2540 // TODO: This should be moved to AudioTrack to modify the notification period
2541 // on AudioTrack::setBufferSizeInFrames() changes.
2542 const int nBuffering =
2543 (uint64_t{frameCount} * mSampleRate)
2544 / (uint64_t{mNormalFrameCount} * sampleRate) == 3 ? 3 : 2;
2545
Eric Laurent21da6472017-11-09 16:29:26 -08002546 maxNotificationFrames = frameCount / nBuffering;
2547 // If client requested a fast track but this was denied, then use the smaller maximum.
2548 if (requestedFlags & AUDIO_OUTPUT_FLAG_FAST) {
2549 size_t maxNotificationFramesFastDenied = FMS_20 * sampleRate / 1000;
2550 if (maxNotificationFrames > maxNotificationFramesFastDenied) {
2551 maxNotificationFrames = maxNotificationFramesFastDenied;
2552 }
2553 }
2554 }
2555 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
2556 if (notificationFrameCount == 0) {
2557 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
2558 maxNotificationFrames, frameCount);
2559 } else {
2560 ALOGW("Client adjusted notificationFrames from %zu to %zu for frameCount %zu",
2561 notificationFrameCount, maxNotificationFrames, frameCount);
2562 }
2563 notificationFrameCount = maxNotificationFrames;
2564 }
2565 }
2566
Glenn Kasten74935e42013-12-19 08:56:45 -08002567 *pFrameCount = frameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002568 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002569
Glenn Kastenc3df8382014-03-13 15:05:25 -07002570 switch (mType) {
jiabinc658e452022-10-21 20:52:21 +00002571 case BIT_PERFECT:
2572 if (isBitPerfect) {
2573 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
2574 ALOGE("%s, bad parameter when request streaming bit-perfect, sampleRate=%u, "
2575 "format=%#x, channelMask=%#x, mSampleRate=%u, mFormat=%#x, mChannelMask=%#x",
2576 __func__, sampleRate, format, channelMask, mSampleRate, mFormat,
2577 mChannelMask);
2578 lStatus = BAD_VALUE;
2579 goto Exit;
2580 }
2581 }
2582 break;
Glenn Kastenc3df8382014-03-13 15:05:25 -07002583
2584 case DIRECT:
Phil Burkfdb3c072016-02-09 10:47:02 -08002585 if (audio_is_linear_pcm(format)) { // TODO maybe use audio_has_proportional_frames()?
Eric Laurent81784c32012-11-19 14:55:58 -08002586 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002587 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
2588 "for output %p with format %#x",
Eric Laurent81784c32012-11-19 14:55:58 -08002589 sampleRate, format, channelMask, mOutput, mFormat);
2590 lStatus = BAD_VALUE;
2591 goto Exit;
2592 }
2593 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002594 break;
2595
2596 case OFFLOAD:
Eric Laurentbfb1b832013-01-07 09:53:42 -08002597 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002598 ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
2599 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002600 sampleRate, format, channelMask, mOutput, mFormat);
2601 lStatus = BAD_VALUE;
2602 goto Exit;
2603 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002604 break;
2605
2606 default:
Glenn Kasten993fa062014-05-02 11:14:34 -07002607 if (!audio_is_linear_pcm(format)) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002608 ALOGE("createTrack_l() Bad parameter: format %#x \""
2609 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002610 format, mOutput, mFormat);
2611 lStatus = BAD_VALUE;
2612 goto Exit;
2613 }
Andy Hungcd044842014-08-07 11:04:34 -07002614 if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Eric Laurent81784c32012-11-19 14:55:58 -08002615 ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
2616 lStatus = BAD_VALUE;
2617 goto Exit;
2618 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002619 break;
2620
Eric Laurent81784c32012-11-19 14:55:58 -08002621 }
2622
2623 lStatus = initCheck();
2624 if (lStatus != NO_ERROR) {
Glenn Kasten15e57982013-09-24 11:52:37 -07002625 ALOGE("createTrack_l() audio driver not initialized");
Eric Laurent81784c32012-11-19 14:55:58 -08002626 goto Exit;
2627 }
2628
2629 { // scope for mLock
2630 Mutex::Autolock _l(mLock);
2631
2632 // all tracks in same audio session must share the same routing strategy otherwise
2633 // conflicts will happen when tracks are moved from one output to another by audio policy
2634 // manager
Eric Laurentd66d7a12021-07-13 13:35:32 +02002635 product_strategy_t strategy = getStrategyForStream(streamType);
Eric Laurent81784c32012-11-19 14:55:58 -08002636 for (size_t i = 0; i < mTracks.size(); ++i) {
2637 sp<Track> t = mTracks[i];
Eric Laurent83b88082014-06-20 18:31:16 -07002638 if (t != 0 && t->isExternalTrack()) {
Eric Laurentd66d7a12021-07-13 13:35:32 +02002639 product_strategy_t actual = getStrategyForStream(t->streamType());
Eric Laurent81784c32012-11-19 14:55:58 -08002640 if (sessionId == t->sessionId() && strategy != actual) {
2641 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
2642 strategy, actual);
2643 lStatus = BAD_VALUE;
2644 goto Exit;
2645 }
2646 }
2647 }
2648
yucliuc9c49cd2020-07-13 16:25:21 -07002649 // Set DIRECT flag if current thread is DirectOutputThread. This can
2650 // happen when the playback is rerouted to direct output thread by
2651 // dynamic audio policy.
2652 // Do NOT report the flag changes back to client, since the client
2653 // doesn't explicitly request a direct flag.
2654 audio_output_flags_t trackFlags = *flags;
2655 if (mType == DIRECT) {
2656 trackFlags = static_cast<audio_output_flags_t>(trackFlags | AUDIO_OUTPUT_FLAG_DIRECT);
2657 }
2658
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002659 track = new Track(this, client, streamType, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002660 channelMask, frameCount,
2661 nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
Svet Ganov33761132021-05-13 22:51:08 +00002662 sessionId, creatorPid, attributionSource, trackFlags,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02002663 TrackBase::TYPE_DEFAULT, portId, SIZE_MAX /*frameCountToBeReady*/,
jiabinc658e452022-10-21 20:52:21 +00002664 speed, isSpatialized, isBitPerfect);
Glenn Kasten03003332013-08-06 15:40:54 -07002665
Glenn Kasten03003332013-08-06 15:40:54 -07002666 lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
2667 if (lStatus != NO_ERROR) {
Glenn Kasten0cde0762014-01-16 15:06:36 -08002668 ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002669 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08002670 goto Exit;
2671 }
2672 mTracks.add(track);
jiabinf6eb4c32020-02-25 14:06:25 -08002673 {
2674 Mutex::Autolock _atCbL(mAudioTrackCbLock);
2675 if (callback.get() != nullptr) {
jiabin18a4b1c2020-09-17 11:40:42 -07002676 mAudioTrackCallbacks.emplace(track, callback);
jiabinf6eb4c32020-02-25 14:06:25 -08002677 }
2678 }
Eric Laurent81784c32012-11-19 14:55:58 -08002679
2680 sp<EffectChain> chain = getEffectChain_l(sessionId);
2681 if (chain != 0) {
2682 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
2683 track->setMainBuffer(chain->inBuffer());
Eric Laurentd66d7a12021-07-13 13:35:32 +02002684 chain->setStrategy(getStrategyForStream(track->streamType()));
Eric Laurent81784c32012-11-19 14:55:58 -08002685 chain->incTrackCnt();
2686 }
2687
Eric Laurent05067782016-06-01 18:27:28 -07002688 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) && (tid != -1)) {
Eric Laurent81784c32012-11-19 14:55:58 -08002689 pid_t callingPid = IPCThreadState::self()->getCallingPid();
2690 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
2691 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07002692 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08002693 }
2694 }
2695
2696 lStatus = NO_ERROR;
2697
2698Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07002699 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08002700 return track;
2701}
2702
Andy Hung1bc088a2018-02-09 15:57:31 -08002703template<typename T>
Andy Hung1bc088a2018-02-09 15:57:31 -08002704ssize_t AudioFlinger::PlaybackThread::Tracks<T>::remove(const sp<T> &track)
2705{
Andy Hungc0691382018-09-12 18:01:57 -07002706 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08002707 const ssize_t index = mTracks.remove(track);
2708 if (index >= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07002709 if (mSaveDeletedTrackIds) {
Andy Hung1bc088a2018-02-09 15:57:31 -08002710 // We can't directly access mAudioMixer since the caller may be outside of threadLoop.
Andy Hungc0691382018-09-12 18:01:57 -07002711 // Instead, we add to mDeletedTrackIds which is solely used for mAudioMixer update,
Andy Hung1bc088a2018-02-09 15:57:31 -08002712 // to be handled when MixerThread::prepareTracks_l() next changes mAudioMixer.
Andy Hungc0691382018-09-12 18:01:57 -07002713 mDeletedTrackIds.emplace(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08002714 }
Andy Hung1bc088a2018-02-09 15:57:31 -08002715 }
2716 return index;
2717}
2718
Eric Laurent81784c32012-11-19 14:55:58 -08002719uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
2720{
2721 return latency;
2722}
2723
2724uint32_t AudioFlinger::PlaybackThread::latency() const
2725{
2726 Mutex::Autolock _l(mLock);
2727 return latency_l();
2728}
2729uint32_t AudioFlinger::PlaybackThread::latency_l() const
2730{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002731 uint32_t latency;
2732 if (initCheck() == NO_ERROR && mOutput->stream->getLatency(&latency) == OK) {
2733 return correctLatency_l(latency);
Eric Laurent81784c32012-11-19 14:55:58 -08002734 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002735 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002736}
2737
2738void AudioFlinger::PlaybackThread::setMasterVolume(float value)
2739{
2740 Mutex::Autolock _l(mLock);
2741 // Don't apply master volume in SW if our HAL can do it for us.
2742 if (mOutput && mOutput->audioHwDev &&
2743 mOutput->audioHwDev->canSetMasterVolume()) {
2744 mMasterVolume = 1.0;
2745 } else {
2746 mMasterVolume = value;
2747 }
2748}
2749
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002750void AudioFlinger::PlaybackThread::setMasterBalance(float balance)
2751{
2752 mMasterBalance.store(balance);
2753}
2754
Eric Laurent81784c32012-11-19 14:55:58 -08002755void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
2756{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002757 if (isDuplicating()) {
2758 return;
2759 }
Eric Laurent81784c32012-11-19 14:55:58 -08002760 Mutex::Autolock _l(mLock);
2761 // Don't apply master mute in SW if our HAL can do it for us.
2762 if (mOutput && mOutput->audioHwDev &&
2763 mOutput->audioHwDev->canSetMasterMute()) {
2764 mMasterMute = false;
2765 } else {
2766 mMasterMute = muted;
2767 }
2768}
2769
2770void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
2771{
2772 Mutex::Autolock _l(mLock);
2773 mStreamTypes[stream].volume = value;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002774 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002775}
2776
2777void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
2778{
2779 Mutex::Autolock _l(mLock);
2780 mStreamTypes[stream].mute = muted;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002781 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002782}
2783
2784float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
2785{
2786 Mutex::Autolock _l(mLock);
2787 return mStreamTypes[stream].volume;
2788}
2789
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09002790void AudioFlinger::PlaybackThread::setVolumeForOutput_l(float left, float right) const
2791{
2792 mOutput->stream->setVolume(left, right);
2793}
2794
Eric Laurent81784c32012-11-19 14:55:58 -08002795// addTrack_l() must be called with ThreadBase::mLock held
2796status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
Andy Hung920f6572022-10-06 12:09:49 -07002797NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
Eric Laurent81784c32012-11-19 14:55:58 -08002798{
2799 status_t status = ALREADY_EXISTS;
2800
Eric Laurent81784c32012-11-19 14:55:58 -08002801 if (mActiveTracks.indexOf(track) < 0) {
2802 // the track is newly added, make sure it fills up all its
2803 // buffers before playing. This is to ensure the client will
2804 // effectively get the latency it requested.
Eric Laurent83b88082014-06-20 18:31:16 -07002805 if (track->isExternalTrack()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002806 TrackBase::track_state state = track->mState;
2807 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002808 status = AudioSystem::startOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002809 mLock.lock();
2810 // abort track was stopped/paused while we released the lock
2811 if (state != track->mState) {
2812 if (status == NO_ERROR) {
2813 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002814 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002815 mLock.lock();
2816 }
2817 return INVALID_OPERATION;
2818 }
2819 // abort if start is rejected by audio policy manager
2820 if (status != NO_ERROR) {
jiabina84c3d32022-12-02 18:59:55 +00002821 // Do not replace the error if it is DEAD_OBJECT. When this happens, it indicates
2822 // current playback thread is reopened, which may happen when clients set preferred
2823 // mixer configuration. Returning DEAD_OBJECT will make the client restore track
2824 // immediately.
2825 return status == DEAD_OBJECT ? status : PERMISSION_DENIED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002826 }
2827#ifdef ADD_BATTERY_DATA
2828 // to track the speaker usage
2829 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
2830#endif
Eric Laurent09f1ed22019-04-24 17:45:17 -07002831 sendIoConfigEvent_l(AUDIO_CLIENT_STARTED, track->creatorPid(), track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002832 }
2833
Eric Laurent51716182016-02-29 18:00:56 -08002834 // set retry count for buffer fill
2835 if (track->isOffloaded()) {
Eric Laurente93cc032016-05-05 10:15:10 -07002836 if (track->isStopping_1()) {
2837 track->mRetryCount = kMaxTrackStopRetriesOffload;
2838 } else {
2839 track->mRetryCount = kMaxTrackStartupRetriesOffload;
2840 }
2841 track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
Eric Laurent51716182016-02-29 18:00:56 -08002842 } else {
2843 track->mRetryCount = kMaxTrackStartupRetries;
Eric Laurente93cc032016-05-05 10:15:10 -07002844 track->mFillingUpStatus =
2845 track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
Eric Laurent51716182016-02-29 18:00:56 -08002846 }
2847
jiabineb3bda02020-06-30 14:07:03 -07002848 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2849 if (mHapticChannelMask != AUDIO_CHANNEL_NONE
2850 && ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
2851 || (chain != nullptr && chain->containsHapticGeneratingEffect_l()))) {
jiabin57303cc2018-12-18 15:45:57 -08002852 // Unlock due to VibratorService will lock for this call and will
2853 // call Tracks.mute/unmute which also require thread's lock.
2854 mLock.unlock();
Simon Bowden62823412022-10-17 14:52:26 +00002855 const os::HapticScale intensity = AudioFlinger::onExternalVibrationStart(
jiabin57303cc2018-12-18 15:45:57 -08002856 track->getExternalVibration());
Lais Andradebc3f37a2021-07-02 00:13:19 +01002857 std::optional<media::AudioVibratorInfo> vibratorInfo;
2858 {
2859 // TODO(b/184194780): Use the vibrator information from the vibrator that will be
2860 // used to play this track.
2861 Mutex::Autolock _l(mAudioFlinger->mLock);
2862 vibratorInfo = std::move(mAudioFlinger->getDefaultVibratorInfo_l());
2863 }
jiabin57303cc2018-12-18 15:45:57 -08002864 mLock.lock();
Simon Bowden62823412022-10-17 14:52:26 +00002865 track->setHapticIntensity(intensity);
Lais Andradebc3f37a2021-07-02 00:13:19 +01002866 if (vibratorInfo) {
2867 track->setHapticMaxAmplitude(vibratorInfo->maxAmplitude);
2868 }
2869
jiabin57303cc2018-12-18 15:45:57 -08002870 // Haptic playback should be enabled by vibrator service.
2871 if (track->getHapticPlaybackEnabled()) {
2872 // Disable haptic playback of all active track to ensure only
2873 // one track playing haptic if current track should play haptic.
2874 for (const auto &t : mActiveTracks) {
2875 t->setHapticPlaybackEnabled(false);
2876 }
jiabin245cdd92018-12-07 17:55:15 -08002877 }
jiabine70bc7f2020-06-30 22:07:55 -07002878
2879 // Set haptic intensity for effect
2880 if (chain != nullptr) {
2881 chain->setHapticIntensity_l(track->id(), intensity);
2882 }
jiabin245cdd92018-12-07 17:55:15 -08002883 }
2884
Eric Laurent81784c32012-11-19 14:55:58 -08002885 track->mResetDone = false;
Andy Hung59de4262021-06-14 10:53:54 -07002886 track->resetPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08002887 mActiveTracks.add(track);
Eric Laurentd0107bc2013-06-11 14:38:48 -07002888 if (chain != 0) {
2889 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2890 track->sessionId());
2891 chain->incActiveTrackCnt();
Eric Laurent81784c32012-11-19 14:55:58 -08002892 }
2893
Andy Hungc2b11cb2020-04-22 09:04:01 -07002894 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent81784c32012-11-19 14:55:58 -08002895 status = NO_ERROR;
2896 }
2897
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08002898 onAddNewTrack_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002899 return status;
2900}
2901
Eric Laurentbfb1b832013-01-07 09:53:42 -08002902bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
Eric Laurent81784c32012-11-19 14:55:58 -08002903{
Eric Laurentbfb1b832013-01-07 09:53:42 -08002904 track->terminate();
Eric Laurent81784c32012-11-19 14:55:58 -08002905 // active tracks are removed by threadLoop()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002906 bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2907 track->mState = TrackBase::STOPPED;
2908 if (!trackActive) {
Eric Laurent81784c32012-11-19 14:55:58 -08002909 removeTrack_l(track);
Eric Laurentab5cdba2014-06-09 17:22:27 -07002910 } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
Andy Hung916987e2023-03-20 19:08:16 -07002911 if (track->isPausePending()) {
2912 track->pauseAck();
2913 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002914 track->mState = TrackBase::STOPPING_1;
Eric Laurent81784c32012-11-19 14:55:58 -08002915 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002916
2917 return trackActive;
Eric Laurent81784c32012-11-19 14:55:58 -08002918}
2919
2920void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2921{
2922 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Andy Hung2148bf02016-11-28 19:01:02 -08002923
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002924 String8 result;
2925 track->appendDump(result, false /* active */);
2926 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
Andy Hung2148bf02016-11-28 19:01:02 -08002927
Eric Laurent81784c32012-11-19 14:55:58 -08002928 mTracks.remove(track);
jiabin18a4b1c2020-09-17 11:40:42 -07002929 {
2930 Mutex::Autolock _atCbL(mAudioTrackCbLock);
2931 mAudioTrackCallbacks.erase(track);
2932 }
Eric Laurent81784c32012-11-19 14:55:58 -08002933 if (track->isFastTrack()) {
2934 int index = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07002935 ALOG_ASSERT(0 < index && index < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08002936 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
2937 mFastTrackAvailMask |= 1 << index;
2938 // redundant as track is about to be destroyed, for dumpsys only
2939 track->mFastIndex = -1;
2940 }
2941 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2942 if (chain != 0) {
2943 chain->decTrackCnt();
2944 }
2945}
2946
2947String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
2948{
Eric Laurent81784c32012-11-19 14:55:58 -08002949 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002950 String8 out_s8;
2951 if (initCheck() == NO_ERROR && mOutput->stream->getParameters(keys, &out_s8) == OK) {
2952 return out_s8;
Eric Laurent81784c32012-11-19 14:55:58 -08002953 }
Andy Hung920f6572022-10-06 12:09:49 -07002954 return {};
Eric Laurent81784c32012-11-19 14:55:58 -08002955}
2956
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002957status_t AudioFlinger::DirectOutputThread::selectPresentation(int presentationId, int programId) {
2958 Mutex::Autolock _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002959 if (!isStreamInitialized()) {
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002960 return NO_INIT;
2961 }
2962 return mOutput->stream->selectPresentation(presentationId, programId);
2963}
2964
Mikhail Naganov88536df2021-07-26 17:30:29 -07002965void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002966 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002967 ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
Mikhail Naganov88536df2021-07-26 17:30:29 -07002968 sp<AudioIoDescriptor> desc;
2969 const struct audio_patch patch = isMsdDevice() ? mDownStreamPatch : mPatch;
Eric Laurent81784c32012-11-19 14:55:58 -08002970 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002971 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002972 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07002973 case AUDIO_OUTPUT_CONFIG_CHANGED:
Mikhail Naganov88536df2021-07-26 17:30:29 -07002974 desc = sp<AudioIoDescriptor>::make(mId, patch, false /*isInput*/,
2975 mSampleRate, mFormat, mChannelMask,
2976 // FIXME AudioFlinger::frameCount(audio_io_handle_t) instead of mNormalFrameCount?
2977 mNormalFrameCount, mFrameCount, latency_l());
Eric Laurent81784c32012-11-19 14:55:58 -08002978 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07002979 case AUDIO_CLIENT_STARTED:
Mikhail Naganov88536df2021-07-26 17:30:29 -07002980 desc = sp<AudioIoDescriptor>::make(mId, patch, portId);
Eric Laurent09f1ed22019-04-24 17:45:17 -07002981 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07002982 case AUDIO_OUTPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08002983 default:
Mikhail Naganov88536df2021-07-26 17:30:29 -07002984 desc = sp<AudioIoDescriptor>::make(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08002985 break;
2986 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002987 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08002988}
2989
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002990void AudioFlinger::PlaybackThread::onWriteReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002991{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002992 mCallbackThread->resetWriteBlocked();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002993}
2994
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002995void AudioFlinger::PlaybackThread::onDrainReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002996{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002997 mCallbackThread->resetDraining();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002998}
2999
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003000void AudioFlinger::PlaybackThread::onError()
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07003001{
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07003002 mCallbackThread->setAsyncError();
3003}
3004
jiabinf6eb4c32020-02-25 14:06:25 -08003005void AudioFlinger::PlaybackThread::onCodecFormatChanged(
3006 const std::basic_string<uint8_t>& metadataBs)
3007{
Kuowei Li9e2f6162022-11-23 16:25:26 +08003008 wp<AudioFlinger::PlaybackThread> weakPointerThis = this;
3009 std::thread([this, metadataBs, weakPointerThis]() {
3010 sp<AudioFlinger::PlaybackThread> playbackThread = weakPointerThis.promote();
3011 if (playbackThread == nullptr) {
3012 ALOGW("PlaybackThread was destroyed, skip codec format change event");
3013 return;
3014 }
3015
jiabinf6eb4c32020-02-25 14:06:25 -08003016 audio_utils::metadata::Data metadata =
3017 audio_utils::metadata::dataFromByteString(metadataBs);
3018 if (metadata.empty()) {
3019 ALOGW("Can not transform the buffer to audio metadata, %s, %d",
3020 reinterpret_cast<char*>(const_cast<uint8_t*>(metadataBs.data())),
3021 (int)metadataBs.size());
3022 return;
3023 }
3024
3025 audio_utils::metadata::ByteString metaDataStr =
3026 audio_utils::metadata::byteStringFromData(metadata);
3027 std::vector metadataVec(metaDataStr.begin(), metaDataStr.end());
3028 Mutex::Autolock _l(mAudioTrackCbLock);
jiabin18a4b1c2020-09-17 11:40:42 -07003029 for (const auto& callbackPair : mAudioTrackCallbacks) {
3030 callbackPair.second->onCodecFormatChanged(metadataVec);
jiabinf6eb4c32020-02-25 14:06:25 -08003031 }
3032 }).detach();
3033}
3034
Eric Laurent3b4529e2013-09-05 18:09:19 -07003035void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08003036{
3037 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003038 // reject out of sequence requests
3039 if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
3040 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003041 mWaitWorkCV.signal();
3042 }
3043}
3044
Eric Laurent3b4529e2013-09-05 18:09:19 -07003045void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08003046{
3047 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003048 // reject out of sequence requests
3049 if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
Andy Hungf3234512018-07-03 14:51:47 -07003050 // Register discontinuity when HW drain is completed because that can cause
3051 // the timestamp frame position to reset to 0 for direct and offload threads.
3052 // (Out of sequence requests are ignored, since the discontinuity would be handled
3053 // elsewhere, e.g. in flush).
Dean Wheatley12473e92021-03-18 23:00:55 +11003054 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003055 mDrainSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003056 mWaitWorkCV.signal();
3057 }
3058}
3059
Glenn Kastendeca2ae2014-02-07 10:25:56 -08003060void AudioFlinger::PlaybackThread::readOutputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08003061{
Glenn Kastenadad3d72014-02-21 14:51:43 -08003062 // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
Mikhail Naganov560637e2021-03-31 22:40:13 +00003063 const audio_config_base_t audioConfig = mOutput->getAudioProperties();
3064 mSampleRate = audioConfig.sample_rate;
3065 mChannelMask = audioConfig.channel_mask;
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003066 if (!audio_is_output_channel(mChannelMask)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08003067 LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003068 }
Eric Laurentb3f315a2021-07-13 15:09:05 +02003069 if (hasMixer() && !isValidPcmSinkChannelMask(mChannelMask)) {
Andy Hung9a592762014-07-21 21:56:01 -07003070 LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
3071 mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003072 }
Eric Laurentf1f22e72021-07-13 14:04:14 +02003073
3074 if (mMixerChannelMask == AUDIO_CHANNEL_NONE) {
3075 mMixerChannelMask = mChannelMask;
3076 }
3077
Andy Hunge5412692014-05-16 11:25:07 -07003078 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003079 mBalance.setChannelMask(mChannelMask);
Phil Burkca5e6142015-07-14 09:42:29 -07003080
Eric Laurentf1f22e72021-07-13 14:04:14 +02003081 uint32_t mixerChannelCount = audio_channel_count_from_out_mask(mMixerChannelMask);
3082
Phil Burkca5e6142015-07-14 09:42:29 -07003083 // Get actual HAL format.
Mikhail Naganov560637e2021-03-31 22:40:13 +00003084 status_t result = mOutput->stream->getAudioProperties(nullptr, nullptr, &mHALFormat);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003085 LOG_ALWAYS_FATAL_IF(result != OK, "Error when retrieving output stream format: %d", result);
Phil Burkca5e6142015-07-14 09:42:29 -07003086 // Get format from the shim, which will be different than the HAL format
3087 // if playing compressed audio over HDMI passthrough.
Mikhail Naganov560637e2021-03-31 22:40:13 +00003088 mFormat = audioConfig.format;
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003089 if (!audio_is_valid_format(mFormat)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08003090 LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003091 }
Eric Laurentb3f315a2021-07-13 15:09:05 +02003092 if (hasMixer() && !isValidPcmSinkFormat(mFormat)) {
Andy Hung6146c082014-03-18 11:56:15 -07003093 LOG_FATAL("HAL format %#x not supported for mixed output",
3094 mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07003095 }
Phil Burk062e67a2015-02-11 13:40:50 -08003096 mFrameSize = mOutput->getFrameSize();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003097 result = mOutput->stream->getBufferSize(&mBufferSize);
3098 LOG_ALWAYS_FATAL_IF(result != OK,
3099 "Error when retrieving output stream buffer size: %d", result);
Glenn Kasten70949c42013-08-06 07:40:12 -07003100 mFrameCount = mBufferSize / mFrameSize;
Eric Laurentb3f315a2021-07-13 15:09:05 +02003101 if (hasMixer() && (mFrameCount & 15)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003102 ALOGW("HAL output buffer size is %zu frames but AudioMixer requires multiples of 16 frames",
Eric Laurent81784c32012-11-19 14:55:58 -08003103 mFrameCount);
3104 }
3105
Eric Laurentd1f69b02014-12-15 14:33:13 -08003106 mHwSupportsPause = false;
3107 if (mOutput->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003108 bool supportsPause = false, supportsResume = false;
3109 if (mOutput->stream->supportsPauseAndResume(&supportsPause, &supportsResume) == OK) {
3110 if (supportsPause && supportsResume) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08003111 mHwSupportsPause = true;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003112 } else if (supportsPause) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08003113 ALOGW("direct output implements pause but not resume");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003114 } else if (supportsResume) {
3115 ALOGW("direct output implements resume but not pause");
Eric Laurentd1f69b02014-12-15 14:33:13 -08003116 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08003117 }
3118 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07003119 if (!mHwSupportsPause && mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
3120 LOG_ALWAYS_FATAL("HW_AV_SYNC requested but HAL does not implement pause and resume");
3121 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08003122
Andy Hungfbfc3952015-01-15 13:33:51 -08003123 if (mType == DUPLICATING && mMixerBufferEnabled && mEffectBufferEnabled) {
3124 // For best precision, we use float instead of the associated output
3125 // device format (typically PCM 16 bit).
3126
3127 mFormat = AUDIO_FORMAT_PCM_FLOAT;
3128 mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
3129 mBufferSize = mFrameSize * mFrameCount;
3130
3131 // TODO: We currently use the associated output device channel mask and sample rate.
3132 // (1) Perhaps use the ORed channel mask of all downstream MixerThreads
3133 // (if a valid mask) to avoid premature downmix.
3134 // (2) Perhaps use the maximum sample rate of all downstream MixerThreads
3135 // instead of the output device sample rate to avoid loss of high frequency information.
3136 // This may need to be updated as MixerThread/OutputTracks are added and not here.
3137 }
3138
Andy Hung09a50072014-02-27 14:30:47 -08003139 // Calculate size of normal sink buffer relative to the HAL output buffer size
Eric Laurent81784c32012-11-19 14:55:58 -08003140 double multiplier = 1.0;
Andy Hungd3639922022-04-28 18:00:49 -07003141 // Note: mType == SPATIALIZER does not support FastMixer.
Eric Laurent81784c32012-11-19 14:55:58 -08003142 if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
3143 kUseFastMixer == FastMixer_Dynamic)) {
Andy Hung09a50072014-02-27 14:30:47 -08003144 size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
3145 size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
Haynes Mathew George227a14b2016-05-09 12:45:48 -07003146
Eric Laurent81784c32012-11-19 14:55:58 -08003147 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
3148 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
3149 maxNormalFrameCount = maxNormalFrameCount & ~15;
3150 if (maxNormalFrameCount < minNormalFrameCount) {
3151 maxNormalFrameCount = minNormalFrameCount;
3152 }
3153 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
3154 if (multiplier <= 1.0) {
3155 multiplier = 1.0;
3156 } else if (multiplier <= 2.0) {
3157 if (2 * mFrameCount <= maxNormalFrameCount) {
3158 multiplier = 2.0;
3159 } else {
3160 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
3161 }
3162 } else {
Haynes Mathew George227a14b2016-05-09 12:45:48 -07003163 multiplier = floor(multiplier);
Eric Laurent81784c32012-11-19 14:55:58 -08003164 }
3165 }
3166 mNormalFrameCount = multiplier * mFrameCount;
3167 // round up to nearest 16 frames to satisfy AudioMixer
Eric Laurentb3f315a2021-07-13 15:09:05 +02003168 if (hasMixer()) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07003169 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
3170 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003171 ALOGI("HAL output buffer size %zu frames, normal sink buffer size %zu frames", mFrameCount,
Eric Laurent81784c32012-11-19 14:55:58 -08003172 mNormalFrameCount);
3173
Andy Hung08fb1742015-05-31 23:22:10 -07003174 // Check if we want to throttle the processing to no more than 2x normal rate
3175 mThreadThrottle = property_get_bool("af.thread.throttle", true /* default_value */);
Andy Hung40eb1a12015-06-18 13:42:02 -07003176 mThreadThrottleTimeMs = 0;
3177 mThreadThrottleEndMs = 0;
Andy Hung08fb1742015-05-31 23:22:10 -07003178 mHalfBufferMs = mNormalFrameCount * 1000 / (2 * mSampleRate);
3179
Andy Hung010a1a12014-03-13 13:57:33 -07003180 // mSinkBuffer is the sink buffer. Size is always multiple-of-16 frames.
3181 // Originally this was int16_t[] array, need to remove legacy implications.
3182 free(mSinkBuffer);
3183 mSinkBuffer = NULL;
Eric Laurent39095982021-08-24 18:29:27 +02003184
Andy Hung5b10a202014-03-13 13:59:29 -07003185 // For sink buffer size, we use the frame size from the downstream sink to avoid problems
3186 // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
3187 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
Andy Hung010a1a12014-03-13 13:57:33 -07003188 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08003189
Andy Hung69aed5f2014-02-25 17:24:40 -08003190 // We resize the mMixerBuffer according to the requirements of the sink buffer which
3191 // drives the output.
3192 free(mMixerBuffer);
3193 mMixerBuffer = NULL;
3194 if (mMixerBufferEnabled) {
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003195 mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // no longer valid: AUDIO_FORMAT_PCM_16_BIT.
Eric Laurentf1f22e72021-07-13 14:04:14 +02003196 mMixerBufferSize = mNormalFrameCount * mixerChannelCount
Andy Hung69aed5f2014-02-25 17:24:40 -08003197 * audio_bytes_per_sample(mMixerBufferFormat);
3198 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
3199 }
Andy Hung98ef9782014-03-04 14:46:50 -08003200 free(mEffectBuffer);
3201 mEffectBuffer = NULL;
3202 if (mEffectBufferEnabled) {
rago94a1ee82017-07-21 15:11:02 -07003203 mEffectBufferFormat = EFFECT_BUFFER_FORMAT;
Eric Laurentf1f22e72021-07-13 14:04:14 +02003204 mEffectBufferSize = mNormalFrameCount * mixerChannelCount
Andy Hung98ef9782014-03-04 14:46:50 -08003205 * audio_bytes_per_sample(mEffectBufferFormat);
3206 (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
3207 }
Andy Hung69aed5f2014-02-25 17:24:40 -08003208
Eric Laurentb62d0362021-10-26 17:40:18 +02003209 if (mType == SPATIALIZER) {
3210 free(mPostSpatializerBuffer);
3211 mPostSpatializerBuffer = nullptr;
3212 mPostSpatializerBufferSize = mNormalFrameCount * mChannelCount
3213 * audio_bytes_per_sample(mEffectBufferFormat);
3214 (void)posix_memalign(&mPostSpatializerBuffer, 32, mPostSpatializerBufferSize);
3215 }
3216
Mikhail Naganov55773032020-10-01 15:08:13 -07003217 mHapticChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & AUDIO_CHANNEL_HAPTIC_ALL);
3218 mChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & ~mHapticChannelMask);
jiabin245cdd92018-12-07 17:55:15 -08003219 mHapticChannelCount = audio_channel_count_from_out_mask(mHapticChannelMask);
3220 mChannelCount -= mHapticChannelCount;
Eric Laurentf1f22e72021-07-13 14:04:14 +02003221 mMixerChannelMask = static_cast<audio_channel_mask_t>(mMixerChannelMask & ~mHapticChannelMask);
jiabin245cdd92018-12-07 17:55:15 -08003222
Eric Laurent81784c32012-11-19 14:55:58 -08003223 // force reconfiguration of effect chains and engines to take new buffer size and audio
3224 // parameters into account
Glenn Kastendeca2ae2014-02-07 10:25:56 -08003225 // Note that mLock is not held when readOutputParameters_l() is called from the constructor
Eric Laurent81784c32012-11-19 14:55:58 -08003226 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
3227 // matter.
3228 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
3229 Vector< sp<EffectChain> > effectChains = mEffectChains;
3230 for (size_t i = 0; i < effectChains.size(); i ++) {
Eric Laurent6c796322019-04-09 14:13:17 -07003231 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(),
3232 this/* srcThread */, this/* dstThread */);
Eric Laurent81784c32012-11-19 14:55:58 -08003233 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08003234
George Burgess IV5e4d86f2020-02-18 12:55:36 -08003235 audio_output_flags_t flags = mOutput->flags;
Andy Hungcf10d742020-04-28 15:38:24 -07003236 mediametrics::LogItem item(mThreadMetrics.getMetricsId()); // TODO: method in ThreadMetrics?
Andy Hungb68f5eb2019-12-03 16:49:17 -08003237 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
3238 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
3239 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
3240 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
3241 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
3242 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mNormalFrameCount)
3243 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
3244 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
3245 (int32_t)mHapticChannelMask)
3246 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
3247 (int32_t)mHapticChannelCount)
3248 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
3249 formatToString(mHALFormat).c_str())
3250 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
3251 (int32_t)mFrameCount) // sic - added HAL
3252 ;
3253 uint32_t latencyMs;
3254 if (mOutput->stream->getLatency(&latencyMs) == NO_ERROR) {
3255 item.set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_LATENCYMS, (double)latencyMs);
3256 }
3257 item.record();
Eric Laurent81784c32012-11-19 14:55:58 -08003258}
3259
Vlad Popa7e81cea2023-01-19 16:34:16 +01003260AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::PlaybackThread::updateMetadata_l()
Kevin Rocard069c2712018-03-29 19:09:14 -07003261{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08003262 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +01003263 return {}; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07003264 }
3265 StreamOutHalInterface::SourceMetadata metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07003266 auto backInserter = std::back_inserter(metadata.tracks);
Kevin Rocard069c2712018-03-29 19:09:14 -07003267 for (const sp<Track> &track : mActiveTracks) {
3268 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent49e39282022-06-24 18:42:45 +02003269 track->copyMetadataTo(backInserter);
Kevin Rocard069c2712018-03-29 19:09:14 -07003270 }
Kevin Rocard12381092018-04-11 09:19:59 -07003271 sendMetadataToBackend_l(metadata);
Vlad Popa7e81cea2023-01-19 16:34:16 +01003272 MetadataUpdate change;
3273 change.playbackMetadataUpdate = metadata.tracks;
3274 return change;
Kevin Rocard80ee2722018-04-11 15:53:48 +00003275}
Kevin Rocardc86a7f72018-04-03 09:00:09 -07003276
Kevin Rocard12381092018-04-11 09:19:59 -07003277void AudioFlinger::PlaybackThread::sendMetadataToBackend_l(
3278 const StreamOutHalInterface::SourceMetadata& metadata)
3279{
3280 mOutput->stream->updateSourceMetadata(metadata);
3281};
3282
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003283status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08003284{
3285 if (halFrames == NULL || dspFrames == NULL) {
3286 return BAD_VALUE;
3287 }
3288 Mutex::Autolock _l(mLock);
3289 if (initCheck() != NO_ERROR) {
3290 return INVALID_OPERATION;
3291 }
Andy Hung818e7a32016-02-16 18:08:07 -08003292 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08003293 *halFrames = framesWritten;
3294
3295 if (isSuspended()) {
3296 // return an estimation of rendered frames when the output is suspended
3297 size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08003298 *dspFrames = (uint32_t)
3299 (framesWritten >= (int64_t)latencyFrames ? framesWritten - latencyFrames : 0);
Eric Laurent81784c32012-11-19 14:55:58 -08003300 return NO_ERROR;
3301 } else {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003302 status_t status;
3303 uint32_t frames;
Phil Burk062e67a2015-02-11 13:40:50 -08003304 status = mOutput->getRenderPosition(&frames);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003305 *dspFrames = (size_t)frames;
3306 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08003307 }
3308}
3309
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08003310product_strategy_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08003311{
3312 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
3313 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
3314 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurentd66d7a12021-07-13 13:35:32 +02003315 return getStrategyForStream(AUDIO_STREAM_MUSIC);
Eric Laurent81784c32012-11-19 14:55:58 -08003316 }
3317 for (size_t i = 0; i < mTracks.size(); i++) {
3318 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08003319 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurentd66d7a12021-07-13 13:35:32 +02003320 return getStrategyForStream(track->streamType());
Eric Laurent81784c32012-11-19 14:55:58 -08003321 }
3322 }
Eric Laurentd66d7a12021-07-13 13:35:32 +02003323 return getStrategyForStream(AUDIO_STREAM_MUSIC);
Eric Laurent81784c32012-11-19 14:55:58 -08003324}
3325
3326
Phil Burk062e67a2015-02-11 13:40:50 -08003327AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
Eric Laurent81784c32012-11-19 14:55:58 -08003328{
3329 Mutex::Autolock _l(mLock);
3330 return mOutput;
3331}
3332
Phil Burk062e67a2015-02-11 13:40:50 -08003333AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
Eric Laurent81784c32012-11-19 14:55:58 -08003334{
3335 Mutex::Autolock _l(mLock);
3336 AudioStreamOut *output = mOutput;
3337 mOutput = NULL;
3338 // FIXME FastMixer might also have a raw ptr to mOutputSink;
3339 // must push a NULL and wait for ack
3340 mOutputSink.clear();
3341 mPipeSink.clear();
3342 mNormalSink.clear();
3343 return output;
3344}
3345
3346// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003347sp<StreamHalInterface> AudioFlinger::PlaybackThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08003348{
3349 if (mOutput == NULL) {
3350 return NULL;
3351 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003352 return mOutput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08003353}
3354
3355uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
3356{
3357 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
3358}
3359
Andy Hunge45f2192023-05-15 19:02:55 -07003360status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -08003361{
3362 if (!isValidSyncEvent(event)) {
3363 return BAD_VALUE;
3364 }
3365
3366 Mutex::Autolock _l(mLock);
3367
3368 for (size_t i = 0; i < mTracks.size(); ++i) {
3369 sp<Track> track = mTracks[i];
3370 if (event->triggerSession() == track->sessionId()) {
3371 (void) track->setSyncEvent(event);
3372 return NO_ERROR;
3373 }
3374 }
3375
3376 return NAME_NOT_FOUND;
3377}
3378
Andy Hunge45f2192023-05-15 19:02:55 -07003379bool AudioFlinger::PlaybackThread::isValidSyncEvent(
3380 const sp<audioflinger::SyncEvent>& event) const
Eric Laurent81784c32012-11-19 14:55:58 -08003381{
3382 return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
3383}
3384
3385void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
Jing Mike537412f2023-03-12 11:01:47 +08003386 [[maybe_unused]] const Vector< sp<Track> >& tracksToRemove)
Eric Laurent81784c32012-11-19 14:55:58 -08003387{
Andy Hungfe726a62018-09-27 15:17:25 -07003388 // Miscellaneous track cleanup when removed from the active list,
3389 // called without Thread lock but synchronized with threadLoop processing.
Eric Laurentbfb1b832013-01-07 09:53:42 -08003390#ifdef ADD_BATTERY_DATA
Andy Hungfe726a62018-09-27 15:17:25 -07003391 for (const auto& track : tracksToRemove) {
3392 if (track->isExternalTrack()) {
3393 // to track the speaker usage
3394 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Eric Laurent81784c32012-11-19 14:55:58 -08003395 }
3396 }
Andy Hungfe726a62018-09-27 15:17:25 -07003397#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003398}
3399
3400void AudioFlinger::PlaybackThread::checkSilentMode_l()
3401{
3402 if (!mMasterMute) {
3403 char value[PROPERTY_VALUE_MAX];
jiabin0a957d32020-04-29 10:56:20 -07003404 if (mOutDeviceTypeAddrs.empty()) {
3405 ALOGD("ro.audio.silent is ignored since no output device is set");
3406 return;
3407 }
jiabinc52b1ff2019-10-31 17:20:42 -07003408 if (isSingleDeviceType(outDeviceTypes(), AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) {
Jean-Michel Trivi32f37c22016-03-31 16:00:32 -07003409 ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
3410 return;
3411 }
Eric Laurent81784c32012-11-19 14:55:58 -08003412 if (property_get("ro.audio.silent", value, "0") > 0) {
3413 char *endptr;
3414 unsigned long ul = strtoul(value, &endptr, 0);
3415 if (*endptr == '\0' && ul != 0) {
3416 ALOGD("Silence is golden");
3417 // The setprop command will not allow a property to be changed after
3418 // the first time it is set, so we don't have to worry about un-muting.
3419 setMasterMute_l(true);
3420 }
3421 }
3422 }
3423}
3424
3425// shared by MIXER and DIRECT, overridden by DUPLICATING
Eric Laurentbfb1b832013-01-07 09:53:42 -08003426ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08003427{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003428 LOG_HIST_TS();
Eric Laurent81784c32012-11-19 14:55:58 -08003429 mInWrite = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003430 ssize_t bytesWritten;
Andy Hung010a1a12014-03-13 13:57:33 -07003431 const size_t offset = mCurrentWriteLength - mBytesRemaining;
Eric Laurent81784c32012-11-19 14:55:58 -08003432
3433 // If an NBAIO sink is present, use it to write the normal mixer's submix
3434 if (mNormalSink != 0) {
Glenn Kasten4c053ea2014-09-28 14:41:07 -07003435
Andy Hung010a1a12014-03-13 13:57:33 -07003436 const size_t count = mBytesRemaining / mFrameSize;
3437
Simon Wilson2d590962012-11-29 15:18:50 -08003438 ATRACE_BEGIN("write");
Eric Laurent81784c32012-11-19 14:55:58 -08003439 // update the setpoint when AudioFlinger::mScreenState changes
3440 uint32_t screenState = AudioFlinger::mScreenState;
3441 if (screenState != mScreenState) {
3442 mScreenState = screenState;
3443 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
3444 if (pipe != NULL) {
3445 pipe->setAvgFrames((mScreenState & 1) ?
3446 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
3447 }
3448 }
Andy Hung010a1a12014-03-13 13:57:33 -07003449 ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
Simon Wilson2d590962012-11-29 15:18:50 -08003450 ATRACE_END();
Vlad Popab042ee62022-10-20 18:05:00 +02003451
Eric Laurent81784c32012-11-19 14:55:58 -08003452 if (framesWritten > 0) {
Andy Hung010a1a12014-03-13 13:57:33 -07003453 bytesWritten = framesWritten * mFrameSize;
Andy Hung58e32872022-11-15 16:12:24 -08003454
Andy Hung8946a282018-04-19 20:04:56 -07003455#ifdef TEE_SINK
3456 mTee.write((char *)mSinkBuffer + offset, framesWritten);
3457#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003458 } else {
3459 bytesWritten = framesWritten;
3460 }
3461 // otherwise use the HAL / AudioStreamOut directly
3462 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003463 // Direct output and offload threads
Andy Hung010a1a12014-03-13 13:57:33 -07003464
Eric Laurentbfb1b832013-01-07 09:53:42 -08003465 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003466 ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
3467 mWriteAckSequence += 2;
3468 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003469 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003470 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003471 }
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07003472 ATRACE_BEGIN("write");
Glenn Kasten767094d2013-08-23 13:51:43 -07003473 // FIXME We should have an implementation of timestamps for direct output threads.
3474 // They are used e.g for multichannel PCM playback over HDMI.
Phil Burk062e67a2015-02-11 13:40:50 -08003475 bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07003476 ATRACE_END();
Eric Laurent51716182016-02-29 18:00:56 -08003477
Eric Laurentbfb1b832013-01-07 09:53:42 -08003478 if (mUseAsyncWrite &&
3479 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
3480 // do not wait for async callback in case of error of full write
Eric Laurent3b4529e2013-09-05 18:09:19 -07003481 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003482 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003483 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003484 }
Eric Laurent81784c32012-11-19 14:55:58 -08003485 }
3486
Eric Laurent81784c32012-11-19 14:55:58 -08003487 mNumWrites++;
3488 mInWrite = false;
Andy Hungcf10d742020-04-28 15:38:24 -07003489 if (mStandby) {
3490 mThreadMetrics.logBeginInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07003491 mThreadSnapshot.onBegin();
Andy Hungcf10d742020-04-28 15:38:24 -07003492 mStandby = false;
3493 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003494 return bytesWritten;
3495}
3496
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01003497// startMelComputation_l() must be called with AudioFlinger::mLock held
3498void AudioFlinger::PlaybackThread::startMelComputation_l(
Vlad Popaf09e93f2022-10-31 16:27:12 +01003499 const sp<audio_utils::MelProcessor>& processor)
Vlad Popab042ee62022-10-20 18:05:00 +02003500{
Vlad Popa3c7a2662023-02-14 20:09:47 +01003501 auto outputSink = static_cast<AudioStreamOutSink*>(mOutputSink.get());
Vlad Popa1a0c3ab2023-03-17 01:07:01 +01003502 if (outputSink != nullptr) {
3503 outputSink->startMelComputation(processor);
3504 }
Vlad Popab042ee62022-10-20 18:05:00 +02003505}
3506
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01003507// stopMelComputation_l() must be called with AudioFlinger::mLock held
3508void AudioFlinger::PlaybackThread::stopMelComputation_l()
Vlad Popa3c7a2662023-02-14 20:09:47 +01003509{
3510 auto outputSink = static_cast<AudioStreamOutSink*>(mOutputSink.get());
Vlad Popa1a0c3ab2023-03-17 01:07:01 +01003511 if (outputSink != nullptr) {
3512 outputSink->stopMelComputation();
3513 }
Vlad Popab042ee62022-10-20 18:05:00 +02003514}
3515
Eric Laurentbfb1b832013-01-07 09:53:42 -08003516void AudioFlinger::PlaybackThread::threadLoop_drain()
3517{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003518 bool supportsDrain = false;
3519 if (mOutput->stream->supportsDrain(&supportsDrain) == OK && supportsDrain) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003520 ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
3521 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003522 ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
3523 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003524 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003525 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003526 }
Mikhail Naganovcbc8f612016-10-11 18:05:13 -07003527 status_t result = mOutput->stream->drain(mMixerStatus == MIXER_DRAIN_TRACK);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003528 ALOGE_IF(result != OK, "Error when draining stream: %d", result);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003529 }
3530}
3531
3532void AudioFlinger::PlaybackThread::threadLoop_exit()
3533{
Eric Laurent275e8e92014-11-30 15:14:47 -08003534 {
3535 Mutex::Autolock _l(mLock);
3536 for (size_t i = 0; i < mTracks.size(); i++) {
3537 sp<Track> track = mTracks[i];
3538 track->invalidate();
3539 }
Andy Hungdae27702016-10-31 14:01:16 -07003540 // Clear ActiveTracks to update BatteryNotifier in case active tracks remain.
3541 // After we exit there are no more track changes sent to BatteryNotifier
3542 // because that requires an active threadLoop.
3543 // TODO: should we decActiveTrackCnt() of the cleared track effect chain?
3544 mActiveTracks.clear();
Eric Laurent275e8e92014-11-30 15:14:47 -08003545 }
Eric Laurent81784c32012-11-19 14:55:58 -08003546}
3547
3548/*
3549The derived values that are cached:
Andy Hung25c2dac2014-02-27 14:56:00 -08003550 - mSinkBufferSize from frame count * frame size
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003551 - mActiveSleepTimeUs from activeSleepTimeUs()
3552 - mIdleSleepTimeUs from idleSleepTimeUs()
Eric Laurent42537be2016-01-08 17:16:42 -08003553 - mStandbyDelayNs from mActiveSleepTimeUs (DIRECT only) or forced to at least
3554 kDefaultStandbyTimeInNsecs when connected to an A2DP device.
Eric Laurent81784c32012-11-19 14:55:58 -08003555 - maxPeriod from frame count and sample rate (MIXER only)
3556
3557The parameters that affect these derived values are:
3558 - frame count
3559 - frame size
3560 - sample rate
3561 - device type: A2DP or not
3562 - device latency
3563 - format: PCM or not
3564 - active sleep time
3565 - idle sleep time
3566*/
3567
3568void AudioFlinger::PlaybackThread::cacheParameters_l()
3569{
Andy Hung25c2dac2014-02-27 14:56:00 -08003570 mSinkBufferSize = mNormalFrameCount * mFrameSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003571 mActiveSleepTimeUs = activeSleepTimeUs();
3572 mIdleSleepTimeUs = idleSleepTimeUs();
Eric Laurent42537be2016-01-08 17:16:42 -08003573
Eric Laurent52568142022-10-28 11:23:28 +02003574 mStandbyDelayNs = AudioFlinger::mStandbyTimeInNsecs;
3575 // Shorten standby delay on VOIP RX output to avoid delayed routing updates
3576 // after a call due to call end tone.
3577 if (mOutput != nullptr && (mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
3578 const nsecs_t NS_PER_MS = 1000000;
3579 mStandbyDelayNs = std::min(mStandbyDelayNs, latency_l() * NS_PER_MS);
3580 }
Eric Laurent42537be2016-01-08 17:16:42 -08003581 // make sure standby delay is not too short when connected to an A2DP sink to avoid
3582 // truncating audio when going to standby.
jiabinc52b1ff2019-10-31 17:20:42 -07003583 if (!Intersection(outDeviceTypes(), getAudioDeviceOutAllA2dpSet()).empty()) {
Eric Laurent42537be2016-01-08 17:16:42 -08003584 if (mStandbyDelayNs < kDefaultStandbyTimeInNsecs) {
3585 mStandbyDelayNs = kDefaultStandbyTimeInNsecs;
3586 }
3587 }
Eric Laurent81784c32012-11-19 14:55:58 -08003588}
3589
Eric Laurent13084622016-05-17 10:51:49 -07003590bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
Eric Laurent81784c32012-11-19 14:55:58 -08003591{
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003592 ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
Eric Laurent81784c32012-11-19 14:55:58 -08003593 this, streamType, mTracks.size());
Eric Laurent13084622016-05-17 10:51:49 -07003594 bool trackMatch = false;
Eric Laurent81784c32012-11-19 14:55:58 -08003595 size_t size = mTracks.size();
3596 for (size_t i = 0; i < size; i++) {
3597 sp<Track> t = mTracks[i];
Eric Laurentd60560a2015-04-10 11:31:20 -07003598 if (t->streamType() == streamType && t->isExternalTrack()) {
Glenn Kasten5736c352012-12-04 12:12:34 -08003599 t->invalidate();
Eric Laurent13084622016-05-17 10:51:49 -07003600 trackMatch = true;
Eric Laurent81784c32012-11-19 14:55:58 -08003601 }
3602 }
Eric Laurent13084622016-05-17 10:51:49 -07003603 return trackMatch;
Eric Laurent81784c32012-11-19 14:55:58 -08003604}
3605
Haynes Mathew George05317d22016-05-03 16:34:26 -07003606void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
3607{
3608 Mutex::Autolock _l(mLock);
3609 invalidateTracks_l(streamType);
3610}
3611
jiabinc44b3462022-12-08 12:52:31 -08003612void AudioFlinger::PlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
3613 Mutex::Autolock _l(mLock);
3614 invalidateTracks_l(portIds);
3615}
3616
3617bool AudioFlinger::PlaybackThread::invalidateTracks_l(std::set<audio_port_handle_t>& portIds) {
3618 bool trackMatch = false;
3619 const size_t size = mTracks.size();
3620 for (size_t i = 0; i < size; i++) {
3621 sp<Track> t = mTracks[i];
3622 if (t->isExternalTrack() && portIds.find(t->portId()) != portIds.end()) {
3623 t->invalidate();
3624 portIds.erase(t->portId());
3625 trackMatch = true;
3626 }
3627 if (portIds.empty()) {
3628 break;
3629 }
3630 }
3631 return trackMatch;
3632}
3633
jiabinf042b9b2021-05-07 23:46:28 +00003634// getTrackById_l must be called with holding thread lock
3635AudioFlinger::PlaybackThread::Track* AudioFlinger::PlaybackThread::getTrackById_l(
3636 audio_port_handle_t trackPortId) {
3637 for (size_t i = 0; i < mTracks.size(); i++) {
3638 if (mTracks[i]->portId() == trackPortId) {
3639 return mTracks[i].get();
3640 }
3641 }
3642 return nullptr;
3643}
3644
Eric Laurent81784c32012-11-19 14:55:58 -08003645status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
3646{
Glenn Kastend848eb42016-03-08 13:42:11 -08003647 audio_session_t session = chain->sessionId();
Mikhail Naganov022b9952017-01-04 16:36:51 -08003648 sp<EffectBufferHalInterface> halInBuffer, halOutBuffer;
Eric Laurentb62d0362021-10-26 17:40:18 +02003649 effect_buffer_t *buffer = nullptr; // only used for non global sessions
3650
Andy Hungd3639922022-04-28 18:00:49 -07003651 if (mType == SPATIALIZER) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003652 if (!audio_is_global_session(session)) {
3653 // player sessions on a spatializer output will use a dedicated input buffer and
3654 // will either output multi channel to mEffectBuffer if the track is spatilaized
3655 // or stereo to mPostSpatializerBuffer if not spatialized.
3656 uint32_t channelMask;
3657 bool isSessionSpatialized =
3658 (hasAudioSession_l(session) & ThreadBase::SPATIALIZED_SESSION) != 0;
3659 if (isSessionSpatialized) {
3660 channelMask = mMixerChannelMask;
3661 } else {
3662 channelMask = mChannelMask;
3663 }
Eric Laurentf1f22e72021-07-13 14:04:14 +02003664 size_t numSamples = mNormalFrameCount
Eric Laurentb62d0362021-10-26 17:40:18 +02003665 * (audio_channel_count_from_out_mask(channelMask) + mHapticChannelCount);
Kevin Rocard7588ff42018-01-08 11:11:30 -08003666 status_t result = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
rago94a1ee82017-07-21 15:11:02 -07003667 numSamples * sizeof(effect_buffer_t),
Mikhail Naganov022b9952017-01-04 16:36:51 -08003668 &halInBuffer);
3669 if (result != OK) return result;
Eric Laurentb62d0362021-10-26 17:40:18 +02003670
3671 result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
3672 isSessionSpatialized ? mEffectBuffer : mPostSpatializerBuffer,
3673 isSessionSpatialized ? mEffectBufferSize : mPostSpatializerBufferSize,
3674 &halOutBuffer);
3675 if (result != OK) return result;
3676
rago94a1ee82017-07-21 15:11:02 -07003677#ifdef FLOAT_EFFECT_CHAIN
Shunkai Yao44bdbad2023-01-14 05:11:58 +00003678 buffer = halInBuffer ? halInBuffer->audioBuffer()->f32 : buffer;
rago94a1ee82017-07-21 15:11:02 -07003679#else
Shunkai Yao44bdbad2023-01-14 05:11:58 +00003680 buffer = halInBuffer ? halInBuffer->audioBuffer()->s16 : buffer;
rago94a1ee82017-07-21 15:11:02 -07003681#endif
Mikhail Naganov022b9952017-01-04 16:36:51 -08003682 ALOGV("addEffectChain_l() creating new input buffer %p session %d",
3683 buffer, session);
Eric Laurentb62d0362021-10-26 17:40:18 +02003684 } else {
3685 // A global session on a SPATIALIZER thread is either OUTPUT_STAGE or DEVICE
3686 // - OUTPUT_STAGE session uses the mEffectBuffer as input buffer and
3687 // mPostSpatializerBuffer as output buffer
3688 // - DEVICE session uses the mPostSpatializerBuffer as input and output buffer.
3689 status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
3690 mEffectBuffer, mEffectBufferSize, &halInBuffer);
3691 if (result != OK) return result;
3692 result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
3693 mPostSpatializerBuffer, mPostSpatializerBufferSize, &halOutBuffer);
3694 if (result != OK) return result;
Eric Laurent81784c32012-11-19 14:55:58 -08003695
Eric Laurentb62d0362021-10-26 17:40:18 +02003696 if (session == AUDIO_SESSION_DEVICE) {
3697 halInBuffer = halOutBuffer;
3698 }
3699 }
3700 } else {
3701 status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
3702 mEffectBufferEnabled ? mEffectBuffer : mSinkBuffer,
3703 mEffectBufferEnabled ? mEffectBufferSize : mSinkBufferSize,
3704 &halInBuffer);
3705 if (result != OK) return result;
3706 halOutBuffer = halInBuffer;
3707 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
3708 if (!audio_is_global_session(session)) {
Shunkai Yao44bdbad2023-01-14 05:11:58 +00003709 buffer = halInBuffer ? reinterpret_cast<effect_buffer_t*>(halInBuffer->externalData())
3710 : buffer;
Eric Laurentb62d0362021-10-26 17:40:18 +02003711 // Only one effect chain can be present in direct output thread and it uses
3712 // the sink buffer as input
3713 if (mType != DIRECT) {
3714 size_t numSamples = mNormalFrameCount
3715 * (audio_channel_count_from_out_mask(mMixerChannelMask)
3716 + mHapticChannelCount);
Andy Hung920f6572022-10-06 12:09:49 -07003717 const status_t allocateStatus = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
Eric Laurentb62d0362021-10-26 17:40:18 +02003718 numSamples * sizeof(effect_buffer_t),
3719 &halInBuffer);
Andy Hung920f6572022-10-06 12:09:49 -07003720 if (allocateStatus != OK) return allocateStatus;
Eric Laurentb62d0362021-10-26 17:40:18 +02003721#ifdef FLOAT_EFFECT_CHAIN
Shunkai Yao44bdbad2023-01-14 05:11:58 +00003722 buffer = halInBuffer ? halInBuffer->audioBuffer()->f32 : buffer;
Eric Laurentb62d0362021-10-26 17:40:18 +02003723#else
Shunkai Yao44bdbad2023-01-14 05:11:58 +00003724 buffer = halInBuffer ? halInBuffer->audioBuffer()->s16 : buffer;
Eric Laurentb62d0362021-10-26 17:40:18 +02003725#endif
3726 ALOGV("addEffectChain_l() creating new input buffer %p session %d",
3727 buffer, session);
3728 }
3729 }
3730 }
3731
3732 if (!audio_is_global_session(session)) {
Eric Laurent81784c32012-11-19 14:55:58 -08003733 // Attach all tracks with same session ID to this chain.
3734 for (size_t i = 0; i < mTracks.size(); ++i) {
3735 sp<Track> track = mTracks[i];
3736 if (session == track->sessionId()) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003737 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p",
3738 track.get(), buffer);
Eric Laurent81784c32012-11-19 14:55:58 -08003739 track->setMainBuffer(buffer);
3740 chain->incTrackCnt();
3741 }
3742 }
3743
3744 // indicate all active tracks in the chain
Andy Hungdae27702016-10-31 14:01:16 -07003745 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003746 if (session == track->sessionId()) {
Eric Laurentb62d0362021-10-26 17:40:18 +02003747 ALOGV("addEffectChain_l() activating track %p on session %d",
3748 track.get(), session);
Eric Laurent81784c32012-11-19 14:55:58 -08003749 chain->incActiveTrackCnt();
3750 }
3751 }
3752 }
Eric Laurentb62d0362021-10-26 17:40:18 +02003753
Eric Laurentaaa44472014-09-12 17:41:50 -07003754 chain->setThread(this);
Mikhail Naganov022b9952017-01-04 16:36:51 -08003755 chain->setInBuffer(halInBuffer);
3756 chain->setOutBuffer(halOutBuffer);
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003757 // Effect chain for session AUDIO_SESSION_DEVICE is inserted at end of effect
3758 // chains list in order to be processed last as it contains output device effects.
3759 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted just before to apply post
3760 // processing effects specific to an output stream before effects applied to all streams
3761 // routed to a given device.
Eric Laurent81784c32012-11-19 14:55:58 -08003762 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
3763 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
Glenn Kastend848eb42016-03-08 13:42:11 -08003764 // after track specific effects and before output stage.
Eric Laurent81784c32012-11-19 14:55:58 -08003765 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
Glenn Kastend848eb42016-03-08 13:42:11 -08003766 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX.
Eric Laurent81784c32012-11-19 14:55:58 -08003767 // Effect chain for other sessions are inserted at beginning of effect
3768 // chains list to be processed before output mix effects. Relative order between other
Glenn Kastend848eb42016-03-08 13:42:11 -08003769 // sessions is not important.
3770 static_assert(AUDIO_SESSION_OUTPUT_MIX == 0 &&
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003771 AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX &&
3772 AUDIO_SESSION_DEVICE < AUDIO_SESSION_OUTPUT_STAGE,
Glenn Kastend848eb42016-03-08 13:42:11 -08003773 "audio_session_t constants misdefined");
Eric Laurent81784c32012-11-19 14:55:58 -08003774 size_t size = mEffectChains.size();
3775 size_t i = 0;
3776 for (i = 0; i < size; i++) {
3777 if (mEffectChains[i]->sessionId() < session) {
3778 break;
3779 }
3780 }
3781 mEffectChains.insertAt(chain, i);
3782 checkSuspendOnAddEffectChain_l(chain);
3783
3784 return NO_ERROR;
3785}
3786
3787size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
3788{
Glenn Kastend848eb42016-03-08 13:42:11 -08003789 audio_session_t session = chain->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08003790
3791 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
3792
3793 for (size_t i = 0; i < mEffectChains.size(); i++) {
3794 if (chain == mEffectChains[i]) {
3795 mEffectChains.removeAt(i);
3796 // detach all active tracks from the chain
Andy Hungdae27702016-10-31 14:01:16 -07003797 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003798 if (session == track->sessionId()) {
3799 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
3800 chain.get(), session);
3801 chain->decActiveTrackCnt();
3802 }
3803 }
3804
3805 // detach all tracks with same session ID from this chain
Andy Hung920f6572022-10-06 12:09:49 -07003806 for (size_t j = 0; j < mTracks.size(); ++j) {
3807 sp<Track> track = mTracks[j];
Eric Laurent81784c32012-11-19 14:55:58 -08003808 if (session == track->sessionId()) {
rago94a1ee82017-07-21 15:11:02 -07003809 track->setMainBuffer(reinterpret_cast<effect_buffer_t*>(mSinkBuffer));
Eric Laurent81784c32012-11-19 14:55:58 -08003810 chain->decTrackCnt();
3811 }
3812 }
3813 break;
3814 }
3815 }
3816 return mEffectChains.size();
3817}
3818
3819status_t AudioFlinger::PlaybackThread::attachAuxEffect(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003820 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003821{
3822 Mutex::Autolock _l(mLock);
3823 return attachAuxEffect_l(track, EffectId);
3824}
3825
3826status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003827 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003828{
3829 status_t status = NO_ERROR;
3830
3831 if (EffectId == 0) {
3832 track->setAuxBuffer(0, NULL);
3833 } else {
3834 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
3835 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
3836 if (effect != 0) {
3837 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
3838 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
3839 } else {
3840 status = INVALID_OPERATION;
3841 }
3842 } else {
3843 status = BAD_VALUE;
3844 }
3845 }
3846 return status;
3847}
3848
3849void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
3850{
3851 for (size_t i = 0; i < mTracks.size(); ++i) {
3852 sp<Track> track = mTracks[i];
3853 if (track->auxEffectId() == effectId) {
3854 attachAuxEffect_l(track, 0);
3855 }
3856 }
3857}
3858
3859bool AudioFlinger::PlaybackThread::threadLoop()
Andy Hung920f6572022-10-06 12:09:49 -07003860NO_THREAD_SAFETY_ANALYSIS // manual locking of AudioFlinger
Eric Laurent81784c32012-11-19 14:55:58 -08003861{
Glenn Kasten388d5712017-04-07 14:38:41 -07003862 tlNBLogWriter = mNBLogWriter.get();
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003863
Eric Laurent81784c32012-11-19 14:55:58 -08003864 Vector< sp<Track> > tracksToRemove;
3865
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003866 mStandbyTimeNs = systemTime();
Andy Hung446f4df2019-02-21 12:26:41 -08003867 int64_t lastLoopCountWritten = -2; // never matches "previous" loop, when loopCount = 0.
Eric Laurent81784c32012-11-19 14:55:58 -08003868
3869 // MIXER
3870 nsecs_t lastWarning = 0;
3871
3872 // DUPLICATING
3873 // FIXME could this be made local to while loop?
3874 writeFrames = 0;
3875
3876 cacheParameters_l();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003877 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003878
Andy Hungd3639922022-04-28 18:00:49 -07003879 if (mType == MIXER || mType == SPATIALIZER) {
Eric Laurent81784c32012-11-19 14:55:58 -08003880 sleepTimeShift = 0;
3881 }
3882
3883 CpuStats cpuStats;
3884 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
3885
3886 acquireWakeLock();
3887
Glenn Kasteneef598c2017-04-03 14:41:13 -07003888 // mNBLogWriter logging APIs can only be called by a single thread, typically the
3889 // thread associated with this PlaybackThread.
3890 // If you want to share the mNBLogWriter with other threads (for example, binder threads)
3891 // then all such threads must agree to hold a common mutex before logging.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003892 // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
3893 // and then that string will be logged at the next convenient opportunity.
Glenn Kasteneef598c2017-04-03 14:41:13 -07003894 // See reference to logString below.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003895 const char *logString = NULL;
3896
rago1bb90822017-05-02 18:31:48 -07003897 // Estimated time for next buffer to be written to hal. This is used only on
3898 // suspended mode (for now) to help schedule the wait time until next iteration.
3899 nsecs_t timeLoopNextNs = 0;
3900
Eric Laurent664539d2013-09-23 18:24:31 -07003901 checkSilentMode_l();
Glenn Kasteneef598c2017-04-03 14:41:13 -07003902
Andy Hung2dbffc22018-08-08 18:50:41 -07003903 audio_patch_handle_t lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Andy Hungf3234512018-07-03 14:51:47 -07003904
Eric Laurentb3f315a2021-07-13 15:09:05 +02003905 sendCheckOutputStageEffectsEvent();
3906
Andy Hung446f4df2019-02-21 12:26:41 -08003907 // loopCount is used for statistics and diagnostics.
3908 for (int64_t loopCount = 0; !exitPending(); ++loopCount)
Eric Laurent81784c32012-11-19 14:55:58 -08003909 {
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08003910 // Log merge requests are performed during AudioFlinger binder transactions, but
3911 // that does not cover audio playback. It's requested here for that reason.
3912 mAudioFlinger->requestLogMerge();
3913
Eric Laurent81784c32012-11-19 14:55:58 -08003914 cpuStats.sample(myName);
3915
3916 Vector< sp<EffectChain> > effectChains;
Andy Hung6e6a2e62019-04-30 16:38:41 -07003917 audio_session_t activeHapticSessionId = AUDIO_SESSION_NONE;
Eric Laurentb62d0362021-10-26 17:40:18 +02003918 bool isHapticSessionSpatialized = false;
Andy Hungc1646382019-04-30 16:12:10 -07003919 std::vector<sp<Track>> activeTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08003920
Andy Hung2dbffc22018-08-08 18:50:41 -07003921 // If the device is AUDIO_DEVICE_OUT_BUS, check for downstream latency.
3922 //
jiabinc52b1ff2019-10-31 17:20:42 -07003923 // Note: we access outDeviceTypes() outside of mLock.
3924 if (isMsdDevice() && outDeviceTypes().count(AUDIO_DEVICE_OUT_BUS) != 0) {
Andy Hung2dbffc22018-08-08 18:50:41 -07003925 // Here, we try for the AF lock, but do not block on it as the latency
3926 // is more informational.
3927 if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
3928 std::vector<PatchPanel::SoftwarePatch> swPatches;
Andy Hung920f6572022-10-06 12:09:49 -07003929 double latencyMs = 0.; // not required; initialized for clang-tidy
Andy Hung2dbffc22018-08-08 18:50:41 -07003930 status_t status = INVALID_OPERATION;
3931 audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3932 if (mAudioFlinger->mPatchPanel.getDownstreamSoftwarePatches(id(), &swPatches) == OK
3933 && swPatches.size() > 0) {
3934 status = swPatches[0].getLatencyMs_l(&latencyMs);
3935 downstreamPatchHandle = swPatches[0].getPatchHandle();
3936 }
3937 if (downstreamPatchHandle != lastDownstreamPatchHandle) {
Dean Wheatley30d28422018-11-06 10:27:40 +11003938 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003939 lastDownstreamPatchHandle = downstreamPatchHandle;
3940 }
3941 if (status == OK) {
3942 // verify downstream latency (we assume a max reasonable
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003943 // latency of 5 seconds).
3944 const double minLatency = 0., maxLatency = 5000.;
3945 if (latencyMs >= minLatency && latencyMs <= maxLatency) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10003946 ALOGVV("new downstream latency %lf ms", latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003947 } else {
3948 ALOGD("out of range downstream latency %lf ms", latencyMs);
Andy Hung920f6572022-10-06 12:09:49 -07003949 latencyMs = std::clamp(latencyMs, minLatency, maxLatency);
Andy Hung2dbffc22018-08-08 18:50:41 -07003950 }
Dean Wheatley30d28422018-11-06 10:27:40 +11003951 mDownstreamLatencyStatMs.add(latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003952 }
3953 mAudioFlinger->mLock.unlock();
3954 }
3955 } else {
3956 if (lastDownstreamPatchHandle != AUDIO_PATCH_HANDLE_NONE) {
3957 // our device is no longer AUDIO_DEVICE_OUT_BUS, reset patch handle and stats.
Dean Wheatley30d28422018-11-06 10:27:40 +11003958 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003959 lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3960 }
3961 }
3962
Eric Laurentb3f315a2021-07-13 15:09:05 +02003963 if (mCheckOutputStageEffects.exchange(false)) {
3964 checkOutputStageEffects();
3965 }
3966
Vlad Popa7e81cea2023-01-19 16:34:16 +01003967 MetadataUpdate metadataUpdate;
Eric Laurent81784c32012-11-19 14:55:58 -08003968 { // scope for mLock
3969
3970 Mutex::Autolock _l(mLock);
3971
Eric Laurent021cf962014-05-13 10:18:14 -07003972 processConfigEvents_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +02003973 if (mCheckOutputStageEffects.load()) {
3974 continue;
3975 }
Eric Laurent10351942014-05-08 18:49:52 -07003976
Glenn Kasteneef598c2017-04-03 14:41:13 -07003977 // See comment at declaration of logString for why this is done under mLock
Glenn Kasten9e58b552013-01-18 15:09:48 -08003978 if (logString != NULL) {
3979 mNBLogWriter->logTimestamp();
3980 mNBLogWriter->log(logString);
3981 logString = NULL;
3982 }
3983
Dean Wheatley12473e92021-03-18 23:00:55 +11003984 collectTimestamps_l();
Andy Hungc8fddf32018-08-08 18:32:37 -07003985
Eric Laurent81784c32012-11-19 14:55:58 -08003986 saveOutputTracks();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003987 if (mSignalPending) {
3988 // A signal was raised while we were unlocked
3989 mSignalPending = false;
3990 } else if (waitingAsyncCallback_l()) {
3991 if (exitPending()) {
3992 break;
3993 }
Marco Nelissen078538c2015-05-12 09:17:57 -07003994 bool released = false;
Eric Laurent64667972016-03-30 18:19:46 -07003995 if (!keepWakeLock()) {
Marco Nelissen078538c2015-05-12 09:17:57 -07003996 releaseWakeLock_l();
3997 released = true;
3998 }
Andy Hung10cbff12017-02-21 17:30:14 -08003999
4000 const int64_t waitNs = computeWaitTimeNs_l();
4001 ALOGV("wait async completion (wait time: %lld)", (long long)waitNs);
4002 status_t status = mWaitWorkCV.waitRelative(mLock, waitNs);
4003 if (status == TIMED_OUT) {
4004 mSignalPending = true; // if timeout recheck everything
4005 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004006 ALOGV("async completion/wake");
Marco Nelissen078538c2015-05-12 09:17:57 -07004007 if (released) {
4008 acquireWakeLock_l();
4009 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004010 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
4011 mSleepTimeUs = 0;
Eric Laurentede6c3b2013-09-19 14:37:46 -07004012
4013 continue;
4014 }
Eric Tan39ec8d62018-07-24 09:49:29 -07004015 if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
Eric Laurentbfb1b832013-01-07 09:53:42 -08004016 isSuspended()) {
4017 // put audio hardware into standby after short delay
4018 if (shouldStandby_l()) {
Eric Laurent81784c32012-11-19 14:55:58 -08004019
4020 threadLoop_standby();
4021
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07004022 // This is where we go into standby
4023 if (!mStandby) {
4024 LOG_AUDIO_STATE();
Andy Hungcf10d742020-04-28 15:38:24 -07004025 mThreadMetrics.logEndInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07004026 mThreadSnapshot.onEnd();
Eric Laurent19952e12023-04-20 10:08:29 +02004027 setStandby_l();
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07004028 }
Andy Hungd0979812019-02-21 15:51:44 -08004029 sendStatistics(false /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -08004030 }
4031
Eric Tan39ec8d62018-07-24 09:49:29 -07004032 if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
Eric Laurent81784c32012-11-19 14:55:58 -08004033 // we're about to wait, flush the binder command buffer
4034 IPCThreadState::self()->flushCommands();
4035
4036 clearOutputTracks();
4037
4038 if (exitPending()) {
4039 break;
4040 }
4041
4042 releaseWakeLock_l();
4043 // wait until we have something to do...
4044 ALOGV("%s going to sleep", myName.string());
4045 mWaitWorkCV.wait(mLock);
4046 ALOGV("%s waking up", myName.string());
4047 acquireWakeLock_l();
4048
4049 mMixerStatus = MIXER_IDLE;
4050 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
4051 mBytesWritten = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004052 mBytesRemaining = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08004053 checkSilentMode_l();
4054
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004055 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
4056 mSleepTimeUs = mIdleSleepTimeUs;
Andy Hungd3639922022-04-28 18:00:49 -07004057 if (mType == MIXER || mType == SPATIALIZER) {
Eric Laurent81784c32012-11-19 14:55:58 -08004058 sleepTimeShift = 0;
4059 }
4060
4061 continue;
4062 }
4063 }
Eric Laurent81784c32012-11-19 14:55:58 -08004064 // mMixerStatusIgnoringFastTracks is also updated internally
4065 mMixerStatus = prepareTracks_l(&tracksToRemove);
4066
Andy Hungdae27702016-10-31 14:01:16 -07004067 mActiveTracks.updatePowerState(this);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08004068
Vlad Popa7e81cea2023-01-19 16:34:16 +01004069 metadataUpdate = updateMetadata_l();
Kevin Rocard069c2712018-03-29 19:09:14 -07004070
Eric Laurent81784c32012-11-19 14:55:58 -08004071 // prevent any changes in effect chain list and in each effect chain
4072 // during mixing and effect process as the audio buffers could be deleted
4073 // or modified if an effect is created or deleted
4074 lockEffectChains_l(effectChains);
Andy Hung6e6a2e62019-04-30 16:38:41 -07004075
4076 // Determine which session to pick up haptic data.
4077 // This must be done under the same lock as prepareTracks_l().
jiabineb3bda02020-06-30 14:07:03 -07004078 // The haptic data from the effect is at a higher priority than the one from track.
Andy Hung6e6a2e62019-04-30 16:38:41 -07004079 // TODO: Write haptic data directly to sink buffer when mixing.
Eric Laurentb62d0362021-10-26 17:40:18 +02004080 if (mHapticChannelCount > 0) {
Andy Hung6e6a2e62019-04-30 16:38:41 -07004081 for (const auto& track : mActiveTracks) {
jiabineb3bda02020-06-30 14:07:03 -07004082 sp<EffectChain> effectChain = getEffectChain_l(track->sessionId());
Eric Laurentb62d0362021-10-26 17:40:18 +02004083 if (effectChain != nullptr
4084 && effectChain->containsHapticGeneratingEffect_l()) {
jiabineb3bda02020-06-30 14:07:03 -07004085 activeHapticSessionId = track->sessionId();
Eric Laurentb62d0362021-10-26 17:40:18 +02004086 isHapticSessionSpatialized =
Eric Laurentb0a7bc92022-04-05 15:06:08 +02004087 mType == SPATIALIZER && track->isSpatialized();
jiabineb3bda02020-06-30 14:07:03 -07004088 break;
4089 }
Eric Laurentb62d0362021-10-26 17:40:18 +02004090 if (activeHapticSessionId == AUDIO_SESSION_NONE
4091 && track->getHapticPlaybackEnabled()) {
Andy Hung6e6a2e62019-04-30 16:38:41 -07004092 activeHapticSessionId = track->sessionId();
Eric Laurentb62d0362021-10-26 17:40:18 +02004093 isHapticSessionSpatialized =
Eric Laurentb0a7bc92022-04-05 15:06:08 +02004094 mType == SPATIALIZER && track->isSpatialized();
Andy Hung6e6a2e62019-04-30 16:38:41 -07004095 }
4096 }
4097 }
4098
Andy Hungc1646382019-04-30 16:12:10 -07004099 // Acquire a local copy of active tracks with lock (release w/o lock).
4100 //
4101 // Control methods on the track acquire the ThreadBase lock (e.g. start()
4102 // stop(), pause(), etc.), but the threadLoop is entitled to call audio
4103 // data / buffer methods on tracks from activeTracks without the ThreadBase lock.
4104 activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
Eric Laurent68a40a82022-05-03 18:15:04 +02004105
4106 setHalLatencyMode_l();
Eric Laurent19952e12023-04-20 10:08:29 +02004107
Jiabin Huangfb476842022-12-06 03:18:10 +00004108 for (const auto &track : mActiveTracks ) {
4109 track->updateTeePatches();
4110 }
4111
Eric Laurent19952e12023-04-20 10:08:29 +02004112 // signal actual start of output stream when the render position reported by the kernel
4113 // starts moving.
4114 if (!mStandby && !mHalStarted && mKernelPositionOnStandby !=
4115 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]) {
4116 mHalStarted = true;
4117 mWaitHalStartCV.broadcast();
4118 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08004119 } // mLock scope ends
Eric Laurent81784c32012-11-19 14:55:58 -08004120
Eric Laurentbfb1b832013-01-07 09:53:42 -08004121 if (mBytesRemaining == 0) {
4122 mCurrentWriteLength = 0;
4123 if (mMixerStatus == MIXER_TRACKS_READY) {
4124 // threadLoop_mix() sets mCurrentWriteLength
4125 threadLoop_mix();
4126 } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
4127 && (mMixerStatus != MIXER_DRAIN_ALL)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004128 // threadLoop_sleepTime sets mSleepTimeUs to 0 if data
Eric Laurentbfb1b832013-01-07 09:53:42 -08004129 // must be written to HAL
4130 threadLoop_sleepTime();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004131 if (mSleepTimeUs == 0) {
Andy Hung25c2dac2014-02-27 14:56:00 -08004132 mCurrentWriteLength = mSinkBufferSize;
Andy Hungc1646382019-04-30 16:12:10 -07004133
4134 // Tally underrun frames as we are inserting 0s here.
4135 for (const auto& track : activeTracks) {
Andy Hunge2e830f2019-12-03 12:54:46 -08004136 if (track->mFillingUpStatus == Track::FS_ACTIVE
4137 && !track->isStopped()
4138 && !track->isPaused()
4139 && !track->isTerminated()) {
4140 ALOGV("%s: track(%d) %s underrun due to thread sleep of %zu frames",
4141 __func__, track->id(), track->getTrackStateAsString(),
4142 mNormalFrameCount);
Andy Hungc1646382019-04-30 16:12:10 -07004143 track->mAudioTrackServerProxy->tallyUnderrunFrames(mNormalFrameCount);
4144 }
4145 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004146 }
4147 }
Andy Hung98ef9782014-03-04 14:46:50 -08004148 // Either threadLoop_mix() or threadLoop_sleepTime() should have set
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004149 // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
Andy Hung98ef9782014-03-04 14:46:50 -08004150 // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
jiabinc658e452022-10-21 20:52:21 +00004151 // or mSinkBuffer (if there are no effects and there is no data already copied to
4152 // mSinkBuffer).
Andy Hung98ef9782014-03-04 14:46:50 -08004153 //
4154 // This is done pre-effects computation; if effects change to
4155 // support higher precision, this needs to move.
4156 //
4157 // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004158 // TODO use mSleepTimeUs == 0 as an additional condition.
Eric Laurent39095982021-08-24 18:29:27 +02004159 uint32_t mixerChannelCount = mEffectBufferValid ?
4160 audio_channel_count_from_out_mask(mMixerChannelMask) : mChannelCount;
jiabinc658e452022-10-21 20:52:21 +00004161 if (mMixerBufferValid && (mEffectBufferValid || !mHasDataCopiedToSinkBuffer)) {
Andy Hung98ef9782014-03-04 14:46:50 -08004162 void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
4163 audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
4164
David Li88ee0902022-06-22 10:01:21 +08004165 // Apply mono blending and balancing if the effect buffer is not valid. Otherwise,
4166 // do these processes after effects are applied.
4167 if (!mEffectBufferValid) {
4168 // mono blend occurs for mixer threads only (not direct or offloaded)
4169 // and is handled here if we're going directly to the sink.
4170 if (requireMonoBlend()) {
4171 mono_blend(mMixerBuffer, mMixerBufferFormat, mChannelCount,
4172 mNormalFrameCount, true /*limit*/);
4173 }
Andy Hung2ddee192015-12-18 17:34:44 -08004174
David Li88ee0902022-06-22 10:01:21 +08004175 if (!hasFastMixer()) {
4176 // Balance must take effect after mono conversion.
4177 // We do it here if there is no FastMixer.
4178 // mBalance detects zero balance within the class for speed
4179 // (not needed here).
4180 mBalance.setBalance(mMasterBalance.load());
4181 mBalance.process((float *)mMixerBuffer, mNormalFrameCount);
4182 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004183 }
4184
Andy Hung98ef9782014-03-04 14:46:50 -08004185 memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
Eric Laurent39095982021-08-24 18:29:27 +02004186 mNormalFrameCount * (mixerChannelCount + mHapticChannelCount));
jiabin245cdd92018-12-07 17:55:15 -08004187
4188 // If we're going directly to the sink and there are haptic channels,
4189 // we should adjust channels as the sample data is partially interleaved
4190 // in this case.
4191 if (!mEffectBufferValid && mHapticChannelCount > 0) {
4192 adjust_channels_non_destructive(buffer, mChannelCount, buffer,
4193 mChannelCount + mHapticChannelCount,
4194 audio_bytes_per_sample(format),
4195 audio_bytes_per_frame(mChannelCount, format) * mNormalFrameCount);
4196 }
Andy Hung98ef9782014-03-04 14:46:50 -08004197 }
4198
Eric Laurentbfb1b832013-01-07 09:53:42 -08004199 mBytesRemaining = mCurrentWriteLength;
4200 if (isSuspended()) {
Andy Hung238fa3d2016-07-28 10:53:22 -07004201 // Simulate write to HAL when suspended (e.g. BT SCO phone call).
4202 mSleepTimeUs = suspendSleepTimeUs(); // assumes full buffer.
4203 const size_t framesRemaining = mBytesRemaining / mFrameSize;
4204 mBytesWritten += mBytesRemaining;
4205 mFramesWritten += framesRemaining;
4206 mSuspendedFrames += framesRemaining; // to adjust kernel HAL position
Eric Laurentbfb1b832013-01-07 09:53:42 -08004207 mBytesRemaining = 0;
4208 }
Eric Laurent81784c32012-11-19 14:55:58 -08004209
Eric Laurentbfb1b832013-01-07 09:53:42 -08004210 // only process effects if we're going to write
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004211 if (mSleepTimeUs == 0 && mType != OFFLOAD) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08004212 for (size_t i = 0; i < effectChains.size(); i ++) {
4213 effectChains[i]->process_l();
jiabin47affe52019-04-04 18:02:07 -07004214 // TODO: Write haptic data directly to sink buffer when mixing.
Andy Hung6e6a2e62019-04-30 16:38:41 -07004215 if (activeHapticSessionId != AUDIO_SESSION_NONE
4216 && activeHapticSessionId == effectChains[i]->sessionId()) {
jiabin47affe52019-04-04 18:02:07 -07004217 // Haptic data is active in this case, copy it directly from
4218 // in buffer to out buffer.
Eric Laurentb62d0362021-10-26 17:40:18 +02004219 uint32_t hapticSessionChannelCount = mEffectBufferValid ?
4220 audio_channel_count_from_out_mask(mMixerChannelMask) :
4221 mChannelCount;
4222 if (mType == SPATIALIZER && !isHapticSessionSpatialized) {
4223 hapticSessionChannelCount = mChannelCount;
4224 }
4225
jiabin47affe52019-04-04 18:02:07 -07004226 const size_t audioBufferSize = mNormalFrameCount
Eric Laurentb62d0362021-10-26 17:40:18 +02004227 * audio_bytes_per_frame(hapticSessionChannelCount,
4228 EFFECT_BUFFER_FORMAT);
jiabin47affe52019-04-04 18:02:07 -07004229 memcpy_by_audio_format(
4230 (uint8_t*)effectChains[i]->outBuffer() + audioBufferSize,
4231 EFFECT_BUFFER_FORMAT,
4232 (const uint8_t*)effectChains[i]->inBuffer() + audioBufferSize,
4233 EFFECT_BUFFER_FORMAT, mNormalFrameCount * mHapticChannelCount);
4234 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004235 }
Eric Laurent81784c32012-11-19 14:55:58 -08004236 }
4237 }
Eric Laurent59fe0102013-09-27 18:48:26 -07004238 // Process effect chains for offloaded thread even if no audio
4239 // was read from audio track: process only updates effect state
4240 // and thus does have to be synchronized with audio writes but may have
4241 // to be called while waiting for async write callback
4242 if (mType == OFFLOAD) {
4243 for (size_t i = 0; i < effectChains.size(); i ++) {
4244 effectChains[i]->process_l();
4245 }
4246 }
Eric Laurent81784c32012-11-19 14:55:58 -08004247
Andy Hung98ef9782014-03-04 14:46:50 -08004248 // Only if the Effects buffer is enabled and there is data in the
4249 // Effects buffer (buffer valid), we need to
4250 // copy into the sink buffer.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004251 // TODO use mSleepTimeUs == 0 as an additional condition.
jiabinc658e452022-10-21 20:52:21 +00004252 if (mEffectBufferValid && !mHasDataCopiedToSinkBuffer) {
Andy Hung98ef9782014-03-04 14:46:50 -08004253 //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
Eric Laurentb62d0362021-10-26 17:40:18 +02004254 void *effectBuffer = (mType == SPATIALIZER) ? mPostSpatializerBuffer : mEffectBuffer;
Andy Hung2ddee192015-12-18 17:34:44 -08004255 if (requireMonoBlend()) {
Eric Laurentb62d0362021-10-26 17:40:18 +02004256 mono_blend(effectBuffer, mEffectBufferFormat, mChannelCount, mNormalFrameCount,
Glenn Kasten03c48d52016-01-27 17:25:17 -08004257 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08004258 }
4259
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004260 if (!hasFastMixer()) {
4261 // Balance must take effect after mono conversion.
4262 // We do it here if there is no FastMixer.
4263 // mBalance detects zero balance within the class for speed (not needed here).
4264 mBalance.setBalance(mMasterBalance.load());
Eric Laurentb62d0362021-10-26 17:40:18 +02004265 mBalance.process((float *)effectBuffer, mNormalFrameCount);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004266 }
4267
Eric Laurentb62d0362021-10-26 17:40:18 +02004268 // for SPATIALIZER thread, Move haptics channels from mEffectBuffer to
4269 // mPostSpatializerBuffer if the haptics track is spatialized.
4270 // Otherwise, the haptics channels are already in mPostSpatializerBuffer.
4271 // For other thread types, the haptics channels are already in mEffectBuffer.
4272 if (mType == SPATIALIZER && isHapticSessionSpatialized) {
4273 const size_t srcBufferSize = mNormalFrameCount *
4274 audio_bytes_per_frame(audio_channel_count_from_out_mask(mMixerChannelMask),
4275 mEffectBufferFormat);
4276 const size_t dstBufferSize = mNormalFrameCount
4277 * audio_bytes_per_frame(mChannelCount, mEffectBufferFormat);
4278
4279 memcpy_by_audio_format((uint8_t*)mPostSpatializerBuffer + dstBufferSize,
4280 mEffectBufferFormat,
4281 (uint8_t*)mEffectBuffer + srcBufferSize,
4282 mEffectBufferFormat,
4283 mNormalFrameCount * mHapticChannelCount);
Eric Laurent39095982021-08-24 18:29:27 +02004284 }
Atneya Nairba9a1072022-09-19 17:51:37 -07004285 const size_t framesToCopy = mNormalFrameCount * (mChannelCount + mHapticChannelCount);
4286 if (mFormat == AUDIO_FORMAT_PCM_FLOAT &&
4287 mEffectBufferFormat == AUDIO_FORMAT_PCM_FLOAT) {
4288 // Clamp PCM float values more than this distance from 0 to insulate
4289 // a HAL which doesn't handle NaN correctly.
4290 static constexpr float HAL_FLOAT_SAMPLE_LIMIT = 2.0f;
4291 memcpy_to_float_from_float_with_clamping(static_cast<float*>(mSinkBuffer),
4292 static_cast<const float*>(effectBuffer),
4293 framesToCopy, HAL_FLOAT_SAMPLE_LIMIT /* absMax */);
4294 } else {
4295 memcpy_by_audio_format(mSinkBuffer, mFormat,
4296 effectBuffer, mEffectBufferFormat, framesToCopy);
4297 }
jiabin245cdd92018-12-07 17:55:15 -08004298 // The sample data is partially interleaved when haptic channels exist,
4299 // we need to adjust channels here.
4300 if (mHapticChannelCount > 0) {
4301 adjust_channels_non_destructive(mSinkBuffer, mChannelCount, mSinkBuffer,
4302 mChannelCount + mHapticChannelCount,
4303 audio_bytes_per_sample(mFormat),
4304 audio_bytes_per_frame(mChannelCount, mFormat) * mNormalFrameCount);
4305 }
Andy Hung98ef9782014-03-04 14:46:50 -08004306 }
4307
Eric Laurent81784c32012-11-19 14:55:58 -08004308 // enable changes in effect chain
4309 unlockEffectChains(effectChains);
4310
Vlad Popafce10862023-02-03 10:37:07 +01004311 if (!metadataUpdate.playbackMetadataUpdate.empty()) {
4312 mAudioFlinger->mMelReporter->updateMetadataForCsd(id(),
4313 metadataUpdate.playbackMetadataUpdate);
4314 }
4315
Eric Laurentbfb1b832013-01-07 09:53:42 -08004316 if (!waitingAsyncCallback()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004317 // mSleepTimeUs == 0 means we must write to audio hardware
4318 if (mSleepTimeUs == 0) {
Andy Hung08fb1742015-05-31 23:22:10 -07004319 ssize_t ret = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08004320 // writePeriodNs is updated >= 0 when ret > 0.
4321 int64_t writePeriodNs = -1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004322 if (mBytesRemaining) {
Andy Hung69488c42016-05-16 18:43:33 -07004323 // FIXME rewrite to reduce number of system calls
Andy Hung446f4df2019-02-21 12:26:41 -08004324 const int64_t lastIoBeginNs = systemTime();
Andy Hung08fb1742015-05-31 23:22:10 -07004325 ret = threadLoop_write();
Andy Hung446f4df2019-02-21 12:26:41 -08004326 const int64_t lastIoEndNs = systemTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004327 if (ret < 0) {
4328 mBytesRemaining = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08004329 } else if (ret > 0) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08004330 mBytesWritten += ret;
4331 mBytesRemaining -= ret;
Andy Hung446f4df2019-02-21 12:26:41 -08004332 const int64_t frames = ret / mFrameSize;
4333 mFramesWritten += frames;
4334
4335 writePeriodNs = lastIoEndNs - mLastIoEndNs;
4336 // process information relating to write time.
4337 if (audio_has_proportional_frames(mFormat)) {
4338 // we are in a continuous mixing cycle
4339 if (mMixerStatus == MIXER_TRACKS_READY &&
4340 loopCount == lastLoopCountWritten + 1) {
4341
4342 const double jitterMs =
4343 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
4344 {frames, writePeriodNs},
4345 {0, 0} /* lastTimestamp */, mSampleRate);
4346 const double processMs =
4347 (lastIoBeginNs - mLastIoEndNs) * 1e-6;
4348
4349 Mutex::Autolock _l(mLock);
4350 mIoJitterMs.add(jitterMs);
4351 mProcessTimeMs.add(processMs);
Robert Wu06db0a32021-08-10 19:05:34 +00004352
4353 if (mPipeSink.get() != nullptr) {
4354 // Using the Monopipe availableToWrite, we estimate the current
4355 // buffer size.
4356 MonoPipe* monoPipe = static_cast<MonoPipe*>(mPipeSink.get());
4357 const ssize_t
4358 availableToWrite = mPipeSink->availableToWrite();
4359 const size_t pipeFrames = monoPipe->maxFrames();
4360 const size_t
4361 remainingFrames = pipeFrames - max(availableToWrite, 0);
4362 mMonopipePipeDepthStats.add(remainingFrames);
4363 }
Andy Hung446f4df2019-02-21 12:26:41 -08004364 }
4365
4366 // write blocked detection
4367 const int64_t deltaWriteNs = lastIoEndNs - lastIoBeginNs;
Andy Hungd3639922022-04-28 18:00:49 -07004368 if ((mType == MIXER || mType == SPATIALIZER)
4369 && deltaWriteNs > maxPeriod) {
Andy Hung446f4df2019-02-21 12:26:41 -08004370 mNumDelayedWrites++;
4371 if ((lastIoEndNs - lastWarning) > kWarningThrottleNs) {
4372 ATRACE_NAME("underrun");
4373 ALOGW("write blocked for %lld msecs, "
4374 "%d delayed writes, thread %d",
4375 (long long)deltaWriteNs / NANOS_PER_MILLISECOND,
4376 mNumDelayedWrites, mId);
4377 lastWarning = lastIoEndNs;
4378 }
4379 }
4380 }
4381 // update timing info.
4382 mLastIoBeginNs = lastIoBeginNs;
4383 mLastIoEndNs = lastIoEndNs;
4384 lastLoopCountWritten = loopCount;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004385 }
4386 } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
4387 (mMixerStatus == MIXER_DRAIN_ALL)) {
4388 threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -08004389 }
Andy Hungd3639922022-04-28 18:00:49 -07004390 if ((mType == MIXER || mType == SPATIALIZER) && !mStandby) {
Andy Hung08fb1742015-05-31 23:22:10 -07004391
4392 if (mThreadThrottle
4393 && mMixerStatus == MIXER_TRACKS_READY // we are mixing (active tracks)
Andy Hung446f4df2019-02-21 12:26:41 -08004394 && writePeriodNs > 0) { // we have write period info
Andy Hung08fb1742015-05-31 23:22:10 -07004395 // Limit MixerThread data processing to no more than twice the
4396 // expected processing rate.
4397 //
4398 // This helps prevent underruns with NuPlayer and other applications
4399 // which may set up buffers that are close to the minimum size, or use
4400 // deep buffers, and rely on a double-buffering sleep strategy to fill.
4401 //
4402 // The throttle smooths out sudden large data drains from the device,
4403 // e.g. when it comes out of standby, which often causes problems with
4404 // (1) mixer threads without a fast mixer (which has its own warm-up)
4405 // (2) minimum buffer sized tracks (even if the track is full,
4406 // the app won't fill fast enough to handle the sudden draw).
Haynes Mathew Georgef92b2172016-05-09 11:34:15 -07004407 //
4408 // Total time spent in last processing cycle equals time spent in
4409 // 1. threadLoop_write, as well as time spent in
4410 // 2. threadLoop_mix (significant for heavy mixing, especially
4411 // on low tier processors)
Andy Hung08fb1742015-05-31 23:22:10 -07004412
Andy Hung446f4df2019-02-21 12:26:41 -08004413 // it's OK if deltaMs is an overestimate.
4414
4415 const int32_t deltaMs = writePeriodNs / NANOS_PER_MILLISECOND;
Ivan Lozanoe02bc542017-10-26 09:51:54 -07004416
Ivan Lozanoea04d392017-11-07 14:37:07 -08004417 const int32_t throttleMs = (int32_t)mHalfBufferMs - deltaMs;
Andy Hung08fb1742015-05-31 23:22:10 -07004418 if ((signed)mHalfBufferMs >= throttleMs && throttleMs > 0) {
Andy Hungcf10d742020-04-28 15:38:24 -07004419 mThreadMetrics.logThrottleMs((double)throttleMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08004420
Andy Hung08fb1742015-05-31 23:22:10 -07004421 usleep(throttleMs * 1000);
Andy Hung40eb1a12015-06-18 13:42:02 -07004422 // notify of throttle start on verbose log
4423 ALOGV_IF(mThreadThrottleEndMs == mThreadThrottleTimeMs,
4424 "mixer(%p) throttle begin:"
4425 " ret(%zd) deltaMs(%d) requires sleep %d ms",
Andy Hung08fb1742015-05-31 23:22:10 -07004426 this, ret, deltaMs, throttleMs);
Andy Hung40eb1a12015-06-18 13:42:02 -07004427 mThreadThrottleTimeMs += throttleMs;
Andy Hung0a31ddd2016-07-06 19:10:29 -07004428 // Throttle must be attributed to the previous mixer loop's write time
4429 // to allow back-to-back throttling.
Andy Hung446f4df2019-02-21 12:26:41 -08004430 // This also ensures proper timing statistics.
4431 mLastIoEndNs = systemTime(); // we fetch the write end time again.
Andy Hung40eb1a12015-06-18 13:42:02 -07004432 } else {
4433 uint32_t diff = mThreadThrottleTimeMs - mThreadThrottleEndMs;
4434 if (diff > 0) {
4435 // notify of throttle end on debug log
Andy Hung3ea004d2016-05-05 16:48:37 -07004436 // but prevent spamming for bluetooth
jiabinc52b1ff2019-10-31 17:20:42 -07004437 ALOGD_IF(!isSingleDeviceType(
4438 outDeviceTypes(), audio_is_a2dp_out_device) &&
4439 !isSingleDeviceType(
4440 outDeviceTypes(), audio_is_hearing_aid_out_device),
Andy Hung3ea004d2016-05-05 16:48:37 -07004441 "mixer(%p) throttle end: throttle time(%u)", this, diff);
Andy Hung40eb1a12015-06-18 13:42:02 -07004442 mThreadThrottleEndMs = mThreadThrottleTimeMs;
4443 }
Andy Hung08fb1742015-05-31 23:22:10 -07004444 }
4445 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004446 }
Eric Laurent81784c32012-11-19 14:55:58 -08004447
Eric Laurentbfb1b832013-01-07 09:53:42 -08004448 } else {
Glenn Kastene7754022014-10-31 12:11:26 -07004449 ATRACE_BEGIN("sleep");
Eric Laurente93cc032016-05-05 10:15:10 -07004450 Mutex::Autolock _l(mLock);
rago1bb90822017-05-02 18:31:48 -07004451 // suspended requires accurate metering of sleep time.
4452 if (isSuspended()) {
4453 // advance by expected sleepTime
4454 timeLoopNextNs += microseconds((nsecs_t)mSleepTimeUs);
4455 const nsecs_t nowNs = systemTime();
4456
4457 // compute expected next time vs current time.
4458 // (negative deltas are treated as delays).
4459 nsecs_t deltaNs = timeLoopNextNs - nowNs;
4460 if (deltaNs < -kMaxNextBufferDelayNs) {
4461 // Delays longer than the max allowed trigger a reset.
4462 ALOGV("DelayNs: %lld, resetting timeLoopNextNs", (long long) deltaNs);
4463 deltaNs = microseconds((nsecs_t)mSleepTimeUs);
4464 timeLoopNextNs = nowNs + deltaNs;
4465 } else if (deltaNs < 0) {
4466 // Delays within the max delay allowed: zero the delta/sleepTime
4467 // to help the system catch up in the next iteration(s)
4468 ALOGV("DelayNs: %lld, catching-up", (long long) deltaNs);
4469 deltaNs = 0;
4470 }
4471 // update sleep time (which is >= 0)
4472 mSleepTimeUs = deltaNs / 1000;
4473 }
Eric Laurente93cc032016-05-05 10:15:10 -07004474 if (!mSignalPending && mConfigEvents.isEmpty() && !exitPending()) {
4475 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)mSleepTimeUs));
Eric Laurent51716182016-02-29 18:00:56 -08004476 }
Glenn Kastene7754022014-10-31 12:11:26 -07004477 ATRACE_END();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004478 }
Eric Laurent81784c32012-11-19 14:55:58 -08004479 }
4480
4481 // Finally let go of removed track(s), without the lock held
4482 // since we can't guarantee the destructors won't acquire that
4483 // same lock. This will also mutate and push a new fast mixer state.
4484 threadLoop_removeTracks(tracksToRemove);
4485 tracksToRemove.clear();
4486
4487 // FIXME I don't understand the need for this here;
4488 // it was in the original code but maybe the
4489 // assignment in saveOutputTracks() makes this unnecessary?
4490 clearOutputTracks();
4491
4492 // Effect chains will be actually deleted here if they were removed from
4493 // mEffectChains list during mixing or effects processing
4494 effectChains.clear();
4495
4496 // FIXME Note that the above .clear() is no longer necessary since effectChains
4497 // is now local to this block, but will keep it for now (at least until merge done).
4498 }
4499
Eric Laurentbfb1b832013-01-07 09:53:42 -08004500 threadLoop_exit();
4501
Eric Laurentcf817a22014-08-04 20:36:31 -07004502 if (!mStandby) {
4503 threadLoop_standby();
Eric Laurent19952e12023-04-20 10:08:29 +02004504 setStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08004505 }
4506
4507 releaseWakeLock();
4508
4509 ALOGV("Thread %p type %d exiting", this, mType);
4510 return false;
4511}
4512
Dean Wheatley12473e92021-03-18 23:00:55 +11004513void AudioFlinger::PlaybackThread::collectTimestamps_l()
4514{
Dean Wheatley12473e92021-03-18 23:00:55 +11004515 if (mStandby) {
4516 mTimestampVerifier.discontinuity(discontinuityForStandbyOrFlush());
4517 return;
4518 } else if (mHwPaused) {
4519 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS);
4520 return;
4521 }
4522
4523 // Gather the framesReleased counters for all active tracks,
4524 // and associate with the sink frames written out. We need
4525 // this to convert the sink timestamp to the track timestamp.
4526 bool kernelLocationUpdate = false;
4527 ExtendedTimestamp timestamp; // use private copy to fetch
4528
4529 // Always query HAL timestamp and update timestamp verifier. In standby or pause,
4530 // HAL may be draining some small duration buffered data for fade out.
4531 if (threadloop_getHalTimestamp_l(&timestamp) == OK) {
4532 mTimestampVerifier.add(timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
4533 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4534 mSampleRate);
4535
4536 if (isTimestampCorrectionEnabled()) {
4537 ALOGVV("TS_BEFORE: %d %lld %lld", id(),
4538 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4539 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
4540 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
4541 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4542 = correctedTimestamp.mFrames;
4543 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
4544 = correctedTimestamp.mTimeNs;
4545 ALOGVV("TS_AFTER: %d %lld %lld", id(),
4546 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4547 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
4548
4549 // Note: Downstream latency only added if timestamp correction enabled.
4550 if (mDownstreamLatencyStatMs.getN() > 0) { // we have latency info.
4551 const int64_t newPosition =
4552 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4553 - int64_t(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
4554 // prevent retrograde
4555 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = max(
4556 newPosition,
4557 (mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4558 - mSuspendedFrames));
4559 }
4560 }
4561
4562 // We always fetch the timestamp here because often the downstream
4563 // sink will block while writing.
4564
4565 // We keep track of the last valid kernel position in case we are in underrun
4566 // and the normal mixer period is the same as the fast mixer period, or there
4567 // is some error from the HAL.
4568 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
4569 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
4570 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
4571 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
4572 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4573
4574 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
4575 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER];
4576 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
4577 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER];
4578 }
4579
4580 if (timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
4581 kernelLocationUpdate = true;
4582 } else {
4583 ALOGVV("getTimestamp error - no valid kernel position");
4584 }
4585
4586 // copy over kernel info
4587 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
4588 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4589 + mSuspendedFrames; // add frames discarded when suspended
4590 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
4591 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4592 } else {
4593 mTimestampVerifier.error();
4594 }
4595
4596 // mFramesWritten for non-offloaded tracks are contiguous
4597 // even after standby() is called. This is useful for the track frame
4598 // to sink frame mapping.
4599 bool serverLocationUpdate = false;
4600 if (mFramesWritten != mLastFramesWritten) {
4601 serverLocationUpdate = true;
4602 mLastFramesWritten = mFramesWritten;
4603 }
4604 // Only update timestamps if there is a meaningful change.
4605 // Either the kernel timestamp must be valid or we have written something.
4606 if (kernelLocationUpdate || serverLocationUpdate) {
4607 if (serverLocationUpdate) {
4608 // use the time before we called the HAL write - it is a bit more accurate
4609 // to when the server last read data than the current time here.
4610 //
4611 // If we haven't written anything, mLastIoBeginNs will be -1
4612 // and we use systemTime().
4613 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = mFramesWritten;
4614 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = mLastIoBeginNs == -1
4615 ? systemTime() : mLastIoBeginNs;
4616 }
4617
4618 for (const sp<Track> &t : mActiveTracks) {
4619 if (!t->isFastTrack()) {
4620 t->updateTrackFrameInfo(
4621 t->mAudioTrackServerProxy->framesReleased(),
4622 mFramesWritten,
4623 mSampleRate,
4624 mTimestamp);
4625 }
4626 }
4627 }
4628
4629 if (audio_has_proportional_frames(mFormat)) {
4630 const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
4631 if (latencyMs != 0.) { // note 0. means timestamp is empty.
4632 mLatencyMs.add(latencyMs);
4633 }
4634 }
4635#if 0
4636 // logFormat example
4637 if (z % 100 == 0) {
4638 timespec ts;
4639 clock_gettime(CLOCK_MONOTONIC, &ts);
4640 LOGT("This is an integer %d, this is a float %f, this is my "
4641 "pid %p %% %s %t", 42, 3.14, "and this is a timestamp", ts);
4642 LOGT("A deceptive null-terminated string %\0");
4643 }
4644 ++z;
4645#endif
4646}
4647
Eric Laurentbfb1b832013-01-07 09:53:42 -08004648// removeTracks_l() must be called with ThreadBase::mLock held
4649void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
Andy Hung920f6572022-10-06 12:09:49 -07004650NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
Eric Laurentbfb1b832013-01-07 09:53:42 -08004651{
Andy Hungfe726a62018-09-27 15:17:25 -07004652 for (const auto& track : tracksToRemove) {
4653 mActiveTracks.remove(track);
4654 ALOGV("%s(%d): removing track on session %d", __func__, track->id(), track->sessionId());
4655 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
4656 if (chain != 0) {
4657 ALOGV("%s(%d): stopping track on chain %p for session Id: %d",
4658 __func__, track->id(), chain.get(), track->sessionId());
4659 chain->decActiveTrackCnt();
4660 }
4661 // If an external client track, inform APM we're no longer active, and remove if needed.
4662 // We do this under lock so that the state is consistent if the Track is destroyed.
4663 if (track->isExternalTrack()) {
4664 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004665 if (track->isTerminated()) {
Andy Hungfe726a62018-09-27 15:17:25 -07004666 AudioSystem::releaseOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004667 }
4668 }
Andy Hungfe726a62018-09-27 15:17:25 -07004669 if (track->isTerminated()) {
4670 // remove from our tracks vector
4671 removeTrack_l(track);
4672 }
jiabineb3bda02020-06-30 14:07:03 -07004673 if (mHapticChannelCount > 0 &&
4674 ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
4675 || (chain != nullptr && chain->containsHapticGeneratingEffect_l()))) {
jiabin57303cc2018-12-18 15:45:57 -08004676 mLock.unlock();
4677 // Unlock due to VibratorService will lock for this call and will
4678 // call Tracks.mute/unmute which also require thread's lock.
4679 AudioFlinger::onExternalVibrationStop(track->getExternalVibration());
4680 mLock.lock();
jiabine70bc7f2020-06-30 22:07:55 -07004681
4682 // When the track is stop, set the haptic intensity as MUTE
4683 // for the HapticGenerator effect.
4684 if (chain != nullptr) {
Simon Bowden62823412022-10-17 14:52:26 +00004685 chain->setHapticIntensity_l(track->id(), os::HapticScale::MUTE);
jiabine70bc7f2020-06-30 22:07:55 -07004686 }
jiabin245cdd92018-12-07 17:55:15 -08004687 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004688 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004689}
Eric Laurent81784c32012-11-19 14:55:58 -08004690
Eric Laurentaccc1472013-09-20 09:36:34 -07004691status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
4692{
4693 if (mNormalSink != 0) {
Andy Hung818e7a32016-02-16 18:08:07 -08004694 ExtendedTimestamp ets;
4695 status_t status = mNormalSink->getTimestamp(ets);
4696 if (status == NO_ERROR) {
4697 status = ets.getBestTimestamp(&timestamp);
4698 }
4699 return status;
Eric Laurentaccc1472013-09-20 09:36:34 -07004700 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004701 if ((mType == OFFLOAD || mType == DIRECT) && mOutput != NULL) {
Dean Wheatley12473e92021-03-18 23:00:55 +11004702 collectTimestamps_l();
4703 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] <= 0) {
4704 return INVALID_OPERATION;
Eric Laurentaccc1472013-09-20 09:36:34 -07004705 }
Dean Wheatley12473e92021-03-18 23:00:55 +11004706 timestamp.mPosition = mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
4707 const int64_t timeNs = mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4708 timestamp.mTime.tv_sec = timeNs / NANOS_PER_SECOND;
4709 timestamp.mTime.tv_nsec = timeNs - (timestamp.mTime.tv_sec * NANOS_PER_SECOND);
4710 return NO_ERROR;
Eric Laurentaccc1472013-09-20 09:36:34 -07004711 }
4712 return INVALID_OPERATION;
4713}
Eric Laurent1c333e22014-05-20 10:48:17 -07004714
Eric Laurenteab90452019-06-24 15:17:46 -07004715// For dedicated VoIP outputs, let the HAL apply the stream volume. Track volume is
4716// still applied by the mixer.
4717// All tracks attached to a mixer with flag VOIP_RX are tied to the same
4718// stream type STREAM_VOICE_CALL so this will only change the HAL volume once even
4719// if more than one track are active
4720status_t AudioFlinger::PlaybackThread::handleVoipVolume_l(float *volume)
4721{
4722 status_t result = NO_ERROR;
4723 if ((mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
4724 if (*volume != mLeftVolFloat) {
4725 result = mOutput->stream->setVolume(*volume, *volume);
4726 ALOGE_IF(result != OK,
4727 "Error when setting output stream volume: %d", result);
4728 if (result == NO_ERROR) {
4729 mLeftVolFloat = *volume;
4730 }
4731 }
4732 // if stream volume was successfully sent to the HAL, mLeftVolFloat == v here and we
4733 // remove stream volume contribution from software volume.
4734 if (mLeftVolFloat == *volume) {
4735 *volume = 1.0f;
4736 }
4737 }
4738 return result;
4739}
4740
Eric Laurent054d9d32015-04-24 08:48:48 -07004741status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
4742 audio_patch_handle_t *handle)
4743{
Andy Hungf60abce2016-08-26 11:37:54 -07004744 status_t status;
4745 if (property_get_bool("af.patch_park", false /* default_value */)) {
4746 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4747 // or if HAL does not properly lock against access.
4748 AutoPark<FastMixer> park(mFastMixer);
4749 status = PlaybackThread::createAudioPatch_l(patch, handle);
4750 } else {
4751 status = PlaybackThread::createAudioPatch_l(patch, handle);
4752 }
Eric Laurentb0463942022-12-20 16:31:10 +01004753
4754 updateHalSupportedLatencyModes_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07004755 return status;
4756}
4757
Eric Laurent1c333e22014-05-20 10:48:17 -07004758status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
4759 audio_patch_handle_t *handle)
4760{
4761 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004762
4763 // store new device and send to effects
4764 audio_devices_t type = AUDIO_DEVICE_NONE;
jiabinc52b1ff2019-10-31 17:20:42 -07004765 AudioDeviceTypeAddrVector deviceTypeAddrs;
Eric Laurent054d9d32015-04-24 08:48:48 -07004766 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabinc52b1ff2019-10-31 17:20:42 -07004767 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
4768 && !mOutput->audioHwDev->supportsAudioPatches(),
4769 "Enumerated device type(%#x) must not be used "
4770 "as it does not support audio patches",
4771 patch->sinks[i].ext.device.type);
Mikhail Naganov55773032020-10-01 15:08:13 -07004772 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
Andy Hung920f6572022-10-06 12:09:49 -07004773 deviceTypeAddrs.emplace_back(patch->sinks[i].ext.device.type,
4774 patch->sinks[i].ext.device.address);
Eric Laurent054d9d32015-04-24 08:48:48 -07004775 }
4776
François Gaffie0c280aa2018-07-25 10:02:15 +02004777 audio_port_handle_t sinkPortId = patch->sinks[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07004778#ifdef ADD_BATTERY_DATA
4779 // when changing the audio output device, call addBatteryData to notify
4780 // the change
jiabinc52b1ff2019-10-31 17:20:42 -07004781 if (outDeviceTypes() != deviceTypes) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004782 uint32_t params = 0;
4783 // check whether speaker is on
jiabinc52b1ff2019-10-31 17:20:42 -07004784 if (deviceTypes.count(AUDIO_DEVICE_OUT_SPEAKER) > 0) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004785 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
Eric Laurent1c333e22014-05-20 10:48:17 -07004786 }
4787
Eric Laurent054d9d32015-04-24 08:48:48 -07004788 // check if any other device (except speaker) is on
jiabinc52b1ff2019-10-31 17:20:42 -07004789 if (!isSingleDeviceType(deviceTypes, AUDIO_DEVICE_OUT_SPEAKER)) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004790 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
4791 }
4792
4793 if (params != 0) {
4794 addBatteryData(params);
4795 }
4796 }
4797#endif
4798
4799 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08004800 mEffectChains[i]->setDevices_l(deviceTypeAddrs);
Eric Laurent054d9d32015-04-24 08:48:48 -07004801 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07004802
jiabinc52b1ff2019-10-31 17:20:42 -07004803 // mPatch.num_sinks is not set when the thread is created so that
4804 // the first patch creation triggers an ioConfigChanged callback
4805 bool configChanged = (mPatch.num_sinks == 0) ||
4806 (mPatch.sinks[0].id != sinkPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07004807 mPatch = *patch;
jiabinc52b1ff2019-10-31 17:20:42 -07004808 mOutDeviceTypeAddrs = deviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -07004809 checkSilentMode_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07004810
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004811 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004812 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4813 status = hwDevice->createAudioPatch(patch->num_sources,
4814 patch->sources,
4815 patch->num_sinks,
4816 patch->sinks,
4817 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004818 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -08004819 status = mOutput->stream->legacyCreateAudioPatch(patch->sinks[0], std::nullopt, type);
Eric Laurent054d9d32015-04-24 08:48:48 -07004820 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07004821 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07004822 const std::string patchSinksAsString = patchSinksToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07004823
4824 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07004825 mThreadMetrics.logCreatePatch(/* inDevices */ {}, patchSinksAsString);
Andy Hungcf10d742020-04-28 15:38:24 -07004826 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07004827 // also dispatch to active AudioTracks for MediaMetrics
4828 for (const auto &track : mActiveTracks) {
4829 track->logEndInterval();
4830 track->logBeginInterval(patchSinksAsString);
4831 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08004832
Eric Laurente8726fe2015-06-26 09:39:24 -07004833 if (configChanged) {
4834 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
4835 }
Vlad Popa7e81cea2023-01-19 16:34:16 +01004836 // Force metadata update after a route change
Eric Laurentdda206a2022-07-08 17:28:35 +02004837 mActiveTracks.setHasChanged();
4838
Eric Laurent1c333e22014-05-20 10:48:17 -07004839 return status;
4840}
4841
Eric Laurent054d9d32015-04-24 08:48:48 -07004842status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4843{
Andy Hungf60abce2016-08-26 11:37:54 -07004844 status_t status;
4845 if (property_get_bool("af.patch_park", false /* default_value */)) {
4846 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4847 // or if HAL does not properly lock against access.
4848 AutoPark<FastMixer> park(mFastMixer);
4849 status = PlaybackThread::releaseAudioPatch_l(handle);
4850 } else {
4851 status = PlaybackThread::releaseAudioPatch_l(handle);
4852 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004853 return status;
4854}
4855
Eric Laurent1c333e22014-05-20 10:48:17 -07004856status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4857{
4858 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004859
jiabinc52b1ff2019-10-31 17:20:42 -07004860 mPatch = audio_patch{};
4861 mOutDeviceTypeAddrs.clear();
Eric Laurent054d9d32015-04-24 08:48:48 -07004862
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004863 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004864 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4865 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004866 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -08004867 status = mOutput->stream->legacyReleaseAudioPatch();
Eric Laurent1c333e22014-05-20 10:48:17 -07004868 }
Eric Laurentdda206a2022-07-08 17:28:35 +02004869 // Force meteadata update after a route change
4870 mActiveTracks.setHasChanged();
4871
Eric Laurent1c333e22014-05-20 10:48:17 -07004872 return status;
4873}
4874
Eric Laurent83b88082014-06-20 18:31:16 -07004875void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
4876{
4877 Mutex::Autolock _l(mLock);
4878 mTracks.add(track);
4879}
4880
4881void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
4882{
4883 Mutex::Autolock _l(mLock);
4884 destroyTrack_l(track);
4885}
4886
Mikhail Naganovdc769682018-05-04 15:34:08 -07004887void AudioFlinger::PlaybackThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07004888{
Mikhail Naganovdc769682018-05-04 15:34:08 -07004889 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07004890 config->role = AUDIO_PORT_ROLE_SOURCE;
4891 config->ext.mix.hw_module = mOutput->audioHwDev->handle();
4892 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07004893 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
4894 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
4895 config->flags.output = mOutput->flags;
4896 }
Eric Laurent83b88082014-06-20 18:31:16 -07004897}
4898
Eric Laurent81784c32012-11-19 14:55:58 -08004899// ----------------------------------------------------------------------------
4900
4901AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurentf1f22e72021-07-13 14:04:14 +02004902 audio_io_handle_t id, bool systemReady, type_t type, audio_config_base_t *mixerConfig)
4903 : PlaybackThread(audioFlinger, output, id, type, systemReady, mixerConfig),
Eric Laurent81784c32012-11-19 14:55:58 -08004904 // mAudioMixer below
4905 // mFastMixer below
Eric Laurentb0463942022-12-20 16:31:10 +01004906 mBluetoothLatencyModesEnabled(false),
Andy Hung2ddee192015-12-18 17:34:44 -08004907 mFastMixerFutex(0),
4908 mMasterMono(false)
Eric Laurent81784c32012-11-19 14:55:58 -08004909 // mOutputSink below
4910 // mPipeSink below
4911 // mNormalSink below
4912{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004913 setMasterBalance(audioFlinger->getMasterBalance_l());
jiabinc52b1ff2019-10-31 17:20:42 -07004914 ALOGV("MixerThread() id=%d type=%d", id, type);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004915 ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004916 "mFrameCount=%zu, mNormalFrameCount=%zu",
Eric Laurent81784c32012-11-19 14:55:58 -08004917 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
4918 mNormalFrameCount);
4919 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
4920
Andy Hungfbfc3952015-01-15 13:33:51 -08004921 if (type == DUPLICATING) {
4922 // The Duplicating thread uses the AudioMixer and delivers data to OutputTracks
4923 // (downstream MixerThreads) in DuplicatingThread::threadLoop_write().
4924 // Do not create or use mFastMixer, mOutputSink, mPipeSink, or mNormalSink.
4925 return;
4926 }
Eric Laurent81784c32012-11-19 14:55:58 -08004927 // create an NBAIO sink for the HAL output stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07004928 mOutputSink = new AudioStreamOutSink(output->stream);
Eric Laurent81784c32012-11-19 14:55:58 -08004929 size_t numCounterOffers = 0;
jiabin245cdd92018-12-07 17:55:15 -08004930 const NBAIO_Format offers[1] = {Format_from_SR_C(
4931 mSampleRate, mChannelCount + mHapticChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004932#if !LOG_NDEBUG
4933 ssize_t index =
4934#else
4935 (void)
4936#endif
4937 mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004938 ALOG_ASSERT(index == 0);
4939
4940 // initialize fast mixer depending on configuration
4941 bool initFastMixer;
jiabinc658e452022-10-21 20:52:21 +00004942 if (mType == SPATIALIZER || mType == BIT_PERFECT) {
Eric Laurent81784c32012-11-19 14:55:58 -08004943 initFastMixer = false;
Eric Laurentb62d0362021-10-26 17:40:18 +02004944 } else {
4945 switch (kUseFastMixer) {
4946 case FastMixer_Never:
4947 initFastMixer = false;
4948 break;
4949 case FastMixer_Always:
4950 initFastMixer = true;
4951 break;
4952 case FastMixer_Static:
4953 case FastMixer_Dynamic:
4954 initFastMixer = mFrameCount < mNormalFrameCount;
4955 break;
4956 }
4957 ALOGW_IF(initFastMixer == false && mFrameCount < mNormalFrameCount,
4958 "FastMixer is preferred for this sink as frameCount %zu is less than threshold %zu",
4959 mFrameCount, mNormalFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08004960 }
4961 if (initFastMixer) {
Andy Hung1258c1a2014-05-23 21:22:17 -07004962 audio_format_t fastMixerFormat;
4963 if (mMixerBufferEnabled && mEffectBufferEnabled) {
4964 fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
4965 } else {
4966 fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
4967 }
4968 if (mFormat != fastMixerFormat) {
4969 // change our Sink format to accept our intermediate precision
4970 mFormat = fastMixerFormat;
4971 free(mSinkBuffer);
jiabin245cdd92018-12-07 17:55:15 -08004972 mFrameSize = audio_bytes_per_frame(mChannelCount + mHapticChannelCount, mFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004973 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
4974 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
4975 }
Eric Laurent81784c32012-11-19 14:55:58 -08004976
4977 // create a MonoPipe to connect our submix to FastMixer
4978 NBAIO_Format format = mOutputSink->format();
Andy Hung8946a282018-04-19 20:04:56 -07004979
Andy Hung1258c1a2014-05-23 21:22:17 -07004980 // adjust format to match that of the Fast Mixer
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004981 ALOGV("format changed from %#x to %#x", format.mFormat, fastMixerFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004982 format.mFormat = fastMixerFormat;
4983 format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
4984
Eric Laurent81784c32012-11-19 14:55:58 -08004985 // This pipe depth compensates for scheduling latency of the normal mixer thread.
4986 // When it wakes up after a maximum latency, it runs a few cycles quickly before
4987 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
4988 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
Andy Hung920f6572022-10-06 12:09:49 -07004989 const NBAIO_Format offersFast[1] = {format};
4990 size_t numCounterOffersFast = 0;
Andy Hung8946a282018-04-19 20:04:56 -07004991#if !LOG_NDEBUG
Eric Laurent1e28aaa2023-04-16 19:34:23 +02004992 index =
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004993#else
4994 (void)
4995#endif
Andy Hung920f6572022-10-06 12:09:49 -07004996 monoPipe->negotiate(offersFast, std::size(offersFast),
4997 nullptr /* counterOffers */, numCounterOffersFast);
Eric Laurent81784c32012-11-19 14:55:58 -08004998 ALOG_ASSERT(index == 0);
4999 monoPipe->setAvgFrames((mScreenState & 1) ?
5000 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
5001 mPipeSink = monoPipe;
5002
Eric Laurent81784c32012-11-19 14:55:58 -08005003 // create fast mixer and configure it initially with just one fast track for our submix
Andy Hung8946a282018-04-19 20:04:56 -07005004 mFastMixer = new FastMixer(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08005005 FastMixerStateQueue *sq = mFastMixer->sq();
5006#ifdef STATE_QUEUE_DUMP
5007 sq->setObserverDump(&mStateQueueObserverDump);
5008 sq->setMutatorDump(&mStateQueueMutatorDump);
5009#endif
5010 FastMixerState *state = sq->begin();
5011 FastTrack *fastTrack = &state->mFastTracks[0];
5012 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
5013 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
5014 fastTrack->mVolumeProvider = NULL;
Mikhail Naganov55773032020-10-01 15:08:13 -07005015 fastTrack->mChannelMask = static_cast<audio_channel_mask_t>(
5016 mChannelMask | mHapticChannelMask); // mPipeSink channel mask for
5017 // audio to FastMixer
Andy Hunge8a1ced2014-05-09 15:02:21 -07005018 fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer
jiabin245cdd92018-12-07 17:55:15 -08005019 fastTrack->mHapticPlaybackEnabled = mHapticChannelMask != AUDIO_CHANNEL_NONE;
jiabine70bc7f2020-06-30 22:07:55 -07005020 fastTrack->mHapticIntensity = os::HapticScale::NONE;
Lais Andradebc3f37a2021-07-02 00:13:19 +01005021 fastTrack->mHapticMaxAmplitude = NAN;
Eric Laurent81784c32012-11-19 14:55:58 -08005022 fastTrack->mGeneration++;
5023 state->mFastTracksGen++;
5024 state->mTrackMask = 1;
5025 // fast mixer will use the HAL output sink
5026 state->mOutputSink = mOutputSink.get();
5027 state->mOutputSinkGen++;
5028 state->mFrameCount = mFrameCount;
jiabin245cdd92018-12-07 17:55:15 -08005029 // specify sink channel mask when haptic channel mask present as it can not
5030 // be calculated directly from channel count
5031 state->mSinkChannelMask = mHapticChannelMask == AUDIO_CHANNEL_NONE
Mikhail Naganov55773032020-10-01 15:08:13 -07005032 ? AUDIO_CHANNEL_NONE
5033 : static_cast<audio_channel_mask_t>(mChannelMask | mHapticChannelMask);
Eric Laurent81784c32012-11-19 14:55:58 -08005034 state->mCommand = FastMixerState::COLD_IDLE;
5035 // already done in constructor initialization list
5036 //mFastMixerFutex = 0;
5037 state->mColdFutexAddr = &mFastMixerFutex;
5038 state->mColdGen++;
5039 state->mDumpState = &mFastMixerDumpState;
Glenn Kasten9e58b552013-01-18 15:09:48 -08005040 mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
5041 state->mNBLogWriter = mFastMixerNBLogWriter.get();
Eric Laurent81784c32012-11-19 14:55:58 -08005042 sq->end();
5043 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
5044
Eric Tan0513b5d2018-09-17 10:32:48 -07005045 NBLog::thread_info_t info;
5046 info.id = mId;
5047 info.type = NBLog::FASTMIXER;
5048 mFastMixerNBLogWriter->log<NBLog::EVENT_THREAD_INFO>(info);
5049
Eric Laurent81784c32012-11-19 14:55:58 -08005050 // start the fast mixer
5051 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
5052 pid_t tid = mFastMixer->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07005053 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08005054 stream()->setHalThreadPriority(kPriorityFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08005055
5056#ifdef AUDIO_WATCHDOG
5057 // create and start the watchdog
5058 mAudioWatchdog = new AudioWatchdog();
5059 mAudioWatchdog->setDump(&mAudioWatchdogDump);
5060 mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
5061 tid = mAudioWatchdog->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07005062 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08005063#endif
Andy Hung8946a282018-04-19 20:04:56 -07005064 } else {
5065#ifdef TEE_SINK
5066 // Only use the MixerThread tee if there is no FastMixer.
5067 mTee.set(mOutputSink->format(), NBAIO_Tee::TEE_FLAG_OUTPUT_THREAD);
5068 mTee.setId(std::string("_") + std::to_string(mId) + "_M");
5069#endif
Eric Laurent81784c32012-11-19 14:55:58 -08005070 }
5071
5072 switch (kUseFastMixer) {
5073 case FastMixer_Never:
5074 case FastMixer_Dynamic:
5075 mNormalSink = mOutputSink;
5076 break;
5077 case FastMixer_Always:
5078 mNormalSink = mPipeSink;
5079 break;
5080 case FastMixer_Static:
5081 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
5082 break;
5083 }
5084}
5085
5086AudioFlinger::MixerThread::~MixerThread()
5087{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005088 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005089 FastMixerStateQueue *sq = mFastMixer->sq();
5090 FastMixerState *state = sq->begin();
5091 if (state->mCommand == FastMixerState::COLD_IDLE) {
5092 int32_t old = android_atomic_inc(&mFastMixerFutex);
5093 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07005094 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08005095 }
5096 }
5097 state->mCommand = FastMixerState::EXIT;
5098 sq->end();
5099 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
5100 mFastMixer->join();
5101 // Though the fast mixer thread has exited, it's state queue is still valid.
5102 // We'll use that extract the final state which contains one remaining fast track
5103 // corresponding to our sub-mix.
5104 state = sq->begin();
5105 ALOG_ASSERT(state->mTrackMask == 1);
5106 FastTrack *fastTrack = &state->mFastTracks[0];
5107 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
5108 delete fastTrack->mBufferProvider;
5109 sq->end(false /*didModify*/);
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005110 mFastMixer.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08005111#ifdef AUDIO_WATCHDOG
5112 if (mAudioWatchdog != 0) {
5113 mAudioWatchdog->requestExit();
5114 mAudioWatchdog->requestExitAndWait();
5115 mAudioWatchdog.clear();
5116 }
5117#endif
5118 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08005119 mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -08005120 delete mAudioMixer;
5121}
5122
Eric Laurentb0463942022-12-20 16:31:10 +01005123void AudioFlinger::MixerThread::onFirstRef() {
5124 PlaybackThread::onFirstRef();
5125
5126 Mutex::Autolock _l(mLock);
5127 if (mOutput != nullptr && mOutput->stream != nullptr) {
5128 status_t status = mOutput->stream->setLatencyModeCallback(this);
5129 if (status != INVALID_OPERATION) {
5130 updateHalSupportedLatencyModes_l();
5131 }
5132 // Default to enabled if the HAL supports it. This can be changed by Audioflinger after
5133 // the thread construction according to AudioFlinger::mBluetoothLatencyModesEnabled
5134 mBluetoothLatencyModesEnabled.store(
5135 mOutput->audioHwDev->supportsBluetoothVariableLatency());
5136 }
5137}
Eric Laurent81784c32012-11-19 14:55:58 -08005138
5139uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
5140{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005141 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005142 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
5143 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
5144 }
5145 return latency;
5146}
5147
Eric Laurentbfb1b832013-01-07 09:53:42 -08005148ssize_t AudioFlinger::MixerThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08005149{
5150 // FIXME we should only do one push per cycle; confirm this is true
5151 // Start the fast mixer if it's not already running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005152 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005153 FastMixerStateQueue *sq = mFastMixer->sq();
5154 FastMixerState *state = sq->begin();
5155 if (state->mCommand != FastMixerState::MIX_WRITE &&
5156 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
5157 if (state->mCommand == FastMixerState::COLD_IDLE) {
Eric Laurenta2ab4502015-09-09 12:25:51 -07005158
5159 // FIXME workaround for first HAL write being CPU bound on some devices
5160 ATRACE_BEGIN("write");
5161 mOutput->write((char *)mSinkBuffer, 0);
5162 ATRACE_END();
5163
Eric Laurent81784c32012-11-19 14:55:58 -08005164 int32_t old = android_atomic_inc(&mFastMixerFutex);
5165 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07005166 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08005167 }
5168#ifdef AUDIO_WATCHDOG
5169 if (mAudioWatchdog != 0) {
5170 mAudioWatchdog->resume();
5171 }
5172#endif
5173 }
5174 state->mCommand = FastMixerState::MIX_WRITE;
Glenn Kastend797a9d2015-03-02 14:19:25 -08005175#ifdef FAST_THREAD_STATISTICS
Glenn Kasten4182c4e2013-07-15 14:45:07 -07005176 mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08005177 FastThreadDumpState::kSamplingNforLowRamDevice : FastThreadDumpState::kSamplingN);
Glenn Kastend797a9d2015-03-02 14:19:25 -08005178#endif
Eric Laurent81784c32012-11-19 14:55:58 -08005179 sq->end();
5180 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
5181 if (kUseFastMixer == FastMixer_Dynamic) {
5182 mNormalSink = mPipeSink;
5183 }
5184 } else {
5185 sq->end(false /*didModify*/);
5186 }
5187 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005188 return PlaybackThread::threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08005189}
5190
5191void AudioFlinger::MixerThread::threadLoop_standby()
5192{
5193 // Idle the fast mixer if it's currently running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005194 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005195 FastMixerStateQueue *sq = mFastMixer->sq();
5196 FastMixerState *state = sq->begin();
5197 if (!(state->mCommand & FastMixerState::IDLE)) {
Andy Hung2148bf02016-11-28 19:01:02 -08005198 // Report any frames trapped in the Monopipe
5199 MonoPipe *monoPipe = (MonoPipe *)mPipeSink.get();
5200 const long long pipeFrames = monoPipe->maxFrames() - monoPipe->availableToWrite();
5201 mLocalLog.log("threadLoop_standby: framesWritten:%lld suspendedFrames:%lld "
5202 "monoPipeWritten:%lld monoPipeLeft:%lld",
5203 (long long)mFramesWritten, (long long)mSuspendedFrames,
5204 (long long)mPipeSink->framesWritten(), pipeFrames);
5205 mLocalLog.log("threadLoop_standby: %s", mTimestamp.toString().c_str());
5206
Eric Laurent81784c32012-11-19 14:55:58 -08005207 state->mCommand = FastMixerState::COLD_IDLE;
5208 state->mColdFutexAddr = &mFastMixerFutex;
5209 state->mColdGen++;
5210 mFastMixerFutex = 0;
5211 sq->end();
5212 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
5213 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
5214 if (kUseFastMixer == FastMixer_Dynamic) {
5215 mNormalSink = mOutputSink;
5216 }
5217#ifdef AUDIO_WATCHDOG
5218 if (mAudioWatchdog != 0) {
5219 mAudioWatchdog->pause();
5220 }
5221#endif
5222 } else {
5223 sq->end(false /*didModify*/);
5224 }
5225 }
5226 PlaybackThread::threadLoop_standby();
5227}
5228
Eric Laurentbfb1b832013-01-07 09:53:42 -08005229bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
5230{
5231 return false;
5232}
5233
5234bool AudioFlinger::PlaybackThread::shouldStandby_l()
5235{
5236 return !mStandby;
5237}
5238
5239bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
5240{
5241 Mutex::Autolock _l(mLock);
5242 return waitingAsyncCallback_l();
5243}
5244
Eric Laurent81784c32012-11-19 14:55:58 -08005245// shared by MIXER and DIRECT, overridden by DUPLICATING
5246void AudioFlinger::PlaybackThread::threadLoop_standby()
5247{
5248 ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
Phil Burk062e67a2015-02-11 13:40:50 -08005249 mOutput->standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -08005250 if (mUseAsyncWrite != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07005251 // discard any pending drain or write ack by incrementing sequence
5252 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
5253 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08005254 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07005255 mCallbackThread->setWriteBlocked(mWriteAckSequence);
5256 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005257 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005258 mHwPaused = false;
Eric Laurent68a40a82022-05-03 18:15:04 +02005259 setHalLatencyMode_l();
Eric Laurent81784c32012-11-19 14:55:58 -08005260}
5261
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08005262void AudioFlinger::PlaybackThread::onAddNewTrack_l()
5263{
5264 ALOGV("signal playback thread");
5265 broadcast_l();
5266}
5267
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07005268void AudioFlinger::PlaybackThread::onAsyncError()
5269{
5270 for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
5271 invalidateTracks((audio_stream_type_t)i);
5272 }
5273}
5274
Eric Laurent81784c32012-11-19 14:55:58 -08005275void AudioFlinger::MixerThread::threadLoop_mix()
5276{
Eric Laurent81784c32012-11-19 14:55:58 -08005277 // mix buffers...
Glenn Kastend79072e2016-01-06 08:41:20 -08005278 mAudioMixer->process();
Andy Hung25c2dac2014-02-27 14:56:00 -08005279 mCurrentWriteLength = mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005280 // increase sleep time progressively when application underrun condition clears.
5281 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
5282 // that a steady state of alternating ready/not ready conditions keeps the sleep time
5283 // such that we would underrun the audio HAL.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005284 if ((mSleepTimeUs == 0) && (sleepTimeShift > 0)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005285 sleepTimeShift--;
5286 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005287 mSleepTimeUs = 0;
5288 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08005289 //TODO: delay standby when effects have a tail
Glenn Kasten4c053ea2014-09-28 14:41:07 -07005290
Eric Laurent81784c32012-11-19 14:55:58 -08005291}
5292
5293void AudioFlinger::MixerThread::threadLoop_sleepTime()
5294{
5295 // If no tracks are ready, sleep once for the duration of an output
5296 // buffer size, then write 0s to the output
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005297 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005298 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Andy Hung06d13222018-05-03 20:13:31 -07005299 if (mPipeSink.get() != nullptr && mPipeSink == mNormalSink) {
5300 // Using the Monopipe availableToWrite, we estimate the
5301 // sleep time to retry for more data (before we underrun).
5302 MonoPipe *monoPipe = static_cast<MonoPipe *>(mPipeSink.get());
5303 const ssize_t availableToWrite = mPipeSink->availableToWrite();
5304 const size_t pipeFrames = monoPipe->maxFrames();
5305 const size_t framesLeft = pipeFrames - max(availableToWrite, 0);
5306 // HAL_framecount <= framesDelay ~ framesLeft / 2 <= Normal_Mixer_framecount
5307 const size_t framesDelay = std::min(
5308 mNormalFrameCount, max(framesLeft / 2, mFrameCount));
5309 ALOGV("pipeFrames:%zu framesLeft:%zu framesDelay:%zu",
5310 pipeFrames, framesLeft, framesDelay);
5311 mSleepTimeUs = framesDelay * MICROS_PER_SECOND / mSampleRate;
5312 } else {
5313 mSleepTimeUs = mActiveSleepTimeUs >> sleepTimeShift;
5314 if (mSleepTimeUs < kMinThreadSleepTimeUs) {
5315 mSleepTimeUs = kMinThreadSleepTimeUs;
5316 }
5317 // reduce sleep time in case of consecutive application underruns to avoid
5318 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
5319 // duration we would end up writing less data than needed by the audio HAL if
5320 // the condition persists.
5321 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
5322 sleepTimeShift++;
5323 }
Eric Laurent81784c32012-11-19 14:55:58 -08005324 }
5325 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005326 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005327 }
5328 } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
Andy Hung98ef9782014-03-04 14:46:50 -08005329 // clear out mMixerBuffer or mSinkBuffer, to ensure buffers are cleared
5330 // before effects processing or output.
5331 if (mMixerBufferValid) {
5332 memset(mMixerBuffer, 0, mMixerBufferSize);
Eric Laurent39095982021-08-24 18:29:27 +02005333 if (mType == SPATIALIZER) {
5334 memset(mSinkBuffer, 0, mSinkBufferSize);
5335 }
Andy Hung98ef9782014-03-04 14:46:50 -08005336 } else {
5337 memset(mSinkBuffer, 0, mSinkBufferSize);
5338 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005339 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08005340 ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
5341 "anticipated start");
5342 }
5343 // TODO add standby time extension fct of effect tail
5344}
5345
5346// prepareTracks_l() must be called with ThreadBase::mLock held
5347AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
5348 Vector< sp<Track> > *tracksToRemove)
5349{
Andy Hungc0691382018-09-12 18:01:57 -07005350 // clean up deleted track ids in AudioMixer before allocating new tracks
5351 (void)mTracks.processDeletedTrackIds([this](int trackId) {
5352 // for each trackId, destroy it in the AudioMixer
5353 if (mAudioMixer->exists(trackId)) {
5354 mAudioMixer->destroy(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005355 }
5356 });
Andy Hungc0691382018-09-12 18:01:57 -07005357 mTracks.clearDeletedTrackIds();
Eric Laurent81784c32012-11-19 14:55:58 -08005358
5359 mixer_state mixerStatus = MIXER_IDLE;
5360 // find out which tracks need to be processed
5361 size_t count = mActiveTracks.size();
5362 size_t mixedTracks = 0;
5363 size_t tracksWithEffect = 0;
5364 // counts only _active_ fast tracks
5365 size_t fastTracks = 0;
5366 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
5367
5368 float masterVolume = mMasterVolume;
5369 bool masterMute = mMasterMute;
5370
5371 if (masterMute) {
5372 masterVolume = 0;
5373 }
5374 // Delegate master volume control to effect in output mix effect chain if needed
5375 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
5376 if (chain != 0) {
5377 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
5378 chain->setVolume_l(&v, &v);
5379 masterVolume = (float)((v + (1 << 23)) >> 24);
5380 chain.clear();
5381 }
5382
5383 // prepare a new state to push
5384 FastMixerStateQueue *sq = NULL;
5385 FastMixerState *state = NULL;
5386 bool didModify = false;
5387 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
Andy Hungf2285312017-02-14 18:31:59 -08005388 bool coldIdle = false;
Glenn Kasten4d23ca32014-05-13 10:39:51 -07005389 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005390 sq = mFastMixer->sq();
5391 state = sq->begin();
Andy Hungf2285312017-02-14 18:31:59 -08005392 coldIdle = state->mCommand == FastMixerState::COLD_IDLE;
Eric Laurent81784c32012-11-19 14:55:58 -08005393 }
5394
Andy Hung69aed5f2014-02-25 17:24:40 -08005395 mMixerBufferValid = false; // mMixerBuffer has no valid data until appropriate tracks found.
Andy Hung98ef9782014-03-04 14:46:50 -08005396 mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found.
Andy Hung69aed5f2014-02-25 17:24:40 -08005397
Andy Hungbd3b2b02018-05-21 10:53:11 -07005398 // DeferredOperations handles statistics after setting mixerStatus.
5399 class DeferredOperations {
5400 public:
Andy Hungea840382020-05-05 21:50:17 -07005401 DeferredOperations(mixer_state *mixerStatus, ThreadMetrics *threadMetrics)
5402 : mMixerStatus(mixerStatus)
5403 , mThreadMetrics(threadMetrics) {}
Andy Hungbd3b2b02018-05-21 10:53:11 -07005404
5405 // when leaving scope, tally frames properly.
5406 ~DeferredOperations() {
5407 // Tally underrun frames only if we are actually mixing (MIXER_TRACKS_READY)
5408 // because that is when the underrun occurs.
5409 // We do not distinguish between FastTracks and NormalTracks here.
Andy Hungea840382020-05-05 21:50:17 -07005410 size_t maxUnderrunFrames = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08005411 if (*mMixerStatus == MIXER_TRACKS_READY && mUnderrunFrames.size() > 0) {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005412 for (const auto &underrun : mUnderrunFrames) {
Andy Hungc2b11cb2020-04-22 09:04:01 -07005413 underrun.first->tallyUnderrunFrames(underrun.second);
Andy Hungea840382020-05-05 21:50:17 -07005414 maxUnderrunFrames = max(underrun.second, maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005415 }
5416 }
Andy Hungea840382020-05-05 21:50:17 -07005417 // send the max underrun frames for this mixer period
5418 mThreadMetrics->logUnderrunFrames(maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005419 }
5420
5421 // tallyUnderrunFrames() is called to update the track counters
5422 // with the number of underrun frames for a particular mixer period.
5423 // We defer tallying until we know the final mixer status.
Andy Hung920f6572022-10-06 12:09:49 -07005424 void tallyUnderrunFrames(const sp<Track>& track, size_t underrunFrames) {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005425 mUnderrunFrames.emplace_back(track, underrunFrames);
5426 }
5427
5428 private:
5429 const mixer_state * const mMixerStatus;
Andy Hungea840382020-05-05 21:50:17 -07005430 ThreadMetrics * const mThreadMetrics;
Andy Hungbd3b2b02018-05-21 10:53:11 -07005431 std::vector<std::pair<sp<Track>, size_t>> mUnderrunFrames;
Andy Hungea840382020-05-05 21:50:17 -07005432 } deferredOperations(&mixerStatus, &mThreadMetrics);
Andy Hungb68f5eb2019-12-03 16:49:17 -08005433 // implicit nested scope for variable capture
Andy Hungbd3b2b02018-05-21 10:53:11 -07005434
jiabin245cdd92018-12-07 17:55:15 -08005435 bool noFastHapticTrack = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005436 for (size_t i=0 ; i<count ; i++) {
Andy Hungdae27702016-10-31 14:01:16 -07005437 const sp<Track> t = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08005438
5439 // this const just means the local variable doesn't change
5440 Track* const track = t.get();
5441
5442 // process fast tracks
5443 if (track->isFastTrack()) {
Andy Hungae22b482019-05-09 15:38:55 -07005444 LOG_ALWAYS_FATAL_IF(mFastMixer.get() == nullptr,
5445 "%s(%d): FastTrack(%d) present without FastMixer",
5446 __func__, id(), track->id());
5447
jiabin245cdd92018-12-07 17:55:15 -08005448 if (track->getHapticPlaybackEnabled()) {
5449 noFastHapticTrack = false;
5450 }
Eric Laurent81784c32012-11-19 14:55:58 -08005451
5452 // It's theoretically possible (though unlikely) for a fast track to be created
5453 // and then removed within the same normal mix cycle. This is not a problem, as
5454 // the track never becomes active so it's fast mixer slot is never touched.
5455 // The converse, of removing an (active) track and then creating a new track
5456 // at the identical fast mixer slot within the same normal mix cycle,
5457 // is impossible because the slot isn't marked available until the end of each cycle.
5458 int j = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07005459 ALOG_ASSERT(0 < j && j < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08005460 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
5461 FastTrack *fastTrack = &state->mFastTracks[j];
5462
5463 // Determine whether the track is currently in underrun condition,
5464 // and whether it had a recent underrun.
5465 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
5466 FastTrackUnderruns underruns = ftDump->mUnderruns;
5467 uint32_t recentFull = (underruns.mBitFields.mFull -
5468 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
5469 uint32_t recentPartial = (underruns.mBitFields.mPartial -
5470 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
5471 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
5472 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
5473 uint32_t recentUnderruns = recentPartial + recentEmpty;
5474 track->mObservedUnderruns = underruns;
5475 // don't count underruns that occur while stopping or pausing
5476 // or stopped which can occur when flush() is called while active
Andy Hungbd3b2b02018-05-21 10:53:11 -07005477 size_t underrunFrames = 0;
Glenn Kasten82aaf942013-07-17 16:05:07 -07005478 if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
5479 recentUnderruns > 0) {
5480 // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun
Andy Hungbd3b2b02018-05-21 10:53:11 -07005481 underrunFrames = recentUnderruns * mFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08005482 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005483 // Immediately account for FastTrack underruns.
5484 track->mAudioTrackServerProxy->tallyUnderrunFrames(underrunFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08005485
5486 // This is similar to the state machine for normal tracks,
5487 // with a few modifications for fast tracks.
5488 bool isActive = true;
5489 switch (track->mState) {
5490 case TrackBase::STOPPING_1:
5491 // track stays active in STOPPING_1 state until first underrun
Eric Laurentbfb1b832013-01-07 09:53:42 -08005492 if (recentUnderruns > 0 || track->isTerminated()) {
Eric Laurent81784c32012-11-19 14:55:58 -08005493 track->mState = TrackBase::STOPPING_2;
5494 }
5495 break;
5496 case TrackBase::PAUSING:
5497 // ramp down is not yet implemented
5498 track->setPaused();
5499 break;
5500 case TrackBase::RESUMING:
5501 // ramp up is not yet implemented
5502 track->mState = TrackBase::ACTIVE;
5503 break;
5504 case TrackBase::ACTIVE:
5505 if (recentFull > 0 || recentPartial > 0) {
5506 // track has provided at least some frames recently: reset retry count
5507 track->mRetryCount = kMaxTrackRetries;
5508 }
5509 if (recentUnderruns == 0) {
5510 // no recent underruns: stay active
5511 break;
5512 }
5513 // there has recently been an underrun of some kind
5514 if (track->sharedBuffer() == 0) {
5515 // were any of the recent underruns "empty" (no frames available)?
5516 if (recentEmpty == 0) {
5517 // no, then ignore the partial underruns as they are allowed indefinitely
5518 break;
5519 }
5520 // there has recently been an "empty" underrun: decrement the retry counter
5521 if (--(track->mRetryCount) > 0) {
5522 break;
5523 }
5524 // indicate to client process that the track was disabled because of underrun;
5525 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005526 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08005527 // remove from active list, but state remains ACTIVE [confusing but true]
5528 isActive = false;
5529 break;
5530 }
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07005531 FALLTHROUGH_INTENDED;
Eric Laurent81784c32012-11-19 14:55:58 -08005532 case TrackBase::STOPPING_2:
5533 case TrackBase::PAUSED:
Eric Laurent81784c32012-11-19 14:55:58 -08005534 case TrackBase::STOPPED:
5535 case TrackBase::FLUSHED: // flush() while active
5536 // Check for presentation complete if track is inactive
5537 // We have consumed all the buffers of this track.
5538 // This would be incomplete if we auto-paused on underrun
5539 {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005540 uint32_t latency = 0;
5541 status_t result = mOutput->stream->getLatency(&latency);
5542 ALOGE_IF(result != OK,
5543 "Error when retrieving output stream latency: %d", result);
5544 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005545 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005546 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
5547 // track stays in active list until presentation is complete
5548 break;
5549 }
5550 }
5551 if (track->isStopping_2()) {
5552 track->mState = TrackBase::STOPPED;
5553 }
5554 if (track->isStopped()) {
5555 // Can't reset directly, as fast mixer is still polling this track
5556 // track->reset();
5557 // So instead mark this track as needing to be reset after push with ack
5558 resetMask |= 1 << i;
5559 }
5560 isActive = false;
5561 break;
5562 case TrackBase::IDLE:
5563 default:
Andy Hung959b5b82021-09-24 10:46:20 -07005564 LOG_ALWAYS_FATAL("unexpected track state %d", (int)track->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08005565 }
5566
5567 if (isActive) {
5568 // was it previously inactive?
5569 if (!(state->mTrackMask & (1 << j))) {
5570 ExtendedAudioBufferProvider *eabp = track;
5571 VolumeProvider *vp = track;
5572 fastTrack->mBufferProvider = eabp;
5573 fastTrack->mVolumeProvider = vp;
Eric Laurent81784c32012-11-19 14:55:58 -08005574 fastTrack->mChannelMask = track->mChannelMask;
Andy Hunge8a1ced2014-05-09 15:02:21 -07005575 fastTrack->mFormat = track->mFormat;
jiabin245cdd92018-12-07 17:55:15 -08005576 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
jiabin77270b82018-12-18 15:41:29 -08005577 fastTrack->mHapticIntensity = track->getHapticIntensity();
Lais Andradebc3f37a2021-07-02 00:13:19 +01005578 fastTrack->mHapticMaxAmplitude = track->getHapticMaxAmplitude();
Eric Laurent81784c32012-11-19 14:55:58 -08005579 fastTrack->mGeneration++;
5580 state->mTrackMask |= 1 << j;
5581 didModify = true;
5582 // no acknowledgement required for newly active tracks
5583 }
Kevin Rocard12381092018-04-11 09:19:59 -07005584 sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
Eric Laurenteab90452019-06-24 15:17:46 -07005585 float volume;
5586 if (track->isPlaybackRestricted() || mStreamTypes[track->streamType()].mute) {
5587 volume = 0.f;
5588 } else {
5589 volume = masterVolume * mStreamTypes[track->streamType()].volume;
5590 }
5591
5592 handleVoipVolume_l(&volume);
5593
Eric Laurent81784c32012-11-19 14:55:58 -08005594 // cache the combined master volume and stream type volume for fast mixer; this
5595 // lacks any synchronization or barrier so VolumeProvider may read a stale value
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005596 const float vh = track->getVolumeHandler()->getVolume(
Eric Laurenteab90452019-06-24 15:17:46 -07005597 proxy->framesReleased()).first;
5598 volume *= vh;
Kevin Rocardb0eeaf122018-04-11 08:30:16 -07005599 track->mCachedVolume = volume;
Kevin Rocard12381092018-04-11 09:19:59 -07005600 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
Vlad Popae2f5aef2022-07-25 16:00:20 +02005601 float vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
5602 float vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
5603
5604 track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
5605 /*muteState=*/{masterVolume == 0.f,
5606 mStreamTypes[track->streamType()].volume == 0.f,
5607 mStreamTypes[track->streamType()].mute,
5608 track->isPlaybackRestricted(),
Vlad Popa436c9172022-08-02 15:25:08 +02005609 vlf == 0.f && vrf == 0.f,
5610 vh == 0.f});
Vlad Popae2f5aef2022-07-25 16:00:20 +02005611
5612 vlf *= volume;
5613 vrf *= volume;
Eric Laurenteab90452019-06-24 15:17:46 -07005614
jiabin76d94692022-12-15 21:51:21 +00005615 track->setFinalVolume(vlf, vrf);
Eric Laurent81784c32012-11-19 14:55:58 -08005616 ++fastTracks;
5617 } else {
5618 // was it previously active?
5619 if (state->mTrackMask & (1 << j)) {
5620 fastTrack->mBufferProvider = NULL;
5621 fastTrack->mGeneration++;
5622 state->mTrackMask &= ~(1 << j);
5623 didModify = true;
5624 // If any fast tracks were removed, we must wait for acknowledgement
5625 // because we're about to decrement the last sp<> on those tracks.
5626 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5627 } else {
Glenn Kastenbf848af2017-12-22 11:55:01 -08005628 // ALOGW rather than LOG_ALWAYS_FATAL because it seems there are cases where an
5629 // AudioTrack may start (which may not be with a start() but with a write()
5630 // after underrun) and immediately paused or released. In that case the
5631 // FastTrack state hasn't had time to update.
5632 // TODO Remove the ALOGW when this theory is confirmed.
5633 ALOGW("fast track %d should have been active; "
Glenn Kastenf7d65ee2015-12-02 13:45:01 -08005634 "mState=%d, mTrackMask=%#x, recentUnderruns=%u, isShared=%d",
Andy Hung959b5b82021-09-24 10:46:20 -07005635 j, (int)track->mState, state->mTrackMask, recentUnderruns,
Glenn Kastenf7d65ee2015-12-02 13:45:01 -08005636 track->sharedBuffer() != 0);
Glenn Kastenbf848af2017-12-22 11:55:01 -08005637 // Since the FastMixer state already has the track inactive, do nothing here.
Eric Laurent81784c32012-11-19 14:55:58 -08005638 }
5639 tracksToRemove->add(track);
5640 // Avoids a misleading display in dumpsys
5641 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
5642 }
jiabin245cdd92018-12-07 17:55:15 -08005643 if (fastTrack->mHapticPlaybackEnabled != track->getHapticPlaybackEnabled()) {
5644 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
5645 didModify = true;
5646 }
Eric Laurent81784c32012-11-19 14:55:58 -08005647 continue;
5648 }
5649
5650 { // local variable scope to avoid goto warning
5651
5652 audio_track_cblk_t* cblk = track->cblk();
5653
5654 // The first time a track is added we wait
5655 // for all its buffers to be filled before processing it
Andy Hungc0691382018-09-12 18:01:57 -07005656 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005657
5658 // if an active track doesn't exist in the AudioMixer, create it.
Andy Hungc0691382018-09-12 18:01:57 -07005659 // use the trackId as the AudioMixer name.
5660 if (!mAudioMixer->exists(trackId)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005661 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005662 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005663 track->mChannelMask,
5664 track->mFormat,
5665 track->mSessionId);
5666 if (status != OK) {
Andy Hungc0691382018-09-12 18:01:57 -07005667 ALOGW("%s(): AudioMixer cannot create track(%d)"
5668 " mask %#x, format %#x, sessionId %d",
5669 __func__, trackId,
5670 track->mChannelMask, track->mFormat, track->mSessionId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005671 tracksToRemove->add(track);
5672 track->invalidate(); // consider it dead.
5673 continue;
5674 }
5675 }
5676
Eric Laurent81784c32012-11-19 14:55:58 -08005677 // make sure that we have enough frames to mix one full buffer.
5678 // enforce this condition only once to enable draining the buffer in case the client
5679 // app does not call stop() and relies on underrun to stop:
5680 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
5681 // during last round
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005682 size_t desiredFrames;
Andy Hung8edb8dc2015-03-26 19:13:55 -07005683 const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate();
Andy Hung920f6572022-10-06 12:09:49 -07005684 const AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005685
5686 desiredFrames = sourceFramesNeededWithTimestretch(
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005687 sampleRate, mNormalFrameCount, mSampleRate, playbackRate.mSpeed);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005688 // TODO: ONLY USED FOR LEGACY RESAMPLERS, remove when they are removed.
5689 // add frames already consumed but not yet released by the resampler
5690 // because mAudioTrackServerProxy->framesReady() will include these frames
Andy Hungc0691382018-09-12 18:01:57 -07005691 desiredFrames += mAudioMixer->getUnreleasedFrames(trackId);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005692
Eric Laurent81784c32012-11-19 14:55:58 -08005693 uint32_t minFrames = 1;
5694 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
5695 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005696 minFrames = desiredFrames;
Eric Laurent81784c32012-11-19 14:55:58 -08005697 }
Eric Laurent13e4c962013-12-20 17:36:01 -08005698
5699 size_t framesReady = track->framesReady();
Glenn Kastene7754022014-10-31 12:11:26 -07005700 if (ATRACE_ENABLED()) {
5701 // I wish we had formatted trace names
Andy Hung1bc088a2018-02-09 15:57:31 -08005702 std::string traceName("nRdy");
Andy Hungc0691382018-09-12 18:01:57 -07005703 traceName += std::to_string(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005704 ATRACE_INT(traceName.c_str(), framesReady);
Glenn Kastene7754022014-10-31 12:11:26 -07005705 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005706 if ((framesReady >= minFrames) && track->isReady() &&
Eric Laurent81784c32012-11-19 14:55:58 -08005707 !track->isPaused() && !track->isTerminated())
5708 {
Andy Hungc0691382018-09-12 18:01:57 -07005709 ALOGVV("track(%d) s=%08x [OK] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005710
5711 mixedTracks++;
5712
Andy Hung69aed5f2014-02-25 17:24:40 -08005713 // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
5714 // there is an effect chain connected to the track
Eric Laurent81784c32012-11-19 14:55:58 -08005715 chain.clear();
Andy Hung69aed5f2014-02-25 17:24:40 -08005716 if (track->mainBuffer() != mSinkBuffer &&
5717 track->mainBuffer() != mMixerBuffer) {
Andy Hung98ef9782014-03-04 14:46:50 -08005718 if (mEffectBufferEnabled) {
5719 mEffectBufferValid = true; // Later can set directly.
5720 }
Eric Laurent81784c32012-11-19 14:55:58 -08005721 chain = getEffectChain_l(track->sessionId());
5722 // Delegate volume control to effect in track effect chain if needed
5723 if (chain != 0) {
5724 tracksWithEffect++;
5725 } else {
Andy Hungc0691382018-09-12 18:01:57 -07005726 ALOGW("prepareTracks_l(): track(%d) attached to effect but no chain found on "
Eric Laurent81784c32012-11-19 14:55:58 -08005727 "session %d",
Andy Hungc0691382018-09-12 18:01:57 -07005728 trackId, track->sessionId());
Eric Laurent81784c32012-11-19 14:55:58 -08005729 }
5730 }
5731
5732
5733 int param = AudioMixer::VOLUME;
5734 if (track->mFillingUpStatus == Track::FS_FILLED) {
5735 // no ramp for the first volume setting
5736 track->mFillingUpStatus = Track::FS_ACTIVE;
5737 if (track->mState == TrackBase::RESUMING) {
5738 track->mState = TrackBase::ACTIVE;
Revathi Uddaraju453bcb52017-08-14 14:19:40 +08005739 // If a new track is paused immediately after start, do not ramp on resume.
5740 if (cblk->mServer != 0) {
5741 param = AudioMixer::RAMP_VOLUME;
5742 }
Eric Laurent81784c32012-11-19 14:55:58 -08005743 }
Andy Hungc0691382018-09-12 18:01:57 -07005744 mAudioMixer->setParameter(trackId, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
Eric Laurent7c29ec92017-09-20 17:54:22 -07005745 mLeftVolFloat = -1.0;
Glenn Kastenf20e1d82013-07-12 09:45:18 -07005746 // FIXME should not make a decision based on mServer
5747 } else if (cblk->mServer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005748 // If the track is stopped before the first frame was mixed,
5749 // do not apply ramp
5750 param = AudioMixer::RAMP_VOLUME;
5751 }
5752
5753 // compute volume for this track
Andy Hung6be49402014-05-30 10:42:03 -07005754 uint32_t vl, vr; // in U8.24 integer format
5755 float vlf, vrf, vaf; // in [0.0, 1.0] float format
Eric Laurent7c29ec92017-09-20 17:54:22 -07005756 // read original volumes with volume control
Eric Laurenteab90452019-06-24 15:17:46 -07005757 float v = masterVolume * mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005758 // Always fetch volumeshaper volume to ensure state is updated.
5759 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5760 const float vh = track->getVolumeHandler()->getVolume(
5761 track->mAudioTrackServerProxy->framesReleased()).first;
Eric Laurent7c29ec92017-09-20 17:54:22 -07005762
Eric Laurenteab90452019-06-24 15:17:46 -07005763 if (mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
5764 v = 0;
5765 }
5766
5767 handleVoipVolume_l(&v);
5768
5769 if (track->isPausing()) {
Andy Hung6be49402014-05-30 10:42:03 -07005770 vl = vr = 0;
5771 vlf = vrf = vaf = 0.;
Eric Laurenteab90452019-06-24 15:17:46 -07005772 track->setPaused();
Eric Laurent81784c32012-11-19 14:55:58 -08005773 } else {
Glenn Kastenc56f3422014-03-21 17:53:17 -07005774 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
Andy Hung6be49402014-05-30 10:42:03 -07005775 vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
5776 vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08005777 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07005778 if (vlf > GAIN_FLOAT_UNITY) {
5779 ALOGV("Track left volume out of range: %.3g", vlf);
5780 vlf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005781 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07005782 if (vrf > GAIN_FLOAT_UNITY) {
5783 ALOGV("Track right volume out of range: %.3g", vrf);
5784 vrf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005785 }
Vlad Popae2f5aef2022-07-25 16:00:20 +02005786
5787 track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
5788 /*muteState=*/{masterVolume == 0.f,
5789 mStreamTypes[track->streamType()].volume == 0.f,
5790 mStreamTypes[track->streamType()].mute,
5791 track->isPlaybackRestricted(),
Vlad Popa436c9172022-08-02 15:25:08 +02005792 vlf == 0.f && vrf == 0.f,
5793 vh == 0.f});
Vlad Popae2f5aef2022-07-25 16:00:20 +02005794
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005795 // now apply the master volume and stream type volume and shaper volume
5796 vlf *= v * vh;
5797 vrf *= v * vh;
Eric Laurent81784c32012-11-19 14:55:58 -08005798 // assuming master volume and stream type volume each go up to 1.0,
Andy Hung6be49402014-05-30 10:42:03 -07005799 // then derive vl and vr as U8.24 versions for the effect chain
5800 const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT;
5801 vl = (uint32_t) (scaleto8_24 * vlf);
5802 vr = (uint32_t) (scaleto8_24 * vrf);
5803 // vl and vr are now in U8.24 format
Glenn Kastene3aa6592012-12-04 12:22:46 -08005804 uint16_t sendLevel = proxy->getSendLevel_U4_12();
Eric Laurent81784c32012-11-19 14:55:58 -08005805 // send level comes from shared memory and so may be corrupt
5806 if (sendLevel > MAX_GAIN_INT) {
5807 ALOGV("Track send level out of range: %04X", sendLevel);
5808 sendLevel = MAX_GAIN_INT;
5809 }
Andy Hung6be49402014-05-30 10:42:03 -07005810 // vaf is represented as [0.0, 1.0] float by rescaling sendLevel
5811 vaf = v * sendLevel * (1. / MAX_GAIN_INT);
Eric Laurent81784c32012-11-19 14:55:58 -08005812 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005813
jiabin76d94692022-12-15 21:51:21 +00005814 track->setFinalVolume(vrf, vlf);
Kevin Rocard12381092018-04-11 09:19:59 -07005815
Eric Laurent81784c32012-11-19 14:55:58 -08005816 // Delegate volume control to effect in track effect chain if needed
5817 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
5818 // Do not ramp volume if volume is controlled by effect
5819 param = AudioMixer::VOLUME;
Bryant Liub6be7f22014-06-12 22:02:41 +08005820 // Update remaining floating point volume levels
5821 vlf = (float)vl / (1 << 24);
5822 vrf = (float)vr / (1 << 24);
Eric Laurent81784c32012-11-19 14:55:58 -08005823 track->mHasVolumeController = true;
5824 } else {
5825 // force no volume ramp when volume controller was just disabled or removed
5826 // from effect chain to avoid volume spike
5827 if (track->mHasVolumeController) {
5828 param = AudioMixer::VOLUME;
5829 }
5830 track->mHasVolumeController = false;
5831 }
5832
Eric Laurent81784c32012-11-19 14:55:58 -08005833 // XXX: these things DON'T need to be done each time
Andy Hungc0691382018-09-12 18:01:57 -07005834 mAudioMixer->setBufferProvider(trackId, track);
5835 mAudioMixer->enable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005836
Andy Hungc0691382018-09-12 18:01:57 -07005837 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME0, &vlf);
5838 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME1, &vrf);
5839 mAudioMixer->setParameter(trackId, param, AudioMixer::AUXLEVEL, &vaf);
Eric Laurent81784c32012-11-19 14:55:58 -08005840 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005841 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005842 AudioMixer::TRACK,
5843 AudioMixer::FORMAT, (void *)track->format());
5844 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005845 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005846 AudioMixer::TRACK,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005847 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
Eric Laurent39095982021-08-24 18:29:27 +02005848
Eric Laurentb0a7bc92022-04-05 15:06:08 +02005849 if (mType == SPATIALIZER && !track->isSpatialized()) {
Eric Laurent39095982021-08-24 18:29:27 +02005850 mAudioMixer->setParameter(
5851 trackId,
5852 AudioMixer::TRACK,
5853 AudioMixer::MIXER_CHANNEL_MASK,
5854 (void *)(uintptr_t)(mChannelMask | mHapticChannelMask));
5855 } else {
5856 mAudioMixer->setParameter(
5857 trackId,
5858 AudioMixer::TRACK,
5859 AudioMixer::MIXER_CHANNEL_MASK,
5860 (void *)(uintptr_t)(mMixerChannelMask | mHapticChannelMask));
5861 }
5862
Glenn Kastene3aa6592012-12-04 12:22:46 -08005863 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
Andy Hungcd044842014-08-07 11:04:34 -07005864 uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX;
Andy Hung333ab962019-05-28 20:23:35 -07005865 uint32_t reqSampleRate = proxy->getSampleRate();
Glenn Kastene3aa6592012-12-04 12:22:46 -08005866 if (reqSampleRate == 0) {
5867 reqSampleRate = mSampleRate;
5868 } else if (reqSampleRate > maxSampleRate) {
5869 reqSampleRate = maxSampleRate;
5870 }
Eric Laurent81784c32012-11-19 14:55:58 -08005871 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005872 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005873 AudioMixer::RESAMPLE,
5874 AudioMixer::SAMPLE_RATE,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005875 (void *)(uintptr_t)reqSampleRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005876
Andy Hung8edb8dc2015-03-26 19:13:55 -07005877 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005878 trackId,
Andy Hung8edb8dc2015-03-26 19:13:55 -07005879 AudioMixer::TIMESTRETCH,
5880 AudioMixer::PLAYBACK_RATE,
Andy Hung920f6572022-10-06 12:09:49 -07005881 // cast away constness for this generic API.
5882 const_cast<void *>(reinterpret_cast<const void *>(&playbackRate)));
Andy Hung8edb8dc2015-03-26 19:13:55 -07005883
Andy Hung69aed5f2014-02-25 17:24:40 -08005884 /*
5885 * Select the appropriate output buffer for the track.
5886 *
Andy Hung98ef9782014-03-04 14:46:50 -08005887 * Tracks with effects go into their own effects chain buffer
5888 * and from there into either mEffectBuffer or mSinkBuffer.
Andy Hung69aed5f2014-02-25 17:24:40 -08005889 *
5890 * Other tracks can use mMixerBuffer for higher precision
5891 * channel accumulation. If this buffer is enabled
5892 * (mMixerBufferEnabled true), then selected tracks will accumulate
5893 * into it.
5894 *
5895 */
5896 if (mMixerBufferEnabled
5897 && (track->mainBuffer() == mSinkBuffer
5898 || track->mainBuffer() == mMixerBuffer)) {
Eric Laurentb0a7bc92022-04-05 15:06:08 +02005899 if (mType == SPATIALIZER && !track->isSpatialized()) {
Eric Laurent39095982021-08-24 18:29:27 +02005900 mAudioMixer->setParameter(
5901 trackId,
5902 AudioMixer::TRACK,
Eric Laurentb62d0362021-10-26 17:40:18 +02005903 AudioMixer::MIXER_FORMAT, (void *)mEffectBufferFormat);
Eric Laurent39095982021-08-24 18:29:27 +02005904 mAudioMixer->setParameter(
5905 trackId,
5906 AudioMixer::TRACK,
Eric Laurentb62d0362021-10-26 17:40:18 +02005907 AudioMixer::MAIN_BUFFER, (void *)mPostSpatializerBuffer);
Eric Laurent39095982021-08-24 18:29:27 +02005908 } else {
5909 mAudioMixer->setParameter(
5910 trackId,
5911 AudioMixer::TRACK,
5912 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
5913 mAudioMixer->setParameter(
5914 trackId,
5915 AudioMixer::TRACK,
5916 AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer);
5917 // TODO: override track->mainBuffer()?
5918 mMixerBufferValid = true;
5919 }
Andy Hung69aed5f2014-02-25 17:24:40 -08005920 } else {
5921 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005922 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005923 AudioMixer::TRACK,
rago94a1ee82017-07-21 15:11:02 -07005924 AudioMixer::MIXER_FORMAT, (void *)EFFECT_BUFFER_FORMAT);
Andy Hung69aed5f2014-02-25 17:24:40 -08005925 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005926 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005927 AudioMixer::TRACK,
5928 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
5929 }
Eric Laurent81784c32012-11-19 14:55:58 -08005930 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005931 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005932 AudioMixer::TRACK,
5933 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
jiabin245cdd92018-12-07 17:55:15 -08005934 mAudioMixer->setParameter(
5935 trackId,
5936 AudioMixer::TRACK,
5937 AudioMixer::HAPTIC_ENABLED, (void *)(uintptr_t)track->getHapticPlaybackEnabled());
jiabin77270b82018-12-18 15:41:29 -08005938 mAudioMixer->setParameter(
5939 trackId,
5940 AudioMixer::TRACK,
5941 AudioMixer::HAPTIC_INTENSITY, (void *)(uintptr_t)track->getHapticIntensity());
Lais Andradebc3f37a2021-07-02 00:13:19 +01005942 mAudioMixer->setParameter(
5943 trackId,
5944 AudioMixer::TRACK,
5945 AudioMixer::HAPTIC_MAX_AMPLITUDE, (void *)(&(track->mHapticMaxAmplitude)));
Eric Laurent81784c32012-11-19 14:55:58 -08005946
5947 // reset retry count
5948 track->mRetryCount = kMaxTrackRetries;
5949
5950 // If one track is ready, set the mixer ready if:
5951 // - the mixer was not ready during previous round OR
5952 // - no other track is not ready
5953 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
5954 mixerStatus != MIXER_TRACKS_ENABLED) {
5955 mixerStatus = MIXER_TRACKS_READY;
5956 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08005957
5958 // Enable the next few lines to instrument a test for underrun log handling.
5959 // TODO: Remove when we have a better way of testing the underrun log.
5960#if 0
5961 static int i;
5962 if ((++i & 0xf) == 0) {
5963 deferredOperations.tallyUnderrunFrames(track, 10 /* underrunFrames */);
5964 }
5965#endif
Eric Laurent81784c32012-11-19 14:55:58 -08005966 } else {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005967 size_t underrunFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005968 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
Andy Hungb68f5eb2019-12-03 16:49:17 -08005969 ALOGV("track(%d) underrun, track state %s framesReady(%zu) < framesDesired(%zd)",
5970 trackId, track->getTrackStateAsString(), framesReady, desiredFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005971 underrunFrames = desiredFrames;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005972 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005973 deferredOperations.tallyUnderrunFrames(track, underrunFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08005974
Eric Laurent81784c32012-11-19 14:55:58 -08005975 // clear effect chain input buffer if an active track underruns to avoid sending
5976 // previous audio buffer again to effects
5977 chain = getEffectChain_l(track->sessionId());
5978 if (chain != 0) {
5979 chain->clearInputBuffer();
5980 }
5981
Andy Hungc0691382018-09-12 18:01:57 -07005982 ALOGVV("track(%d) s=%08x [NOT READY] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005983 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
5984 track->isStopped() || track->isPaused()) {
5985 // We have consumed all the buffers of this track.
5986 // Remove it from the list of active tracks.
5987 // TODO: use actual buffer filling status instead of latency when available from
5988 // audio HAL
5989 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005990 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005991 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
5992 if (track->isStopped()) {
5993 track->reset();
5994 }
5995 tracksToRemove->add(track);
5996 }
5997 } else {
Eric Laurent81784c32012-11-19 14:55:58 -08005998 // No buffers for this track. Give it a few chances to
5999 // fill a buffer, then remove it from active list.
6000 if (--(track->mRetryCount) <= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07006001 ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p",
6002 trackId, this);
Eric Laurent81784c32012-11-19 14:55:58 -08006003 tracksToRemove->add(track);
6004 // indicate to client process that the track was disabled because of underrun;
6005 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08006006 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08006007 // If one track is not ready, mark the mixer also not ready if:
6008 // - the mixer was ready during previous round OR
6009 // - no other track is ready
6010 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
6011 mixerStatus != MIXER_TRACKS_READY) {
6012 mixerStatus = MIXER_TRACKS_ENABLED;
6013 }
6014 }
Andy Hungc0691382018-09-12 18:01:57 -07006015 mAudioMixer->disable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08006016 }
6017
6018 } // local variable scope to avoid goto warning
Eric Laurent81784c32012-11-19 14:55:58 -08006019
6020 }
6021
jiabin245cdd92018-12-07 17:55:15 -08006022 if (mHapticChannelMask != AUDIO_CHANNEL_NONE && sq != NULL) {
6023 // When there is no fast track playing haptic and FastMixer exists,
6024 // enabling the first FastTrack, which provides mixed data from normal
6025 // tracks, to play haptic data.
6026 FastTrack *fastTrack = &state->mFastTracks[0];
6027 if (fastTrack->mHapticPlaybackEnabled != noFastHapticTrack) {
6028 fastTrack->mHapticPlaybackEnabled = noFastHapticTrack;
6029 didModify = true;
6030 }
6031 }
6032
Eric Laurent81784c32012-11-19 14:55:58 -08006033 // Push the new FastMixer state if necessary
Jing Mike537412f2023-03-12 11:01:47 +08006034 [[maybe_unused]] bool pauseAudioWatchdog = false;
Eric Laurent81784c32012-11-19 14:55:58 -08006035 if (didModify) {
6036 state->mFastTracksGen++;
6037 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
6038 if (kUseFastMixer == FastMixer_Dynamic &&
6039 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
6040 state->mCommand = FastMixerState::COLD_IDLE;
6041 state->mColdFutexAddr = &mFastMixerFutex;
6042 state->mColdGen++;
6043 mFastMixerFutex = 0;
6044 if (kUseFastMixer == FastMixer_Dynamic) {
6045 mNormalSink = mOutputSink;
6046 }
6047 // If we go into cold idle, need to wait for acknowledgement
6048 // so that fast mixer stops doing I/O.
6049 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
6050 pauseAudioWatchdog = true;
6051 }
Eric Laurent81784c32012-11-19 14:55:58 -08006052 }
6053 if (sq != NULL) {
6054 sq->end(didModify);
Andy Hungf2285312017-02-14 18:31:59 -08006055 // No need to block if the FastMixer is in COLD_IDLE as the FastThread
6056 // is not active. (We BLOCK_UNTIL_ACKED when entering COLD_IDLE
6057 // when bringing the output sink into standby.)
6058 //
6059 // We will get the latest FastMixer state when we come out of COLD_IDLE.
6060 //
6061 // This occurs with BT suspend when we idle the FastMixer with
6062 // active tracks, which may be added or removed.
6063 sq->push(coldIdle ? FastMixerStateQueue::BLOCK_NEVER : block);
Eric Laurent81784c32012-11-19 14:55:58 -08006064 }
6065#ifdef AUDIO_WATCHDOG
6066 if (pauseAudioWatchdog && mAudioWatchdog != 0) {
6067 mAudioWatchdog->pause();
6068 }
6069#endif
6070
6071 // Now perform the deferred reset on fast tracks that have stopped
6072 while (resetMask != 0) {
6073 size_t i = __builtin_ctz(resetMask);
6074 ALOG_ASSERT(i < count);
6075 resetMask &= ~(1 << i);
Andy Hungdae27702016-10-31 14:01:16 -07006076 sp<Track> track = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08006077 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
6078 track->reset();
6079 }
6080
Andy Hung80d03d22018-04-10 10:32:11 -07006081 // Track destruction may occur outside of threadLoop once it is removed from active tracks.
6082 // Ensure the AudioMixer doesn't have a raw "buffer provider" pointer to the track if
6083 // it ceases to be active, to allow safe removal from the AudioMixer at the start
6084 // of prepareTracks_l(); this releases any outstanding buffer back to the track.
6085 // See also the implementation of destroyTrack_l().
6086 for (const auto &track : *tracksToRemove) {
Andy Hungc0691382018-09-12 18:01:57 -07006087 const int trackId = track->id();
6088 if (mAudioMixer->exists(trackId)) { // Normal tracks here, fast tracks in FastMixer.
6089 mAudioMixer->setBufferProvider(trackId, nullptr /* bufferProvider */);
Andy Hung80d03d22018-04-10 10:32:11 -07006090 }
6091 }
6092
Eric Laurent81784c32012-11-19 14:55:58 -08006093 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08006094 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08006095
Eric Laurentb3f315a2021-07-13 15:09:05 +02006096 if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0 ||
6097 getEffectChain_l(AUDIO_SESSION_OUTPUT_STAGE) != 0) {
Eric Laurent97d547d2014-09-02 14:45:53 -07006098 mEffectBufferValid = true;
Marco Nelissenac302142014-10-20 13:15:38 -07006099 }
6100
6101 if (mEffectBufferValid) {
Marco Nelissen57088b52014-10-17 16:39:39 -07006102 // as long as there are effects we should clear the effects buffer, to avoid
6103 // passing a non-clean buffer to the effect chain
6104 memset(mEffectBuffer, 0, mEffectBufferSize);
Eric Laurentb62d0362021-10-26 17:40:18 +02006105 if (mType == SPATIALIZER) {
6106 memset(mPostSpatializerBuffer, 0, mPostSpatializerBufferSize);
6107 }
Eric Laurent97d547d2014-09-02 14:45:53 -07006108 }
Andy Hung69aed5f2014-02-25 17:24:40 -08006109 // sink or mix buffer must be cleared if all tracks are connected to an
6110 // effect chain as in this case the mixer will not write to the sink or mix buffer
6111 // and track effects will accumulate into it
Eric Laurent39095982021-08-24 18:29:27 +02006112 // always clear sink buffer for spatializer output as the output of the spatializer
6113 // effect will be accumulated into it
6114 if ((mBytesRemaining == 0) && (((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
6115 (mixedTracks == 0 && fastTracks > 0)) || (mType == SPATIALIZER))) {
Eric Laurent81784c32012-11-19 14:55:58 -08006116 // FIXME as a performance optimization, should remember previous zero status
Andy Hung69aed5f2014-02-25 17:24:40 -08006117 if (mMixerBufferValid) {
6118 memset(mMixerBuffer, 0, mMixerBufferSize);
6119 // TODO: In testing, mSinkBuffer below need not be cleared because
6120 // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer
6121 // after mixing.
6122 //
6123 // To enforce this guarantee:
6124 // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
6125 // (mixedTracks == 0 && fastTracks > 0))
6126 // must imply MIXER_TRACKS_READY.
6127 // Later, we may clear buffers regardless, and skip much of this logic.
6128 }
Andy Hung98ef9782014-03-04 14:46:50 -08006129 // FIXME as a performance optimization, should remember previous zero status
Andy Hung5567aaf2014-07-17 14:00:07 -07006130 memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08006131 }
6132
6133 // if any fast tracks, then status is ready
6134 mMixerStatusIgnoringFastTracks = mixerStatus;
6135 if (fastTracks > 0) {
6136 mixerStatus = MIXER_TRACKS_READY;
6137 }
6138 return mixerStatus;
6139}
6140
Eric Laurentad7dd962016-09-22 12:38:37 -07006141// trackCountForUid_l() must be called with ThreadBase::mLock held
Andy Hung1bc088a2018-02-09 15:57:31 -08006142uint32_t AudioFlinger::PlaybackThread::trackCountForUid_l(uid_t uid) const
Eric Laurentad7dd962016-09-22 12:38:37 -07006143{
6144 uint32_t trackCount = 0;
6145 for (size_t i = 0; i < mTracks.size() ; i++) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08006146 if (mTracks[i]->uid() == uid) {
Eric Laurentad7dd962016-09-22 12:38:37 -07006147 trackCount++;
6148 }
6149 }
6150 return trackCount;
6151}
6152
Brian Lindahl65e90012022-07-27 18:01:07 +02006153bool AudioFlinger::PlaybackThread::IsTimestampAdvancing::check(AudioStreamOut * output)
ziyangch8f194f12021-12-01 13:48:04 -08006154{
Brian Lindahl65e90012022-07-27 18:01:07 +02006155 // Check the timestamp to see if it's advancing once every 150ms. If we check too frequently, we
6156 // could falsely detect that the frame position has stalled due to underrun because we haven't
6157 // given the Audio HAL enough time to update.
6158 const nsecs_t nowNs = systemTime();
6159 if (nowNs - mPreviousNs < mMinimumTimeBetweenChecksNs) {
6160 return mLatchedValue;
6161 }
6162 mPreviousNs = nowNs;
6163 mLatchedValue = false;
6164 // Determine if the presentation position is still advancing.
ziyangch8f194f12021-12-01 13:48:04 -08006165 uint64_t position = 0;
6166 struct timespec unused;
Brian Lindahl65e90012022-07-27 18:01:07 +02006167 const status_t ret = output->getPresentationPosition(&position, &unused);
ziyangch8f194f12021-12-01 13:48:04 -08006168 if (ret == NO_ERROR) {
Brian Lindahl65e90012022-07-27 18:01:07 +02006169 if (position != mPreviousPosition) {
6170 mPreviousPosition = position;
6171 mLatchedValue = true;
ziyangch8f194f12021-12-01 13:48:04 -08006172 }
6173 }
Brian Lindahl65e90012022-07-27 18:01:07 +02006174 return mLatchedValue;
6175}
6176
6177void AudioFlinger::PlaybackThread::IsTimestampAdvancing::clear()
6178{
6179 mLatchedValue = true;
6180 mPreviousPosition = 0;
6181 mPreviousNs = 0;
ziyangch8f194f12021-12-01 13:48:04 -08006182}
6183
Andy Hung1bc088a2018-02-09 15:57:31 -08006184// isTrackAllowed_l() must be called with ThreadBase::mLock held
6185bool AudioFlinger::MixerThread::isTrackAllowed_l(
6186 audio_channel_mask_t channelMask, audio_format_t format,
6187 audio_session_t sessionId, uid_t uid) const
Eric Laurent81784c32012-11-19 14:55:58 -08006188{
Andy Hung1bc088a2018-02-09 15:57:31 -08006189 if (!PlaybackThread::isTrackAllowed_l(channelMask, format, sessionId, uid)) {
6190 return false;
Eric Laurentad7dd962016-09-22 12:38:37 -07006191 }
Andy Hung1bc088a2018-02-09 15:57:31 -08006192 // Check validity as we don't call AudioMixer::create() here.
Mikhail Naganov7ad7a252019-07-30 14:42:32 -07006193 if (!mAudioMixer->isValidFormat(format)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08006194 ALOGW("%s: invalid format: %#x", __func__, format);
6195 return false;
6196 }
Mikhail Naganov7ad7a252019-07-30 14:42:32 -07006197 if (!mAudioMixer->isValidChannelMask(channelMask)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08006198 ALOGW("%s: invalid channelMask: %#x", __func__, channelMask);
6199 return false;
6200 }
6201 return true;
Eric Laurent81784c32012-11-19 14:55:58 -08006202}
6203
Eric Laurent10351942014-05-08 18:49:52 -07006204// checkForNewParameter_l() must be called with ThreadBase::mLock held
6205bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
6206 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08006207{
Eric Laurent81784c32012-11-19 14:55:58 -08006208 bool reconfig = false;
Eric Laurent10351942014-05-08 18:49:52 -07006209 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08006210
Glenn Kastenc05b8d72016-03-24 09:48:17 -07006211 AutoPark<FastMixer> park(mFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08006212
Eric Laurent10351942014-05-08 18:49:52 -07006213 AudioParameter param = AudioParameter(keyValuePair);
6214 int value;
6215 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
6216 reconfig = true;
6217 }
6218 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07006219 if (!isValidPcmSinkFormat((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07006220 status = BAD_VALUE;
6221 } else {
6222 // no need to save value, since it's constant
Eric Laurent81784c32012-11-19 14:55:58 -08006223 reconfig = true;
6224 }
Eric Laurent10351942014-05-08 18:49:52 -07006225 }
6226 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07006227 if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07006228 status = BAD_VALUE;
6229 } else {
6230 // no need to save value, since it's constant
6231 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08006232 }
Eric Laurent10351942014-05-08 18:49:52 -07006233 }
6234 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
6235 // do not accept frame count changes if tracks are open as the track buffer
6236 // size depends on frame count and correct behavior would not be guaranteed
6237 // if frame count is changed after track creation
6238 if (!mTracks.isEmpty()) {
6239 status = INVALID_OPERATION;
6240 } else {
6241 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08006242 }
Eric Laurent10351942014-05-08 18:49:52 -07006243 }
6244 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07006245 LOG_FATAL("Should not set routing device in MixerThread");
Eric Laurent10351942014-05-08 18:49:52 -07006246 }
Eric Laurent81784c32012-11-19 14:55:58 -08006247
Eric Laurent10351942014-05-08 18:49:52 -07006248 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006249 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006250 if (!mStandby && status == INVALID_OPERATION) {
Andy Hungdda7aed2023-03-27 15:53:06 -07006251 ALOGW("%s: setParameters failed with keyValuePair %s, entering standby",
6252 __func__, keyValuePair.c_str());
Phil Burk062e67a2015-02-11 13:40:50 -08006253 mOutput->standby();
Andy Hungdda7aed2023-03-27 15:53:06 -07006254 mThreadMetrics.logEndInterval();
6255 mThreadSnapshot.onEnd();
6256 setStandby_l();
Eric Laurent10351942014-05-08 18:49:52 -07006257 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006258 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent81784c32012-11-19 14:55:58 -08006259 }
Eric Laurent10351942014-05-08 18:49:52 -07006260 if (status == NO_ERROR && reconfig) {
6261 readOutputParameters_l();
6262 delete mAudioMixer;
6263 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
Andy Hung1bc088a2018-02-09 15:57:31 -08006264 for (const auto &track : mTracks) {
Andy Hungc0691382018-09-12 18:01:57 -07006265 const int trackId = track->id();
Andy Hung920f6572022-10-06 12:09:49 -07006266 const status_t createStatus = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07006267 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08006268 track->mChannelMask,
6269 track->mFormat,
6270 track->mSessionId);
Andy Hung920f6572022-10-06 12:09:49 -07006271 ALOGW_IF(createStatus != NO_ERROR,
Andy Hungc0691382018-09-12 18:01:57 -07006272 "%s(): AudioMixer cannot create track(%d)"
6273 " mask %#x, format %#x, sessionId %d",
Andy Hung1bc088a2018-02-09 15:57:31 -08006274 __func__,
Andy Hungc0691382018-09-12 18:01:57 -07006275 trackId, track->mChannelMask, track->mFormat, track->mSessionId);
Eric Laurent10351942014-05-08 18:49:52 -07006276 }
Eric Laurent73e26b62015-04-27 16:55:58 -07006277 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07006278 }
Eric Laurent81784c32012-11-19 14:55:58 -08006279 }
6280
Dean Wheatley68918102021-03-19 22:09:19 +11006281 return reconfig;
Eric Laurent81784c32012-11-19 14:55:58 -08006282}
6283
6284
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006285void AudioFlinger::MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08006286{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006287 PlaybackThread::dumpInternals_l(fd, args);
Andy Hung40eb1a12015-06-18 13:42:02 -07006288 dprintf(fd, " Thread throttle time (msecs): %u\n", mThreadThrottleTimeMs);
Andy Hung8ed196a2018-01-05 13:21:11 -08006289 dprintf(fd, " AudioMixer tracks: %s\n", mAudioMixer->trackNames().c_str());
Andy Hung2ddee192015-12-18 17:34:44 -08006290 dprintf(fd, " Master mono: %s\n", mMasterMono ? "on" : "off");
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01006291 dprintf(fd, " Master balance: %f (%s)\n", mMasterBalance.load(),
6292 (hasFastMixer() ? std::to_string(mFastMixer->getMasterBalance())
6293 : mBalance.toString()).c_str());
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08006294 if (hasFastMixer()) {
6295 dprintf(fd, " FastMixer thread %p tid=%d", mFastMixer.get(), mFastMixer->getTid());
6296
6297 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
6298 // while we are dumping it. It may be inconsistent, but it won't mutate!
6299 // This is a large object so we place it on the heap.
6300 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07006301 const std::unique_ptr<FastMixerDumpState> copy =
6302 std::make_unique<FastMixerDumpState>(mFastMixerDumpState);
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08006303 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08006304
6305#ifdef STATE_QUEUE_DUMP
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08006306 // Similar for state queue
6307 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
6308 observerCopy.dump(fd);
6309 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
6310 mutatorCopy.dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08006311#endif
6312
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08006313#ifdef AUDIO_WATCHDOG
6314 if (mAudioWatchdog != 0) {
6315 // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
6316 AudioWatchdogDump wdCopy = mAudioWatchdogDump;
6317 wdCopy.dump(fd);
6318 }
6319#endif
6320
6321 } else {
6322 dprintf(fd, " No FastMixer\n");
6323 }
Eric Laurent90cea102023-05-15 15:08:27 +02006324
6325 dprintf(fd, "Bluetooth latency modes are %senabled\n",
6326 mBluetoothLatencyModesEnabled ? "" : "not ");
6327 dprintf(fd, "HAL does %ssupport Bluetooth latency modes\n", mOutput != nullptr &&
6328 mOutput->audioHwDev->supportsBluetoothVariableLatency() ? "" : "not ");
6329 dprintf(fd, "Supported latency modes: %s\n", toString(mSupportedLatencyModes).c_str());
Eric Laurent81784c32012-11-19 14:55:58 -08006330}
6331
6332uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
6333{
6334 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
6335}
6336
6337uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
6338{
6339 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
6340}
6341
6342void AudioFlinger::MixerThread::cacheParameters_l()
6343{
6344 PlaybackThread::cacheParameters_l();
6345
6346 // FIXME: Relaxed timing because of a certain device that can't meet latency
6347 // Should be reduced to 2x after the vendor fixes the driver issue
6348 // increase threshold again due to low power audio mode. The way this warning
6349 // threshold is calculated and its usefulness should be reconsidered anyway.
6350 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
6351}
6352
Eric Laurentb0463942022-12-20 16:31:10 +01006353void AudioFlinger::MixerThread::onHalLatencyModesChanged_l() {
6354 mAudioFlinger->onSupportedLatencyModesChanged(mId, mSupportedLatencyModes);
6355}
6356
6357void AudioFlinger::MixerThread::setHalLatencyMode_l() {
6358 // Only handle latency mode if:
6359 // - mBluetoothLatencyModesEnabled is true
6360 // - the HAL supports latency modes
6361 // - the selected device is Bluetooth LE or A2DP
6362 if (!mBluetoothLatencyModesEnabled.load() || mSupportedLatencyModes.empty()) {
6363 return;
6364 }
6365 if (mOutDeviceTypeAddrs.size() != 1
6366 || !(audio_is_a2dp_out_device(mOutDeviceTypeAddrs[0].mType)
6367 || audio_is_ble_out_device(mOutDeviceTypeAddrs[0].mType))) {
6368 return;
6369 }
6370
6371 audio_latency_mode_t latencyMode = AUDIO_LATENCY_MODE_FREE;
6372 if (mSupportedLatencyModes.size() == 1) {
6373 // If the HAL only support one latency mode currently, confirm the choice
6374 latencyMode = mSupportedLatencyModes[0];
6375 } else if (mSupportedLatencyModes.size() > 1) {
6376 // Request low latency if:
6377 // - At least one active track is either:
6378 // - a fast track with gaming usage or
6379 // - a track with acessibility usage
6380 for (const auto& track : mActiveTracks) {
6381 if ((track->isFastTrack() && track->attributes().usage == AUDIO_USAGE_GAME)
6382 || track->attributes().usage == AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY) {
6383 latencyMode = AUDIO_LATENCY_MODE_LOW;
6384 break;
6385 }
6386 }
6387 }
6388
6389 if (latencyMode != mSetLatencyMode) {
6390 status_t status = mOutput->stream->setLatencyMode(latencyMode);
6391 ALOGD("%s: thread(%d) setLatencyMode(%s) returned %d",
6392 __func__, mId, toString(latencyMode).c_str(), status);
6393 if (status == NO_ERROR) {
6394 mSetLatencyMode = latencyMode;
6395 }
6396 }
6397}
6398
6399void AudioFlinger::MixerThread::updateHalSupportedLatencyModes_l() {
6400
6401 if (mOutput == nullptr || mOutput->stream == nullptr) {
6402 return;
6403 }
6404 std::vector<audio_latency_mode_t> latencyModes;
6405 const status_t status = mOutput->stream->getRecommendedLatencyModes(&latencyModes);
6406 if (status != NO_ERROR) {
6407 latencyModes.clear();
6408 }
6409 if (latencyModes != mSupportedLatencyModes) {
6410 ALOGD("%s: thread(%d) status %d supported latency modes: %s",
6411 __func__, mId, status, toString(latencyModes).c_str());
6412 mSupportedLatencyModes.swap(latencyModes);
6413 sendHalLatencyModesChangedEvent_l();
6414 }
6415}
6416
6417status_t AudioFlinger::MixerThread::getSupportedLatencyModes(
6418 std::vector<audio_latency_mode_t>* modes) {
6419 if (modes == nullptr) {
6420 return BAD_VALUE;
6421 }
6422 Mutex::Autolock _l(mLock);
6423 *modes = mSupportedLatencyModes;
6424 return NO_ERROR;
6425}
6426
6427void AudioFlinger::MixerThread::onRecommendedLatencyModeChanged(
6428 std::vector<audio_latency_mode_t> modes) {
6429 Mutex::Autolock _l(mLock);
6430 if (modes != mSupportedLatencyModes) {
6431 ALOGD("%s: thread(%d) supported latency modes: %s",
6432 __func__, mId, toString(modes).c_str());
6433 mSupportedLatencyModes.swap(modes);
6434 sendHalLatencyModesChangedEvent_l();
6435 }
6436}
6437
6438status_t AudioFlinger::MixerThread::setBluetoothVariableLatencyEnabled(bool enabled) {
6439 if (mOutput == nullptr || mOutput->audioHwDev == nullptr
6440 || !mOutput->audioHwDev->supportsBluetoothVariableLatency()) {
6441 return INVALID_OPERATION;
6442 }
6443 mBluetoothLatencyModesEnabled.store(enabled);
6444 return NO_ERROR;
6445}
6446
Eric Laurent81784c32012-11-19 14:55:58 -08006447// ----------------------------------------------------------------------------
6448
6449AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
Gareth Fennb18c1a32022-10-05 13:42:36 -07006450 AudioStreamOut* output, audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
6451 const audio_offload_info_t& offloadInfo)
jiabinc52b1ff2019-10-31 17:20:42 -07006452 : PlaybackThread(audioFlinger, output, id, type, systemReady)
Gareth Fennb18c1a32022-10-05 13:42:36 -07006453 , mOffloadInfo(offloadInfo)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006454{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01006455 setMasterBalance(audioFlinger->getMasterBalance_l());
Eric Laurentbfb1b832013-01-07 09:53:42 -08006456}
6457
Eric Laurent81784c32012-11-19 14:55:58 -08006458AudioFlinger::DirectOutputThread::~DirectOutputThread()
6459{
6460}
6461
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006462void AudioFlinger::DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01006463{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006464 PlaybackThread::dumpInternals_l(fd, args);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01006465 dprintf(fd, " Master balance: %f Left: %f Right: %f\n",
6466 mMasterBalance.load(), mMasterBalanceLeft, mMasterBalanceRight);
6467}
6468
6469void AudioFlinger::DirectOutputThread::setMasterBalance(float balance)
6470{
6471 Mutex::Autolock _l(mLock);
6472 if (mMasterBalance != balance) {
6473 mMasterBalance.store(balance);
6474 mBalance.computeStereoBalance(balance, &mMasterBalanceLeft, &mMasterBalanceRight);
6475 broadcast_l();
6476 }
6477}
6478
Eric Laurent5850c4c2016-11-10 13:04:31 -08006479void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006480{
Eric Laurentbfb1b832013-01-07 09:53:42 -08006481 float left, right;
6482
Andy Hung333ab962019-05-28 20:23:35 -07006483 // Ensure volumeshaper state always advances even when muted.
6484 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
Andy Hung398ffa22022-12-13 19:19:53 -08006485
6486 const size_t framesReleased = proxy->framesReleased();
6487 const int64_t frames = mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
6488 const int64_t time = mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
6489
6490 ALOGV("%s: Direct/Offload bufferConsumed:%zu timestamp frames:%lld time:%lld",
6491 __func__, framesReleased, (long long)frames, (long long)time);
6492
6493 const int64_t volumeShaperFrames =
6494 mMonotonicFrameCounter.updateAndGetMonotonicFrameCount(frames, time);
6495 const auto [shaperVolume, shaperActive] =
6496 track->getVolumeHandler()->getVolume(volumeShaperFrames);
Andy Hung333ab962019-05-28 20:23:35 -07006497 mVolumeShaperActive = shaperActive;
6498
Vlad Popae2f5aef2022-07-25 16:00:20 +02006499 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
6500 left = float_from_gain(gain_minifloat_unpack_left(vlr));
6501 right = float_from_gain(gain_minifloat_unpack_right(vlr));
6502
6503 const bool clientVolumeMute = (left == 0.f && right == 0.f);
6504
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08006505 if (mMasterMute || mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006506 left = right = 0;
6507 } else {
6508 float typeVolume = mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07006509 const float v = mMasterVolume * typeVolume * shaperVolume;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08006510
Glenn Kastenc56f3422014-03-21 17:53:17 -07006511 if (left > GAIN_FLOAT_UNITY) {
6512 left = GAIN_FLOAT_UNITY;
6513 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07006514 if (right > GAIN_FLOAT_UNITY) {
6515 right = GAIN_FLOAT_UNITY;
6516 }
zhangjincheng86cb3bc2023-01-16 17:17:38 +08006517 left *= v;
6518 right *= v;
6519 if (mAudioFlinger->getMode() != AUDIO_MODE_IN_COMMUNICATION
6520 || audio_channel_count_from_out_mask(mChannelMask) > 1) {
6521 left *= mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
6522 right *= mMasterBalanceRight;
6523 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006524 }
6525
Vlad Popae8d99472022-06-30 16:02:48 +02006526 track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
6527 /*muteState=*/{mMasterMute,
6528 mStreamTypes[track->streamType()].volume == 0.f,
6529 mStreamTypes[track->streamType()].mute,
Vlad Popae2f5aef2022-07-25 16:00:20 +02006530 track->isPlaybackRestricted(),
Vlad Popa436c9172022-08-02 15:25:08 +02006531 clientVolumeMute,
6532 shaperVolume == 0.f});
Vlad Popae8d99472022-06-30 16:02:48 +02006533
Eric Laurentbfb1b832013-01-07 09:53:42 -08006534 if (lastTrack) {
jiabin76d94692022-12-15 21:51:21 +00006535 track->setFinalVolume(left, right);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006536 if (left != mLeftVolFloat || right != mRightVolFloat) {
6537 mLeftVolFloat = left;
6538 mRightVolFloat = right;
6539
Eric Laurentbfb1b832013-01-07 09:53:42 -08006540 // Delegate volume control to effect in track effect chain if needed
6541 // only one effect chain can be present on DirectOutputThread, so if
6542 // there is one, the track is connected to it
6543 if (!mEffectChains.isEmpty()) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09006544 // if effect chain exists, volume is handled by it.
6545 // Convert volumes from float to 8.24
6546 uint32_t vl = (uint32_t)(left * (1 << 24));
6547 uint32_t vr = (uint32_t)(right * (1 << 24));
6548 // Direct/Offload effect chains set output volume in setVolume_l().
6549 (void)mEffectChains[0]->setVolume_l(&vl, &vr);
6550 } else {
6551 // otherwise we directly set the volume.
6552 setVolumeForOutput_l(left, right);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006553 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006554 }
6555 }
6556}
6557
Phil Burk43b4dcc2015-06-09 16:53:44 -07006558void AudioFlinger::DirectOutputThread::onAddNewTrack_l()
6559{
6560 sp<Track> previousTrack = mPreviousTrack.promote();
Andy Hungdae27702016-10-31 14:01:16 -07006561 sp<Track> latestTrack = mActiveTracks.getLatest();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006562
Eric Laurent0f0631e2015-07-06 18:01:25 -07006563 if (previousTrack != 0 && latestTrack != 0) {
6564 if (mType == DIRECT) {
6565 if (previousTrack.get() != latestTrack.get()) {
6566 mFlushPending = true;
6567 }
6568 } else /* mType == OFFLOAD */ {
Dean Wheatley0f51fd02022-08-31 16:41:40 +10006569 if (previousTrack->sessionId() != latestTrack->sessionId() ||
6570 previousTrack->isFlushPending()) {
Eric Laurent0f0631e2015-07-06 18:01:25 -07006571 mFlushPending = true;
6572 }
6573 }
Revathi Uddaraju20413a92016-10-13 17:16:14 +08006574 } else if (previousTrack == 0) {
6575 // there could be an old track added back during track transition for direct
6576 // output, so always issues flush to flush data of the previous track if it
6577 // was already destroyed with HAL paused, then flush can resume the playback
6578 mFlushPending = true;
Phil Burk43b4dcc2015-06-09 16:53:44 -07006579 }
6580 PlaybackThread::onAddNewTrack_l();
6581}
Eric Laurentbfb1b832013-01-07 09:53:42 -08006582
Eric Laurent81784c32012-11-19 14:55:58 -08006583AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
6584 Vector< sp<Track> > *tracksToRemove
6585)
6586{
Eric Laurentd595b7c2013-04-03 17:27:56 -07006587 size_t count = mActiveTracks.size();
Eric Laurent81784c32012-11-19 14:55:58 -08006588 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006589 bool doHwPause = false;
6590 bool doHwResume = false;
Eric Laurent81784c32012-11-19 14:55:58 -08006591
6592 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07006593 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08006594 if (t->isInvalid()) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07006595 ALOGW("An invalidated track shouldn't be in active list");
Eric Laurent5850c4c2016-11-10 13:04:31 -08006596 tracksToRemove->add(t);
Phil Burk43b4dcc2015-06-09 16:53:44 -07006597 continue;
6598 }
6599
Eric Laurent5850c4c2016-11-10 13:04:31 -08006600 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006601#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurent81784c32012-11-19 14:55:58 -08006602 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006603#endif
Eric Laurentfd477972013-10-25 18:10:40 -07006604 // Only consider last track started for volume and mixer state control.
6605 // In theory an older track could underrun and restart after the new one starts
6606 // but as we only care about the transition phase between two tracks on a
6607 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07006608 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08006609 bool last = l.get() == track;
Eric Laurent81784c32012-11-19 14:55:58 -08006610
Kuowei Li23666472021-01-20 10:23:25 +08006611 if (track->isPausePending()) {
6612 track->pauseAck();
6613 // It is possible a track might have been flushed or stopped.
6614 // Other operations such as flush pending might occur on the next prepare.
6615 if (track->isPausing()) {
6616 track->setPaused();
6617 }
6618 // Always perform pause, as an immediate flush will change
6619 // the pause state to be no longer isPausing().
Phil Burk6fc2a7c2015-04-30 16:08:10 -07006620 if (mHwSupportsPause && last && !mHwPaused) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006621 doHwPause = true;
6622 mHwPaused = true;
6623 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08006624 } else if (track->isFlushPending()) {
6625 track->flushAck();
6626 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07006627 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006628 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07006629 } else if (track->isResumePending()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006630 track->resumeAck();
Eric Laurent3df841a2016-07-15 15:15:40 -07006631 if (last) {
6632 mLeftVolFloat = mRightVolFloat = -1.0;
6633 if (mHwPaused) {
6634 doHwResume = true;
6635 mHwPaused = false;
6636 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08006637 }
6638 }
6639
Eric Laurent81784c32012-11-19 14:55:58 -08006640 // The first time a track is added we wait
Phil Burk99adee32014-12-10 16:46:30 -08006641 // for all its buffers to be filled before processing it.
6642 // Allow draining the buffer in case the client
6643 // app does not call stop() and relies on underrun to stop:
6644 // hence the test on (track->mRetryCount > 1).
Andy Hung455982f2021-04-27 17:46:12 -07006645 // If track->mRetryCount <= 1 then track is about to be disabled, paused, removed,
6646 // so we accept any nonzero amount of data delivered by the AudioTrack (which will
6647 // reset the retry counter).
Phil Burkca5e6142015-07-14 09:42:29 -07006648 // Do not use a high threshold for compressed audio.
Andy Hung455982f2021-04-27 17:46:12 -07006649
6650 // target retry count that we will use is based on the time we wait for retries.
6651 const int32_t targetRetryCount = kMaxTrackRetriesDirectMs * 1000 / mActiveSleepTimeUs;
6652 // the retry threshold is when we accept any size for PCM data. This is slightly
6653 // smaller than the retry count so we can push small bits of data without a glitch.
6654 const int32_t retryThreshold = targetRetryCount > 2 ? targetRetryCount - 1 : 1;
Eric Laurent81784c32012-11-19 14:55:58 -08006655 uint32_t minFrames;
Phil Burk99adee32014-12-10 16:46:30 -08006656 if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
Andy Hung455982f2021-04-27 17:46:12 -07006657 && (track->mRetryCount > retryThreshold) && audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006658 minFrames = mNormalFrameCount;
6659 } else {
6660 minFrames = 1;
6661 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006662
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07006663 const size_t framesReady = track->framesReady();
6664 const int trackId = track->id();
6665 if (ATRACE_ENABLED()) {
6666 std::string traceName("nRdy");
6667 traceName += std::to_string(trackId);
6668 ATRACE_INT(traceName.c_str(), framesReady);
6669 }
6670 if ((framesReady >= minFrames) && track->isReady() && !track->isPaused() &&
Eric Laurentab5cdba2014-06-09 17:22:27 -07006671 !track->isStopping_2() && !track->isStopped())
Eric Laurent81784c32012-11-19 14:55:58 -08006672 {
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07006673 ALOGVV("track(%d) s=%08x [OK]", trackId, cblk->mServer);
Eric Laurent81784c32012-11-19 14:55:58 -08006674
6675 if (track->mFillingUpStatus == Track::FS_FILLED) {
6676 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07006677 if (last) {
6678 // make sure processVolume_l() will apply new volume even if 0
6679 mLeftVolFloat = mRightVolFloat = -1.0;
6680 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08006681 if (!mHwSupportsPause) {
6682 track->resumeAck();
Eric Laurent81784c32012-11-19 14:55:58 -08006683 }
6684 }
6685
6686 // compute volume for this track
Eric Laurentbfb1b832013-01-07 09:53:42 -08006687 processVolume_l(track, last);
6688 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07006689 sp<Track> previousTrack = mPreviousTrack.promote();
6690 if (previousTrack != 0) {
6691 if (track != previousTrack.get()) {
6692 // Flush any data still being written from last track
6693 mBytesRemaining = 0;
Eric Laurent0f0631e2015-07-06 18:01:25 -07006694 // Invalidate previous track to force a seek when resuming.
6695 previousTrack->invalidate();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006696 }
6697 }
6698 mPreviousTrack = track;
6699
Eric Laurentd595b7c2013-04-03 17:27:56 -07006700 // reset retry count
Andy Hung455982f2021-04-27 17:46:12 -07006701 track->mRetryCount = targetRetryCount;
Eric Laurent5850c4c2016-11-10 13:04:31 -08006702 mActiveTrack = t;
Eric Laurentd595b7c2013-04-03 17:27:56 -07006703 mixerStatus = MIXER_TRACKS_READY;
Eric Laurent5cff4032015-05-26 13:49:58 -07006704 if (mHwPaused) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006705 doHwResume = true;
6706 mHwPaused = false;
6707 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07006708 }
Eric Laurent81784c32012-11-19 14:55:58 -08006709 } else {
Eric Laurentd595b7c2013-04-03 17:27:56 -07006710 // clear effect chain input buffer if the last active track started underruns
6711 // to avoid sending previous audio buffer again to effects
Eric Laurentfd477972013-10-25 18:10:40 -07006712 if (!mEffectChains.isEmpty() && last) {
Eric Laurent81784c32012-11-19 14:55:58 -08006713 mEffectChains[0]->clearInputBuffer();
6714 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07006715 if (track->isStopping_1()) {
6716 track->mState = TrackBase::STOPPING_2;
Eric Laurentb369caf2015-03-30 20:51:47 -07006717 if (last && mHwPaused) {
6718 doHwResume = true;
6719 mHwPaused = false;
6720 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07006721 }
6722 if ((track->sharedBuffer() != 0) || track->isStopped() ||
6723 track->isStopping_2() || track->isPaused()) {
Eric Laurent81784c32012-11-19 14:55:58 -08006724 // We have consumed all the buffers of this track.
6725 // Remove it from the list of active tracks.
Atneya Nair0cae0432022-05-10 18:12:12 -04006726 bool presComplete = false;
Eric Laurentfd477972013-10-25 18:10:40 -07006727 if (mStandby || !last ||
Atneya Nair0cae0432022-05-10 18:12:12 -04006728 (presComplete = track->presentationComplete(latency_l())) ||
Jindong32dc26e2019-11-11 18:10:01 +08006729 track->isPaused() || mHwPaused) {
Atneya Nair0cae0432022-05-10 18:12:12 -04006730 if (presComplete) {
6731 mOutput->presentationComplete();
6732 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07006733 if (track->isStopping_2()) {
6734 track->mState = TrackBase::STOPPED;
6735 }
Eric Laurent81784c32012-11-19 14:55:58 -08006736 if (track->isStopped()) {
6737 track->reset();
6738 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07006739 tracksToRemove->add(track);
Eric Laurent81784c32012-11-19 14:55:58 -08006740 }
6741 } else {
6742 // No buffers for this track. Give it a few chances to
6743 // fill a buffer, then remove it from active list.
Eric Laurentd595b7c2013-04-03 17:27:56 -07006744 // Only consider last track started for mixer state control
Brian Lindahl65e90012022-07-27 18:01:07 +02006745 bool isTimestampAdvancing = mIsTimestampAdvancing.check(mOutput);
Gareth Fennb18c1a32022-10-05 13:42:36 -07006746 if (!isTunerStream() // tuner streams remain active in underrun
6747 && --(track->mRetryCount) <= 0) {
Brian Lindahl65e90012022-07-27 18:01:07 +02006748 if (isTimestampAdvancing) { // HAL is still playing audio, give us more time.
ziyangch8f194f12021-12-01 13:48:04 -08006749 track->mRetryCount = kMaxTrackRetriesOffload;
6750 } else {
6751 ALOGV("BUFFER TIMEOUT: remove track(%d) from active list", trackId);
6752 tracksToRemove->add(track);
6753 // indicate to client process that the track was disabled because of
6754 // underrun; it will then automatically call start() when data is available
6755 track->disable();
6756 // only do hw pause when track is going to be removed due to BUFFER TIMEOUT.
6757 // unlike mixerthread, HAL can be paused for direct output
6758 ALOGW("pause because of UNDERRUN, framesReady = %zu,"
6759 "minFrames = %u, mFormat = %#x",
6760 framesReady, minFrames, mFormat);
6761 if (last && mHwSupportsPause && !mHwPaused && !mStandby) {
6762 doHwPause = true;
6763 mHwPaused = true;
6764 }
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006765 }
Haynes Mathew George5c6daae2017-01-24 20:06:05 -08006766 } else if (last) {
6767 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurent81784c32012-11-19 14:55:58 -08006768 }
6769 }
6770 }
6771 }
6772
Eric Laurentd1f69b02014-12-15 14:33:13 -08006773 // if an active track did not command a flush, check for pending flush on stopped tracks
Phil Burk43b4dcc2015-06-09 16:53:44 -07006774 if (!mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006775 for (size_t i = 0; i < mTracks.size(); i++) {
6776 if (mTracks[i]->isFlushPending()) {
6777 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006778 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006779 }
6780 }
6781 }
6782
6783 // make sure the pause/flush/resume sequence is executed in the right order.
6784 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
6785 // before flush and then resume HW. This can happen in case of pause/flush/resume
6786 // if resume is received before pause is executed.
6787 if (mHwSupportsPause && !mStandby &&
Phil Burk43b4dcc2015-06-09 16:53:44 -07006788 (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006789 status_t result = mOutput->stream->pause();
6790 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Gareth Fenncd1e1622022-10-05 11:45:45 -07006791 doHwResume = !doHwPause; // resume if pause is due to flush.
Eric Laurentd1f69b02014-12-15 14:33:13 -08006792 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07006793 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006794 flushHw_l();
6795 }
6796 if (mHwSupportsPause && !mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006797 status_t result = mOutput->stream->resume();
6798 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006799 }
Eric Laurent81784c32012-11-19 14:55:58 -08006800 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08006801 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08006802
6803 return mixerStatus;
6804}
6805
6806void AudioFlinger::DirectOutputThread::threadLoop_mix()
6807{
Eric Laurent81784c32012-11-19 14:55:58 -08006808 size_t frameCount = mFrameCount;
Andy Hung2098f272014-02-27 14:00:06 -08006809 int8_t *curBuf = (int8_t *)mSinkBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08006810 // output audio to hardware
6811 while (frameCount) {
Glenn Kasten34542ac2013-06-26 11:29:02 -07006812 AudioBufferProvider::Buffer buffer;
Eric Laurent81784c32012-11-19 14:55:58 -08006813 buffer.frameCount = frameCount;
Phil Burk062e67a2015-02-11 13:40:50 -08006814 status_t status = mActiveTrack->getNextBuffer(&buffer);
6815 if (status != NO_ERROR || buffer.raw == NULL) {
Eric Laurent51716182016-02-29 18:00:56 -08006816 // no need to pad with 0 for compressed audio
6817 if (audio_has_proportional_frames(mFormat)) {
6818 memset(curBuf, 0, frameCount * mFrameSize);
6819 }
Eric Laurent81784c32012-11-19 14:55:58 -08006820 break;
6821 }
6822 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
6823 frameCount -= buffer.frameCount;
6824 curBuf += buffer.frameCount * mFrameSize;
6825 mActiveTrack->releaseBuffer(&buffer);
6826 }
Andy Hung2098f272014-02-27 14:00:06 -08006827 mCurrentWriteLength = curBuf - (int8_t *)mSinkBuffer;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006828 mSleepTimeUs = 0;
6829 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006830 mActiveTrack.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08006831}
6832
6833void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
6834{
Eric Laurentd1f69b02014-12-15 14:33:13 -08006835 // do not write to HAL when paused
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006836 if (mHwPaused || (usesHwAvSync() && mStandby)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006837 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006838 return;
6839 }
Andy Hung85ba3332021-04-27 17:40:26 -07006840 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
6841 mSleepTimeUs = mActiveSleepTimeUs;
6842 } else {
6843 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006844 }
Andy Hung85ba3332021-04-27 17:40:26 -07006845 // Note: In S or later, we do not write zeroes for
6846 // linear or proportional PCM direct tracks in underrun.
Eric Laurent81784c32012-11-19 14:55:58 -08006847}
6848
Eric Laurentd1f69b02014-12-15 14:33:13 -08006849void AudioFlinger::DirectOutputThread::threadLoop_exit()
6850{
6851 {
6852 Mutex::Autolock _l(mLock);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006853 for (size_t i = 0; i < mTracks.size(); i++) {
6854 if (mTracks[i]->isFlushPending()) {
6855 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006856 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006857 }
6858 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07006859 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006860 flushHw_l();
6861 }
6862 }
6863 PlaybackThread::threadLoop_exit();
6864}
6865
6866// must be called with thread mutex locked
6867bool AudioFlinger::DirectOutputThread::shouldStandby_l()
6868{
6869 bool trackPaused = false;
Eric Laurentb369caf2015-03-30 20:51:47 -07006870 bool trackStopped = false;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006871
6872 // do not put the HAL in standby when paused. AwesomePlayer clear the offloaded AudioTrack
6873 // after a timeout and we will enter standby then.
6874 if (mTracks.size() > 0) {
6875 trackPaused = mTracks[mTracks.size() - 1]->isPaused();
Eric Laurentb369caf2015-03-30 20:51:47 -07006876 trackStopped = mTracks[mTracks.size() - 1]->isStopped() ||
6877 mTracks[mTracks.size() - 1]->mState == TrackBase::IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006878 }
6879
Eric Laurent5cff4032015-05-26 13:49:58 -07006880 return !mStandby && !(trackPaused || (mHwPaused && !trackStopped));
Eric Laurentd1f69b02014-12-15 14:33:13 -08006881}
6882
Eric Laurent10351942014-05-08 18:49:52 -07006883// checkForNewParameter_l() must be called with ThreadBase::mLock held
6884bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
6885 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08006886{
6887 bool reconfig = false;
Eric Laurent10351942014-05-08 18:49:52 -07006888 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08006889
Eric Laurent10351942014-05-08 18:49:52 -07006890 AudioParameter param = AudioParameter(keyValuePair);
6891 int value;
6892 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07006893 LOG_FATAL("Should not set routing device in DirectOutputThread");
Eric Laurent81784c32012-11-19 14:55:58 -08006894 }
Eric Laurent10351942014-05-08 18:49:52 -07006895 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
6896 // do not accept frame count changes if tracks are open as the track buffer
6897 // size depends on frame count and correct behavior would not be garantied
6898 // if frame count is changed after track creation
6899 if (!mTracks.isEmpty()) {
6900 status = INVALID_OPERATION;
6901 } else {
6902 reconfig = true;
6903 }
6904 }
6905 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006906 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006907 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08006908 mOutput->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07006909 if (!mStandby) {
6910 mThreadMetrics.logEndInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07006911 mThreadSnapshot.onEnd();
Eric Laurent19952e12023-04-20 10:08:29 +02006912 setStandby_l();
Andy Hungcf10d742020-04-28 15:38:24 -07006913 }
Eric Laurent10351942014-05-08 18:49:52 -07006914 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006915 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006916 }
6917 if (status == NO_ERROR && reconfig) {
6918 readOutputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07006919 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07006920 }
6921 }
6922
Dean Wheatley68918102021-03-19 22:09:19 +11006923 return reconfig;
Eric Laurent81784c32012-11-19 14:55:58 -08006924}
6925
6926uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
6927{
6928 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006929 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006930 time = PlaybackThread::activeSleepTimeUs();
6931 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006932 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006933 }
6934 return time;
6935}
6936
6937uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
6938{
6939 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006940 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006941 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
6942 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006943 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006944 }
6945 return time;
6946}
6947
6948uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
6949{
6950 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006951 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006952 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
6953 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006954 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006955 }
6956 return time;
6957}
6958
6959void AudioFlinger::DirectOutputThread::cacheParameters_l()
6960{
6961 PlaybackThread::cacheParameters_l();
6962
6963 // use shorter standby delay as on normal output to release
6964 // hardware resources as soon as possible
Eric Laurentb369caf2015-03-30 20:51:47 -07006965 // no delay on outputs with HW A/V sync
6966 if (usesHwAvSync()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006967 mStandbyDelayNs = 0;
Phil Burkfdb3c072016-02-09 10:47:02 -08006968 } else if ((mType == OFFLOAD) && !audio_has_proportional_frames(mFormat)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006969 mStandbyDelayNs = kOffloadStandbyDelayNs;
Eric Laurent5cff4032015-05-26 13:49:58 -07006970 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006971 mStandbyDelayNs = microseconds(mActiveSleepTimeUs*2);
Eric Laurent972a1732013-09-04 09:42:59 -07006972 }
Eric Laurent81784c32012-11-19 14:55:58 -08006973}
6974
Eric Laurente659ef42014-09-29 13:06:46 -07006975void AudioFlinger::DirectOutputThread::flushHw_l()
6976{
ziyangch8f194f12021-12-01 13:48:04 -08006977 PlaybackThread::flushHw_l();
Phil Burk062e67a2015-02-11 13:40:50 -08006978 mOutput->flush();
Eric Laurentd1f69b02014-12-15 14:33:13 -08006979 mHwPaused = false;
Phil Burk43b4dcc2015-06-09 16:53:44 -07006980 mFlushPending = false;
Dean Wheatley12473e92021-03-18 23:00:55 +11006981 mTimestampVerifier.discontinuity(discontinuityForStandbyOrFlush());
Sampath Shetty999f0e82020-01-15 10:19:06 +11006982 mTimestamp.clear();
Andy Hung398ffa22022-12-13 19:19:53 -08006983 mMonotonicFrameCounter.onFlush();
Eric Laurente659ef42014-09-29 13:06:46 -07006984}
6985
Andy Hung10cbff12017-02-21 17:30:14 -08006986int64_t AudioFlinger::DirectOutputThread::computeWaitTimeNs_l() const {
6987 // If a VolumeShaper is active, we must wake up periodically to update volume.
6988 const int64_t NS_PER_MS = 1000000;
6989 return mVolumeShaperActive ?
6990 kMinNormalSinkBufferSizeMs * NS_PER_MS : PlaybackThread::computeWaitTimeNs_l();
6991}
6992
Eric Laurent81784c32012-11-19 14:55:58 -08006993// ----------------------------------------------------------------------------
6994
Eric Laurentbfb1b832013-01-07 09:53:42 -08006995AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
Eric Laurent4de95592013-09-26 15:28:21 -07006996 const wp<AudioFlinger::PlaybackThread>& playbackThread)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006997 : Thread(false /*canCallJava*/),
Eric Laurent4de95592013-09-26 15:28:21 -07006998 mPlaybackThread(playbackThread),
Eric Laurent3b4529e2013-09-05 18:09:19 -07006999 mWriteAckSequence(0),
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007000 mDrainSequence(0),
7001 mAsyncError(false)
Eric Laurentbfb1b832013-01-07 09:53:42 -08007002{
7003}
7004
7005AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
7006{
7007}
7008
7009void AudioFlinger::AsyncCallbackThread::onFirstRef()
7010{
7011 run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
7012}
7013
7014bool AudioFlinger::AsyncCallbackThread::threadLoop()
7015{
7016 while (!exitPending()) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07007017 uint32_t writeAckSequence;
7018 uint32_t drainSequence;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007019 bool asyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007020
7021 {
7022 Mutex::Autolock _l(mLock);
Haynes Mathew George24a325d2013-12-03 21:26:02 -08007023 while (!((mWriteAckSequence & 1) ||
7024 (mDrainSequence & 1) ||
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007025 mAsyncError ||
Haynes Mathew George24a325d2013-12-03 21:26:02 -08007026 exitPending())) {
7027 mWaitWorkCV.wait(mLock);
7028 }
7029
Eric Laurentbfb1b832013-01-07 09:53:42 -08007030 if (exitPending()) {
7031 break;
7032 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07007033 ALOGV("AsyncCallbackThread mWriteAckSequence %d mDrainSequence %d",
7034 mWriteAckSequence, mDrainSequence);
7035 writeAckSequence = mWriteAckSequence;
7036 mWriteAckSequence &= ~1;
7037 drainSequence = mDrainSequence;
7038 mDrainSequence &= ~1;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007039 asyncError = mAsyncError;
7040 mAsyncError = false;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007041 }
7042 {
Eric Laurent4de95592013-09-26 15:28:21 -07007043 sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
7044 if (playbackThread != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07007045 if (writeAckSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07007046 playbackThread->resetWriteBlocked(writeAckSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007047 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07007048 if (drainSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07007049 playbackThread->resetDraining(drainSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007050 }
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007051 if (asyncError) {
7052 playbackThread->onAsyncError();
7053 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007054 }
7055 }
7056 }
7057 return false;
7058}
7059
7060void AudioFlinger::AsyncCallbackThread::exit()
7061{
7062 ALOGV("AsyncCallbackThread::exit");
7063 Mutex::Autolock _l(mLock);
7064 requestExit();
7065 mWaitWorkCV.broadcast();
7066}
7067
Eric Laurent3b4529e2013-09-05 18:09:19 -07007068void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08007069{
7070 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07007071 // bit 0 is cleared
7072 mWriteAckSequence = sequence << 1;
7073}
7074
7075void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
7076{
7077 Mutex::Autolock _l(mLock);
7078 // ignore unexpected callbacks
7079 if (mWriteAckSequence & 2) {
7080 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007081 mWaitWorkCV.signal();
7082 }
7083}
7084
Eric Laurent3b4529e2013-09-05 18:09:19 -07007085void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08007086{
7087 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07007088 // bit 0 is cleared
7089 mDrainSequence = sequence << 1;
7090}
7091
7092void AudioFlinger::AsyncCallbackThread::resetDraining()
7093{
7094 Mutex::Autolock _l(mLock);
7095 // ignore unexpected callbacks
7096 if (mDrainSequence & 2) {
7097 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007098 mWaitWorkCV.signal();
7099 }
7100}
7101
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07007102void AudioFlinger::AsyncCallbackThread::setAsyncError()
7103{
7104 Mutex::Autolock _l(mLock);
7105 mAsyncError = true;
7106 mWaitWorkCV.signal();
7107}
7108
Eric Laurentbfb1b832013-01-07 09:53:42 -08007109
7110// ----------------------------------------------------------------------------
7111AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
Gareth Fennb18c1a32022-10-05 13:42:36 -07007112 AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
7113 const audio_offload_info_t& offloadInfo)
7114 : DirectOutputThread(audioFlinger, output, id, OFFLOAD, systemReady, offloadInfo),
ziyangch8f194f12021-12-01 13:48:04 -08007115 mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true)
Eric Laurentbfb1b832013-01-07 09:53:42 -08007116{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07007117 //FIXME: mStandby should be set to true by ThreadBase constructo
Eric Laurentfd477972013-10-25 18:10:40 -07007118 mStandby = true;
Eric Laurent64667972016-03-30 18:19:46 -07007119 mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007120}
7121
Eric Laurentbfb1b832013-01-07 09:53:42 -08007122void AudioFlinger::OffloadThread::threadLoop_exit()
7123{
7124 if (mFlushPending || mHwPaused) {
7125 // If a flush is pending or track was paused, just discard buffered data
7126 flushHw_l();
7127 } else {
7128 mMixerStatus = MIXER_DRAIN_ALL;
7129 threadLoop_drain();
7130 }
Uday Gupta56604aa2014-05-13 11:19:17 -07007131 if (mUseAsyncWrite) {
7132 ALOG_ASSERT(mCallbackThread != 0);
7133 mCallbackThread->exit();
7134 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007135 PlaybackThread::threadLoop_exit();
7136}
7137
7138AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
7139 Vector< sp<Track> > *tracksToRemove
7140)
7141{
Eric Laurentbfb1b832013-01-07 09:53:42 -08007142 size_t count = mActiveTracks.size();
7143
7144 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurent972a1732013-09-04 09:42:59 -07007145 bool doHwPause = false;
7146 bool doHwResume = false;
7147
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007148 ALOGV("OffloadThread::prepareTracks_l active tracks %zu", count);
Eric Laurentede6c3b2013-09-19 14:37:46 -07007149
Eric Laurentbfb1b832013-01-07 09:53:42 -08007150 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07007151 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08007152 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07007153#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurentbfb1b832013-01-07 09:53:42 -08007154 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07007155#endif
Eric Laurentfd477972013-10-25 18:10:40 -07007156 // Only consider last track started for volume and mixer state control.
7157 // In theory an older track could underrun and restart after the new one starts
7158 // but as we only care about the transition phase between two tracks on a
7159 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07007160 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08007161 bool last = l.get() == track;
Eric Laurentfd477972013-10-25 18:10:40 -07007162
Haynes Mathew George7844f672014-01-15 12:32:55 -08007163 if (track->isInvalid()) {
7164 ALOGW("An invalidated track shouldn't be in active list");
7165 tracksToRemove->add(track);
7166 continue;
7167 }
7168
7169 if (track->mState == TrackBase::IDLE) {
7170 ALOGW("An idle track shouldn't be in active list");
7171 continue;
7172 }
7173
Kuowei Li23666472021-01-20 10:23:25 +08007174 if (track->isPausePending()) {
7175 track->pauseAck();
7176 // It is possible a track might have been flushed or stopped.
7177 // Other operations such as flush pending might occur on the next prepare.
7178 if (track->isPausing()) {
7179 track->setPaused();
7180 }
7181 // Always perform pause if last, as an immediate flush will change
7182 // the pause state to be no longer isPausing().
Eric Laurentbfb1b832013-01-07 09:53:42 -08007183 if (last) {
Eric Laurent5cff4032015-05-26 13:49:58 -07007184 if (mHwSupportsPause && !mHwPaused) {
Eric Laurent972a1732013-09-04 09:42:59 -07007185 doHwPause = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007186 mHwPaused = true;
7187 }
7188 // If we were part way through writing the mixbuffer to
7189 // the HAL we must save this until we resume
7190 // BUG - this will be wrong if a different track is made active,
7191 // in that case we want to discard the pending data in the
7192 // mixbuffer and tell the client to present it again when the
7193 // track is resumed
7194 mPausedWriteLength = mCurrentWriteLength;
7195 mPausedBytesRemaining = mBytesRemaining;
7196 mBytesRemaining = 0; // stop writing
7197 }
7198 tracksToRemove->add(track);
Haynes Mathew George7844f672014-01-15 12:32:55 -08007199 } else if (track->isFlushPending()) {
Eric Laurente93cc032016-05-05 10:15:10 -07007200 if (track->isStopping_1()) {
7201 track->mRetryCount = kMaxTrackStopRetriesOffload;
7202 } else {
7203 track->mRetryCount = kMaxTrackRetriesOffload;
7204 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08007205 track->flushAck();
7206 if (last) {
7207 mFlushPending = true;
7208 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08007209 } else if (track->isResumePending()){
7210 track->resumeAck();
7211 if (last) {
7212 if (mPausedBytesRemaining) {
7213 // Need to continue write that was interrupted
7214 mCurrentWriteLength = mPausedWriteLength;
7215 mBytesRemaining = mPausedBytesRemaining;
7216 mPausedBytesRemaining = 0;
7217 }
7218 if (mHwPaused) {
7219 doHwResume = true;
7220 mHwPaused = false;
7221 // threadLoop_mix() will handle the case that we need to
7222 // resume an interrupted write
7223 }
7224 // enable write to audio HAL
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007225 mSleepTimeUs = 0;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08007226
Eric Laurent3df841a2016-07-15 15:15:40 -07007227 mLeftVolFloat = mRightVolFloat = -1.0;
7228
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08007229 // Do not handle new data in this iteration even if track->framesReady()
7230 mixerStatus = MIXER_TRACKS_ENABLED;
7231 }
7232 } else if (track->framesReady() && track->isReady() &&
Eric Laurent3b4529e2013-09-05 18:09:19 -07007233 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
Andy Hungc0691382018-09-12 18:01:57 -07007234 ALOGVV("OffloadThread: track(%d) s=%08x [OK]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007235 if (track->mFillingUpStatus == Track::FS_FILLED) {
7236 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07007237 if (last) {
7238 // make sure processVolume_l() will apply new volume even if 0
7239 mLeftVolFloat = mRightVolFloat = -1.0;
7240 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007241 }
7242
7243 if (last) {
Eric Laurentd7e59222013-11-15 12:02:28 -08007244 sp<Track> previousTrack = mPreviousTrack.promote();
7245 if (previousTrack != 0) {
7246 if (track != previousTrack.get()) {
Eric Laurent9da3d952013-11-12 19:25:43 -08007247 // Flush any data still being written from last track
7248 mBytesRemaining = 0;
7249 if (mPausedBytesRemaining) {
7250 // Last track was paused so we also need to flush saved
7251 // mixbuffer state and invalidate track so that it will
7252 // re-submit that unwritten data when it is next resumed
7253 mPausedBytesRemaining = 0;
7254 // Invalidate is a bit drastic - would be more efficient
7255 // to have a flag to tell client that some of the
7256 // previously written data was lost
Eric Laurentd7e59222013-11-15 12:02:28 -08007257 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08007258 }
7259 // flush data already sent to the DSP if changing audio session as audio
7260 // comes from a different source. Also invalidate previous track to force a
7261 // seek when resuming.
Eric Laurentd7e59222013-11-15 12:02:28 -08007262 if (previousTrack->sessionId() != track->sessionId()) {
7263 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08007264 }
7265 }
7266 }
7267 mPreviousTrack = track;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007268 // reset retry count
Eric Laurente93cc032016-05-05 10:15:10 -07007269 if (track->isStopping_1()) {
7270 track->mRetryCount = kMaxTrackStopRetriesOffload;
7271 } else {
7272 track->mRetryCount = kMaxTrackRetriesOffload;
7273 }
Eric Laurent5850c4c2016-11-10 13:04:31 -08007274 mActiveTrack = t;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007275 mixerStatus = MIXER_TRACKS_READY;
7276 }
7277 } else {
Andy Hungc0691382018-09-12 18:01:57 -07007278 ALOGVV("OffloadThread: track(%d) s=%08x [NOT READY]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007279 if (track->isStopping_1()) {
Eric Laurente93cc032016-05-05 10:15:10 -07007280 if (--(track->mRetryCount) <= 0) {
7281 // Hardware buffer can hold a large amount of audio so we must
7282 // wait for all current track's data to drain before we say
7283 // that the track is stopped.
7284 if (mBytesRemaining == 0) {
7285 // Only start draining when all data in mixbuffer
7286 // has been written
7287 ALOGV("OffloadThread: underrun and STOPPING_1 -> draining, STOPPING_2");
7288 track->mState = TrackBase::STOPPING_2; // so presentation completes after
7289 // drain do not drain if no data was ever sent to HAL (mStandby == true)
7290 if (last && !mStandby) {
7291 // do not modify drain sequence if we are already draining. This happens
7292 // when resuming from pause after drain.
7293 if ((mDrainSequence & 1) == 0) {
7294 mSleepTimeUs = 0;
7295 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
7296 mixerStatus = MIXER_DRAIN_TRACK;
7297 mDrainSequence += 2;
7298 }
7299 if (mHwPaused) {
7300 // It is possible to move from PAUSED to STOPPING_1 without
7301 // a resume so we must ensure hardware is running
7302 doHwResume = true;
7303 mHwPaused = false;
7304 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007305 }
7306 }
Eric Laurente93cc032016-05-05 10:15:10 -07007307 } else if (last) {
7308 ALOGV("stopping1 underrun retries left %d", track->mRetryCount);
7309 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007310 }
7311 } else if (track->isStopping_2()) {
Eric Laurent6a51d7e2013-10-17 18:59:26 -07007312 // Drain has completed or we are in standby, signal presentation complete
7313 if (!(mDrainSequence & 1) || !last || mStandby) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08007314 track->mState = TrackBase::STOPPED;
Atneya Nair0cae0432022-05-10 18:12:12 -04007315 mOutput->presentationComplete();
7316 track->presentationComplete(latency_l()); // always returns true
Eric Laurentbfb1b832013-01-07 09:53:42 -08007317 track->reset();
7318 tracksToRemove->add(track);
Dean Wheatley12473e92021-03-18 23:00:55 +11007319 // OFFLOADED stop resets frame counts.
Andy Hungf3234512018-07-03 14:51:47 -07007320 if (!mUseAsyncWrite) {
7321 // If we don't get explicit drain notification we must
7322 // register discontinuity regardless of whether this is
7323 // the previous (!last) or the upcoming (last) track
7324 // to avoid skipping the discontinuity.
Dean Wheatley12473e92021-03-18 23:00:55 +11007325 mTimestampVerifier.discontinuity(
7326 mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Andy Hungf3234512018-07-03 14:51:47 -07007327 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007328 }
7329 } else {
7330 // No buffers for this track. Give it a few chances to
7331 // fill a buffer, then remove it from active list.
Brian Lindahl65e90012022-07-27 18:01:07 +02007332 bool isTimestampAdvancing = mIsTimestampAdvancing.check(mOutput);
Gareth Fennb18c1a32022-10-05 13:42:36 -07007333 if (!isTunerStream() // tuner streams remain active in underrun
7334 && --(track->mRetryCount) <= 0) {
Brian Lindahl65e90012022-07-27 18:01:07 +02007335 if (isTimestampAdvancing) { // HAL is still playing audio, give us more time.
Andy Hungf8044752016-07-27 14:58:11 -07007336 track->mRetryCount = kMaxTrackRetriesOffload;
7337 } else {
Andy Hungc0691382018-09-12 18:01:57 -07007338 ALOGV("OffloadThread: BUFFER TIMEOUT: remove track(%d) from active list",
7339 track->id());
Andy Hungf8044752016-07-27 14:58:11 -07007340 tracksToRemove->add(track);
Glenn Kastend3bb6452016-12-05 18:14:37 -08007341 // tell client process that the track was disabled because of underrun;
Andy Hungf8044752016-07-27 14:58:11 -07007342 // it will then automatically call start() when data is available
7343 track->disable();
7344 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007345 } else if (last){
7346 mixerStatus = MIXER_TRACKS_ENABLED;
7347 }
7348 }
7349 }
7350 // compute volume for this track
Wenfeng Sun79458332019-05-29 20:12:43 +08007351 if (track->isReady()) { // check ready to prevent premature start.
7352 processVolume_l(track, last);
7353 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08007354 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07007355
Eric Laurentea0fade2013-10-04 16:23:48 -07007356 // make sure the pause/flush/resume sequence is executed in the right order.
7357 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
7358 // before flush and then resume HW. This can happen in case of pause/flush/resume
7359 // if resume is received before pause is executed.
Eric Laurentfd477972013-10-25 18:10:40 -07007360 if (!mStandby && (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007361 status_t result = mOutput->stream->pause();
7362 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Gareth Fenncd1e1622022-10-05 11:45:45 -07007363 doHwResume = !doHwPause; // resume if pause is due to flush.
Eric Laurent972a1732013-09-04 09:42:59 -07007364 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07007365 if (mFlushPending) {
7366 flushHw_l();
Eric Laurent6bf9ae22013-08-30 15:12:37 -07007367 }
Eric Laurentfd477972013-10-25 18:10:40 -07007368 if (!mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007369 status_t result = mOutput->stream->resume();
7370 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07007371 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07007372
Eric Laurentbfb1b832013-01-07 09:53:42 -08007373 // remove all the tracks that need to be...
7374 removeTracks_l(*tracksToRemove);
7375
7376 return mixerStatus;
7377}
7378
Eric Laurentbfb1b832013-01-07 09:53:42 -08007379// must be called with thread mutex locked
7380bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
7381{
Eric Laurent3b4529e2013-09-05 18:09:19 -07007382 ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
7383 mWriteAckSequence, mDrainSequence);
7384 if (mUseAsyncWrite && ((mWriteAckSequence & 1) || (mDrainSequence & 1))) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08007385 return true;
7386 }
7387 return false;
7388}
7389
Eric Laurentbfb1b832013-01-07 09:53:42 -08007390bool AudioFlinger::OffloadThread::waitingAsyncCallback()
7391{
7392 Mutex::Autolock _l(mLock);
7393 return waitingAsyncCallback_l();
7394}
7395
7396void AudioFlinger::OffloadThread::flushHw_l()
7397{
Eric Laurente659ef42014-09-29 13:06:46 -07007398 DirectOutputThread::flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08007399 // Flush anything still waiting in the mixbuffer
7400 mCurrentWriteLength = 0;
7401 mBytesRemaining = 0;
7402 mPausedWriteLength = 0;
7403 mPausedBytesRemaining = 0;
Eric Laurent3eaf66b2016-04-01 14:44:17 -07007404 // reset bytes written count to reflect that DSP buffers are empty after flush.
7405 mBytesWritten = 0;
Haynes Mathew George0f02f262014-01-11 13:03:57 -08007406
Eric Laurentbfb1b832013-01-07 09:53:42 -08007407 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07007408 // discard any pending drain or write ack by incrementing sequence
7409 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
7410 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08007411 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07007412 mCallbackThread->setWriteBlocked(mWriteAckSequence);
7413 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08007414 }
7415}
7416
Haynes Mathew George05317d22016-05-03 16:34:26 -07007417void AudioFlinger::OffloadThread::invalidateTracks(audio_stream_type_t streamType)
7418{
7419 Mutex::Autolock _l(mLock);
Eric Laurent13084622016-05-17 10:51:49 -07007420 if (PlaybackThread::invalidateTracks_l(streamType)) {
7421 mFlushPending = true;
7422 }
Haynes Mathew George05317d22016-05-03 16:34:26 -07007423}
7424
jiabinc44b3462022-12-08 12:52:31 -08007425void AudioFlinger::OffloadThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
7426 Mutex::Autolock _l(mLock);
7427 if (PlaybackThread::invalidateTracks_l(portIds)) {
7428 mFlushPending = true;
7429 }
7430}
7431
Eric Laurentbfb1b832013-01-07 09:53:42 -08007432// ----------------------------------------------------------------------------
7433
Eric Laurent81784c32012-11-19 14:55:58 -08007434AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurent72e3f392015-05-20 14:43:50 -07007435 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id, bool systemReady)
jiabinc52b1ff2019-10-31 17:20:42 -07007436 : MixerThread(audioFlinger, mainThread->getOutput(), id,
Eric Laurent72e3f392015-05-20 14:43:50 -07007437 systemReady, DUPLICATING),
Eric Laurent81784c32012-11-19 14:55:58 -08007438 mWaitTimeMs(UINT_MAX)
7439{
7440 addOutputTrack(mainThread);
7441}
7442
7443AudioFlinger::DuplicatingThread::~DuplicatingThread()
7444{
7445 for (size_t i = 0; i < mOutputTracks.size(); i++) {
7446 mOutputTracks[i]->destroy();
7447 }
7448}
7449
7450void AudioFlinger::DuplicatingThread::threadLoop_mix()
7451{
7452 // mix buffers...
Andy Hung920f6572022-10-06 12:09:49 -07007453 if (outputsReady()) {
Glenn Kastend79072e2016-01-06 08:41:20 -08007454 mAudioMixer->process();
Eric Laurent81784c32012-11-19 14:55:58 -08007455 } else {
Eric Laurent02b57082014-11-07 17:28:28 -08007456 if (mMixerBufferValid) {
7457 memset(mMixerBuffer, 0, mMixerBufferSize);
7458 } else {
7459 memset(mSinkBuffer, 0, mSinkBufferSize);
7460 }
Eric Laurent81784c32012-11-19 14:55:58 -08007461 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007462 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08007463 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08007464 mCurrentWriteLength = mSinkBufferSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007465 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08007466}
7467
7468void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
7469{
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007470 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08007471 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007472 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08007473 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007474 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08007475 }
7476 } else if (mBytesWritten != 0) {
7477 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
7478 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08007479 memset(mSinkBuffer, 0, mSinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08007480 } else {
7481 // flush remaining overflow buffers in output tracks
7482 writeFrames = 0;
7483 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07007484 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08007485 }
7486}
7487
Eric Laurentbfb1b832013-01-07 09:53:42 -08007488ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08007489{
7490 for (size_t i = 0; i < outputTracks.size(); i++) {
Andy Hung1c86ebe2018-05-29 20:29:08 -07007491 const ssize_t actualWritten = outputTracks[i]->write(mSinkBuffer, writeFrames);
7492
7493 // Consider the first OutputTrack for timestamp and frame counting.
7494
7495 // The threadLoop() generally assumes writing a full sink buffer size at a time.
7496 // Here, we correct for writeFrames of 0 (a stop) or underruns because
7497 // we always claim success.
7498 if (i == 0) {
7499 const ssize_t correction = mSinkBufferSize / mFrameSize - actualWritten;
7500 ALOGD_IF(correction != 0 && writeFrames != 0,
7501 "%s: writeFrames:%u actualWritten:%zd correction:%zd mFramesWritten:%lld",
7502 __func__, writeFrames, actualWritten, correction, (long long)mFramesWritten);
7503 mFramesWritten -= correction;
7504 }
7505
7506 // TODO: Report correction for the other output tracks and show in the dump.
Eric Laurent81784c32012-11-19 14:55:58 -08007507 }
Andy Hungcf10d742020-04-28 15:38:24 -07007508 if (mStandby) {
7509 mThreadMetrics.logBeginInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07007510 mThreadSnapshot.onBegin();
Andy Hungcf10d742020-04-28 15:38:24 -07007511 mStandby = false;
7512 }
Andy Hung25c2dac2014-02-27 14:56:00 -08007513 return (ssize_t)mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08007514}
7515
7516void AudioFlinger::DuplicatingThread::threadLoop_standby()
7517{
7518 // DuplicatingThread implements standby by stopping all tracks
7519 for (size_t i = 0; i < outputTracks.size(); i++) {
7520 outputTracks[i]->stop();
7521 }
7522}
7523
Andy Hung920f6572022-10-06 12:09:49 -07007524void AudioFlinger::DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args)
Andy Hung1bc088a2018-02-09 15:57:31 -08007525{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07007526 MixerThread::dumpInternals_l(fd, args);
Andy Hung1bc088a2018-02-09 15:57:31 -08007527
7528 std::stringstream ss;
7529 const size_t numTracks = mOutputTracks.size();
7530 ss << " " << numTracks << " OutputTracks";
7531 if (numTracks > 0) {
7532 ss << ":";
7533 for (const auto &track : mOutputTracks) {
7534 const sp<ThreadBase> thread = track->thread().promote();
Andy Hungc0691382018-09-12 18:01:57 -07007535 ss << " (" << track->id() << " : ";
Andy Hung1bc088a2018-02-09 15:57:31 -08007536 if (thread.get() != nullptr) {
7537 ss << thread.get() << ", " << thread->id();
7538 } else {
7539 ss << "null";
7540 }
7541 ss << ")";
7542 }
7543 }
7544 ss << "\n";
7545 std::string result = ss.str();
7546 write(fd, result.c_str(), result.size());
7547}
7548
Eric Laurent81784c32012-11-19 14:55:58 -08007549void AudioFlinger::DuplicatingThread::saveOutputTracks()
7550{
7551 outputTracks = mOutputTracks;
7552}
7553
7554void AudioFlinger::DuplicatingThread::clearOutputTracks()
7555{
7556 outputTracks.clear();
7557}
7558
7559void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
7560{
7561 Mutex::Autolock _l(mLock);
Andy Hungc25b84a2015-01-14 19:04:10 -08007562 // The downstream MixerThread consumes thread->frameCount() amount of frames per mix pass.
7563 // Adjust for thread->sampleRate() to determine minimum buffer frame count.
7564 // Then triple buffer because Threads do not run synchronously and may not be clock locked.
7565 const size_t frameCount =
7566 3 * sourceFramesNeeded(mSampleRate, thread->frameCount(), thread->sampleRate());
7567 // TODO: Consider asynchronous sample rate conversion to handle clock disparity
7568 // from different OutputTracks and their associated MixerThreads (e.g. one may
7569 // nearly empty and the other may be dropping data).
7570
Svet Ganov33761132021-05-13 22:51:08 +00007571 // TODO b/182392769: use attribution source util, move to server edge
7572 AttributionSourceState attributionSource = AttributionSourceState();
7573 attributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
Philip P. Moltmannbda45752020-07-17 16:41:18 -07007574 IPCThreadState::self()->getCallingUid()));
Svet Ganov33761132021-05-13 22:51:08 +00007575 attributionSource.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(
Philip P. Moltmannbda45752020-07-17 16:41:18 -07007576 IPCThreadState::self()->getCallingPid()));
Svet Ganov33761132021-05-13 22:51:08 +00007577 attributionSource.token = sp<BBinder>::make();
Andy Hungc25b84a2015-01-14 19:04:10 -08007578 sp<OutputTrack> outputTrack = new OutputTrack(thread,
Eric Laurent81784c32012-11-19 14:55:58 -08007579 this,
7580 mSampleRate,
Andy Hungc25b84a2015-01-14 19:04:10 -08007581 mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08007582 mChannelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08007583 frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00007584 attributionSource);
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07007585 status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
7586 if (status != NO_ERROR) {
7587 ALOGE("addOutputTrack() initCheck failed %d", status);
7588 return;
Eric Laurent81784c32012-11-19 14:55:58 -08007589 }
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07007590 thread->setStreamVolume(AUDIO_STREAM_PATCH, 1.0f);
7591 mOutputTracks.add(outputTrack);
7592 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
7593 updateWaitTime_l();
Eric Laurent81784c32012-11-19 14:55:58 -08007594}
7595
7596void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
7597{
7598 Mutex::Autolock _l(mLock);
7599 for (size_t i = 0; i < mOutputTracks.size(); i++) {
7600 if (mOutputTracks[i]->thread() == thread) {
7601 mOutputTracks[i]->destroy();
7602 mOutputTracks.removeAt(i);
7603 updateWaitTime_l();
Eric Laurentf6870ae2015-05-08 10:50:03 -07007604 if (thread->getOutput() == mOutput) {
7605 mOutput = NULL;
7606 }
Eric Laurent81784c32012-11-19 14:55:58 -08007607 return;
7608 }
7609 }
Eric Laurentf6870ae2015-05-08 10:50:03 -07007610 ALOGV("removeOutputTrack(): unknown thread: %p", thread);
Eric Laurent81784c32012-11-19 14:55:58 -08007611}
7612
7613// caller must hold mLock
7614void AudioFlinger::DuplicatingThread::updateWaitTime_l()
7615{
7616 mWaitTimeMs = UINT_MAX;
7617 for (size_t i = 0; i < mOutputTracks.size(); i++) {
7618 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
7619 if (strong != 0) {
7620 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
7621 if (waitTimeMs < mWaitTimeMs) {
7622 mWaitTimeMs = waitTimeMs;
7623 }
7624 }
7625 }
7626}
7627
Andy Hung920f6572022-10-06 12:09:49 -07007628bool AudioFlinger::DuplicatingThread::outputsReady()
Eric Laurent81784c32012-11-19 14:55:58 -08007629{
7630 for (size_t i = 0; i < outputTracks.size(); i++) {
7631 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
7632 if (thread == 0) {
7633 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
7634 outputTracks[i].get());
7635 return false;
7636 }
7637 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
7638 // see note at standby() declaration
7639 if (playbackThread->standby() && !playbackThread->isSuspended()) {
7640 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
7641 thread.get());
7642 return false;
7643 }
7644 }
7645 return true;
7646}
7647
Kevin Rocard12381092018-04-11 09:19:59 -07007648void AudioFlinger::DuplicatingThread::sendMetadataToBackend_l(
7649 const StreamOutHalInterface::SourceMetadata& metadata)
Kevin Rocard069c2712018-03-29 19:09:14 -07007650{
Kevin Rocard12381092018-04-11 09:19:59 -07007651 for (auto& outputTrack : outputTracks) { // not mOutputTracks
7652 outputTrack->setMetadatas(metadata.tracks);
7653 }
Kevin Rocard069c2712018-03-29 19:09:14 -07007654}
7655
Eric Laurent81784c32012-11-19 14:55:58 -08007656uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
7657{
7658 return (mWaitTimeMs * 1000) / 2;
7659}
7660
7661void AudioFlinger::DuplicatingThread::cacheParameters_l()
7662{
7663 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
7664 updateWaitTime_l();
7665
7666 MixerThread::cacheParameters_l();
7667}
7668
Eric Laurentb3f315a2021-07-13 15:09:05 +02007669// ----------------------------------------------------------------------------
7670
Eric Laurentfa0f6742021-08-17 18:39:44 +02007671AudioFlinger::SpatializerThread::SpatializerThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurentb3f315a2021-07-13 15:09:05 +02007672 AudioStreamOut* output,
7673 audio_io_handle_t id,
7674 bool systemReady,
7675 audio_config_base_t *mixerConfig)
Eric Laurent1c5e2e32021-08-18 18:50:28 +02007676 : MixerThread(audioFlinger, output, id, systemReady, SPATIALIZER, mixerConfig)
Eric Laurentb3f315a2021-07-13 15:09:05 +02007677{
7678}
7679
Eric Laurent68a40a82022-05-03 18:15:04 +02007680void AudioFlinger::SpatializerThread::onFirstRef() {
Eric Laurentb0463942022-12-20 16:31:10 +01007681 MixerThread::onFirstRef();
Andy Hungfeb4e5c2022-10-17 19:10:02 -07007682
Andy Hung41ccf7f2022-12-14 14:25:49 -08007683 const pid_t tid = getTid();
7684 if (tid == -1) {
7685 // Unusual: PlaybackThread::onFirstRef() should set the threadLoop running.
7686 ALOGW("%s: Cannot update Spatializer mixer thread priority, not running", __func__);
7687 } else {
7688 const int priorityBoost = requestSpatializerPriority(getpid(), tid);
7689 if (priorityBoost > 0) {
Andy Hungfeb4e5c2022-10-17 19:10:02 -07007690 stream()->setHalThreadPriority(priorityBoost);
7691 }
7692 }
Eric Laurent68a40a82022-05-03 18:15:04 +02007693}
7694
Eric Laurent68a40a82022-05-03 18:15:04 +02007695void AudioFlinger::SpatializerThread::setHalLatencyMode_l() {
7696 // if mSupportedLatencyModes is empty, the HAL stream does not support
7697 // latency mode control and we can exit.
7698 if (mSupportedLatencyModes.empty()) {
7699 return;
7700 }
7701 audio_latency_mode_t latencyMode = AUDIO_LATENCY_MODE_FREE;
7702 if (mSupportedLatencyModes.size() == 1) {
7703 // If the HAL only support one latency mode currently, confirm the choice
7704 latencyMode = mSupportedLatencyModes[0];
7705 } else if (mSupportedLatencyModes.size() > 1) {
7706 // Request low latency if:
7707 // - The low latency mode is requested by the spatializer controller
7708 // (mRequestedLatencyMode = AUDIO_LATENCY_MODE_LOW)
7709 // AND
7710 // - At least one active track is spatialized
7711 bool hasSpatializedActiveTrack = false;
7712 for (const auto& track : mActiveTracks) {
7713 if (track->isSpatialized()) {
7714 hasSpatializedActiveTrack = true;
7715 break;
7716 }
7717 }
7718 if (hasSpatializedActiveTrack && mRequestedLatencyMode == AUDIO_LATENCY_MODE_LOW) {
7719 latencyMode = AUDIO_LATENCY_MODE_LOW;
7720 }
7721 }
7722
7723 if (latencyMode != mSetLatencyMode) {
7724 status_t status = mOutput->stream->setLatencyMode(latencyMode);
Andy Hung4bd53e72022-11-17 17:21:45 -08007725 ALOGD("%s: thread(%d) setLatencyMode(%s) returned %d",
7726 __func__, mId, toString(latencyMode).c_str(), status);
Eric Laurent68a40a82022-05-03 18:15:04 +02007727 if (status == NO_ERROR) {
7728 mSetLatencyMode = latencyMode;
7729 }
7730 }
7731}
7732
7733status_t AudioFlinger::SpatializerThread::setRequestedLatencyMode(audio_latency_mode_t mode) {
7734 if (mode != AUDIO_LATENCY_MODE_LOW && mode != AUDIO_LATENCY_MODE_FREE) {
7735 return BAD_VALUE;
7736 }
7737 Mutex::Autolock _l(mLock);
7738 mRequestedLatencyMode = mode;
7739 return NO_ERROR;
7740}
7741
Eric Laurentfa0f6742021-08-17 18:39:44 +02007742void AudioFlinger::SpatializerThread::checkOutputStageEffects()
Eric Laurentb3f315a2021-07-13 15:09:05 +02007743{
7744 bool hasVirtualizer = false;
7745 bool hasDownMixer = false;
7746 sp<EffectHandle> finalDownMixer;
7747 {
7748 Mutex::Autolock _l(mLock);
7749 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_STAGE);
7750 if (chain != 0) {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02007751 hasVirtualizer = chain->getEffectFromType_l(FX_IID_SPATIALIZER) != nullptr;
Eric Laurentb3f315a2021-07-13 15:09:05 +02007752 hasDownMixer = chain->getEffectFromType_l(EFFECT_UIID_DOWNMIX) != nullptr;
7753 }
7754
7755 finalDownMixer = mFinalDownMixer;
7756 mFinalDownMixer.clear();
7757 }
7758
7759 if (hasVirtualizer) {
7760 if (finalDownMixer != nullptr) {
7761 int32_t ret;
7762 finalDownMixer->disable(&ret);
7763 }
7764 finalDownMixer.clear();
7765 } else if (!hasDownMixer) {
7766 std::vector<effect_descriptor_t> descriptors;
7767 status_t status = mAudioFlinger->mEffectsFactoryHal->getDescriptors(
7768 EFFECT_UIID_DOWNMIX, &descriptors);
7769 if (status != NO_ERROR) {
7770 return;
7771 }
7772 ALOG_ASSERT(!descriptors.empty(),
7773 "%s getDescriptors() returned no error but empty list", __func__);
7774
7775 finalDownMixer = createEffect_l(nullptr /*client*/, nullptr /*effectClient*/,
7776 0 /*priority*/, AUDIO_SESSION_OUTPUT_STAGE, &descriptors[0], nullptr /*enabled*/,
Eric Laurentde8caf42021-08-11 17:19:25 +02007777 &status, false /*pinned*/, false /*probe*/, false /*notifyFramesProcessed*/);
Eric Laurentb3f315a2021-07-13 15:09:05 +02007778
7779 if (finalDownMixer == nullptr || (status != NO_ERROR && status != ALREADY_EXISTS)) {
7780 ALOGW("%s error creating downmixer %d", __func__, status);
7781 finalDownMixer.clear();
7782 } else {
7783 int32_t ret;
7784 finalDownMixer->enable(&ret);
7785 }
7786 }
7787
7788 {
7789 Mutex::Autolock _l(mLock);
7790 mFinalDownMixer = finalDownMixer;
7791 }
7792}
7793
Eric Laurent81784c32012-11-19 14:55:58 -08007794// ----------------------------------------------------------------------------
7795// Record
7796// ----------------------------------------------------------------------------
7797
7798AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
7799 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08007800 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07007801 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08007802 ) :
Andy Hungcf10d742020-04-28 15:38:24 -07007803 ThreadBase(audioFlinger, id, RECORD, systemReady, false /* isOut */),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007804 mInput(input),
Mikhail Naganov2534b382019-09-25 13:05:02 -07007805 mSource(mInput),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007806 mActiveTracks(&this->mLocalLog),
7807 mRsmpInBuffer(NULL),
Glenn Kasten1b291842016-07-18 14:55:21 -07007808 // mRsmpInFrames, mRsmpInFramesP2, and mRsmpInFramesOA are set by readInputParameters_l()
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007809 mRsmpInRear(0)
Glenn Kastenb880f5e2014-05-07 08:43:45 -07007810 , mReadOnlyHeap(new MemoryDealer(kRecordThreadReadOnlyHeapSize,
7811 "RecordThreadRO", MemoryHeapBase::READ_ONLY))
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007812 // mFastCapture below
7813 , mFastCaptureFutex(0)
7814 // mInputSource
7815 // mPipeSink
7816 // mPipeSource
7817 , mPipeFramesP2(0)
7818 // mPipeMemory
7819 // mFastCaptureNBLogWriter
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007820 , mFastTrackAvail(false)
Eric Laurentd8365c52017-07-16 15:27:05 -07007821 , mBtNrecSuspended(false)
Eric Laurent81784c32012-11-19 14:55:58 -08007822{
Glenn Kastend7dca052015-03-05 16:05:54 -08007823 snprintf(mThreadName, kThreadNameLength, "AudioIn_%X", id);
7824 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08007825
George Burgess IVa8f90c12020-05-14 11:27:19 -07007826 if (mInput->audioHwDev != nullptr) {
Andy Hungc8fddf32018-08-08 18:32:37 -07007827 mIsMsdDevice = strcmp(
7828 mInput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
7829 }
7830
Glenn Kastendeca2ae2014-02-07 10:25:56 -08007831 readInputParameters_l();
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007832
Andy Hungc8fddf32018-08-08 18:32:37 -07007833 // TODO: We may also match on address as well as device type for
7834 // AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_IN_REMOTE_SUBMIX
jiabinc52b1ff2019-10-31 17:20:42 -07007835 // TODO: This property should be ensure that only contains one single device type.
7836 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
7837 "audio.timestamp.corrected_input_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07007838 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_IN_BUS // turn on by default for MSD
7839 : AUDIO_DEVICE_NONE));
7840
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007841 // create an NBAIO source for the HAL input stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07007842 mInputSource = new AudioStreamInSource(input->stream);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007843 size_t numCounterOffers = 0;
7844 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07007845#if !LOG_NDEBUG
Jing Mike537412f2023-03-12 11:01:47 +08007846 [[maybe_unused]] ssize_t index =
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07007847#else
7848 (void)
7849#endif
7850 mInputSource->negotiate(offers, 1, NULL, numCounterOffers);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007851 ALOG_ASSERT(index == 0);
7852
7853 // initialize fast capture depending on configuration
7854 bool initFastCapture;
7855 switch (kUseFastCapture) {
7856 case FastCapture_Never:
7857 initFastCapture = false;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007858 ALOGV("%p kUseFastCapture = Never, initFastCapture = false", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007859 break;
7860 case FastCapture_Always:
7861 initFastCapture = true;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007862 ALOGV("%p kUseFastCapture = Always, initFastCapture = true", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007863 break;
7864 case FastCapture_Static:
Sampath6fac2332022-12-16 17:34:37 +11007865 initFastCapture = !mIsMsdDevice // Disable fast capture for MSD BUS devices.
7866 && (mFrameCount * 1000) / mSampleRate < kMinNormalCaptureBufferSizeMs;
7867 ALOGV("%p kUseFastCapture = Static, (%lld * 1000) / %u vs %u, initFastCapture = %d "
7868 "mIsMsdDevice = %d", this, (long long)mFrameCount, mSampleRate,
7869 kMinNormalCaptureBufferSizeMs, initFastCapture, mIsMsdDevice);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007870 break;
7871 // case FastCapture_Dynamic:
7872 }
7873
7874 if (initFastCapture) {
Glenn Kastend198b852015-03-16 14:55:53 -07007875 // create a Pipe for FastCapture to write to, and for us and fast tracks to read from
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007876 NBAIO_Format format = mInputSource->format();
Glenn Kasten1b291842016-07-18 14:55:21 -07007877 // quadruple-buffering of 20 ms each; this ensures we can sleep for 20ms in RecordThread
7878 size_t pipeFramesP2 = roundup(4 * FMS_20 * mSampleRate / 1000);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007879 size_t pipeSize = pipeFramesP2 * Format_frameSize(format);
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007880 void *pipeBuffer = nullptr;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007881 const sp<MemoryDealer> roHeap(readOnlyHeap());
7882 sp<IMemory> pipeMemory;
7883 if ((roHeap == 0) ||
7884 (pipeMemory = roHeap->allocate(pipeSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07007885 (pipeBuffer = pipeMemory->unsecurePointer()) == nullptr) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007886 ALOGE("not enough memory for pipe buffer size=%zu; "
7887 "roHeap=%p, pipeMemory=%p, pipeBuffer=%p; roHeapSize: %lld",
7888 pipeSize, roHeap.get(), pipeMemory.get(), pipeBuffer,
7889 (long long)kRecordThreadReadOnlyHeapSize);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007890 goto failed;
7891 }
7892 // pipe will be shared directly with fast clients, so clear to avoid leaking old information
7893 memset(pipeBuffer, 0, pipeSize);
7894 Pipe *pipe = new Pipe(pipeFramesP2, format, pipeBuffer);
Andy Hung920f6572022-10-06 12:09:49 -07007895 const NBAIO_Format offersFast[1] = {format};
7896 size_t numCounterOffersFast = 0;
Eric Laurent1e28aaa2023-04-16 19:34:23 +02007897 [[maybe_unused]] ssize_t index2 = pipe->negotiate(offersFast, std::size(offersFast),
Andy Hung920f6572022-10-06 12:09:49 -07007898 nullptr /* counterOffers */, numCounterOffersFast);
Eric Laurent1e28aaa2023-04-16 19:34:23 +02007899 ALOG_ASSERT(index2 == 0);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007900 mPipeSink = pipe;
7901 PipeReader *pipeReader = new PipeReader(*pipe);
Andy Hung920f6572022-10-06 12:09:49 -07007902 numCounterOffersFast = 0;
Eric Laurent1e28aaa2023-04-16 19:34:23 +02007903 index2 = pipeReader->negotiate(offersFast, std::size(offersFast),
Andy Hung920f6572022-10-06 12:09:49 -07007904 nullptr /* counterOffers */, numCounterOffersFast);
Eric Laurent1e28aaa2023-04-16 19:34:23 +02007905 ALOG_ASSERT(index2 == 0);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007906 mPipeSource = pipeReader;
7907 mPipeFramesP2 = pipeFramesP2;
7908 mPipeMemory = pipeMemory;
7909
7910 // create fast capture
7911 mFastCapture = new FastCapture();
7912 FastCaptureStateQueue *sq = mFastCapture->sq();
7913#ifdef STATE_QUEUE_DUMP
7914 // FIXME
7915#endif
7916 FastCaptureState *state = sq->begin();
7917 state->mCblk = NULL;
7918 state->mInputSource = mInputSource.get();
7919 state->mInputSourceGen++;
7920 state->mPipeSink = pipe;
7921 state->mPipeSinkGen++;
7922 state->mFrameCount = mFrameCount;
7923 state->mCommand = FastCaptureState::COLD_IDLE;
7924 // already done in constructor initialization list
7925 //mFastCaptureFutex = 0;
7926 state->mColdFutexAddr = &mFastCaptureFutex;
7927 state->mColdGen++;
7928 state->mDumpState = &mFastCaptureDumpState;
7929#ifdef TEE_SINK
7930 // FIXME
7931#endif
7932 mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
7933 state->mNBLogWriter = mFastCaptureNBLogWriter.get();
7934 sq->end();
7935 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
7936
7937 // start the fast capture
7938 mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
7939 pid_t tid = mFastCapture->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07007940 sendPrioConfigEvent(getpid(), tid, kPriorityFastCapture, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08007941 stream()->setHalThreadPriority(kPriorityFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007942#ifdef AUDIO_WATCHDOG
7943 // FIXME
7944#endif
7945
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007946 mFastTrackAvail = true;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007947 }
Andy Hung8946a282018-04-19 20:04:56 -07007948#ifdef TEE_SINK
7949 mTee.set(mInputSource->format(), NBAIO_Tee::TEE_FLAG_INPUT_THREAD);
7950 mTee.setId(std::string("_") + std::to_string(mId) + "_C");
7951#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007952failed: ;
7953
7954 // FIXME mNormalSource
Eric Laurent81784c32012-11-19 14:55:58 -08007955}
7956
Eric Laurent81784c32012-11-19 14:55:58 -08007957AudioFlinger::RecordThread::~RecordThread()
7958{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007959 if (mFastCapture != 0) {
7960 FastCaptureStateQueue *sq = mFastCapture->sq();
7961 FastCaptureState *state = sq->begin();
7962 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7963 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7964 if (old == -1) {
7965 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7966 }
7967 }
7968 state->mCommand = FastCaptureState::EXIT;
7969 sq->end();
7970 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
7971 mFastCapture->join();
7972 mFastCapture.clear();
7973 }
7974 mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
Glenn Kasten481fb672013-09-30 14:39:28 -07007975 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung57446612015-04-19 23:56:46 -07007976 free(mRsmpInBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08007977}
7978
7979void AudioFlinger::RecordThread::onFirstRef()
7980{
Glenn Kastend7dca052015-03-05 16:05:54 -08007981 run(mThreadName, PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08007982}
7983
Eric Laurent555530a2017-02-07 18:17:24 -08007984void AudioFlinger::RecordThread::preExit()
7985{
7986 ALOGV(" preExit()");
7987 Mutex::Autolock _l(mLock);
7988 for (size_t i = 0; i < mTracks.size(); i++) {
7989 sp<RecordTrack> track = mTracks[i];
7990 track->invalidate();
7991 }
7992 mActiveTracks.clear();
7993 mStartStopCond.broadcast();
7994}
7995
Eric Laurent81784c32012-11-19 14:55:58 -08007996bool AudioFlinger::RecordThread::threadLoop()
7997{
Eric Laurent81784c32012-11-19 14:55:58 -08007998 nsecs_t lastWarning = 0;
7999
8000 inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08008001
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008002reacquire_wakelock:
8003 sp<RecordTrack> activeTrack;
8004 {
8005 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -07008006 acquireWakeLock_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008007 }
8008
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008009 // used to request a deferred sleep, to be executed later while mutex is unlocked
8010 uint32_t sleepUs = 0;
8011
Andy Hung446f4df2019-02-21 12:26:41 -08008012 int64_t lastLoopCountRead = -2; // never matches "previous" loop, when loopCount = 0.
8013
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008014 // loop while there is work to do
Andy Hung446f4df2019-02-21 12:26:41 -08008015 for (int64_t loopCount = 0;; ++loopCount) { // loopCount used for statistics tracking
Glenn Kastenc527a7c2013-08-13 15:43:49 -07008016 Vector< sp<EffectChain> > effectChains;
Glenn Kasten2cfbf882013-08-14 13:12:11 -07008017
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008018 // activeTracks accumulates a copy of a subset of mActiveTracks
8019 Vector< sp<RecordTrack> > activeTracks;
8020
Glenn Kasten735f45f2014-08-18 15:51:59 -07008021 // reference to the (first and only) active fast track
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008022 sp<RecordTrack> fastTrack;
Eric Laurent10351942014-05-08 18:49:52 -07008023
Glenn Kasten735f45f2014-08-18 15:51:59 -07008024 // reference to a fast track which is about to be removed
8025 sp<RecordTrack> fastTrackToRemove;
8026
Eric Laurent33403f02020-05-29 18:35:06 -07008027 bool silenceFastCapture = false;
8028
Eric Laurent81784c32012-11-19 14:55:58 -08008029 { // scope for mLock
8030 Mutex::Autolock _l(mLock);
Eric Laurent000a4192014-01-29 15:17:32 -08008031
Eric Laurent021cf962014-05-13 10:18:14 -07008032 processConfigEvents_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008033
Eric Laurent000a4192014-01-29 15:17:32 -08008034 // check exitPending here because checkForNewParameters_l() and
8035 // checkForNewParameters_l() can temporarily release mLock
8036 if (exitPending()) {
8037 break;
8038 }
8039
Eric Laurent5c25d562016-07-13 17:17:45 -07008040 // sleep with mutex unlocked
8041 if (sleepUs > 0) {
Glenn Kastenf9715e42016-07-13 14:02:03 -07008042 ATRACE_BEGIN("sleepC");
Eric Laurent5c25d562016-07-13 17:17:45 -07008043 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)sleepUs));
8044 ATRACE_END();
8045 sleepUs = 0;
8046 continue;
8047 }
8048
Glenn Kasten2b806402013-11-20 16:37:38 -08008049 // if no active track(s), then standby and release wakelock
8050 size_t size = mActiveTracks.size();
8051 if (size == 0) {
Glenn Kasten93e471f2013-08-19 08:40:07 -07008052 standbyIfNotAlreadyInStandby();
Glenn Kasten4ef0b462013-08-14 13:52:27 -07008053 // exitPending() can't become true here
Eric Laurent81784c32012-11-19 14:55:58 -08008054 releaseWakeLock_l();
8055 ALOGV("RecordThread: loop stopping");
8056 // go to sleep
8057 mWaitWorkCV.wait(mLock);
8058 ALOGV("RecordThread: loop starting");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008059 goto reacquire_wakelock;
8060 }
8061
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008062 bool doBroadcast = false;
Eric Laurent5c25d562016-07-13 17:17:45 -07008063 bool allStopped = true;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008064 for (size_t i = 0; i < size; ) {
Glenn Kasten9e982352013-08-14 14:39:50 -07008065
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008066 activeTrack = mActiveTracks[i];
8067 if (activeTrack->isTerminated()) {
Glenn Kasten735f45f2014-08-18 15:51:59 -07008068 if (activeTrack->isFastTrack()) {
8069 ALOG_ASSERT(fastTrackToRemove == 0);
8070 fastTrackToRemove = activeTrack;
8071 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008072 removeTrack_l(activeTrack);
Glenn Kasten2b806402013-11-20 16:37:38 -08008073 mActiveTracks.remove(activeTrack);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008074 size--;
Glenn Kasten9e982352013-08-14 14:39:50 -07008075 continue;
8076 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008077
8078 TrackBase::track_state activeTrackState = activeTrack->mState;
8079 switch (activeTrackState) {
8080
8081 case TrackBase::PAUSING:
8082 mActiveTracks.remove(activeTrack);
Andy Hungce685402018-10-05 17:23:27 -07008083 activeTrack->mState = TrackBase::PAUSED;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008084 doBroadcast = true;
8085 size--;
8086 continue;
8087
8088 case TrackBase::STARTING_1:
8089 sleepUs = 10000;
8090 i++;
Eric Laurent5c25d562016-07-13 17:17:45 -07008091 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008092 continue;
8093
8094 case TrackBase::STARTING_2:
8095 doBroadcast = true;
Andy Hungcf10d742020-04-28 15:38:24 -07008096 if (mStandby) {
8097 mThreadMetrics.logBeginInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07008098 mThreadSnapshot.onBegin();
Andy Hungcf10d742020-04-28 15:38:24 -07008099 mStandby = false;
8100 }
Glenn Kasten9e982352013-08-14 14:39:50 -07008101 activeTrack->mState = TrackBase::ACTIVE;
Eric Laurent5c25d562016-07-13 17:17:45 -07008102 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008103 break;
8104
8105 case TrackBase::ACTIVE:
Eric Laurent5c25d562016-07-13 17:17:45 -07008106 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008107 break;
8108
Andy Hungce685402018-10-05 17:23:27 -07008109 case TrackBase::IDLE: // cannot be on ActiveTracks if idle
8110 case TrackBase::PAUSED: // cannot be on ActiveTracks if paused
8111 case TrackBase::STOPPED: // cannot be on ActiveTracks if destroyed/terminated
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008112 default:
Andy Hungce685402018-10-05 17:23:27 -07008113 LOG_ALWAYS_FATAL("%s: Unexpected active track state:%d, id:%d, tracks:%zu",
8114 __func__, activeTrackState, activeTrack->id(), size);
Glenn Kasten9e982352013-08-14 14:39:50 -07008115 }
Glenn Kasten9e982352013-08-14 14:39:50 -07008116
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008117 if (activeTrack->isFastTrack()) {
8118 ALOG_ASSERT(!mFastTrackAvail);
8119 ALOG_ASSERT(fastTrack == 0);
Eric Laurent33403f02020-05-29 18:35:06 -07008120 // if the active fast track is silenced either:
8121 // 1) silence the whole capture from fast capture buffer if this is
8122 // the only active track
8123 // 2) invalidate this track: this will cause the client to reconnect and possibly
8124 // be invalidated again until unsilenced
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008125 bool invalidate = false;
Eric Laurent33403f02020-05-29 18:35:06 -07008126 if (activeTrack->isSilenced()) {
8127 if (size > 1) {
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008128 invalidate = true;
Eric Laurent33403f02020-05-29 18:35:06 -07008129 } else {
8130 silenceFastCapture = true;
8131 }
8132 }
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008133 // Invalidate fast tracks if access to audio history is required as this is not
8134 // possible with fast tracks. Once the fast track has been invalidated, no new
8135 // fast track will be created until mMaxSharedAudioHistoryMs is cleared.
8136 if (mMaxSharedAudioHistoryMs != 0) {
8137 invalidate = true;
8138 }
8139 if (invalidate) {
8140 activeTrack->invalidate();
8141 ALOG_ASSERT(fastTrackToRemove == 0);
8142 fastTrackToRemove = activeTrack;
8143 removeTrack_l(activeTrack);
8144 mActiveTracks.remove(activeTrack);
8145 size--;
8146 continue;
8147 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008148 fastTrack = activeTrack;
8149 }
Eric Laurent33403f02020-05-29 18:35:06 -07008150
8151 activeTracks.add(activeTrack);
8152 i++;
8153
Glenn Kasten9e982352013-08-14 14:39:50 -07008154 }
Eric Laurent5c25d562016-07-13 17:17:45 -07008155
Andy Hungdae27702016-10-31 14:01:16 -07008156 mActiveTracks.updatePowerState(this);
8157
Kevin Rocard069c2712018-03-29 19:09:14 -07008158 updateMetadata_l();
8159
Eric Laurent5c25d562016-07-13 17:17:45 -07008160 if (allStopped) {
8161 standbyIfNotAlreadyInStandby();
8162 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008163 if (doBroadcast) {
8164 mStartStopCond.broadcast();
8165 }
8166
8167 // sleep if there are no active tracks to process
Eric Tan39ec8d62018-07-24 09:49:29 -07008168 if (activeTracks.isEmpty()) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008169 if (sleepUs == 0) {
8170 sleepUs = kRecordThreadSleepUs;
8171 }
8172 continue;
8173 }
8174 sleepUs = 0;
Glenn Kasten9e982352013-08-14 14:39:50 -07008175
Eric Laurent81784c32012-11-19 14:55:58 -08008176 lockEffectChains_l(effectChains);
8177 }
8178
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008179 // thread mutex is now unlocked, mActiveTracks unknown, activeTracks.size() > 0
Glenn Kasten71652682013-08-14 15:17:55 -07008180
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008181 size_t size = effectChains.size();
8182 for (size_t i = 0; i < size; i++) {
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07008183 // thread mutex is not locked, but effect chain is locked
8184 effectChains[i]->process_l();
8185 }
8186
Glenn Kasten735f45f2014-08-18 15:51:59 -07008187 // Push a new fast capture state if fast capture is not already running, or cblk change
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008188 if (mFastCapture != 0) {
8189 FastCaptureStateQueue *sq = mFastCapture->sq();
8190 FastCaptureState *state = sq->begin();
Glenn Kasten735f45f2014-08-18 15:51:59 -07008191 bool didModify = false;
8192 FastCaptureStateQueue::block_t block = FastCaptureStateQueue::BLOCK_UNTIL_PUSHED;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008193 if (state->mCommand != FastCaptureState::READ_WRITE /* FIXME &&
8194 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)*/) {
8195 if (state->mCommand == FastCaptureState::COLD_IDLE) {
8196 int32_t old = android_atomic_inc(&mFastCaptureFutex);
8197 if (old == -1) {
8198 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
8199 }
8200 }
8201 state->mCommand = FastCaptureState::READ_WRITE;
8202#if 0 // FIXME
8203 mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08008204 FastThreadDumpState::kSamplingNforLowRamDevice :
8205 FastThreadDumpState::kSamplingN);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008206#endif
Glenn Kasten735f45f2014-08-18 15:51:59 -07008207 didModify = true;
8208 }
8209 audio_track_cblk_t *cblkOld = state->mCblk;
8210 audio_track_cblk_t *cblkNew = fastTrack != 0 ? fastTrack->cblk() : NULL;
8211 if (cblkNew != cblkOld) {
8212 state->mCblk = cblkNew;
8213 // block until acked if removing a fast track
8214 if (cblkOld != NULL) {
8215 block = FastCaptureStateQueue::BLOCK_UNTIL_ACKED;
8216 }
8217 didModify = true;
8218 }
jiabin01c8f562018-07-19 17:47:28 -07008219 AudioBufferProvider* abp = (fastTrack != 0 && fastTrack->isPatchTrack()) ?
8220 reinterpret_cast<AudioBufferProvider*>(fastTrack.get()) : nullptr;
8221 if (state->mFastPatchRecordBufferProvider != abp) {
8222 state->mFastPatchRecordBufferProvider = abp;
8223 state->mFastPatchRecordFormat = fastTrack == 0 ?
8224 AUDIO_FORMAT_INVALID : fastTrack->format();
8225 didModify = true;
8226 }
Eric Laurent33403f02020-05-29 18:35:06 -07008227 if (state->mSilenceCapture != silenceFastCapture) {
8228 state->mSilenceCapture = silenceFastCapture;
8229 didModify = true;
8230 }
Glenn Kasten735f45f2014-08-18 15:51:59 -07008231 sq->end(didModify);
8232 if (didModify) {
8233 sq->push(block);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008234#if 0
8235 if (kUseFastCapture == FastCapture_Dynamic) {
8236 mNormalSource = mPipeSource;
8237 }
8238#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008239 }
8240 }
8241
Glenn Kasten735f45f2014-08-18 15:51:59 -07008242 // now run the fast track destructor with thread mutex unlocked
8243 fastTrackToRemove.clear();
8244
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008245 // Read from HAL to keep up with fastest client if multiple active tracks, not slowest one.
8246 // Only the client(s) that are too slow will overrun. But if even the fastest client is too
8247 // slow, then this RecordThread will overrun by not calling HAL read often enough.
8248 // If destination is non-contiguous, first read past the nominal end of buffer, then
8249 // copy to the right place. Permitted because mRsmpInBuffer was over-allocated.
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07008250
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008251 int32_t rear = mRsmpInRear & (mRsmpInFramesP2 - 1);
Andy Hung920f6572022-10-06 12:09:49 -07008252 ssize_t framesRead = 0; // not needed, remove clang-tidy warning.
Andy Hung446f4df2019-02-21 12:26:41 -08008253 const int64_t lastIoBeginNs = systemTime(); // start IO timing
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008254
8255 // If an NBAIO source is present, use it to read the normal capture's data
8256 if (mPipeSource != 0) {
Andy Hung156317a2018-08-02 11:49:29 -07008257 size_t framesToRead = min(mRsmpInFramesOA - rear, mRsmpInFramesP2 / 2);
Andy Hungd5b638f2018-04-30 13:56:10 -07008258
8259 // The audio fifo read() returns OVERRUN on overflow, and advances the read pointer
8260 // to the full buffer point (clearing the overflow condition). Upon OVERRUN error,
8261 // we immediately retry the read() to get data and prevent another overflow.
8262 for (int retries = 0; retries <= 2; ++retries) {
8263 ALOGW_IF(retries > 0, "overrun on read from pipe, retry #%d", retries);
8264 framesRead = mPipeSource->read((uint8_t*)mRsmpInBuffer + rear * mFrameSize,
8265 framesToRead);
8266 if (framesRead != OVERRUN) break;
8267 }
8268
Andy Hung7a3dc6b2018-05-01 16:39:51 -07008269 const ssize_t availableToRead = mPipeSource->availableToRead();
8270 if (availableToRead >= 0) {
Robert Wu06db0a32021-08-10 19:05:34 +00008271 mMonopipePipeDepthStats.add(availableToRead);
Glenn Kastena2f59b32020-08-03 16:37:24 -07008272 // PipeSource is the primary clock. It is up to the AudioRecord client to keep up.
Andy Hung7a3dc6b2018-05-01 16:39:51 -07008273 LOG_ALWAYS_FATAL_IF((size_t)availableToRead > mPipeFramesP2,
8274 "more frames to read than fifo size, %zd > %zu",
8275 availableToRead, mPipeFramesP2);
8276 const size_t pipeFramesFree = mPipeFramesP2 - availableToRead;
8277 const size_t sleepFrames = min(pipeFramesFree, mRsmpInFramesP2) / 2;
8278 ALOGVV("mPipeFramesP2:%zu mRsmpInFramesP2:%zu sleepFrames:%zu availableToRead:%zd",
8279 mPipeFramesP2, mRsmpInFramesP2, sleepFrames, availableToRead);
Glenn Kasten1b291842016-07-18 14:55:21 -07008280 sleepUs = (sleepFrames * 1000000LL) / mSampleRate;
8281 }
8282 if (framesRead < 0) {
8283 status_t status = (status_t) framesRead;
8284 switch (status) {
8285 case OVERRUN:
8286 ALOGW("overrun on read from pipe");
8287 framesRead = 0;
8288 break;
8289 case NEGOTIATE:
8290 ALOGE("re-negotiation is needed");
8291 framesRead = -1; // Will cause an attempt to recover.
8292 break;
8293 default:
8294 ALOGE("unknown error %d on read from pipe", status);
8295 break;
8296 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008297 }
8298 // otherwise use the HAL / AudioStreamIn directly
8299 } else {
Glenn Kastenec6a7032016-03-14 07:40:23 -07008300 ATRACE_BEGIN("read");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008301 size_t bytesRead;
Mikhail Naganov2534b382019-09-25 13:05:02 -07008302 status_t result = mSource->read(
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008303 (uint8_t*)mRsmpInBuffer + rear * mFrameSize, mBufferSize, &bytesRead);
Glenn Kastenec6a7032016-03-14 07:40:23 -07008304 ATRACE_END();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008305 if (result < 0) {
8306 framesRead = result;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008307 } else {
8308 framesRead = bytesRead / mFrameSize;
8309 }
8310 }
8311
Andy Hung446f4df2019-02-21 12:26:41 -08008312 const int64_t lastIoEndNs = systemTime(); // end IO timing
8313
Andy Hung3f0c9022016-01-15 17:49:46 -08008314 // Update server timestamp with server stats
8315 // systemTime() is optional if the hardware supports timestamps.
Andy Hung743f6402020-06-03 13:17:04 -07008316 if (framesRead >= 0) {
8317 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += framesRead;
8318 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = lastIoEndNs;
8319 }
Andy Hung3f0c9022016-01-15 17:49:46 -08008320
8321 // Update server timestamp with kernel stats
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008322 if (mPipeSource.get() == nullptr /* don't obtain for FastCapture, could block */) {
Andy Hung3f0c9022016-01-15 17:49:46 -08008323 int64_t position, time;
Andy Hung2e2c0bb2018-06-11 19:13:11 -07008324 if (mStandby) {
Dean Wheatley12473e92021-03-18 23:00:55 +11008325 mTimestampVerifier.discontinuity(audio_is_linear_pcm(mFormat) ?
8326 mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS :
8327 mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Mikhail Naganov2534b382019-09-25 13:05:02 -07008328 } else if (mSource->getCapturePosition(&position, &time) == NO_ERROR
Andy Hungc8fddf32018-08-08 18:32:37 -07008329 && time > mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]) {
8330
8331 mTimestampVerifier.add(position, time, mSampleRate);
8332
8333 // Correct timestamps
8334 if (isTimestampCorrectionEnabled()) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10008335 ALOGVV("TS_BEFORE: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07008336 id(), (long long)time, (long long)position);
8337 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
8338 position = correctedTimestamp.mFrames;
8339 time = correctedTimestamp.mTimeNs;
Dean Wheatley56a583e2020-05-08 15:12:17 +10008340 ALOGVV("TS_AFTER: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07008341 id(), (long long)time, (long long)position);
8342 }
8343
Andy Hung3f0c9022016-01-15 17:49:46 -08008344 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = position;
8345 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = time;
8346 // Note: In general record buffers should tend to be empty in
8347 // a properly running pipeline.
8348 //
8349 // Also, it is not advantageous to call get_presentation_position during the read
8350 // as the read obtains a lock, preventing the timestamp call from executing.
Andy Hung2e2c0bb2018-06-11 19:13:11 -07008351 } else {
8352 mTimestampVerifier.error();
Andy Hung3f0c9022016-01-15 17:49:46 -08008353 }
8354 }
Andy Hunge6c37112019-02-26 17:38:10 -08008355
8356 // From the timestamp, input read latency is negative output write latency.
8357 const audio_input_flags_t flags = mInput != NULL ? mInput->flags : AUDIO_INPUT_FLAG_NONE;
8358 const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
8359 ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
8360 if (latencyMs != 0.) { // note 0. means timestamp is empty.
8361 mLatencyMs.add(latencyMs);
8362 }
8363
Andy Hung3f0c9022016-01-15 17:49:46 -08008364 // Use this to track timestamp information
8365 // ALOGD("%s", mTimestamp.toString().c_str());
8366
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008367 if (framesRead < 0 || (framesRead == 0 && mPipeSource == 0)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07008368 ALOGE("read failed: framesRead=%zd", framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008369 // Force input into standby so that it tries to recover at next read attempt
8370 inputStandBy();
8371 sleepUs = kRecordThreadSleepUs;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008372 }
8373 if (framesRead <= 0) {
Glenn Kasten3d61bc12014-06-16 10:25:20 -07008374 goto unlock;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07008375 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008376 ALOG_ASSERT(framesRead > 0);
Andy Hung6427e442018-08-09 12:51:02 -07008377 mFramesRead += framesRead;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008378
Andy Hung8946a282018-04-19 20:04:56 -07008379#ifdef TEE_SINK
8380 (void)mTee.write((uint8_t*)mRsmpInBuffer + rear * mFrameSize, framesRead);
8381#endif
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008382 // If destination is non-contiguous, we now correct for reading past end of buffer.
Glenn Kasten3d61bc12014-06-16 10:25:20 -07008383 {
8384 size_t part1 = mRsmpInFramesP2 - rear;
8385 if ((size_t) framesRead > part1) {
Andy Hung57446612015-04-19 23:56:46 -07008386 memcpy(mRsmpInBuffer, (uint8_t*)mRsmpInBuffer + mRsmpInFramesP2 * mFrameSize,
Glenn Kasten3d61bc12014-06-16 10:25:20 -07008387 (framesRead - part1) * mFrameSize);
8388 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008389 }
Dean Wheatleyfd56e812020-11-06 22:32:21 +11008390 mRsmpInRear = audio_utils::safe_add_overflow(mRsmpInRear, (int32_t)framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008391
8392 size = activeTracks.size();
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008393
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008394 // loop over each active track
8395 for (size_t i = 0; i < size; i++) {
8396 activeTrack = activeTracks[i];
8397
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008398 // skip fast tracks, as those are handled directly by FastCapture
8399 if (activeTrack->isFastTrack()) {
8400 continue;
8401 }
8402
Andy Hung73c02e42015-03-29 01:13:58 -07008403 // TODO: This code probably should be moved to RecordTrack.
Andy Hung97a893e2015-03-29 01:03:07 -07008404 // TODO: Update the activeTrack buffer converter in case of reconfigure.
8405
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008406 enum {
8407 OVERRUN_UNKNOWN,
8408 OVERRUN_TRUE,
8409 OVERRUN_FALSE
8410 } overrun = OVERRUN_UNKNOWN;
8411
8412 // loop over getNextBuffer to handle circular sink
8413 for (;;) {
8414
8415 activeTrack->mSink.frameCount = ~0;
8416 status_t status = activeTrack->getNextBuffer(&activeTrack->mSink);
8417 size_t framesOut = activeTrack->mSink.frameCount;
8418 LOG_ALWAYS_FATAL_IF((status == OK) != (framesOut > 0));
8419
Andy Hung73c02e42015-03-29 01:13:58 -07008420 // check available frames and handle overrun conditions
8421 // if the record track isn't draining fast enough.
8422 bool hasOverrun;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008423 size_t framesIn;
Andy Hung73c02e42015-03-29 01:13:58 -07008424 activeTrack->mResamplerBufferProvider->sync(&framesIn, &hasOverrun);
8425 if (hasOverrun) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008426 overrun = OVERRUN_TRUE;
8427 }
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008428 if (framesOut == 0 || framesIn == 0) {
8429 break;
8430 }
8431
Andy Hung6770c6f2015-04-07 13:43:36 -07008432 // Don't allow framesOut to be larger than what is possible with resampling
8433 // from framesIn.
8434 // This isn't strictly necessary but helps limit buffer resizing in
8435 // RecordBufferConverter. TODO: remove when no longer needed.
8436 framesOut = min(framesOut,
8437 destinationFramesPossible(
8438 framesIn, mSampleRate, activeTrack->mSampleRate));
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008439
8440 if (activeTrack->isDirect()) {
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10008441 // No RecordBufferConverter used for direct streams. Pass
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008442 // straight from RecordThread buffer to RecordTrack buffer.
8443 AudioBufferProvider::Buffer buffer;
8444 buffer.frameCount = framesOut;
Andy Hung920f6572022-10-06 12:09:49 -07008445 const status_t getNextBufferStatus =
8446 activeTrack->mResamplerBufferProvider->getNextBuffer(&buffer);
8447 if (getNextBufferStatus == OK && buffer.frameCount != 0) {
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008448 ALOGV_IF(buffer.frameCount != framesOut,
8449 "%s() read less than expected (%zu vs %zu)",
8450 __func__, buffer.frameCount, framesOut);
8451 framesOut = buffer.frameCount;
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10008452 memcpy(activeTrack->mSink.raw, buffer.raw, buffer.frameCount * mFrameSize);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008453 activeTrack->mResamplerBufferProvider->releaseBuffer(&buffer);
8454 } else {
8455 framesOut = 0;
8456 ALOGE("%s() cannot fill request, status: %d, frameCount: %zu",
Andy Hung920f6572022-10-06 12:09:49 -07008457 __func__, getNextBufferStatus, buffer.frameCount);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008458 }
8459 } else {
8460 // process frames from the RecordThread buffer provider to the RecordTrack
8461 // buffer
8462 framesOut = activeTrack->mRecordBufferConverter->convert(
8463 activeTrack->mSink.raw,
8464 activeTrack->mResamplerBufferProvider,
8465 framesOut);
8466 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008467
8468 if (framesOut > 0 && (overrun == OVERRUN_UNKNOWN)) {
8469 overrun = OVERRUN_FALSE;
8470 }
8471
8472 if (activeTrack->mFramesToDrop == 0) {
8473 if (framesOut > 0) {
8474 activeTrack->mSink.frameCount = framesOut;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008475 // Sanitize before releasing if the track has no access to the source data
8476 // An idle UID receives silence from non virtual devices until active
8477 if (activeTrack->isSilenced()) {
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07008478 memset(activeTrack->mSink.raw, 0, framesOut * activeTrack->frameSize());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008479 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008480 activeTrack->releaseBuffer(&activeTrack->mSink);
8481 }
8482 } else {
8483 // FIXME could do a partial drop of framesOut
8484 if (activeTrack->mFramesToDrop > 0) {
Mikhail Naganov6d91ba52019-03-26 14:35:28 -07008485 activeTrack->mFramesToDrop -= (ssize_t)framesOut;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008486 if (activeTrack->mFramesToDrop <= 0) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008487 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008488 }
8489 } else {
8490 activeTrack->mFramesToDrop += framesOut;
8491 if (activeTrack->mFramesToDrop >= 0 || activeTrack->mSyncStartEvent == 0 ||
8492 activeTrack->mSyncStartEvent->isCancelled()) {
8493 ALOGW("Synced record %s, session %d, trigger session %d",
8494 (activeTrack->mFramesToDrop >= 0) ? "timed out" : "cancelled",
8495 activeTrack->sessionId(),
8496 (activeTrack->mSyncStartEvent != 0) ?
Glenn Kastend848eb42016-03-08 13:42:11 -08008497 activeTrack->mSyncStartEvent->triggerSession() :
8498 AUDIO_SESSION_NONE);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008499 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008500 }
8501 }
8502 }
8503
8504 if (framesOut == 0) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008505 break;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07008506 }
8507 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008508
8509 switch (overrun) {
8510 case OVERRUN_TRUE:
8511 // client isn't retrieving buffers fast enough
8512 if (!activeTrack->setOverflow()) {
8513 nsecs_t now = systemTime();
8514 // FIXME should lastWarning per track?
8515 if ((now - lastWarning) > kWarningThrottleNs) {
8516 ALOGW("RecordThread: buffer overflow");
8517 lastWarning = now;
8518 }
8519 }
8520 break;
8521 case OVERRUN_FALSE:
8522 activeTrack->clearOverflow();
8523 break;
8524 case OVERRUN_UNKNOWN:
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008525 break;
8526 }
8527
Andy Hung3f0c9022016-01-15 17:49:46 -08008528 // update frame information and push timestamp out
8529 activeTrack->updateTrackFrameInfo(
Andy Hung6ae58432016-02-16 18:32:24 -08008530 activeTrack->mServerProxy->framesReleased(),
Andy Hung3f0c9022016-01-15 17:49:46 -08008531 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER],
8532 mSampleRate, mTimestamp);
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07008533 }
8534
Glenn Kasten3d61bc12014-06-16 10:25:20 -07008535unlock:
Eric Laurent81784c32012-11-19 14:55:58 -08008536 // enable changes in effect chain
8537 unlockEffectChains(effectChains);
Glenn Kastenc527a7c2013-08-13 15:43:49 -07008538 // effectChains doesn't need to be cleared, since it is cleared by destructor at scope end
Eric Laurentcccbc762019-04-05 14:20:05 -07008539 if (audio_has_proportional_frames(mFormat)
8540 && loopCount == lastLoopCountRead + 1) {
8541 const int64_t readPeriodNs = lastIoEndNs - mLastIoEndNs;
8542 const double jitterMs =
8543 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
8544 {framesRead, readPeriodNs},
8545 {0, 0} /* lastTimestamp */, mSampleRate);
8546 const double processMs = (lastIoBeginNs - mLastIoEndNs) * 1e-6;
8547
8548 Mutex::Autolock _l(mLock);
8549 mIoJitterMs.add(jitterMs);
8550 mProcessTimeMs.add(processMs);
8551 }
8552 // update timing info.
8553 mLastIoBeginNs = lastIoBeginNs;
8554 mLastIoEndNs = lastIoEndNs;
8555 lastLoopCountRead = loopCount;
Eric Laurent81784c32012-11-19 14:55:58 -08008556 }
8557
Glenn Kasten93e471f2013-08-19 08:40:07 -07008558 standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08008559
8560 {
8561 Mutex::Autolock _l(mLock);
Eric Laurent9a54bc22013-09-09 09:08:44 -07008562 for (size_t i = 0; i < mTracks.size(); i++) {
8563 sp<RecordTrack> track = mTracks[i];
8564 track->invalidate();
8565 }
Glenn Kasten2b806402013-11-20 16:37:38 -08008566 mActiveTracks.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08008567 mStartStopCond.broadcast();
8568 }
8569
8570 releaseWakeLock();
8571
8572 ALOGV("RecordThread %p exiting", this);
8573 return false;
8574}
8575
Glenn Kasten93e471f2013-08-19 08:40:07 -07008576void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
Eric Laurent81784c32012-11-19 14:55:58 -08008577{
8578 if (!mStandby) {
8579 inputStandBy();
Andy Hungcf10d742020-04-28 15:38:24 -07008580 mThreadMetrics.logEndInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07008581 mThreadSnapshot.onEnd();
Eric Laurent81784c32012-11-19 14:55:58 -08008582 mStandby = true;
8583 }
8584}
8585
8586void AudioFlinger::RecordThread::inputStandBy()
8587{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008588 // Idle the fast capture if it's currently running
8589 if (mFastCapture != 0) {
8590 FastCaptureStateQueue *sq = mFastCapture->sq();
8591 FastCaptureState *state = sq->begin();
8592 if (!(state->mCommand & FastCaptureState::IDLE)) {
8593 state->mCommand = FastCaptureState::COLD_IDLE;
8594 state->mColdFutexAddr = &mFastCaptureFutex;
8595 state->mColdGen++;
8596 mFastCaptureFutex = 0;
8597 sq->end();
8598 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
8599 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_ACKED);
8600#if 0
8601 if (kUseFastCapture == FastCapture_Dynamic) {
8602 // FIXME
8603 }
8604#endif
8605#ifdef AUDIO_WATCHDOG
8606 // FIXME
8607#endif
8608 } else {
8609 sq->end(false /*didModify*/);
8610 }
8611 }
Mikhail Naganov2534b382019-09-25 13:05:02 -07008612 status_t result = mSource->standby();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008613 ALOGE_IF(result != OK, "Error when putting input stream into standby: %d", result);
Andy Hungad6d52d2016-07-18 13:42:03 -07008614
8615 // If going into standby, flush the pipe source.
8616 if (mPipeSource.get() != nullptr) {
8617 const ssize_t flushed = mPipeSource->flush();
8618 if (flushed > 0) {
8619 ALOGV("Input standby flushed PipeSource %zd frames", flushed);
8620 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += flushed;
8621 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = systemTime();
8622 }
8623 }
Eric Laurent81784c32012-11-19 14:55:58 -08008624}
8625
Glenn Kasten05997e22014-03-13 15:08:33 -07008626// RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
Glenn Kastene198c362013-08-13 09:13:36 -07008627sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
Eric Laurent81784c32012-11-19 14:55:58 -08008628 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07008629 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08008630 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08008631 audio_format_t format,
8632 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08008633 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08008634 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08008635 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07008636 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00008637 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07008638 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08008639 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08008640 status_t *status,
Eric Laurentec376dc2021-04-08 20:41:22 +02008641 audio_port_handle_t portId,
8642 int32_t maxSharedAudioHistoryMs)
Eric Laurent81784c32012-11-19 14:55:58 -08008643{
Glenn Kasten74935e42013-12-19 08:56:45 -08008644 size_t frameCount = *pFrameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08008645 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08008646 sp<RecordTrack> track;
8647 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07008648 audio_input_flags_t inputFlags = mInput->flags;
Eric Laurentf14db3c2017-12-08 14:20:36 -08008649 audio_input_flags_t requestedFlags = *flags;
8650 uint32_t sampleRate;
8651
8652 lStatus = initCheck();
8653 if (lStatus != NO_ERROR) {
8654 ALOGE("createRecordTrack_l() audio driver not initialized");
8655 goto Exit;
8656 }
8657
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008658 if (!audio_is_linear_pcm(mFormat) && (*flags & AUDIO_INPUT_FLAG_DIRECT) == 0) {
8659 ALOGE("createRecordTrack_l() on an encoded stream requires AUDIO_INPUT_FLAG_DIRECT");
8660 lStatus = BAD_VALUE;
8661 goto Exit;
8662 }
8663
Eric Laurentec376dc2021-04-08 20:41:22 +02008664 if (maxSharedAudioHistoryMs != 0) {
Eric Laurent9ff3e532022-11-10 16:04:44 +01008665 if (!captureHotwordAllowed(attributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02008666 lStatus = PERMISSION_DENIED;
8667 goto Exit;
8668 }
Eric Laurentec376dc2021-04-08 20:41:22 +02008669 if (maxSharedAudioHistoryMs < 0
8670 || maxSharedAudioHistoryMs > AudioFlinger::kMaxSharedAudioHistoryMs) {
8671 lStatus = BAD_VALUE;
8672 goto Exit;
8673 }
8674 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08008675 if (*pSampleRate == 0) {
8676 *pSampleRate = mSampleRate;
8677 }
8678 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07008679
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008680 // special case for FAST flag considered OK if fast capture is present and access to
8681 // audio history is not required
8682 if (hasFastCapture() && mMaxSharedAudioHistoryMs == 0) {
Eric Laurent05067782016-06-01 18:27:28 -07008683 inputFlags = (audio_input_flags_t)(inputFlags | AUDIO_INPUT_FLAG_FAST);
8684 }
8685
Eric Laurentf14db3c2017-12-08 14:20:36 -08008686 // Check if requested flags are compatible with input stream flags
Eric Laurent05067782016-06-01 18:27:28 -07008687 if ((*flags & inputFlags) != *flags) {
8688 ALOGW("createRecordTrack_l(): mismatch between requested flags (%08x) and"
8689 " input flags (%08x)",
8690 *flags, inputFlags);
8691 *flags = (audio_input_flags_t)(*flags & inputFlags);
8692 }
Eric Laurent81784c32012-11-19 14:55:58 -08008693
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008694 // client expresses a preference for FAST and no access to audio history,
8695 // but we get the final say
8696 if (*flags & AUDIO_INPUT_FLAG_FAST && maxSharedAudioHistoryMs == 0) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07008697 if (
Glenn Kastenb7fbf7e2015-03-18 12:57:28 -07008698 // we formerly checked for a callback handler (non-0 tid),
8699 // but that is no longer required for TRANSFER_OBTAIN mode
jiabinb00edc32021-08-16 16:27:54 +00008700 // No need to match hardware format, format conversion will be done in client side.
Glenn Kastenb7fbf7e2015-03-18 12:57:28 -07008701 //
Phil Burk7ed66a12019-04-18 13:20:30 -07008702 // Frame count is not specified (0), or is less than or equal the pipe depth.
8703 // It is OK to provide a higher capacity than requested.
8704 // We will force it to mPipeFramesP2 below.
8705 (frameCount <= mPipeFramesP2) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07008706 // PCM data
8707 audio_is_linear_pcm(format) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08008708 // hardware channel mask
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008709 (channelMask == mChannelMask) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08008710 // hardware sample rate
Glenn Kasten90e58b12013-07-31 16:16:02 -07008711 (sampleRate == mSampleRate) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07008712 // record thread has an associated fast capture
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008713 hasFastCapture() &&
8714 // there are sufficient fast track slots available
8715 mFastTrackAvail
Glenn Kasten90e58b12013-07-31 16:16:02 -07008716 ) {
Eric Laurent4c415062016-06-17 16:14:16 -07008717 // check compatibility with audio effects.
8718 Mutex::Autolock _l(mLock);
8719 // Do not accept FAST flag if the session has software effects
8720 sp<EffectChain> chain = getEffectChain_l(sessionId);
8721 if (chain != 0) {
Andy Hungd3bb0ad2016-10-11 17:16:43 -07008722 audio_input_flags_t old = *flags;
8723 chain->checkInputFlagCompatibility(flags);
8724 if (old != *flags) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07008725 ALOGV("%p AUDIO_INPUT_FLAGS denied by effect old=%#x new=%#x",
8726 this, (int)old, (int)*flags);
Eric Laurent4c415062016-06-17 16:14:16 -07008727 }
8728 }
Eric Laurent122f7e72016-06-29 11:53:29 -07008729 ALOGV_IF((*flags & AUDIO_INPUT_FLAG_FAST) != 0,
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07008730 "%p AUDIO_INPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
8731 this, frameCount, mFrameCount);
Glenn Kasten90e58b12013-07-31 16:16:02 -07008732 } else {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07008733 ALOGV("%p AUDIO_INPUT_FLAG_FAST denied: frameCount=%zu mFrameCount=%zu mPipeFramesP2=%zu "
8734 "format=%#x isLinear=%d mFormat=%#x channelMask=%#x sampleRate=%u mSampleRate=%u "
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008735 "hasFastCapture=%d tid=%d mFastTrackAvail=%d",
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07008736 this, frameCount, mFrameCount, mPipeFramesP2,
8737 format, audio_is_linear_pcm(format), mFormat, channelMask, sampleRate, mSampleRate,
Glenn Kasten74105912014-07-03 12:28:53 -07008738 hasFastCapture(), tid, mFastTrackAvail);
Eric Laurent05067782016-06-01 18:27:28 -07008739 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
Glenn Kasten74105912014-07-03 12:28:53 -07008740 }
8741 }
8742
Eric Laurentf14db3c2017-12-08 14:20:36 -08008743 // If FAST or RAW flags were corrected, ask caller to request new input from audio policy
8744 if ((*flags & AUDIO_INPUT_FLAG_FAST) !=
8745 (requestedFlags & AUDIO_INPUT_FLAG_FAST)) {
8746 *flags = (audio_input_flags_t) (*flags & ~(AUDIO_INPUT_FLAG_FAST | AUDIO_INPUT_FLAG_RAW));
8747 lStatus = BAD_TYPE;
8748 goto Exit;
8749 }
8750
Glenn Kasten74105912014-07-03 12:28:53 -07008751 // compute track buffer size in frames, and suggest the notification frame count
Eric Laurent05067782016-06-01 18:27:28 -07008752 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten74105912014-07-03 12:28:53 -07008753 // fast track: frame count is exactly the pipe depth
8754 frameCount = mPipeFramesP2;
8755 // ignore requested notificationFrames, and always notify exactly once every HAL buffer
Eric Laurentf14db3c2017-12-08 14:20:36 -08008756 notificationFrameCount = mFrameCount;
Glenn Kasten74105912014-07-03 12:28:53 -07008757 } else {
Glenn Kasten49d00ad2014-07-21 11:22:03 -07008758 // not fast track: max notification period is resampled equivalent of one HAL buffer time
8759 // or 20 ms if there is a fast capture
8760 // TODO This could be a roundupRatio inline, and const
8761 size_t maxNotificationFrames = ((int64_t) (hasFastCapture() ? mSampleRate/50 : mFrameCount)
8762 * sampleRate + mSampleRate - 1) / mSampleRate;
8763 // minimum number of notification periods is at least kMinNotifications,
8764 // and at least kMinMs rounded up to a whole notification period (minNotificationsByMs)
8765 static const size_t kMinNotifications = 3;
8766 static const uint32_t kMinMs = 30;
8767 // TODO This could be a roundupRatio inline
8768 const size_t minFramesByMs = (sampleRate * kMinMs + 1000 - 1) / 1000;
8769 // TODO This could be a roundupRatio inline
8770 const size_t minNotificationsByMs = (minFramesByMs + maxNotificationFrames - 1) /
8771 maxNotificationFrames;
8772 const size_t minFrameCount = maxNotificationFrames *
8773 max(kMinNotifications, minNotificationsByMs);
8774 frameCount = max(frameCount, minFrameCount);
Eric Laurentf14db3c2017-12-08 14:20:36 -08008775 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
8776 notificationFrameCount = maxNotificationFrames;
Glenn Kasten74105912014-07-03 12:28:53 -07008777 }
Glenn Kasten90e58b12013-07-31 16:16:02 -07008778 }
Glenn Kasten74935e42013-12-19 08:56:45 -08008779 *pFrameCount = frameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08008780 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08008781
8782 { // scope for mLock
8783 Mutex::Autolock _l(mLock);
Eric Laurent2407ce32021-04-26 14:56:03 +02008784 int32_t startFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02008785 if (!mSharedAudioPackageName.empty()
Eric Laurent9ff3e532022-11-10 16:04:44 +01008786 && mSharedAudioPackageName == attributionSource.packageName
Eric Laurentec376dc2021-04-08 20:41:22 +02008787 && mSharedAudioSessionId == sessionId
Eric Laurent9ff3e532022-11-10 16:04:44 +01008788 && captureHotwordAllowed(attributionSource)) {
Eric Laurent2407ce32021-04-26 14:56:03 +02008789 startFrames = mSharedAudioStartFrames;
Eric Laurentec376dc2021-04-08 20:41:22 +02008790 }
Eric Laurent81784c32012-11-19 14:55:58 -08008791
Kevin Rocard1f564ac2018-03-29 13:53:10 -07008792 track = new RecordTrack(this, client, attr, sampleRate,
Andy Hung8fe68032017-06-05 16:17:51 -07008793 format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07008794 nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid,
Eric Laurent9ff3e532022-11-10 16:04:44 +01008795 attributionSource, *flags, TrackBase::TYPE_DEFAULT, portId,
Svet Ganov33761132021-05-13 22:51:08 +00008796 startFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08008797
Glenn Kasten03003332013-08-06 15:40:54 -07008798 lStatus = track->initCheck();
8799 if (lStatus != NO_ERROR) {
Glenn Kasten35295072013-10-07 09:27:06 -07008800 ALOGE("createRecordTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08008801 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08008802 goto Exit;
8803 }
8804 mTracks.add(track);
8805
Eric Laurent05067782016-06-01 18:27:28 -07008806 if ((*flags & AUDIO_INPUT_FLAG_FAST) && (tid != -1)) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07008807 pid_t callingPid = IPCThreadState::self()->getCallingPid();
8808 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
8809 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07008810 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Glenn Kasten90e58b12013-07-31 16:16:02 -07008811 }
Eric Laurentec376dc2021-04-08 20:41:22 +02008812
8813 if (maxSharedAudioHistoryMs != 0) {
8814 sendResizeBufferConfigEvent_l(maxSharedAudioHistoryMs);
8815 }
Eric Laurent81784c32012-11-19 14:55:58 -08008816 }
Glenn Kasten05997e22014-03-13 15:08:33 -07008817
Eric Laurent81784c32012-11-19 14:55:58 -08008818 lStatus = NO_ERROR;
8819
8820Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07008821 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08008822 return track;
8823}
8824
8825status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
8826 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08008827 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08008828{
8829 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
8830 sp<ThreadBase> strongMe = this;
8831 status_t status = NO_ERROR;
8832
8833 if (event == AudioSystem::SYNC_EVENT_NONE) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008834 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08008835 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008836 recordTrack->mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
Eric Laurent81784c32012-11-19 14:55:58 -08008837 triggerSession,
8838 recordTrack->sessionId(),
8839 syncStartEventCallback,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008840 recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08008841 // Sync event can be cancelled by the trigger session if the track is not in a
8842 // compatible state in which case we start record immediately
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008843 if (recordTrack->mSyncStartEvent->isCancelled()) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008844 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08008845 } else {
8846 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
Ivan Lozano1b35dd62017-12-06 16:55:10 -08008847 recordTrack->mFramesToDrop = -(ssize_t)
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008848 ((AudioSystem::kSyncRecordStartTimeOutMs * recordTrack->mSampleRate) / 1000);
Eric Laurent81784c32012-11-19 14:55:58 -08008849 }
8850 }
8851
8852 {
Glenn Kasten47c20702013-08-13 15:37:35 -07008853 // This section is a rendezvous between binder thread executing start() and RecordThread
Eric Laurent81784c32012-11-19 14:55:58 -08008854 AutoMutex lock(mLock);
Andy Hungce685402018-10-05 17:23:27 -07008855 if (recordTrack->isInvalid()) {
8856 recordTrack->clearSyncStartEvent();
Eric Laurentd52a28c2020-08-21 17:10:39 -07008857 ALOGW("%s track %d: invalidated before startInput", __func__, recordTrack->portId());
8858 return DEAD_OBJECT;
Andy Hungce685402018-10-05 17:23:27 -07008859 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008860 if (mActiveTracks.indexOf(recordTrack) >= 0) {
8861 if (recordTrack->mState == TrackBase::PAUSING) {
Andy Hungce685402018-10-05 17:23:27 -07008862 // We haven't stopped yet (moved to PAUSED and not in mActiveTracks)
8863 // so no need to startInput().
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008864 ALOGV("active record track PAUSING -> ACTIVE");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008865 recordTrack->mState = TrackBase::ACTIVE;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008866 } else {
Andy Hung959b5b82021-09-24 10:46:20 -07008867 ALOGV("active record track state %d", (int)recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08008868 }
8869 return status;
8870 }
8871
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008872 // TODO consider other ways of handling this, such as changing the state to :STARTING and
8873 // adding the track to mActiveTracks after returning from AudioSystem::startInput(),
8874 // or using a separate command thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008875 recordTrack->mState = TrackBase::STARTING_1;
Glenn Kasten2b806402013-11-20 16:37:38 -08008876 mActiveTracks.add(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07008877 if (recordTrack->isExternalTrack()) {
8878 mLock.unlock();
Eric Laurent4eb58f12018-12-07 16:41:02 -08008879 status = AudioSystem::startInput(recordTrack->portId());
Eric Laurent83b88082014-06-20 18:31:16 -07008880 mLock.lock();
Andy Hungce685402018-10-05 17:23:27 -07008881 if (recordTrack->isInvalid()) {
8882 recordTrack->clearSyncStartEvent();
8883 if (status == NO_ERROR && recordTrack->mState == TrackBase::STARTING_1) {
8884 recordTrack->mState = TrackBase::STARTING_2;
8885 // STARTING_2 forces destroy to call stopInput.
8886 }
Eric Laurentd52a28c2020-08-21 17:10:39 -07008887 ALOGW("%s track %d: invalidated after startInput", __func__, recordTrack->portId());
8888 return DEAD_OBJECT;
Andy Hungce685402018-10-05 17:23:27 -07008889 }
8890 if (recordTrack->mState != TrackBase::STARTING_1) {
8891 ALOGW("%s(%d): unsynchronized mState:%d change",
Andy Hung959b5b82021-09-24 10:46:20 -07008892 __func__, recordTrack->id(), (int)recordTrack->mState);
Andy Hungce685402018-10-05 17:23:27 -07008893 // Someone else has changed state, let them take over,
8894 // leave mState in the new state.
8895 recordTrack->clearSyncStartEvent();
8896 return INVALID_OPERATION;
8897 }
8898 // we're ok, but perhaps startInput has failed
Eric Laurent83b88082014-06-20 18:31:16 -07008899 if (status != NO_ERROR) {
Andy Hungce685402018-10-05 17:23:27 -07008900 ALOGW("%s(%d): startInput failed, status %d",
8901 __func__, recordTrack->id(), status);
8902 // We are in ActiveTracks if STARTING_1 and valid, so remove from ActiveTracks,
8903 // leave in STARTING_1, so destroy() will not call stopInput.
Eric Laurent83b88082014-06-20 18:31:16 -07008904 mActiveTracks.remove(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07008905 recordTrack->clearSyncStartEvent();
Eric Laurent83b88082014-06-20 18:31:16 -07008906 return status;
8907 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07008908 sendIoConfigEvent_l(
8909 AUDIO_CLIENT_STARTED, recordTrack->creatorPid(), recordTrack->portId());
Eric Laurent81784c32012-11-19 14:55:58 -08008910 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07008911
8912 recordTrack->logBeginInterval(patchSourcesToString(&mPatch)); // log to MediaMetrics
8913
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008914 // Catch up with current buffer indices if thread is already running.
8915 // This is what makes a new client discard all buffered data. If the track's mRsmpInFront
8916 // was initialized to some value closer to the thread's mRsmpInFront, then the track could
8917 // see previously buffered data before it called start(), but with greater risk of overrun.
8918
Andy Hung73c02e42015-03-29 01:13:58 -07008919 recordTrack->mResamplerBufferProvider->reset();
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008920 if (!recordTrack->isDirect()) {
8921 // clear any converter state as new data will be discontinuous
8922 recordTrack->mRecordBufferConverter->reset();
8923 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008924 recordTrack->mState = TrackBase::STARTING_2;
Eric Laurent81784c32012-11-19 14:55:58 -08008925 // signal thread to start
Eric Laurent81784c32012-11-19 14:55:58 -08008926 mWaitWorkCV.broadcast();
Eric Laurent81784c32012-11-19 14:55:58 -08008927 return status;
8928 }
Eric Laurent81784c32012-11-19 14:55:58 -08008929}
8930
Andy Hunge45f2192023-05-15 19:02:55 -07008931void AudioFlinger::RecordThread::syncStartEventCallback(const wp<audioflinger::SyncEvent>& event)
Eric Laurent81784c32012-11-19 14:55:58 -08008932{
Andy Hunge45f2192023-05-15 19:02:55 -07008933 sp<audioflinger::SyncEvent> strongEvent = event.promote();
Eric Laurent81784c32012-11-19 14:55:58 -08008934
8935 if (strongEvent != 0) {
Eric Laurent8ea16e42014-02-20 16:26:11 -08008936 sp<RefBase> ptr = strongEvent->cookie().promote();
8937 if (ptr != 0) {
8938 RecordTrack *recordTrack = (RecordTrack *)ptr.get();
8939 recordTrack->handleSyncStartEvent(strongEvent);
8940 }
Eric Laurent81784c32012-11-19 14:55:58 -08008941 }
8942}
8943
Glenn Kastena8356f62013-07-25 14:37:52 -07008944bool AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
Eric Laurent81784c32012-11-19 14:55:58 -08008945 ALOGV("RecordThread::stop");
Glenn Kastena8356f62013-07-25 14:37:52 -07008946 AutoMutex _l(mLock);
Andy Hungce685402018-10-05 17:23:27 -07008947 // if we're invalid, we can't be on the ActiveTracks.
Jean-Michel Trivi38f86712017-04-11 14:10:17 -07008948 if (mActiveTracks.indexOf(recordTrack) < 0 || recordTrack->mState == TrackBase::PAUSING) {
Eric Laurent81784c32012-11-19 14:55:58 -08008949 return false;
8950 }
Glenn Kasten47c20702013-08-13 15:37:35 -07008951 // note that threadLoop may still be processing the track at this point [without lock]
Eric Laurent81784c32012-11-19 14:55:58 -08008952 recordTrack->mState = TrackBase::PAUSING;
Andy Hungce685402018-10-05 17:23:27 -07008953
Andy Hungabfab202019-03-07 19:45:54 -08008954 // NOTE: Waiting here is important to keep stop synchronous.
8955 // This is needed for proper patchRecord peer release.
Andy Hungce685402018-10-05 17:23:27 -07008956 while (recordTrack->mState == TrackBase::PAUSING && !recordTrack->isInvalid()) {
8957 mWaitWorkCV.broadcast(); // signal thread to stop
8958 mStartStopCond.wait(mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08008959 }
Andy Hungce685402018-10-05 17:23:27 -07008960
8961 if (recordTrack->mState == TrackBase::PAUSED) { // successful stop
Eric Laurent81784c32012-11-19 14:55:58 -08008962 ALOGV("Record stopped OK");
8963 return true;
8964 }
Andy Hungce685402018-10-05 17:23:27 -07008965
8966 // don't handle anything - we've been invalidated or restarted and in a different state
8967 ALOGW_IF("%s(%d): unsynchronized stop, state: %d",
8968 __func__, recordTrack->id(), recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08008969 return false;
8970}
8971
Andy Hunge45f2192023-05-15 19:02:55 -07008972bool AudioFlinger::RecordThread::isValidSyncEvent(
8973 const sp<audioflinger::SyncEvent>& /* event */) const
Eric Laurent81784c32012-11-19 14:55:58 -08008974{
8975 return false;
8976}
8977
Andy Hunge45f2192023-05-15 19:02:55 -07008978status_t AudioFlinger::RecordThread::setSyncEvent(
8979 const sp<audioflinger::SyncEvent>& event __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008980{
8981#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
8982 if (!isValidSyncEvent(event)) {
8983 return BAD_VALUE;
8984 }
8985
Glenn Kastend848eb42016-03-08 13:42:11 -08008986 audio_session_t eventSession = event->triggerSession();
Eric Laurent81784c32012-11-19 14:55:58 -08008987 status_t ret = NAME_NOT_FOUND;
8988
8989 Mutex::Autolock _l(mLock);
8990
8991 for (size_t i = 0; i < mTracks.size(); i++) {
8992 sp<RecordTrack> track = mTracks[i];
8993 if (eventSession == track->sessionId()) {
8994 (void) track->setSyncEvent(event);
8995 ret = NO_ERROR;
8996 }
8997 }
8998 return ret;
8999#else
9000 return BAD_VALUE;
9001#endif
9002}
9003
jiabin653cc0a2018-01-17 17:54:10 -08009004status_t AudioFlinger::RecordThread::getActiveMicrophones(
Mikhail Naganovd5d9de72023-02-13 11:45:03 -08009005 std::vector<media::MicrophoneInfoFw>* activeMicrophones)
jiabin653cc0a2018-01-17 17:54:10 -08009006{
9007 ALOGV("RecordThread::getActiveMicrophones");
9008 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009009 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06009010 return NO_INIT;
9011 }
jiabin9ff780e2018-03-19 18:19:52 -07009012 status_t status = mInput->stream->getActiveMicrophones(activeMicrophones);
9013 return status;
jiabin653cc0a2018-01-17 17:54:10 -08009014}
9015
Paul McLean12340082019-03-19 09:35:05 -06009016status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
9017 audio_microphone_direction_t direction)
Paul McLean03a6e6a2018-12-04 10:54:13 -07009018{
Paul McLean12340082019-03-19 09:35:05 -06009019 ALOGV("setPreferredMicrophoneDirection(%d)", direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07009020 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009021 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06009022 return NO_INIT;
9023 }
Paul McLean12340082019-03-19 09:35:05 -06009024 return mInput->stream->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07009025}
9026
Paul McLean12340082019-03-19 09:35:05 -06009027status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
Paul McLean03a6e6a2018-12-04 10:54:13 -07009028{
Paul McLean12340082019-03-19 09:35:05 -06009029 ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07009030 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009031 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06009032 return NO_INIT;
9033 }
Paul McLean12340082019-03-19 09:35:05 -06009034 return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07009035}
9036
Eric Laurentec376dc2021-04-08 20:41:22 +02009037status_t AudioFlinger::RecordThread::shareAudioHistory(
9038 const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
9039 int64_t sharedAudioStartMs) {
9040 AutoMutex _l(mLock);
9041 return shareAudioHistory_l(sharedAudioPackageName, sharedSessionId, sharedAudioStartMs);
9042}
9043
9044status_t AudioFlinger::RecordThread::shareAudioHistory_l(
9045 const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
9046 int64_t sharedAudioStartMs) {
Eric Laurent92d0a322021-07-16 15:32:33 +02009047
Eric Laurentec376dc2021-04-08 20:41:22 +02009048 if ((hasAudioSession_l(sharedSessionId) & ThreadBase::TRACK_SESSION) == 0) {
9049 return BAD_VALUE;
9050 }
Eric Laurent2407ce32021-04-26 14:56:03 +02009051
9052 if (sharedAudioStartMs < 0
9053 || sharedAudioStartMs > INT64_MAX / mSampleRate) {
Eric Laurentec376dc2021-04-08 20:41:22 +02009054 return BAD_VALUE;
9055 }
9056
Eric Laurent2407ce32021-04-26 14:56:03 +02009057 // Current implementation of the input resampling buffer wraps around indexes at 32 bit.
9058 // As we cannot detect more than one wraparound, only accept values up current write position
9059 // after one wraparound
9060 // We assume recent wraparounds on mRsmpInRear only given it is unlikely that the requesting
9061 // app waits several hours after the start time was computed.
Eric Laurent92d0a322021-07-16 15:32:33 +02009062 int64_t sharedAudioStartFrames = sharedAudioStartMs * mSampleRate / 1000;
Eric Laurent2407ce32021-04-26 14:56:03 +02009063 const int32_t sharedOffset = audio_utils::safe_sub_overflow(mRsmpInRear,
9064 (int32_t)sharedAudioStartFrames);
Eric Laurent92d0a322021-07-16 15:32:33 +02009065 // Bring the start frame position within the input buffer to match the documented
9066 // "best effort" behavior of the API.
9067 if (sharedOffset < 0) {
9068 sharedAudioStartFrames = mRsmpInRear;
Andy Hung920f6572022-10-06 12:09:49 -07009069 } else if (sharedOffset > static_cast<signed>(mRsmpInFrames)) {
Eric Laurent92d0a322021-07-16 15:32:33 +02009070 sharedAudioStartFrames =
9071 audio_utils::safe_sub_overflow(mRsmpInRear, (int32_t)mRsmpInFrames);
Eric Laurent2407ce32021-04-26 14:56:03 +02009072 }
9073
Eric Laurentec376dc2021-04-08 20:41:22 +02009074 mSharedAudioPackageName = sharedAudioPackageName;
9075 if (mSharedAudioPackageName.empty()) {
Eric Laurent92d0a322021-07-16 15:32:33 +02009076 resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02009077 } else {
9078 mSharedAudioSessionId = sharedSessionId;
Eric Laurent2407ce32021-04-26 14:56:03 +02009079 mSharedAudioStartFrames = (int32_t)sharedAudioStartFrames;
Eric Laurentec376dc2021-04-08 20:41:22 +02009080 }
9081 return NO_ERROR;
9082}
9083
Eric Laurent92d0a322021-07-16 15:32:33 +02009084void AudioFlinger::RecordThread::resetAudioHistory_l() {
9085 mSharedAudioSessionId = AUDIO_SESSION_NONE;
9086 mSharedAudioStartFrames = -1;
9087 mSharedAudioPackageName = "";
9088}
9089
Vlad Popa7e81cea2023-01-19 16:34:16 +01009090AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::RecordThread::updateMetadata_l()
Kevin Rocard069c2712018-03-29 19:09:14 -07009091{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009092 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +01009093 return {}; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07009094 }
9095 StreamInHalInterface::SinkMetadata metadata;
Eric Laurent78b07302022-10-07 16:20:34 +02009096 auto backInserter = std::back_inserter(metadata.tracks);
Kevin Rocard069c2712018-03-29 19:09:14 -07009097 for (const sp<RecordTrack> &track : mActiveTracks) {
Eric Laurent78b07302022-10-07 16:20:34 +02009098 track->copyMetadataTo(backInserter);
Kevin Rocard069c2712018-03-29 19:09:14 -07009099 }
9100 mInput->stream->updateSinkMetadata(metadata);
Vlad Popa7e81cea2023-01-19 16:34:16 +01009101 MetadataUpdate change;
9102 change.recordMetadataUpdate = metadata.tracks;
9103 return change;
Kevin Rocard069c2712018-03-29 19:09:14 -07009104}
9105
Eric Laurent81784c32012-11-19 14:55:58 -08009106// destroyTrack_l() must be called with ThreadBase::mLock held
9107void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
9108{
Eric Laurentbfb1b832013-01-07 09:53:42 -08009109 track->terminate();
9110 track->mState = TrackBase::STOPPED;
Eric Laurentec376dc2021-04-08 20:41:22 +02009111
Eric Laurent81784c32012-11-19 14:55:58 -08009112 // active tracks are removed by threadLoop()
Glenn Kasten2b806402013-11-20 16:37:38 -08009113 if (mActiveTracks.indexOf(track) < 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08009114 removeTrack_l(track);
9115 }
9116}
9117
9118void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
9119{
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009120 String8 result;
9121 track->appendDump(result, false /* active */);
9122 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
9123
Eric Laurent81784c32012-11-19 14:55:58 -08009124 mTracks.remove(track);
9125 // need anything related to effects here?
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07009126 if (track->isFastTrack()) {
9127 ALOG_ASSERT(!mFastTrackAvail);
9128 mFastTrackAvail = true;
9129 }
Eric Laurent81784c32012-11-19 14:55:58 -08009130}
9131
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009132void AudioFlinger::RecordThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08009133{
Mikhail Naganov913d06c2016-11-01 12:49:22 -07009134 AudioStreamIn *input = mInput;
9135 audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
9136 dprintf(fd, " AudioStreamIn: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08009137 input, flags, toString(flags).c_str());
Andy Hung6427e442018-08-09 12:51:02 -07009138 dprintf(fd, " Frames read: %lld\n", (long long)mFramesRead);
Eric Tan39ec8d62018-07-24 09:49:29 -07009139 if (mActiveTracks.isEmpty()) {
Elliott Hughes87cebad2014-05-22 10:14:43 -07009140 dprintf(fd, " No active record clients\n");
Eric Laurent81784c32012-11-19 14:55:58 -08009141 }
Andy Hungbfa64962017-06-12 14:43:19 -07009142
9143 if (input != nullptr) {
9144 dprintf(fd, " Hal stream dump:\n");
9145 (void)input->stream->dump(fd);
9146 }
9147
Glenn Kasten6e6704c2014-07-03 10:20:00 -07009148 dprintf(fd, " Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07009149 dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
Glenn Kasten17c9c992015-03-02 15:53:01 -08009150
Glenn Kasten2f90c512015-12-02 11:40:09 -08009151 // Make a non-atomic copy of fast capture dump state so it won't change underneath us
9152 // while we are dumping it. It may be inconsistent, but it won't mutate!
9153 // This is a large object so we place it on the heap.
9154 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07009155 const std::unique_ptr<FastCaptureDumpState> copy =
9156 std::make_unique<FastCaptureDumpState>(mFastCaptureDumpState);
Glenn Kasten2f90c512015-12-02 11:40:09 -08009157 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08009158}
9159
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009160void AudioFlinger::RecordThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08009161{
Eric Laurent81784c32012-11-19 14:55:58 -08009162 String8 result;
Marco Nelissenb2208842014-02-07 14:00:50 -08009163 size_t numtracks = mTracks.size();
9164 size_t numactive = mActiveTracks.size();
9165 size_t numactiveseen = 0;
Glenn Kastenc42e9b42016-03-21 11:35:03 -07009166 dprintf(fd, " %zu Tracks", numtracks);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009167 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08009168 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07009169 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009170 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07009171 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08009172 for (size_t i = 0; i < numtracks ; ++i) {
9173 sp<RecordTrack> track = mTracks[i];
9174 if (track != 0) {
9175 bool active = mActiveTracks.indexOf(track) >= 0;
9176 if (active) {
9177 numactiveseen++;
9178 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009179 result.append(prefix);
9180 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08009181 }
Eric Laurent81784c32012-11-19 14:55:58 -08009182 }
Marco Nelissenb2208842014-02-07 14:00:50 -08009183 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -07009184 dprintf(fd, "\n");
Eric Laurent81784c32012-11-19 14:55:58 -08009185 }
9186
Marco Nelissenb2208842014-02-07 14:00:50 -08009187 if (numactiveseen != numactive) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009188 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08009189 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009190 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07009191 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08009192 for (size_t i = 0; i < numactive; ++i) {
Glenn Kasten2b806402013-11-20 16:37:38 -08009193 sp<RecordTrack> track = mActiveTracks[i];
Marco Nelissenb2208842014-02-07 14:00:50 -08009194 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009195 result.append(prefix);
9196 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08009197 }
Glenn Kasten2b806402013-11-20 16:37:38 -08009198 }
Eric Laurent81784c32012-11-19 14:55:58 -08009199
9200 }
9201 write(fd, result.string(), result.size());
9202}
9203
Eric Laurent5ada82e2019-08-29 17:53:54 -07009204void AudioFlinger::RecordThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08009205{
9206 Mutex::Autolock _l(mLock);
9207 for (size_t i = 0; i < mTracks.size() ; i++) {
9208 sp<RecordTrack> track = mTracks[i];
Eric Laurent5ada82e2019-08-29 17:53:54 -07009209 if (track != 0 && track->portId() == portId) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08009210 track->setSilenced(silenced);
9211 }
9212 }
9213}
Andy Hung73c02e42015-03-29 01:13:58 -07009214
9215void AudioFlinger::RecordThread::ResamplerBufferProvider::reset()
9216{
9217 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
9218 RecordThread *recordThread = (RecordThread *) threadBase.get();
Andy Hung73c02e42015-03-29 01:13:58 -07009219 mRsmpInUnrel = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02009220 const int32_t rear = recordThread->mRsmpInRear;
9221 ssize_t deltaFrames = 0;
Eric Laurent2407ce32021-04-26 14:56:03 +02009222 if (mRecordTrack->startFrames() >= 0) {
9223 int32_t startFrames = mRecordTrack->startFrames();
9224 // Accept a recent wraparound of mRsmpInRear
9225 if (startFrames <= rear) {
9226 deltaFrames = rear - startFrames;
9227 } else {
9228 deltaFrames = (int32_t)((int64_t)rear + UINT32_MAX + 1 - startFrames);
Eric Laurentec376dc2021-04-08 20:41:22 +02009229 }
Eric Laurentec376dc2021-04-08 20:41:22 +02009230 // start frame cannot be further in the past than start of resampling buffer
9231 if ((size_t) deltaFrames > recordThread->mRsmpInFrames) {
9232 deltaFrames = recordThread->mRsmpInFrames;
9233 }
9234 }
9235 mRsmpInFront = audio_utils::safe_sub_overflow(rear, static_cast<int32_t>(deltaFrames));
Andy Hung73c02e42015-03-29 01:13:58 -07009236}
9237
9238void AudioFlinger::RecordThread::ResamplerBufferProvider::sync(
9239 size_t *framesAvailable, bool *hasOverrun)
9240{
9241 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
9242 RecordThread *recordThread = (RecordThread *) threadBase.get();
9243 const int32_t rear = recordThread->mRsmpInRear;
9244 const int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07009245 const ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Andy Hung73c02e42015-03-29 01:13:58 -07009246
9247 size_t framesIn;
9248 bool overrun = false;
9249 if (filled < 0) {
9250 // should not happen, but treat like a massive overrun and re-sync
9251 framesIn = 0;
9252 mRsmpInFront = rear;
9253 overrun = true;
9254 } else if ((size_t) filled <= recordThread->mRsmpInFrames) {
9255 framesIn = (size_t) filled;
9256 } else {
9257 // client is not keeping up with server, but give it latest data
9258 framesIn = recordThread->mRsmpInFrames;
Hongwei Wang95e37682019-04-12 11:13:36 -07009259 mRsmpInFront = /* front = */ audio_utils::safe_sub_overflow(
9260 rear, static_cast<int32_t>(framesIn));
Andy Hung73c02e42015-03-29 01:13:58 -07009261 overrun = true;
9262 }
9263 if (framesAvailable != NULL) {
9264 *framesAvailable = framesIn;
9265 }
9266 if (hasOverrun != NULL) {
9267 *hasOverrun = overrun;
9268 }
9269}
9270
Eric Laurent81784c32012-11-19 14:55:58 -08009271// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009272status_t AudioFlinger::RecordThread::ResamplerBufferProvider::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08009273 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08009274{
Andy Hung73c02e42015-03-29 01:13:58 -07009275 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009276 if (threadBase == 0) {
9277 buffer->frameCount = 0;
Glenn Kasten607fa3e2014-02-21 14:24:58 -08009278 buffer->raw = NULL;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009279 return NOT_ENOUGH_DATA;
9280 }
9281 RecordThread *recordThread = (RecordThread *) threadBase.get();
9282 int32_t rear = recordThread->mRsmpInRear;
Andy Hung73c02e42015-03-29 01:13:58 -07009283 int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07009284 ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009285 // FIXME should not be P2 (don't want to increase latency)
9286 // FIXME if client not keeping up, discard
Glenn Kasten607fa3e2014-02-21 14:24:58 -08009287 LOG_ALWAYS_FATAL_IF(!(0 <= filled && (size_t) filled <= recordThread->mRsmpInFrames));
Glenn Kasten85948432013-08-19 12:09:05 -07009288 // 'filled' may be non-contiguous, so return only the first contiguous chunk
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02009289
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009290 front &= recordThread->mRsmpInFramesP2 - 1;
9291 size_t part1 = recordThread->mRsmpInFramesP2 - front;
Glenn Kasten85948432013-08-19 12:09:05 -07009292 if (part1 > (size_t) filled) {
9293 part1 = filled;
9294 }
9295 size_t ask = buffer->frameCount;
9296 ALOG_ASSERT(ask > 0);
9297 if (part1 > ask) {
9298 part1 = ask;
9299 }
9300 if (part1 == 0) {
Andy Hung73c02e42015-03-29 01:13:58 -07009301 // out of data is fine since the resampler will return a short-count.
Glenn Kasten85948432013-08-19 12:09:05 -07009302 buffer->raw = NULL;
9303 buffer->frameCount = 0;
Andy Hung73c02e42015-03-29 01:13:58 -07009304 mRsmpInUnrel = 0;
Glenn Kasten85948432013-08-19 12:09:05 -07009305 return NOT_ENOUGH_DATA;
Eric Laurent81784c32012-11-19 14:55:58 -08009306 }
9307
Andy Hung57446612015-04-19 23:56:46 -07009308 buffer->raw = (uint8_t*)recordThread->mRsmpInBuffer + front * recordThread->mFrameSize;
Glenn Kasten85948432013-08-19 12:09:05 -07009309 buffer->frameCount = part1;
Andy Hung73c02e42015-03-29 01:13:58 -07009310 mRsmpInUnrel = part1;
Eric Laurent81784c32012-11-19 14:55:58 -08009311 return NO_ERROR;
9312}
9313
9314// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08009315void AudioFlinger::RecordThread::ResamplerBufferProvider::releaseBuffer(
9316 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08009317{
Hongwei Wang95e37682019-04-12 11:13:36 -07009318 int32_t stepCount = static_cast<int32_t>(buffer->frameCount);
Glenn Kasten85948432013-08-19 12:09:05 -07009319 if (stepCount == 0) {
9320 return;
9321 }
Eric Laurent1e28aaa2023-04-16 19:34:23 +02009322 ALOG_ASSERT(stepCount <= (int32_t)mRsmpInUnrel);
Andy Hung73c02e42015-03-29 01:13:58 -07009323 mRsmpInUnrel -= stepCount;
Hongwei Wang95e37682019-04-12 11:13:36 -07009324 mRsmpInFront = audio_utils::safe_add_overflow(mRsmpInFront, stepCount);
Glenn Kasten85948432013-08-19 12:09:05 -07009325 buffer->raw = NULL;
Eric Laurent81784c32012-11-19 14:55:58 -08009326 buffer->frameCount = 0;
9327}
9328
Eric Laurentd8365c52017-07-16 15:27:05 -07009329void AudioFlinger::RecordThread::checkBtNrec()
9330{
9331 Mutex::Autolock _l(mLock);
9332 checkBtNrec_l();
9333}
9334
9335void AudioFlinger::RecordThread::checkBtNrec_l()
9336{
9337 // disable AEC and NS if the device is a BT SCO headset supporting those
9338 // pre processings
jiabinc52b1ff2019-10-31 17:20:42 -07009339 bool suspend = audio_is_bluetooth_sco_device(inDeviceType()) &&
Eric Laurentd8365c52017-07-16 15:27:05 -07009340 mAudioFlinger->btNrecIsOff();
9341 if (mBtNrecSuspended.exchange(suspend) != suspend) {
9342 for (size_t i = 0; i < mEffectChains.size(); i++) {
9343 setEffectSuspended_l(FX_IID_AEC, suspend, mEffectChains[i]->sessionId());
9344 setEffectSuspended_l(FX_IID_NS, suspend, mEffectChains[i]->sessionId());
9345 }
9346 }
9347}
9348
Andy Hung97a893e2015-03-29 01:03:07 -07009349
Eric Laurent10351942014-05-08 18:49:52 -07009350bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
9351 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08009352{
9353 bool reconfig = false;
9354
Eric Laurent10351942014-05-08 18:49:52 -07009355 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08009356
Eric Laurent10351942014-05-08 18:49:52 -07009357 audio_format_t reqFormat = mFormat;
9358 uint32_t samplingRate = mSampleRate;
Glenn Kastene1635ec2015-06-08 15:46:49 -07009359 // TODO this may change if we want to support capture from HDMI PCM multi channel (e.g on TVs).
Jing Mike537412f2023-03-12 11:01:47 +08009360 [[maybe_unused]] audio_channel_mask_t channelMask =
9361 audio_channel_in_mask_from_count(mChannelCount);
Eric Laurent10351942014-05-08 18:49:52 -07009362
9363 AudioParameter param = AudioParameter(keyValuePair);
9364 int value;
Haynes Mathew George9ce67b52015-09-30 11:40:47 -07009365
9366 // scope for AutoPark extends to end of method
9367 AutoPark<FastCapture> park(mFastCapture);
9368
Eric Laurent10351942014-05-08 18:49:52 -07009369 // TODO Investigate when this code runs. Check with audio policy when a sample rate and
9370 // channel count change can be requested. Do we mandate the first client defines the
9371 // HAL sampling rate and channel count or do we allow changes on the fly?
9372 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
9373 samplingRate = value;
9374 reconfig = true;
9375 }
9376 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung97a893e2015-03-29 01:03:07 -07009377 if (!audio_is_linear_pcm((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07009378 status = BAD_VALUE;
9379 } else {
9380 reqFormat = (audio_format_t) value;
Eric Laurent81784c32012-11-19 14:55:58 -08009381 reconfig = true;
9382 }
Eric Laurent10351942014-05-08 18:49:52 -07009383 }
9384 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
9385 audio_channel_mask_t mask = (audio_channel_mask_t) value;
Andy Hungd330ee42015-04-20 13:23:41 -07009386 if (!audio_is_input_channel(mask) ||
Andy Hung936845a2021-06-08 00:09:06 -07009387 audio_channel_count_from_in_mask(mask) > FCC_LIMIT) {
Eric Laurent10351942014-05-08 18:49:52 -07009388 status = BAD_VALUE;
9389 } else {
9390 channelMask = mask;
9391 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08009392 }
Eric Laurent10351942014-05-08 18:49:52 -07009393 }
9394 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
9395 // do not accept frame count changes if tracks are open as the track buffer
9396 // size depends on frame count and correct behavior would not be guaranteed
9397 // if frame count is changed after track creation
9398 if (mActiveTracks.size() > 0) {
9399 status = INVALID_OPERATION;
9400 } else {
9401 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08009402 }
Eric Laurent10351942014-05-08 18:49:52 -07009403 }
9404 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07009405 LOG_FATAL("Should not set routing device in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07009406 }
9407 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
9408 mAudioSource != (audio_source_t)value) {
jiabinc52b1ff2019-10-31 17:20:42 -07009409 LOG_FATAL("Should not set audio source in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07009410 }
Glenn Kastene198c362013-08-13 09:13:36 -07009411
Eric Laurent10351942014-05-08 18:49:52 -07009412 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009413 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07009414 if (status == INVALID_OPERATION) {
9415 inputStandBy();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009416 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07009417 }
9418 if (reconfig) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009419 if (status == BAD_VALUE) {
Mikhail Naganov560637e2021-03-31 22:40:13 +00009420 audio_config_base_t config = AUDIO_CONFIG_BASE_INITIALIZER;
9421 if (mInput->stream->getAudioProperties(&config) == OK &&
9422 audio_is_linear_pcm(config.format) && audio_is_linear_pcm(reqFormat) &&
9423 config.sample_rate <= (AUDIO_RESAMPLER_DOWN_RATIO_MAX * samplingRate) &&
Andy Hung936845a2021-06-08 00:09:06 -07009424 audio_channel_count_from_in_mask(config.channel_mask) <= FCC_LIMIT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009425 status = NO_ERROR;
9426 }
Eric Laurent81784c32012-11-19 14:55:58 -08009427 }
Eric Laurent10351942014-05-08 18:49:52 -07009428 if (status == NO_ERROR) {
9429 readInputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07009430 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
Eric Laurent81784c32012-11-19 14:55:58 -08009431 }
9432 }
Eric Laurent81784c32012-11-19 14:55:58 -08009433 }
Eric Laurent10351942014-05-08 18:49:52 -07009434
Eric Laurent81784c32012-11-19 14:55:58 -08009435 return reconfig;
9436}
9437
9438String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
9439{
Eric Laurent81784c32012-11-19 14:55:58 -08009440 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009441 if (initCheck() == NO_ERROR) {
9442 String8 out_s8;
9443 if (mInput->stream->getParameters(keys, &out_s8) == OK) {
9444 return out_s8;
9445 }
Eric Laurent81784c32012-11-19 14:55:58 -08009446 }
Andy Hung920f6572022-10-06 12:09:49 -07009447 return {};
Eric Laurent81784c32012-11-19 14:55:58 -08009448}
9449
Mikhail Naganov88536df2021-07-26 17:30:29 -07009450void AudioFlinger::RecordThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -07009451 audio_port_handle_t portId) {
Mikhail Naganov88536df2021-07-26 17:30:29 -07009452 sp<AudioIoDescriptor> desc;
Eric Laurent81784c32012-11-19 14:55:58 -08009453 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07009454 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07009455 case AUDIO_INPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07009456 case AUDIO_INPUT_CONFIG_CHANGED:
Mikhail Naganov88536df2021-07-26 17:30:29 -07009457 desc = sp<AudioIoDescriptor>::make(mId, mPatch, true /*isInput*/,
9458 mSampleRate, mFormat, mChannelMask, mFrameCount, mFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08009459 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07009460 case AUDIO_CLIENT_STARTED:
Mikhail Naganov88536df2021-07-26 17:30:29 -07009461 desc = sp<AudioIoDescriptor>::make(mId, mPatch, portId);
Eric Laurent09f1ed22019-04-24 17:45:17 -07009462 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07009463 case AUDIO_INPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08009464 default:
Mikhail Naganov88536df2021-07-26 17:30:29 -07009465 desc = sp<AudioIoDescriptor>::make(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08009466 break;
9467 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07009468 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08009469}
9470
Glenn Kastendeca2ae2014-02-07 10:25:56 -08009471void AudioFlinger::RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08009472{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009473 status_t result = mInput->stream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
9474 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
Andy Hung463be252014-07-10 16:56:07 -07009475 mFormat = mHALFormat;
Mikhail Naganovce9f2652018-07-16 11:09:24 -07009476 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
9477 if (audio_is_linear_pcm(mFormat)) {
Andy Hung936845a2021-06-08 00:09:06 -07009478 LOG_ALWAYS_FATAL_IF(mChannelCount > FCC_LIMIT, "HAL channel count %d > %d",
9479 mChannelCount, FCC_LIMIT);
Mikhail Naganovce9f2652018-07-16 11:09:24 -07009480 } else {
Andy Hung936845a2021-06-08 00:09:06 -07009481 // Can have more that FCC_LIMIT channels in encoded streams.
Mikhail Naganovce9f2652018-07-16 11:09:24 -07009482 ALOGI("HAL format %#x is not linear pcm", mFormat);
9483 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009484 result = mInput->stream->getFrameSize(&mFrameSize);
9485 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -07009486 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
9487 mFrameSize);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009488 result = mInput->stream->getBufferSize(&mBufferSize);
9489 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
Glenn Kasten548efc92012-11-29 08:48:51 -08009490 mFrameCount = mBufferSize / mFrameSize;
Hayden Gomes1a89ab32020-06-12 11:05:47 -07009491 ALOGV("%p RecordThread params: mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
9492 "mBufferSize=%zu, mFrameCount=%zu",
9493 this, mChannelCount, mFormat, mFrameSize, mBufferSize, mFrameCount);
Glenn Kasten49d00ad2014-07-21 11:22:03 -07009494
Eric Laurentec376dc2021-04-08 20:41:22 +02009495 // mRsmpInFrames must be 0 before calling resizeInputBuffer_l for the first time
9496 mRsmpInFrames = 0;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02009497 resizeInputBuffer_l(0 /*maxSharedAudioHistoryMs*/);
Eric Laurent81784c32012-11-19 14:55:58 -08009498
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08009499 // AudioRecord mSampleRate and mChannelCount are constant due to AudioRecord API constraints.
9500 // But if thread's mSampleRate or mChannelCount changes, how will that affect active tracks?
Andy Hungea840382020-05-05 21:50:17 -07009501
9502 audio_input_flags_t flags = mInput->flags;
9503 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
9504 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
9505 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
9506 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
9507 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
9508 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
9509 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
9510 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
9511 .record();
Eric Laurent81784c32012-11-19 14:55:58 -08009512}
9513
Glenn Kasten5f972c02014-01-13 09:59:31 -08009514uint32_t AudioFlinger::RecordThread::getInputFramesLost()
Eric Laurent81784c32012-11-19 14:55:58 -08009515{
9516 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009517 uint32_t result;
9518 if (initCheck() == NO_ERROR && mInput->stream->getInputFramesLost(&result) == OK) {
9519 return result;
Eric Laurent81784c32012-11-19 14:55:58 -08009520 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009521 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08009522}
9523
Glenn Kastend848eb42016-03-08 13:42:11 -08009524KeyedVector<audio_session_t, bool> AudioFlinger::RecordThread::sessionIds() const
Eric Laurent81784c32012-11-19 14:55:58 -08009525{
Glenn Kastend848eb42016-03-08 13:42:11 -08009526 KeyedVector<audio_session_t, bool> ids;
Eric Laurent81784c32012-11-19 14:55:58 -08009527 Mutex::Autolock _l(mLock);
9528 for (size_t j = 0; j < mTracks.size(); ++j) {
9529 sp<RecordThread::RecordTrack> track = mTracks[j];
Glenn Kastend848eb42016-03-08 13:42:11 -08009530 audio_session_t sessionId = track->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08009531 if (ids.indexOfKey(sessionId) < 0) {
9532 ids.add(sessionId, true);
9533 }
9534 }
9535 return ids;
9536}
9537
9538AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
9539{
9540 Mutex::Autolock _l(mLock);
9541 AudioStreamIn *input = mInput;
9542 mInput = NULL;
9543 return input;
9544}
9545
9546// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009547sp<StreamHalInterface> AudioFlinger::RecordThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08009548{
9549 if (mInput == NULL) {
9550 return NULL;
9551 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07009552 return mInput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08009553}
9554
9555status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
9556{
Eric Laurent81784c32012-11-19 14:55:58 -08009557 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
Eric Laurentaaa44472014-09-12 17:41:50 -07009558 chain->setThread(this);
Eric Laurent81784c32012-11-19 14:55:58 -08009559 chain->setInBuffer(NULL);
9560 chain->setOutBuffer(NULL);
9561
9562 checkSuspendOnAddEffectChain_l(chain);
9563
Eric Laurent1b928682014-10-02 19:41:47 -07009564 // make sure enabled pre processing effects state is communicated to the HAL as we
9565 // just moved them to a new input stream.
9566 chain->syncHalEffectsState();
9567
Eric Laurent81784c32012-11-19 14:55:58 -08009568 mEffectChains.add(chain);
9569
9570 return NO_ERROR;
9571}
9572
9573size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
9574{
9575 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07009576
9577 for (size_t i = 0; i < mEffectChains.size(); i++) {
9578 if (chain == mEffectChains[i]) {
9579 mEffectChains.removeAt(i);
9580 break;
9581 }
Eric Laurent81784c32012-11-19 14:55:58 -08009582 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07009583 return mEffectChains.size();
Eric Laurent81784c32012-11-19 14:55:58 -08009584}
9585
Eric Laurent1c333e22014-05-20 10:48:17 -07009586status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
9587 audio_patch_handle_t *handle)
9588{
9589 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07009590
9591 // store new device and send to effects
jiabinc52b1ff2019-10-31 17:20:42 -07009592 mInDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
jiabin0a488932020-08-07 17:32:40 -07009593 mInDeviceTypeAddr.setAddress(patch->sources[0].ext.device.address);
François Gaffie0c280aa2018-07-25 10:02:15 +02009594 audio_port_handle_t deviceId = patch->sources[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07009595 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08009596 mEffectChains[i]->setInputDevice_l(inDeviceTypeAddr());
Eric Laurent054d9d32015-04-24 08:48:48 -07009597 }
9598
Eric Laurentd8365c52017-07-16 15:27:05 -07009599 checkBtNrec_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07009600
9601 // store new source and send to effects
9602 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
9603 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
Eric Laurent1c333e22014-05-20 10:48:17 -07009604 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurent054d9d32015-04-24 08:48:48 -07009605 mEffectChains[i]->setAudioSource_l(mAudioSource);
Eric Laurent1c333e22014-05-20 10:48:17 -07009606 }
Eric Laurent054d9d32015-04-24 08:48:48 -07009607 }
Eric Laurent1c333e22014-05-20 10:48:17 -07009608
Mikhail Naganov9ee05402016-10-13 15:58:17 -07009609 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07009610 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
9611 status = hwDevice->createAudioPatch(patch->num_sources,
9612 patch->sources,
9613 patch->num_sinks,
9614 patch->sinks,
9615 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07009616 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -08009617 status = mInput->stream->legacyCreateAudioPatch(patch->sources[0],
9618 patch->sinks[0].ext.mix.usecase.source,
9619 patch->sources[0].ext.device.type);
Eric Laurent054d9d32015-04-24 08:48:48 -07009620 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07009621 }
Eric Laurent054d9d32015-04-24 08:48:48 -07009622
jiabinc52b1ff2019-10-31 17:20:42 -07009623 if ((mPatch.num_sources == 0) || (mPatch.sources[0].id != deviceId)) {
Eric Laurente8726fe2015-06-26 09:39:24 -07009624 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
jiabinc52b1ff2019-10-31 17:20:42 -07009625 mPatch = *patch;
Eric Laurente8726fe2015-06-26 09:39:24 -07009626 }
Eric Laurent296fb132015-05-01 11:38:42 -07009627
Andy Hungc2b11cb2020-04-22 09:04:01 -07009628 const std::string pathSourcesAsString = patchSourcesToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07009629 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07009630 mThreadMetrics.logCreatePatch(pathSourcesAsString, /* outDevices */ {});
Andy Hungcf10d742020-04-28 15:38:24 -07009631 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07009632 // also dispatch to active AudioRecords
9633 for (const auto &track : mActiveTracks) {
9634 track->logEndInterval();
9635 track->logBeginInterval(pathSourcesAsString);
9636 }
Eric Laurentdda206a2022-07-08 17:28:35 +02009637 // Force meteadata update after a route change
9638 mActiveTracks.setHasChanged();
9639
Eric Laurent1c333e22014-05-20 10:48:17 -07009640 return status;
9641}
9642
9643status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
9644{
9645 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07009646
jiabinc52b1ff2019-10-31 17:20:42 -07009647 mPatch = audio_patch{};
9648 mInDeviceTypeAddr.reset();
Eric Laurent054d9d32015-04-24 08:48:48 -07009649
Mikhail Naganov9ee05402016-10-13 15:58:17 -07009650 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07009651 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
9652 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07009653 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -08009654 status = mInput->stream->legacyReleaseAudioPatch();
Eric Laurent1c333e22014-05-20 10:48:17 -07009655 }
Eric Laurentdda206a2022-07-08 17:28:35 +02009656 // Force meteadata update after a route change
9657 mActiveTracks.setHasChanged();
9658
Eric Laurent1c333e22014-05-20 10:48:17 -07009659 return status;
9660}
9661
jiabinc52b1ff2019-10-31 17:20:42 -07009662void AudioFlinger::RecordThread::updateOutDevices(const DeviceDescriptorBaseVector& outDevices)
9663{
wendy lin56aa82b2020-12-02 15:19:55 +08009664 Mutex::Autolock _l(mLock);
jiabinc52b1ff2019-10-31 17:20:42 -07009665 mOutDevices = outDevices;
9666 mOutDeviceTypeAddrs = deviceTypeAddrsFromDescriptors(mOutDevices);
9667 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08009668 mEffectChains[i]->setDevices_l(outDeviceTypeAddrs());
jiabinc52b1ff2019-10-31 17:20:42 -07009669 }
9670}
9671
Eric Laurentec376dc2021-04-08 20:41:22 +02009672int32_t AudioFlinger::RecordThread::getOldestFront_l()
9673{
9674 if (mTracks.size() == 0) {
Eric Laurent92d0a322021-07-16 15:32:33 +02009675 return mRsmpInRear;
Eric Laurentec376dc2021-04-08 20:41:22 +02009676 }
Eric Laurent2407ce32021-04-26 14:56:03 +02009677 int32_t oldestFront = mRsmpInRear;
9678 int32_t maxFilled = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02009679 for (size_t i = 0; i < mTracks.size(); i++) {
Eric Laurent2407ce32021-04-26 14:56:03 +02009680 int32_t front = mTracks[i]->mResamplerBufferProvider->getFront();
9681 int32_t filled;
Eric Laurent92d0a322021-07-16 15:32:33 +02009682 (void)__builtin_sub_overflow(mRsmpInRear, front, &filled);
Eric Laurent2407ce32021-04-26 14:56:03 +02009683 if (filled > maxFilled) {
9684 oldestFront = front;
9685 maxFilled = filled;
9686 }
Eric Laurentec376dc2021-04-08 20:41:22 +02009687 }
Andy Hung920f6572022-10-06 12:09:49 -07009688 if (maxFilled > static_cast<signed>(mRsmpInFrames)) {
Eric Laurent92d0a322021-07-16 15:32:33 +02009689 (void)__builtin_sub_overflow(mRsmpInRear, mRsmpInFrames, &oldestFront);
9690 }
Eric Laurent2407ce32021-04-26 14:56:03 +02009691 return oldestFront;
Eric Laurentec376dc2021-04-08 20:41:22 +02009692}
9693
9694void AudioFlinger::RecordThread::updateFronts_l(int32_t offset)
9695{
9696 if (offset == 0) {
9697 return;
9698 }
9699 for (size_t i = 0; i < mTracks.size(); i++) {
9700 int32_t front = mTracks[i]->mResamplerBufferProvider->getFront();
9701 front = audio_utils::safe_sub_overflow(front, offset);
9702 mTracks[i]->mResamplerBufferProvider->setFront(front);
9703 }
9704}
9705
9706void AudioFlinger::RecordThread::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs)
9707{
9708 // This is the formula for calculating the temporary buffer size.
9709 // With 7 HAL buffers, we can guarantee ability to down-sample the input by ratio of 6:1 to
9710 // 1 full output buffer, regardless of the alignment of the available input.
9711 // The value is somewhat arbitrary, and could probably be even larger.
9712 // A larger value should allow more old data to be read after a track calls start(),
9713 // without increasing latency.
9714 //
9715 // Note this is independent of the maximum downsampling ratio permitted for capture.
9716 size_t minRsmpInFrames = mFrameCount * 7;
9717
9718 // maxSharedAudioHistoryMs != 0 indicates a request to possibly make some part of the audio
9719 // capture history available to another client using the same session ID:
9720 // dimension the resampler input buffer accordingly.
9721
9722 // Get oldest client read position: getOldestFront_l() must be called before altering
9723 // mRsmpInRear, or mRsmpInFrames
9724 int32_t previousFront = getOldestFront_l();
9725 size_t previousRsmpInFramesP2 = mRsmpInFramesP2;
9726 int32_t previousRear = mRsmpInRear;
9727 mRsmpInRear = 0;
9728
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02009729 ALOG_ASSERT(maxSharedAudioHistoryMs >= 0
9730 && maxSharedAudioHistoryMs <= AudioFlinger::kMaxSharedAudioHistoryMs,
9731 "resizeInputBuffer_l() called with invalid max shared history %d",
9732 maxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +02009733 if (maxSharedAudioHistoryMs != 0) {
9734 // resizeInputBuffer_l should never be called with a non zero shared history if the
9735 // buffer was not already allocated
9736 ALOG_ASSERT(mRsmpInBuffer != nullptr && mRsmpInFrames != 0,
9737 "resizeInputBuffer_l() called with shared history and unallocated buffer");
9738 size_t rsmpInFrames = (size_t)maxSharedAudioHistoryMs * mSampleRate / 1000;
9739 // never reduce resampler input buffer size
Eric Laurent92d0a322021-07-16 15:32:33 +02009740 if (rsmpInFrames <= mRsmpInFrames) {
Eric Laurentec376dc2021-04-08 20:41:22 +02009741 return;
9742 }
9743 mRsmpInFrames = rsmpInFrames;
9744 }
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02009745 mMaxSharedAudioHistoryMs = maxSharedAudioHistoryMs;
Eric Laurentec376dc2021-04-08 20:41:22 +02009746 // Note: mRsmpInFrames is 0 when called with maxSharedAudioHistoryMs equals to 0 so it is always
9747 // initialized
9748 if (mRsmpInFrames < minRsmpInFrames) {
9749 mRsmpInFrames = minRsmpInFrames;
9750 }
9751 mRsmpInFramesP2 = roundup(mRsmpInFrames);
9752
9753 // TODO optimize audio capture buffer sizes ...
9754 // Here we calculate the size of the sliding buffer used as a source
9755 // for resampling. mRsmpInFramesP2 is currently roundup(mFrameCount * 7).
9756 // For current HAL frame counts, this is usually 2048 = 40 ms. It would
9757 // be better to have it derived from the pipe depth in the long term.
9758 // The current value is higher than necessary. However it should not add to latency.
9759
9760 // Over-allocate beyond mRsmpInFramesP2 to permit a HAL read past end of buffer
9761 mRsmpInFramesOA = mRsmpInFramesP2 + mFrameCount - 1;
9762
9763 void *rsmpInBuffer;
9764 (void)posix_memalign(&rsmpInBuffer, 32, mRsmpInFramesOA * mFrameSize);
9765 // if posix_memalign fails, will segv here.
9766 memset(rsmpInBuffer, 0, mRsmpInFramesOA * mFrameSize);
9767
9768 // Copy audio history if any from old buffer before freeing it
9769 if (previousRear != 0) {
9770 ALOG_ASSERT(mRsmpInBuffer != nullptr,
9771 "resizeInputBuffer_l() called with null buffer but frames already read from HAL");
9772
9773 ssize_t unread = audio_utils::safe_sub_overflow(previousRear, previousFront);
9774 previousFront &= previousRsmpInFramesP2 - 1;
9775 size_t part1 = previousRsmpInFramesP2 - previousFront;
9776 if (part1 > (size_t) unread) {
9777 part1 = unread;
9778 }
9779 if (part1 != 0) {
9780 memcpy(rsmpInBuffer, (const uint8_t*)mRsmpInBuffer + previousFront * mFrameSize,
9781 part1 * mFrameSize);
9782 mRsmpInRear = part1;
9783 part1 = unread - part1;
9784 if (part1 != 0) {
9785 memcpy((uint8_t*)rsmpInBuffer + mRsmpInRear * mFrameSize,
9786 (const uint8_t*)mRsmpInBuffer, part1 * mFrameSize);
9787 mRsmpInRear += part1;
9788 }
9789 }
9790 // Update front for all clients according to new rear
9791 updateFronts_l(audio_utils::safe_sub_overflow(previousRear, mRsmpInRear));
9792 } else {
9793 mRsmpInRear = 0;
9794 }
9795 free(mRsmpInBuffer);
9796 mRsmpInBuffer = rsmpInBuffer;
9797}
9798
Mikhail Naganov444ecc32018-05-01 17:40:05 -07009799void AudioFlinger::RecordThread::addPatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07009800{
9801 Mutex::Autolock _l(mLock);
9802 mTracks.add(record);
Mikhail Naganov2534b382019-09-25 13:05:02 -07009803 if (record->getSource()) {
9804 mSource = record->getSource();
9805 }
Eric Laurent83b88082014-06-20 18:31:16 -07009806}
9807
Mikhail Naganov444ecc32018-05-01 17:40:05 -07009808void AudioFlinger::RecordThread::deletePatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07009809{
9810 Mutex::Autolock _l(mLock);
Mikhail Naganov2534b382019-09-25 13:05:02 -07009811 if (mSource == record->getSource()) {
9812 mSource = mInput;
9813 }
Eric Laurent83b88082014-06-20 18:31:16 -07009814 destroyTrack_l(record);
9815}
9816
Mikhail Naganovdc769682018-05-04 15:34:08 -07009817void AudioFlinger::RecordThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07009818{
Mikhail Naganovdc769682018-05-04 15:34:08 -07009819 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07009820 config->role = AUDIO_PORT_ROLE_SINK;
9821 config->ext.mix.hw_module = mInput->audioHwDev->handle();
9822 config->ext.mix.usecase.source = mAudioSource;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009823 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
9824 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9825 config->flags.input = mInput->flags;
9826 }
Eric Laurent83b88082014-06-20 18:31:16 -07009827}
Eric Laurent1c333e22014-05-20 10:48:17 -07009828
Eric Laurent6acd1d42017-01-04 14:23:29 -08009829// ----------------------------------------------------------------------------
9830// Mmap
9831// ----------------------------------------------------------------------------
9832
9833AudioFlinger::MmapThreadHandle::MmapThreadHandle(const sp<MmapThread>& thread)
9834 : mThread(thread)
9835{
Phil Burk9fabbf82017-08-03 12:02:00 -07009836 assert(thread != 0); // thread must start non-null and stay non-null
Eric Laurent6acd1d42017-01-04 14:23:29 -08009837}
9838
9839AudioFlinger::MmapThreadHandle::~MmapThreadHandle()
9840{
Phil Burk9fabbf82017-08-03 12:02:00 -07009841 mThread->disconnect();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009842}
9843
9844status_t AudioFlinger::MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
9845 struct audio_mmap_buffer_info *info)
9846{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009847 return mThread->createMmapBuffer(minSizeFrames, info);
9848}
9849
9850status_t AudioFlinger::MmapThreadHandle::getMmapPosition(struct audio_mmap_position *position)
9851{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009852 return mThread->getMmapPosition(position);
9853}
9854
jiabinb7d8c5a2020-08-26 17:24:52 -07009855status_t AudioFlinger::MmapThreadHandle::getExternalPosition(uint64_t *position,
9856 int64_t *timeNanos) {
9857 return mThread->getExternalPosition(position, timeNanos);
9858}
9859
Eric Laurenta54f1282017-07-01 19:39:32 -07009860status_t AudioFlinger::MmapThreadHandle::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07009861 const audio_attributes_t *attr, audio_port_handle_t *handle)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009862
9863{
jiabind1f1cb62020-03-24 11:57:57 -07009864 return mThread->start(client, attr, handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009865}
9866
9867status_t AudioFlinger::MmapThreadHandle::stop(audio_port_handle_t handle)
9868{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009869 return mThread->stop(handle);
9870}
9871
Eric Laurent18b57012017-02-13 16:23:52 -08009872status_t AudioFlinger::MmapThreadHandle::standby()
9873{
Eric Laurent18b57012017-02-13 16:23:52 -08009874 return mThread->standby();
9875}
9876
jiabinfc791ee2023-02-15 19:43:40 +00009877status_t AudioFlinger::MmapThreadHandle::reportData(const void* buffer, size_t frameCount) {
9878 return mThread->reportData(buffer, frameCount);
9879}
9880
Eric Laurent6acd1d42017-01-04 14:23:29 -08009881
9882AudioFlinger::MmapThread::MmapThread(
9883 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hung920f6572022-10-06 12:09:49 -07009884 AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady, bool isOut)
Andy Hungea840382020-05-05 21:50:17 -07009885 : ThreadBase(audioFlinger, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009886 mSessionId(AUDIO_SESSION_NONE),
François Gaffie0c280aa2018-07-25 10:02:15 +02009887 mPortId(AUDIO_PORT_HANDLE_NONE),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009888 mHalStream(stream), mHalDevice(hwDev->hwDevice()), mAudioHwDev(hwDev),
Eric Laurent67f97292018-04-20 18:05:41 -07009889 mActiveTracks(&this->mLocalLog),
9890 mHalVolFloat(-1.0f), // Initialize to illegal value so it always gets set properly later.
9891 mNoCallbackWarningCount(0)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009892{
Eric Laurent18b57012017-02-13 16:23:52 -08009893 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009894 readHalParameters_l();
9895}
9896
9897AudioFlinger::MmapThread::~MmapThread()
9898{
9899}
9900
9901void AudioFlinger::MmapThread::onFirstRef()
9902{
9903 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
9904}
9905
9906void AudioFlinger::MmapThread::disconnect()
9907{
Eric Laurent331679c2018-04-16 17:03:16 -07009908 ActiveTracks<MmapTrack> activeTracks;
9909 {
9910 Mutex::Autolock _l(mLock);
9911 for (const sp<MmapTrack> &t : mActiveTracks) {
9912 activeTracks.add(t);
9913 }
9914 }
9915 for (const sp<MmapTrack> &t : activeTracks) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009916 stop(t->portId());
9917 }
Phil Burk9fabbf82017-08-03 12:02:00 -07009918 // This will decrement references and may cause the destruction of this thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08009919 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07009920 AudioSystem::releaseOutput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009921 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08009922 AudioSystem::releaseInput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009923 }
9924}
9925
9926
9927void AudioFlinger::MmapThread::configure(const audio_attributes_t *attr,
9928 audio_stream_type_t streamType __unused,
9929 audio_session_t sessionId,
9930 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009931 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009932 audio_port_handle_t portId)
9933{
9934 mAttr = *attr;
9935 mSessionId = sessionId;
9936 mCallback = callback;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009937 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009938 mPortId = portId;
9939}
9940
9941status_t AudioFlinger::MmapThread::createMmapBuffer(int32_t minSizeFrames,
9942 struct audio_mmap_buffer_info *info)
9943{
9944 if (mHalStream == 0) {
9945 return NO_INIT;
9946 }
Eric Laurent18b57012017-02-13 16:23:52 -08009947 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009948 return mHalStream->createMmapBuffer(minSizeFrames, info);
9949}
9950
9951status_t AudioFlinger::MmapThread::getMmapPosition(struct audio_mmap_position *position)
9952{
9953 if (mHalStream == 0) {
9954 return NO_INIT;
9955 }
9956 return mHalStream->getMmapPosition(position);
9957}
9958
Eric Laurentdda206a2022-07-08 17:28:35 +02009959status_t AudioFlinger::MmapThread::exitStandby_l()
Eric Laurent331679c2018-04-16 17:03:16 -07009960{
Eric Laurentdda206a2022-07-08 17:28:35 +02009961 // The HAL must receive track metadata before starting the stream
9962 updateMetadata_l();
Eric Laurent331679c2018-04-16 17:03:16 -07009963 status_t ret = mHalStream->start();
9964 if (ret != NO_ERROR) {
9965 ALOGE("%s: error mHalStream->start() = %d for first track", __FUNCTION__, ret);
9966 return ret;
9967 }
Andy Hungcf10d742020-04-28 15:38:24 -07009968 if (mStandby) {
9969 mThreadMetrics.logBeginInterval();
Andy Hung44d648b2022-04-08 17:33:40 -07009970 mThreadSnapshot.onBegin();
Andy Hungcf10d742020-04-28 15:38:24 -07009971 mStandby = false;
9972 }
Eric Laurent331679c2018-04-16 17:03:16 -07009973 return NO_ERROR;
9974}
9975
Eric Laurenta54f1282017-07-01 19:39:32 -07009976status_t AudioFlinger::MmapThread::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07009977 const audio_attributes_t *attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009978 audio_port_handle_t *handle)
9979{
Eric Laurenta54f1282017-07-01 19:39:32 -07009980 ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
Svet Ganov33761132021-05-13 22:51:08 +00009981 client.attributionSource.uid, mStandby, mPortId, *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009982 if (mHalStream == 0) {
9983 return NO_INIT;
9984 }
9985
9986 status_t ret;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009987
Eric Laurentdda206a2022-07-08 17:28:35 +02009988 // For the first track, reuse portId and session allocated when the stream was opened.
Eric Laurenta54f1282017-07-01 19:39:32 -07009989 if (*handle == mPortId) {
Eric Laurentdda206a2022-07-08 17:28:35 +02009990 acquireWakeLock();
9991 return NO_ERROR;
Eric Laurenta54f1282017-07-01 19:39:32 -07009992 }
9993
9994 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
9995
9996 audio_io_handle_t io = mId;
Atneya Nairf59db5c2023-05-10 21:37:41 -07009997 AttributionSourceState adjAttributionSource = AudioFlinger::checkAttributionSourcePackage(
9998 client.attributionSource);
9999
Eric Laurenta54f1282017-07-01 19:39:32 -070010000 if (isOutput()) {
10001 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
10002 config.sample_rate = mSampleRate;
10003 config.channel_mask = mChannelMask;
10004 config.format = mFormat;
10005 audio_stream_type_t stream = streamType();
10006 audio_output_flags_t flags =
10007 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010008 audio_port_handle_t deviceId = mDeviceId;
Kevin Rocard153f92d2018-12-18 18:33:28 -080010009 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +020010010 bool isSpatialized;
jiabinc658e452022-10-21 20:52:21 +000010011 bool isBitPerfect;
Eric Laurenta54f1282017-07-01 19:39:32 -070010012 ret = AudioSystem::getOutputForAttr(&mAttr, &io,
10013 mSessionId,
10014 &stream,
Atneya Nairf59db5c2023-05-10 21:37:41 -070010015 adjAttributionSource,
Eric Laurenta54f1282017-07-01 19:39:32 -070010016 &config,
10017 flags,
10018 &deviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -080010019 &portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +020010020 &secondaryOutputs,
jiabinc658e452022-10-21 20:52:21 +000010021 &isSpatialized,
10022 &isBitPerfect);
Kevin Rocard153f92d2018-12-18 18:33:28 -080010023 ALOGD_IF(!secondaryOutputs.empty(),
10024 "MmapThread::start does not support secondary outputs, ignoring them");
Eric Laurent6acd1d42017-01-04 14:23:29 -080010025 } else {
Eric Laurenta54f1282017-07-01 19:39:32 -070010026 audio_config_base_t config;
10027 config.sample_rate = mSampleRate;
10028 config.channel_mask = mChannelMask;
10029 config.format = mFormat;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010030 audio_port_handle_t deviceId = mDeviceId;
Eric Laurenta54f1282017-07-01 19:39:32 -070010031 ret = AudioSystem::getInputForAttr(&mAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -070010032 RECORD_RIID_INVALID,
Eric Laurenta54f1282017-07-01 19:39:32 -070010033 mSessionId,
Atneya Nairf59db5c2023-05-10 21:37:41 -070010034 adjAttributionSource,
Eric Laurenta54f1282017-07-01 19:39:32 -070010035 &config,
10036 AUDIO_INPUT_FLAG_MMAP_NOIRQ,
10037 &deviceId,
10038 &portId);
10039 }
10040 // APM should not chose a different input or output stream for the same set of attributes
10041 // and audo configuration
10042 if (ret != NO_ERROR || io != mId) {
10043 ALOGE("%s: error getting output or input from APM (error %d, io %d expected io %d)",
10044 __FUNCTION__, ret, io, mId);
10045 return BAD_VALUE;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010046 }
10047
10048 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -070010049 ret = AudioSystem::startOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010050 } else {
jiabin09609032022-06-15 19:26:01 +000010051 {
10052 // Add the track record before starting input so that the silent status for the
10053 // client can be cached.
10054 Mutex::Autolock _l(mLock);
10055 setClientSilencedState_l(portId, false /*silenced*/);
10056 }
Eric Laurent4eb58f12018-12-07 16:41:02 -080010057 ret = AudioSystem::startInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010058 }
10059
Eric Laurent331679c2018-04-16 17:03:16 -070010060 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010061 // abort if start is rejected by audio policy manager
10062 if (ret != NO_ERROR) {
Phil Burk7f6b40d2017-02-09 13:18:38 -080010063 ALOGE("%s: error start rejected by AudioPolicyManager = %d", __FUNCTION__, ret);
Eric Tan39ec8d62018-07-24 09:49:29 -070010064 if (!mActiveTracks.isEmpty()) {
Eric Laurent331679c2018-04-16 17:03:16 -070010065 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010066 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -070010067 AudioSystem::releaseOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010068 } else {
Eric Laurentfee19762018-01-29 18:44:13 -080010069 AudioSystem::releaseInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010070 }
Eric Laurent331679c2018-04-16 17:03:16 -070010071 mLock.lock();
Eric Laurent18b57012017-02-13 16:23:52 -080010072 } else {
10073 mHalStream->stop();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010074 }
jiabin09609032022-06-15 19:26:01 +000010075 eraseClientSilencedState_l(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010076 return PERMISSION_DENIED;
10077 }
10078
Kevin Rocard1f564ac2018-03-29 13:53:10 -070010079 // Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
jiabind1f1cb62020-03-24 11:57:57 -070010080 sp<MmapTrack> track = new MmapTrack(this, attr == nullptr ? mAttr : *attr, mSampleRate, mFormat,
Svet Ganov33761132021-05-13 22:51:08 +000010081 mChannelMask, mSessionId, isOutput(),
10082 client.attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070010083 IPCThreadState::self()->getCallingPid(), portId);
jiabin09609032022-06-15 19:26:01 +000010084 if (!isOutput()) {
10085 track->setSilenced_l(isClientSilenced_l(portId));
10086 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010087
Eric Laurent4eb58f12018-12-07 16:41:02 -080010088 if (isOutput()) {
10089 // force volume update when a new track is added
10090 mHalVolFloat = -1.0f;
10091 } else if (!track->isSilenced_l()) {
10092 for (const sp<MmapTrack> &t : mActiveTracks) {
Andy Hung920f6572022-10-06 12:09:49 -070010093 if (t->isSilenced_l()
10094 && t->uid() != static_cast<uid_t>(client.attributionSource.uid)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -080010095 t->invalidate();
Andy Hung920f6572022-10-06 12:09:49 -070010096 }
Eric Laurent4eb58f12018-12-07 16:41:02 -080010097 }
10098 }
10099
Eric Laurent6acd1d42017-01-04 14:23:29 -080010100 mActiveTracks.add(track);
Eric Laurenta54f1282017-07-01 19:39:32 -070010101 sp<EffectChain> chain = getEffectChain_l(mSessionId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010102 if (chain != 0) {
Eric Laurentd66d7a12021-07-13 13:35:32 +020010103 chain->setStrategy(getStrategyForStream(streamType()));
Eric Laurent6acd1d42017-01-04 14:23:29 -080010104 chain->incTrackCnt();
10105 chain->incActiveTrackCnt();
10106 }
10107
Andy Hungc2b11cb2020-04-22 09:04:01 -070010108 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent6acd1d42017-01-04 14:23:29 -080010109 *handle = portId;
Eric Laurentdda206a2022-07-08 17:28:35 +020010110
10111 if (mActiveTracks.size() == 1) {
10112 ret = exitStandby_l();
10113 }
10114
Eric Laurent6acd1d42017-01-04 14:23:29 -080010115 broadcast_l();
10116
Eric Laurentdda206a2022-07-08 17:28:35 +020010117 ALOGV("%s DONE status %d handle %d stream %p", __FUNCTION__, ret, *handle, mHalStream.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -080010118
Eric Laurentdda206a2022-07-08 17:28:35 +020010119 return ret;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010120}
10121
10122status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
10123{
Eric Laurent6acd1d42017-01-04 14:23:29 -080010124 ALOGV("%s handle %d", __FUNCTION__, handle);
10125
10126 if (mHalStream == 0) {
10127 return NO_INIT;
10128 }
10129
Eric Laurenta54f1282017-07-01 19:39:32 -070010130 if (handle == mPortId) {
Phil Burk98ab4082020-09-25 21:46:34 +000010131 releaseWakeLock();
Eric Laurenta54f1282017-07-01 19:39:32 -070010132 return NO_ERROR;
10133 }
10134
Eric Laurent331679c2018-04-16 17:03:16 -070010135 Mutex::Autolock _l(mLock);
10136
Eric Laurent6acd1d42017-01-04 14:23:29 -080010137 sp<MmapTrack> track;
10138 for (const sp<MmapTrack> &t : mActiveTracks) {
10139 if (handle == t->portId()) {
10140 track = t;
10141 break;
10142 }
10143 }
10144 if (track == 0) {
10145 return BAD_VALUE;
10146 }
10147
10148 mActiveTracks.remove(track);
jiabin09609032022-06-15 19:26:01 +000010149 eraseClientSilencedState_l(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -080010150
Eric Laurent331679c2018-04-16 17:03:16 -070010151 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010152 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -070010153 AudioSystem::stopOutput(track->portId());
10154 AudioSystem::releaseOutput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -080010155 } else {
Eric Laurentfee19762018-01-29 18:44:13 -080010156 AudioSystem::stopInput(track->portId());
10157 AudioSystem::releaseInput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -080010158 }
Eric Laurent331679c2018-04-16 17:03:16 -070010159 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010160
10161 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
10162 if (chain != 0) {
10163 chain->decActiveTrackCnt();
10164 chain->decTrackCnt();
10165 }
10166
Eric Laurentdda206a2022-07-08 17:28:35 +020010167 if (mActiveTracks.isEmpty()) {
10168 mHalStream->stop();
10169 }
10170
Eric Laurent6acd1d42017-01-04 14:23:29 -080010171 broadcast_l();
10172
Eric Laurent6acd1d42017-01-04 14:23:29 -080010173 return NO_ERROR;
10174}
10175
Eric Laurent18b57012017-02-13 16:23:52 -080010176status_t AudioFlinger::MmapThread::standby()
10177{
10178 ALOGV("%s", __FUNCTION__);
10179
10180 if (mHalStream == 0) {
10181 return NO_INIT;
10182 }
Eric Tan39ec8d62018-07-24 09:49:29 -070010183 if (!mActiveTracks.isEmpty()) {
Eric Laurent18b57012017-02-13 16:23:52 -080010184 return INVALID_OPERATION;
10185 }
10186 mHalStream->standby();
Andy Hungcf10d742020-04-28 15:38:24 -070010187 if (!mStandby) {
10188 mThreadMetrics.logEndInterval();
Andy Hung44d648b2022-04-08 17:33:40 -070010189 mThreadSnapshot.onEnd();
Andy Hungcf10d742020-04-28 15:38:24 -070010190 mStandby = true;
10191 }
Eric Laurent18b57012017-02-13 16:23:52 -080010192 releaseWakeLock();
10193 return NO_ERROR;
10194}
10195
jiabinfc791ee2023-02-15 19:43:40 +000010196status_t AudioFlinger::MmapThread::reportData(const void* /*buffer*/, size_t /*frameCount*/) {
10197 // This is a stub implementation. The MmapPlaybackThread overrides this function.
10198 return INVALID_OPERATION;
10199}
10200
Eric Laurent6acd1d42017-01-04 14:23:29 -080010201void AudioFlinger::MmapThread::readHalParameters_l()
10202{
10203 status_t result = mHalStream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
10204 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
10205 mFormat = mHALFormat;
10206 LOG_ALWAYS_FATAL_IF(!audio_is_linear_pcm(mFormat), "HAL format %#x is not linear pcm", mFormat);
10207 result = mHalStream->getFrameSize(&mFrameSize);
10208 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -070010209 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
10210 mFrameSize);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010211 result = mHalStream->getBufferSize(&mBufferSize);
10212 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
10213 mFrameCount = mBufferSize / mFrameSize;
Andy Hungc2b11cb2020-04-22 09:04:01 -070010214
Andy Hungcf10d742020-04-28 15:38:24 -070010215 // TODO: make a readHalParameters call?
10216 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
Andy Hungc2b11cb2020-04-22 09:04:01 -070010217 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
10218 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
10219 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
10220 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
10221 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
10222 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
10223 /*
10224 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
10225 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
10226 (int32_t)mHapticChannelMask)
10227 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
10228 (int32_t)mHapticChannelCount)
10229 */
10230 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
10231 formatToString(mHALFormat).c_str())
10232 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
10233 (int32_t)mFrameCount) // sic - added HAL
10234 .record();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010235}
10236
10237bool AudioFlinger::MmapThread::threadLoop()
10238{
Eric Laurent6acd1d42017-01-04 14:23:29 -080010239 checkSilentMode_l();
10240
10241 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
10242
10243 while (!exitPending())
10244 {
Eric Laurent6acd1d42017-01-04 14:23:29 -080010245 Vector< sp<EffectChain> > effectChains;
10246
Andy Hung13850be2019-03-14 11:33:09 -070010247 { // under Thread lock
10248 Mutex::Autolock _l(mLock);
10249
Eric Laurent6acd1d42017-01-04 14:23:29 -080010250 if (mSignalPending) {
10251 // A signal was raised while we were unlocked
10252 mSignalPending = false;
10253 } else {
10254 if (mConfigEvents.isEmpty()) {
10255 // we're about to wait, flush the binder command buffer
10256 IPCThreadState::self()->flushCommands();
10257
10258 if (exitPending()) {
10259 break;
10260 }
10261
Eric Laurent6acd1d42017-01-04 14:23:29 -080010262 // wait until we have something to do...
10263 ALOGV("%s going to sleep", myName.string());
10264 mWaitWorkCV.wait(mLock);
10265 ALOGV("%s waking up", myName.string());
Eric Laurent6acd1d42017-01-04 14:23:29 -080010266
10267 checkSilentMode_l();
10268
10269 continue;
10270 }
10271 }
10272
10273 processConfigEvents_l();
10274
10275 processVolume_l();
10276
10277 checkInvalidTracks_l();
10278
10279 mActiveTracks.updatePowerState(this);
10280
Kevin Rocard069c2712018-03-29 19:09:14 -070010281 updateMetadata_l();
10282
Eric Laurent6acd1d42017-01-04 14:23:29 -080010283 lockEffectChains_l(effectChains);
Andy Hung13850be2019-03-14 11:33:09 -070010284 } // release Thread lock
10285
Eric Laurent6acd1d42017-01-04 14:23:29 -080010286 for (size_t i = 0; i < effectChains.size(); i ++) {
Andy Hung13850be2019-03-14 11:33:09 -070010287 effectChains[i]->process_l(); // Thread is not locked, but effect chain is locked
Eric Laurent6acd1d42017-01-04 14:23:29 -080010288 }
Andy Hung13850be2019-03-14 11:33:09 -070010289
10290 // enable changes in effect chain, including moving to another thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -080010291 unlockEffectChains(effectChains);
10292 // Effect chains will be actually deleted here if they were removed from
10293 // mEffectChains list during mixing or effects processing
10294 }
10295
10296 threadLoop_exit();
10297
10298 if (!mStandby) {
10299 threadLoop_standby();
10300 mStandby = true;
10301 }
10302
Eric Laurent6acd1d42017-01-04 14:23:29 -080010303 ALOGV("Thread %p type %d exiting", this, mType);
10304 return false;
10305}
10306
10307// checkForNewParameter_l() must be called with ThreadBase::mLock held
10308bool AudioFlinger::MmapThread::checkForNewParameter_l(const String8& keyValuePair,
10309 status_t& status)
10310{
10311 AudioParameter param = AudioParameter(keyValuePair);
10312 int value;
Eric Laurente6e9a482017-07-25 19:26:02 -070010313 bool sendToHal = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010314 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -070010315 LOG_FATAL("Should not happen set routing device in MmapThread");
Eric Laurent6acd1d42017-01-04 14:23:29 -080010316 }
Eric Laurente6e9a482017-07-25 19:26:02 -070010317 if (sendToHal) {
10318 status = mHalStream->setParameters(keyValuePair);
10319 } else {
10320 status = NO_ERROR;
10321 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010322
10323 return false;
10324}
10325
10326String8 AudioFlinger::MmapThread::getParameters(const String8& keys)
10327{
10328 Mutex::Autolock _l(mLock);
10329 String8 out_s8;
10330 if (initCheck() == NO_ERROR && mHalStream->getParameters(keys, &out_s8) == OK) {
10331 return out_s8;
10332 }
Andy Hung920f6572022-10-06 12:09:49 -070010333 return {};
Eric Laurent6acd1d42017-01-04 14:23:29 -080010334}
10335
Mikhail Naganov88536df2021-07-26 17:30:29 -070010336void AudioFlinger::MmapThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -070010337 audio_port_handle_t portId __unused) {
Mikhail Naganov88536df2021-07-26 17:30:29 -070010338 sp<AudioIoDescriptor> desc;
10339 bool isInput = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010340 switch (event) {
10341 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -070010342 case AUDIO_INPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -080010343 case AUDIO_INPUT_CONFIG_CHANGED:
Mikhail Naganov88536df2021-07-26 17:30:29 -070010344 isInput = true;
10345 FALLTHROUGH_INTENDED;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010346 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -070010347 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -080010348 case AUDIO_OUTPUT_CONFIG_CHANGED:
Mikhail Naganov88536df2021-07-26 17:30:29 -070010349 desc = sp<AudioIoDescriptor>::make(mId, mPatch, isInput,
10350 mSampleRate, mFormat, mChannelMask, mFrameCount, mFrameCount);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010351 break;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010352 case AUDIO_INPUT_CLOSED:
10353 case AUDIO_OUTPUT_CLOSED:
10354 default:
Mikhail Naganov88536df2021-07-26 17:30:29 -070010355 desc = sp<AudioIoDescriptor>::make(mId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010356 break;
10357 }
10358 mAudioFlinger->ioConfigChanged(event, desc, pid);
10359}
10360
10361status_t AudioFlinger::MmapThread::createAudioPatch_l(const struct audio_patch *patch,
10362 audio_patch_handle_t *handle)
Andy Hung920f6572022-10-06 12:09:49 -070010363NO_THREAD_SAFETY_ANALYSIS // elease and re-acquire mLock
Eric Laurent6acd1d42017-01-04 14:23:29 -080010364{
10365 status_t status = NO_ERROR;
10366
10367 // store new device and send to effects
10368 audio_devices_t type = AUDIO_DEVICE_NONE;
10369 audio_port_handle_t deviceId;
jiabinc52b1ff2019-10-31 17:20:42 -070010370 AudioDeviceTypeAddrVector sinkDeviceTypeAddrs;
10371 AudioDeviceTypeAddr sourceDeviceTypeAddr;
10372 uint32_t numDevices = 0;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010373 if (isOutput()) {
10374 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabinc52b1ff2019-10-31 17:20:42 -070010375 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
10376 && !mAudioHwDev->supportsAudioPatches(),
10377 "Enumerated device type(%#x) must not be used "
10378 "as it does not support audio patches",
10379 patch->sinks[i].ext.device.type);
Mikhail Naganov55773032020-10-01 15:08:13 -070010380 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
Andy Hung920f6572022-10-06 12:09:49 -070010381 sinkDeviceTypeAddrs.emplace_back(patch->sinks[i].ext.device.type,
10382 patch->sinks[i].ext.device.address);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010383 }
10384 deviceId = patch->sinks[0].id;
jiabinc52b1ff2019-10-31 17:20:42 -070010385 numDevices = mPatch.num_sinks;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010386 } else {
10387 type = patch->sources[0].ext.device.type;
10388 deviceId = patch->sources[0].id;
jiabinc52b1ff2019-10-31 17:20:42 -070010389 numDevices = mPatch.num_sources;
10390 sourceDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
jiabin0a488932020-08-07 17:32:40 -070010391 sourceDeviceTypeAddr.setAddress(patch->sources[0].ext.device.address);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010392 }
10393
10394 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -080010395 if (isOutput()) {
10396 mEffectChains[i]->setDevices_l(sinkDeviceTypeAddrs);
10397 } else {
10398 mEffectChains[i]->setInputDevice_l(sourceDeviceTypeAddr);
10399 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010400 }
10401
jiabinc52b1ff2019-10-31 17:20:42 -070010402 if (!isOutput()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -080010403 // store new source and send to effects
10404 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
10405 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
10406 for (size_t i = 0; i < mEffectChains.size(); i++) {
10407 mEffectChains[i]->setAudioSource_l(mAudioSource);
10408 }
10409 }
10410 }
10411
10412 if (mAudioHwDev->supportsAudioPatches()) {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080010413 status = mHalDevice->createAudioPatch(patch->num_sources, patch->sources, patch->num_sinks,
10414 patch->sinks, handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010415 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080010416 audio_port_config port;
10417 std::optional<audio_source_t> source;
10418 if (isOutput()) {
10419 port = patch->sinks[0];
Eric Laurent6acd1d42017-01-04 14:23:29 -080010420 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080010421 port = patch->sources[0];
10422 source = patch->sinks[0].ext.mix.usecase.source;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010423 }
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080010424 status = mHalStream->legacyCreateAudioPatch(port, source, type);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010425 *handle = AUDIO_PATCH_HANDLE_NONE;
10426 }
10427
jiabinc52b1ff2019-10-31 17:20:42 -070010428 if (numDevices == 0 || mDeviceId != deviceId) {
10429 if (isOutput()) {
10430 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
10431 mOutDeviceTypeAddrs = sinkDeviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -070010432 checkSilentMode_l();
jiabinc52b1ff2019-10-31 17:20:42 -070010433 } else {
10434 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
10435 mInDeviceTypeAddr = sourceDeviceTypeAddr;
10436 }
Phil Burk7f6b40d2017-02-09 13:18:38 -080010437 sp<MmapStreamCallback> callback = mCallback.promote();
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010438 if (mDeviceId != deviceId && callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -070010439 mLock.unlock();
Phil Burk7f6b40d2017-02-09 13:18:38 -080010440 callback->onRoutingChanged(deviceId);
Eric Laurent734046e2018-04-16 14:50:52 -070010441 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010442 }
jiabinc52b1ff2019-10-31 17:20:42 -070010443 mPatch = *patch;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010444 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010445 }
Eric Laurentdda206a2022-07-08 17:28:35 +020010446 // Force meteadata update after a route change
10447 mActiveTracks.setHasChanged();
10448
Eric Laurent6acd1d42017-01-04 14:23:29 -080010449 return status;
10450}
10451
10452status_t AudioFlinger::MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
10453{
10454 status_t status = NO_ERROR;
10455
jiabinc52b1ff2019-10-31 17:20:42 -070010456 mPatch = audio_patch{};
10457 mOutDeviceTypeAddrs.clear();
10458 mInDeviceTypeAddr.reset();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010459
10460 bool supportsAudioPatches = mHalDevice->supportsAudioPatches(&supportsAudioPatches) == OK ?
10461 supportsAudioPatches : false;
10462
10463 if (supportsAudioPatches) {
10464 status = mHalDevice->releaseAudioPatch(handle);
10465 } else {
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080010466 status = mHalStream->legacyReleaseAudioPatch();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010467 }
Eric Laurentdda206a2022-07-08 17:28:35 +020010468 // Force meteadata update after a route change
10469 mActiveTracks.setHasChanged();
10470
Eric Laurent6acd1d42017-01-04 14:23:29 -080010471 return status;
10472}
10473
Mikhail Naganovdc769682018-05-04 15:34:08 -070010474void AudioFlinger::MmapThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010475{
Mikhail Naganovdc769682018-05-04 15:34:08 -070010476 ThreadBase::toAudioPortConfig(config);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010477 if (isOutput()) {
10478 config->role = AUDIO_PORT_ROLE_SOURCE;
10479 config->ext.mix.hw_module = mAudioHwDev->handle();
10480 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
10481 } else {
10482 config->role = AUDIO_PORT_ROLE_SINK;
10483 config->ext.mix.hw_module = mAudioHwDev->handle();
10484 config->ext.mix.usecase.source = mAudioSource;
10485 }
10486}
10487
10488status_t AudioFlinger::MmapThread::addEffectChain_l(const sp<EffectChain>& chain)
10489{
10490 audio_session_t session = chain->sessionId();
10491
10492 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
10493 // Attach all tracks with same session ID to this chain.
10494 // indicate all active tracks in the chain
10495 for (const sp<MmapTrack> &track : mActiveTracks) {
10496 if (session == track->sessionId()) {
10497 chain->incTrackCnt();
10498 chain->incActiveTrackCnt();
10499 }
10500 }
10501
10502 chain->setThread(this);
10503 chain->setInBuffer(nullptr);
10504 chain->setOutBuffer(nullptr);
10505 chain->syncHalEffectsState();
10506
10507 mEffectChains.add(chain);
10508 checkSuspendOnAddEffectChain_l(chain);
10509 return NO_ERROR;
10510}
10511
10512size_t AudioFlinger::MmapThread::removeEffectChain_l(const sp<EffectChain>& chain)
10513{
10514 audio_session_t session = chain->sessionId();
10515
10516 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
10517
10518 for (size_t i = 0; i < mEffectChains.size(); i++) {
10519 if (chain == mEffectChains[i]) {
10520 mEffectChains.removeAt(i);
10521 // detach all active tracks from the chain
10522 // detach all tracks with same session ID from this chain
10523 for (const sp<MmapTrack> &track : mActiveTracks) {
10524 if (session == track->sessionId()) {
10525 chain->decActiveTrackCnt();
10526 chain->decTrackCnt();
10527 }
10528 }
10529 break;
10530 }
10531 }
10532 return mEffectChains.size();
10533}
10534
Eric Laurent6acd1d42017-01-04 14:23:29 -080010535void AudioFlinger::MmapThread::threadLoop_standby()
10536{
10537 mHalStream->standby();
10538}
10539
10540void AudioFlinger::MmapThread::threadLoop_exit()
10541{
Phil Burk7dce7282017-09-27 13:51:41 -070010542 // Do not call callback->onTearDown() because it is redundant for thread exit
10543 // and because it can cause a recursive mutex lock on stop().
Eric Laurent6acd1d42017-01-04 14:23:29 -080010544}
10545
Andy Hunge45f2192023-05-15 19:02:55 -070010546status_t AudioFlinger::MmapThread::setSyncEvent(const sp<audioflinger::SyncEvent>& /* event */)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010547{
10548 return BAD_VALUE;
10549}
10550
Andy Hunge45f2192023-05-15 19:02:55 -070010551bool AudioFlinger::MmapThread::isValidSyncEvent(
10552 const sp<audioflinger::SyncEvent>& /* event */) const
Eric Laurent6acd1d42017-01-04 14:23:29 -080010553{
10554 return false;
10555}
10556
10557status_t AudioFlinger::MmapThread::checkEffectCompatibility_l(
10558 const effect_descriptor_t *desc, audio_session_t sessionId)
10559{
10560 // No global effect sessions on mmap threads
Eric Laurent3f75a5b2019-11-12 15:55:51 -080010561 if (audio_is_global_session(sessionId)) {
10562 ALOGW("checkEffectCompatibility_l(): global effect %s on MMAP thread %s",
Eric Laurent6acd1d42017-01-04 14:23:29 -080010563 desc->name, mThreadName);
10564 return BAD_VALUE;
10565 }
10566
10567 if (!isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC)) {
10568 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on capture mmap thread",
10569 desc->name);
10570 return BAD_VALUE;
10571 }
10572 if (isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
Glenn Kastend3bb6452016-12-05 18:14:37 -080010573 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback mmap "
10574 "thread", desc->name);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010575 return BAD_VALUE;
10576 }
10577
10578 // Only allow effects without processing load or latency
10579 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) != EFFECT_FLAG_NO_PROCESS) {
10580 return BAD_VALUE;
10581 }
10582
jiabineb3bda02020-06-30 14:07:03 -070010583 if (EffectModule::isHapticGenerator(&desc->type)) {
10584 ALOGE("%s(): HapticGenerator is not supported for MmapThread", __func__);
10585 return BAD_VALUE;
10586 }
10587
Eric Laurent6acd1d42017-01-04 14:23:29 -080010588 return NO_ERROR;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010589}
10590
10591void AudioFlinger::MmapThread::checkInvalidTracks_l()
Andy Hung920f6572022-10-06 12:09:49 -070010592NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
Eric Laurent6acd1d42017-01-04 14:23:29 -080010593{
Eric Laurent039c24a2022-10-07 14:01:59 +020010594 sp<MmapStreamCallback> callback;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010595 for (const sp<MmapTrack> &track : mActiveTracks) {
10596 if (track->isInvalid()) {
Eric Laurent039c24a2022-10-07 14:01:59 +020010597 callback = mCallback.promote();
10598 if (callback == nullptr && mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
10599 ALOGW("Could not notify MMAP stream tear down: no onRoutingChanged callback!");
10600 mNoCallbackWarningCount++;
10601 }
10602 break;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010603 }
10604 }
Eric Laurent039c24a2022-10-07 14:01:59 +020010605 if (callback != 0) {
10606 mLock.unlock();
10607 callback->onRoutingChanged(AUDIO_PORT_HANDLE_NONE);
10608 mLock.lock();
jiabindfa32482022-10-06 19:45:50 +000010609 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010610}
10611
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010612void AudioFlinger::MmapThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010613{
Eric Laurent6acd1d42017-01-04 14:23:29 -080010614 dprintf(fd, " Attributes: content type %d usage %d source %d\n",
10615 mAttr.content_type, mAttr.usage, mAttr.source);
10616 dprintf(fd, " Session: %d port Id: %d\n", mSessionId, mPortId);
Eric Tan39ec8d62018-07-24 09:49:29 -070010617 if (mActiveTracks.isEmpty()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -080010618 dprintf(fd, " No active clients\n");
10619 }
10620}
10621
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010622void AudioFlinger::MmapThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010623{
Eric Laurent6acd1d42017-01-04 14:23:29 -080010624 String8 result;
Eric Laurent6acd1d42017-01-04 14:23:29 -080010625 size_t numtracks = mActiveTracks.size();
Andy Hung2c6c3bb2017-06-16 14:01:45 -070010626 dprintf(fd, " %zu Tracks\n", numtracks);
10627 const char *prefix = " ";
Eric Laurent6acd1d42017-01-04 14:23:29 -080010628 if (numtracks) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -070010629 result.append(prefix);
Kevin Rocard5f2136e2018-05-11 22:03:00 -070010630 mActiveTracks[0]->appendDumpHeader(result);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010631 for (size_t i = 0; i < numtracks ; ++i) {
10632 sp<MmapTrack> track = mActiveTracks[i];
Andy Hung2c6c3bb2017-06-16 14:01:45 -070010633 result.append(prefix);
10634 track->appendDump(result, true /* active */);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010635 }
10636 } else {
10637 dprintf(fd, "\n");
10638 }
10639 write(fd, result.string(), result.size());
10640}
10641
10642AudioFlinger::MmapPlaybackThread::MmapPlaybackThread(
10643 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -070010644 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -070010645 : MmapThread(audioFlinger, id, hwDev, output->stream, systemReady, true /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -080010646 mStreamType(AUDIO_STREAM_MUSIC),
Phil Burk56ecf3e2018-03-12 15:38:17 -070010647 mStreamVolume(1.0),
10648 mStreamMute(false),
Phil Burk56ecf3e2018-03-12 15:38:17 -070010649 mOutput(output)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010650{
10651 snprintf(mThreadName, kThreadNameLength, "AudioMmapOut_%X", id);
10652 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
10653 mMasterVolume = audioFlinger->masterVolume_l();
10654 mMasterMute = audioFlinger->masterMute_l();
10655 if (mAudioHwDev) {
10656 if (mAudioHwDev->canSetMasterVolume()) {
10657 mMasterVolume = 1.0;
10658 }
10659
10660 if (mAudioHwDev->canSetMasterMute()) {
10661 mMasterMute = false;
10662 }
10663 }
10664}
10665
10666void AudioFlinger::MmapPlaybackThread::configure(const audio_attributes_t *attr,
10667 audio_stream_type_t streamType,
10668 audio_session_t sessionId,
10669 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010670 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -080010671 audio_port_handle_t portId)
10672{
Eric Laurent7aa0ccb2017-08-28 11:12:52 -070010673 MmapThread::configure(attr, streamType, sessionId, callback, deviceId, portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010674 mStreamType = streamType;
10675}
10676
10677AudioStreamOut* AudioFlinger::MmapPlaybackThread::clearOutput()
10678{
10679 Mutex::Autolock _l(mLock);
10680 AudioStreamOut *output = mOutput;
10681 mOutput = NULL;
10682 return output;
10683}
10684
10685void AudioFlinger::MmapPlaybackThread::setMasterVolume(float value)
10686{
10687 Mutex::Autolock _l(mLock);
10688 // Don't apply master volume in SW if our HAL can do it for us.
10689 if (mAudioHwDev &&
10690 mAudioHwDev->canSetMasterVolume()) {
10691 mMasterVolume = 1.0;
10692 } else {
10693 mMasterVolume = value;
10694 }
10695}
10696
10697void AudioFlinger::MmapPlaybackThread::setMasterMute(bool muted)
10698{
10699 Mutex::Autolock _l(mLock);
10700 // Don't apply master mute in SW if our HAL can do it for us.
10701 if (mAudioHwDev && mAudioHwDev->canSetMasterMute()) {
10702 mMasterMute = false;
10703 } else {
10704 mMasterMute = muted;
10705 }
10706}
10707
10708void AudioFlinger::MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
10709{
10710 Mutex::Autolock _l(mLock);
10711 if (stream == mStreamType) {
10712 mStreamVolume = value;
10713 broadcast_l();
10714 }
10715}
10716
10717float AudioFlinger::MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
10718{
10719 Mutex::Autolock _l(mLock);
10720 if (stream == mStreamType) {
10721 return mStreamVolume;
10722 }
10723 return 0.0f;
10724}
10725
10726void AudioFlinger::MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
10727{
10728 Mutex::Autolock _l(mLock);
10729 if (stream == mStreamType) {
10730 mStreamMute= muted;
10731 broadcast_l();
10732 }
10733}
10734
10735void AudioFlinger::MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
10736{
10737 Mutex::Autolock _l(mLock);
10738 if (streamType == mStreamType) {
10739 for (const sp<MmapTrack> &track : mActiveTracks) {
10740 track->invalidate();
10741 }
10742 broadcast_l();
10743 }
10744}
10745
jiabinc44b3462022-12-08 12:52:31 -080010746void AudioFlinger::MmapPlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds)
10747{
10748 Mutex::Autolock _l(mLock);
10749 bool trackMatch = false;
10750 for (const sp<MmapTrack> &track : mActiveTracks) {
10751 if (portIds.find(track->portId()) != portIds.end()) {
10752 track->invalidate();
10753 trackMatch = true;
10754 portIds.erase(track->portId());
10755 }
10756 if (portIds.empty()) {
10757 break;
10758 }
10759 }
10760 if (trackMatch) {
10761 broadcast_l();
10762 }
10763}
10764
Eric Laurent6acd1d42017-01-04 14:23:29 -080010765void AudioFlinger::MmapPlaybackThread::processVolume_l()
Andy Hung920f6572022-10-06 12:09:49 -070010766NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent_l
Eric Laurent6acd1d42017-01-04 14:23:29 -080010767{
10768 float volume;
10769
10770 if (mMasterMute || mStreamMute) {
10771 volume = 0;
10772 } else {
10773 volume = mMasterVolume * mStreamVolume;
10774 }
10775
10776 if (volume != mHalVolFloat) {
Eric Laurent6acd1d42017-01-04 14:23:29 -080010777
10778 // Convert volumes from float to 8.24
10779 uint32_t vol = (uint32_t)(volume * (1 << 24));
10780
10781 // Delegate volume control to effect in track effect chain if needed
10782 // only one effect chain can be present on DirectOutputThread, so if
10783 // there is one, the track is connected to it
10784 if (!mEffectChains.isEmpty()) {
10785 mEffectChains[0]->setVolume_l(&vol, &vol);
10786 volume = (float)vol / (1 << 24);
10787 }
Eric Laurentdff774a2017-04-21 15:29:38 -070010788 // Try to use HW volume control and fall back to SW control if not implemented
Phil Burk56ecf3e2018-03-12 15:38:17 -070010789 if (mOutput->stream->setVolume(volume, volume) == NO_ERROR) {
10790 mHalVolFloat = volume; // HW volume control worked, so update value.
10791 mNoCallbackWarningCount = 0;
10792 } else {
Eric Laurentdff774a2017-04-21 15:29:38 -070010793 sp<MmapStreamCallback> callback = mCallback.promote();
10794 if (callback != 0) {
Phil Burk56ecf3e2018-03-12 15:38:17 -070010795 mHalVolFloat = volume; // SW volume control worked, so update value.
10796 mNoCallbackWarningCount = 0;
Eric Laurent734046e2018-04-16 14:50:52 -070010797 mLock.unlock();
Robert Wu4389ae62022-02-17 18:39:41 +000010798 callback->onVolumeChanged(volume);
Eric Laurent734046e2018-04-16 14:50:52 -070010799 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -080010800 } else {
Phil Burk56ecf3e2018-03-12 15:38:17 -070010801 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
10802 ALOGW("Could not set MMAP stream volume: no volume callback!");
10803 mNoCallbackWarningCount++;
10804 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010805 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010806 }
Jasmine Chaeaa10e42021-05-11 10:11:14 +080010807 for (const sp<MmapTrack> &track : mActiveTracks) {
10808 track->setMetadataHasChanged();
Vlad Popaec1788e2022-08-04 11:23:30 +020010809 track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
10810 /*muteState=*/{mMasterMute,
10811 mStreamVolume == 0.f,
10812 mStreamMute,
10813 // TODO(b/241533526): adjust logic to include mute from AppOps
10814 false /*muteFromPlaybackRestricted*/,
10815 false /*muteFromClientVolume*/,
10816 false /*muteFromVolumeShaper*/});
Jasmine Chaeaa10e42021-05-11 10:11:14 +080010817 }
Eric Laurent6acd1d42017-01-04 14:23:29 -080010818 }
10819}
10820
Vlad Popa7e81cea2023-01-19 16:34:16 +010010821AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::MmapPlaybackThread::updateMetadata_l()
Kevin Rocard069c2712018-03-29 19:09:14 -070010822{
Jasmine Chaeaa10e42021-05-11 10:11:14 +080010823 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +010010824 return {}; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -070010825 }
10826 StreamOutHalInterface::SourceMetadata metadata;
10827 for (const sp<MmapTrack> &track : mActiveTracks) {
10828 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent94579172020-11-20 18:41:04 +010010829 playback_track_metadata_v7_t trackMetadata;
10830 trackMetadata.base = {
Kevin Rocard069c2712018-03-29 19:09:14 -070010831 .usage = track->attributes().usage,
10832 .content_type = track->attributes().content_type,
10833 .gain = mHalVolFloat, // TODO: propagate from aaudio pre-mix volume
Eric Laurent94579172020-11-20 18:41:04 +010010834 };
10835 trackMetadata.channel_mask = track->channelMask(),
10836 strncpy(trackMetadata.tags, track->attributes().tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
10837 metadata.tracks.push_back(trackMetadata);
Kevin Rocard069c2712018-03-29 19:09:14 -070010838 }
10839 mOutput->stream->updateSourceMetadata(metadata);
Vlad Popa7e81cea2023-01-19 16:34:16 +010010840
10841 MetadataUpdate change;
10842 change.playbackMetadataUpdate = metadata.tracks;
10843 return change;
10844};
Kevin Rocard069c2712018-03-29 19:09:14 -070010845
Eric Laurent6acd1d42017-01-04 14:23:29 -080010846void AudioFlinger::MmapPlaybackThread::checkSilentMode_l()
10847{
10848 if (!mMasterMute) {
10849 char value[PROPERTY_VALUE_MAX];
10850 if (property_get("ro.audio.silent", value, "0") > 0) {
10851 char *endptr;
10852 unsigned long ul = strtoul(value, &endptr, 0);
10853 if (*endptr == '\0' && ul != 0) {
10854 ALOGD("Silence is golden");
10855 // The setprop command will not allow a property to be changed after
10856 // the first time it is set, so we don't have to worry about un-muting.
10857 setMasterMute_l(true);
10858 }
10859 }
10860 }
10861}
10862
Mikhail Naganov32abc2b2018-05-24 12:57:11 -070010863void AudioFlinger::MmapPlaybackThread::toAudioPortConfig(struct audio_port_config *config)
10864{
10865 MmapThread::toAudioPortConfig(config);
10866 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
10867 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
10868 config->flags.output = mOutput->flags;
10869 }
10870}
10871
jiabinb7d8c5a2020-08-26 17:24:52 -070010872status_t AudioFlinger::MmapPlaybackThread::getExternalPosition(uint64_t *position,
10873 int64_t *timeNanos)
10874{
10875 if (mOutput == nullptr) {
10876 return NO_INIT;
10877 }
10878 struct timespec timestamp;
10879 status_t status = mOutput->getPresentationPosition(position, &timestamp);
10880 if (status == NO_ERROR) {
10881 *timeNanos = timestamp.tv_sec * NANOS_PER_SECOND + timestamp.tv_nsec;
10882 }
10883 return status;
10884}
10885
jiabinfc791ee2023-02-15 19:43:40 +000010886status_t AudioFlinger::MmapPlaybackThread::reportData(const void* buffer, size_t frameCount) {
Vlad Popa6fbbfbf2023-02-22 15:05:43 +010010887 // Send to MelProcessor for sound dose measurement.
10888 auto processor = mMelProcessor.load();
10889 if (processor) {
10890 processor->process(buffer, frameCount * mFrameSize);
10891 }
10892
jiabinfc791ee2023-02-15 19:43:40 +000010893 return NO_ERROR;
10894}
10895
Vlad Popa6fbbfbf2023-02-22 15:05:43 +010010896// startMelComputation_l() must be called with AudioFlinger::mLock held
10897void AudioFlinger::MmapPlaybackThread::startMelComputation_l(
10898 const sp<audio_utils::MelProcessor>& processor)
10899{
10900 ALOGV("%s: starting mel processor for thread %d", __func__, id());
Vlad Popa1c2f7e12023-03-28 02:08:56 +020010901 mMelProcessor.store(processor);
10902 if (processor) {
10903 processor->resume();
Vlad Popa6fbbfbf2023-02-22 15:05:43 +010010904 }
Vlad Popa1c2f7e12023-03-28 02:08:56 +020010905
10906 // no need to update output format for MMapPlaybackThread since it is
10907 // assigned constant for each thread
Vlad Popa6fbbfbf2023-02-22 15:05:43 +010010908}
10909
10910// stopMelComputation_l() must be called with AudioFlinger::mLock held
10911void AudioFlinger::MmapPlaybackThread::stopMelComputation_l()
10912{
Vlad Popa1c2f7e12023-03-28 02:08:56 +020010913 ALOGV("%s: pausing mel processor for thread %d", __func__, id());
10914 auto melProcessor = mMelProcessor.load();
10915 if (melProcessor != nullptr) {
10916 melProcessor->pause();
10917 }
Vlad Popa6fbbfbf2023-02-22 15:05:43 +010010918}
10919
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010920void AudioFlinger::MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010921{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010922 MmapThread::dumpInternals_l(fd, args);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010923
Glenn Kastend3bb6452016-12-05 18:14:37 -080010924 dprintf(fd, " Stream type: %d Stream volume: %f HAL volume: %f Stream mute %d\n",
10925 mStreamType, mStreamVolume, mHalVolFloat, mStreamMute);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010926 dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
10927}
10928
10929AudioFlinger::MmapCaptureThread::MmapCaptureThread(
10930 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -070010931 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -070010932 : MmapThread(audioFlinger, id, hwDev, input->stream, systemReady, false /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -080010933 mInput(input)
10934{
10935 snprintf(mThreadName, kThreadNameLength, "AudioMmapIn_%X", id);
10936 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
10937}
10938
Eric Laurentdda206a2022-07-08 17:28:35 +020010939status_t AudioFlinger::MmapCaptureThread::exitStandby_l()
Eric Laurent331679c2018-04-16 17:03:16 -070010940{
Phil Burkf054fc32018-12-06 09:45:59 -080010941 {
10942 // mInput might have been cleared by clearInput()
Phil Burkf054fc32018-12-06 09:45:59 -080010943 if (mInput != nullptr && mInput->stream != nullptr) {
10944 mInput->stream->setGain(1.0f);
10945 }
10946 }
Eric Laurentdda206a2022-07-08 17:28:35 +020010947 return MmapThread::exitStandby_l();
Eric Laurent331679c2018-04-16 17:03:16 -070010948}
10949
Eric Laurent6acd1d42017-01-04 14:23:29 -080010950AudioFlinger::AudioStreamIn* AudioFlinger::MmapCaptureThread::clearInput()
10951{
10952 Mutex::Autolock _l(mLock);
10953 AudioStreamIn *input = mInput;
10954 mInput = NULL;
10955 return input;
10956}
Kevin Rocard069c2712018-03-29 19:09:14 -070010957
Eric Laurent331679c2018-04-16 17:03:16 -070010958
10959void AudioFlinger::MmapCaptureThread::processVolume_l()
10960{
10961 bool changed = false;
10962 bool silenced = false;
10963
10964 sp<MmapStreamCallback> callback = mCallback.promote();
10965 if (callback == 0) {
10966 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
10967 ALOGW("Could not set MMAP stream silenced: no onStreamSilenced callback!");
10968 mNoCallbackWarningCount++;
10969 }
10970 }
10971
10972 // After a change occurred in track silenced state, mute capture in audio DSP if at least one
10973 // track is silenced and unmute otherwise
10974 for (size_t i = 0; i < mActiveTracks.size() && !silenced; i++) {
10975 if (!mActiveTracks[i]->getAndSetSilencedNotified_l()) {
10976 changed = true;
10977 silenced = mActiveTracks[i]->isSilenced_l();
10978 }
10979 }
10980
10981 if (changed) {
10982 mInput->stream->setGain(silenced ? 0.0f: 1.0f);
10983 }
10984}
10985
Vlad Popa7e81cea2023-01-19 16:34:16 +010010986AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::MmapCaptureThread::updateMetadata_l()
Kevin Rocard069c2712018-03-29 19:09:14 -070010987{
Jasmine Chaeaa10e42021-05-11 10:11:14 +080010988 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
Vlad Popa7e81cea2023-01-19 16:34:16 +010010989 return {}; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -070010990 }
10991 StreamInHalInterface::SinkMetadata metadata;
10992 for (const sp<MmapTrack> &track : mActiveTracks) {
10993 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent94579172020-11-20 18:41:04 +010010994 record_track_metadata_v7_t trackMetadata;
10995 trackMetadata.base = {
Kevin Rocard069c2712018-03-29 19:09:14 -070010996 .source = track->attributes().source,
10997 .gain = 1, // capture tracks do not have volumes
Eric Laurent94579172020-11-20 18:41:04 +010010998 };
10999 trackMetadata.channel_mask = track->channelMask(),
11000 strncpy(trackMetadata.tags, track->attributes().tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
11001 metadata.tracks.push_back(trackMetadata);
Kevin Rocard069c2712018-03-29 19:09:14 -070011002 }
11003 mInput->stream->updateSinkMetadata(metadata);
Vlad Popa7e81cea2023-01-19 16:34:16 +010011004 MetadataUpdate change;
11005 change.recordMetadataUpdate = metadata.tracks;
11006 return change;
Kevin Rocard069c2712018-03-29 19:09:14 -070011007}
11008
Eric Laurent5ada82e2019-08-29 17:53:54 -070011009void AudioFlinger::MmapCaptureThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Eric Laurent331679c2018-04-16 17:03:16 -070011010{
11011 Mutex::Autolock _l(mLock);
11012 for (size_t i = 0; i < mActiveTracks.size() ; i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -070011013 if (mActiveTracks[i]->portId() == portId) {
Eric Laurent331679c2018-04-16 17:03:16 -070011014 mActiveTracks[i]->setSilenced_l(silenced);
11015 broadcast_l();
11016 }
11017 }
jiabin09609032022-06-15 19:26:01 +000011018 setClientSilencedIfExists_l(portId, silenced);
Eric Laurent331679c2018-04-16 17:03:16 -070011019}
11020
Mikhail Naganov32abc2b2018-05-24 12:57:11 -070011021void AudioFlinger::MmapCaptureThread::toAudioPortConfig(struct audio_port_config *config)
11022{
11023 MmapThread::toAudioPortConfig(config);
11024 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
11025 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
11026 config->flags.input = mInput->flags;
11027 }
11028}
11029
jiabinb7d8c5a2020-08-26 17:24:52 -070011030status_t AudioFlinger::MmapCaptureThread::getExternalPosition(
11031 uint64_t *position, int64_t *timeNanos)
11032{
11033 if (mInput == nullptr) {
11034 return NO_INIT;
11035 }
11036 return mInput->getCapturePosition((int64_t*)position, timeNanos);
11037}
11038
jiabinc658e452022-10-21 20:52:21 +000011039// ----------------------------------------------------------------------------
11040
11041AudioFlinger::BitPerfectThread::BitPerfectThread(const sp<AudioFlinger> &audioflinger,
11042 AudioStreamOut *output, audio_io_handle_t id, bool systemReady)
11043 : MixerThread(audioflinger, output, id, systemReady, BIT_PERFECT) {}
11044
11045AudioFlinger::PlaybackThread::mixer_state AudioFlinger::BitPerfectThread::prepareTracks_l(
11046 Vector<sp<Track>> *tracksToRemove) {
11047 mixer_state result = MixerThread::prepareTracks_l(tracksToRemove);
11048 // If there is only one active track and it is bit-perfect, enable tee buffer.
jiabin76d94692022-12-15 21:51:21 +000011049 float volumeLeft = 1.0f;
11050 float volumeRight = 1.0f;
jiabinc658e452022-10-21 20:52:21 +000011051 if (mActiveTracks.size() == 1 && mActiveTracks[0]->isBitPerfect()) {
11052 const int trackId = mActiveTracks[0]->id();
11053 mAudioMixer->setParameter(
11054 trackId, AudioMixer::TRACK, AudioMixer::TEE_BUFFER, (void *)mSinkBuffer);
11055 mAudioMixer->setParameter(
11056 trackId, AudioMixer::TRACK, AudioMixer::TEE_BUFFER_FRAME_COUNT,
11057 (void *)(uintptr_t)mNormalFrameCount);
jiabin76d94692022-12-15 21:51:21 +000011058 mActiveTracks[0]->getFinalVolume(&volumeLeft, &volumeRight);
jiabinc658e452022-10-21 20:52:21 +000011059 mIsBitPerfect = true;
11060 } else {
11061 mIsBitPerfect = false;
11062 // No need to copy bit-perfect data directly to sink buffer given there are multiple tracks
11063 // active.
11064 for (const auto& track : mActiveTracks) {
11065 const int trackId = track->id();
11066 mAudioMixer->setParameter(
11067 trackId, AudioMixer::TRACK, AudioMixer::TEE_BUFFER, nullptr);
11068 }
11069 }
jiabin76d94692022-12-15 21:51:21 +000011070 if (mVolumeLeft != volumeLeft || mVolumeRight != volumeRight) {
11071 mVolumeLeft = volumeLeft;
11072 mVolumeRight = volumeRight;
11073 setVolumeForOutput_l(volumeLeft, volumeRight);
11074 }
jiabinc658e452022-10-21 20:52:21 +000011075 return result;
11076}
11077
11078void AudioFlinger::BitPerfectThread::threadLoop_mix() {
11079 MixerThread::threadLoop_mix();
11080 mHasDataCopiedToSinkBuffer = mIsBitPerfect;
11081}
11082
Glenn Kasten63238ef2015-03-02 15:50:29 -080011083} // namespace android