blob: 3ec624ffe7da932e22cdc760121464446ffe163c [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
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>
jiabinc52b1ff2019-10-31 17:20:42 -070034#include <media/AudioContainers.h>
35#include <media/AudioDeviceTypeAddr.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070036#include <media/AudioParameter.h>
Andy Hungcd044842014-08-07 11:04:34 -070037#include <media/AudioResamplerPublic.h>
Andy Hung89816052017-01-11 17:08:23 -080038#include <media/RecordBufferConverter.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070039#include <media/TypeConverter.h>
Eric Laurent81784c32012-11-19 14:55:58 -080040#include <utils/Log.h>
Alex Ray371eb972012-11-30 11:11:54 -080041#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080042
43#include <private/media/AudioTrackShared.h>
Wei Jiaf2ae3e12016-10-27 17:10:59 -070044#include <private/android_filesystem_config.h>
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +010045#include <audio_utils/Balance.h>
jiabinf6eb4c32020-02-25 14:06:25 -080046#include <audio_utils/Metadata.h>
jiabin245cdd92018-12-07 17:55:15 -080047#include <audio_utils/channels.h>
Glenn Kasten6bf707f2017-02-23 16:53:58 -080048#include <audio_utils/mono_blend.h>
Eric Laurent81784c32012-11-19 14:55:58 -080049#include <audio_utils/primitives.h>
Andy Hung98ef9782014-03-04 14:46:50 -080050#include <audio_utils/format.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070051#include <audio_utils/minifloat.h>
Hongwei Wang95e37682019-04-12 11:13:36 -070052#include <audio_utils/safe_math.h>
Mikhail Naganov9fe94012016-10-14 14:57:40 -070053#include <system/audio_effects/effect_ns.h>
54#include <system/audio_effects/effect_aec.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070055#include <system/audio.h>
Eric Laurent81784c32012-11-19 14:55:58 -080056
57// NBAIO implementations
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070058#include <media/nbaio/AudioStreamInSource.h>
Eric Laurent81784c32012-11-19 14:55:58 -080059#include <media/nbaio/AudioStreamOutSink.h>
60#include <media/nbaio/MonoPipe.h>
61#include <media/nbaio/MonoPipeReader.h>
62#include <media/nbaio/Pipe.h>
63#include <media/nbaio/PipeReader.h>
64#include <media/nbaio/SourceAudioBufferProvider.h>
Wei Jia3f273d12015-11-24 09:06:49 -080065#include <mediautils/BatteryNotifier.h>
Eric Laurent81784c32012-11-19 14:55:58 -080066
Mikhail Naganov2996f672019-04-18 12:29:59 -070067#include <audiomanager/AudioManager.h>
Eric Laurent81784c32012-11-19 14:55:58 -080068#include <powermanager/PowerManager.h>
69
Kevin Rocard7588ff42018-01-08 11:11:30 -080070#include <media/audiohal/EffectsFactoryHalInterface.h>
Kevin Rocard069c2712018-03-29 19:09:14 -070071#include <media/audiohal/StreamHalInterface.h>
Kevin Rocard7588ff42018-01-08 11:11:30 -080072
Eric Laurent81784c32012-11-19 14:55:58 -080073#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080074#include "FastMixer.h"
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070075#include "FastCapture.h"
Andy Hungab7ef302018-05-15 19:35:29 -070076#include <mediautils/SchedulingPolicyService.h>
77#include <mediautils/ServiceUtilities.h>
Eric Laurent81784c32012-11-19 14:55:58 -080078
Eric Laurent81784c32012-11-19 14:55:58 -080079#ifdef ADD_BATTERY_DATA
80#include <media/IMediaPlayerService.h>
81#include <media/IMediaDeathNotifier.h>
82#endif
83
Eric Laurent81784c32012-11-19 14:55:58 -080084#ifdef DEBUG_CPU_USAGE
Eric Tan5b13ff82018-07-27 11:20:17 -070085#include <audio_utils/Statistics.h>
Eric Laurent81784c32012-11-19 14:55:58 -080086#include <cpustats/ThreadCpuUsage.h>
87#endif
88
Glenn Kastenc05b8d72016-03-24 09:48:17 -070089#include "AutoPark.h"
90
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080091#include <pthread.h>
92#include "TypedLogger.h"
93
Eric Laurent81784c32012-11-19 14:55:58 -080094// ----------------------------------------------------------------------------
95
96// Note: the following macro is used for extremely verbose logging message. In
97// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
98// 0; but one side effect of this is to turn all LOGV's as well. Some messages
99// are so verbose that we want to suppress them even when we have ALOG_ASSERT
100// turned on. Do not uncomment the #def below unless you really know what you
101// are doing and want to see all of the extremely verbose messages.
102//#define VERY_VERY_VERBOSE_LOGGING
103#ifdef VERY_VERY_VERBOSE_LOGGING
104#define ALOGVV ALOGV
105#else
106#define ALOGVV(a...) do { } while(0)
107#endif
108
Andy Hung6770c6f2015-04-07 13:43:36 -0700109// TODO: Move these macro/inlines to a header file.
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700110#define max(a, b) ((a) > (b) ? (a) : (b))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700111
Andy Hung6770c6f2015-04-07 13:43:36 -0700112template <typename T>
113static inline T min(const T& a, const T& b)
114{
115 return a < b ? a : b;
116}
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700117
Eric Laurent81784c32012-11-19 14:55:58 -0800118namespace android {
119
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700120using media::IEffectClient;
Svet Ganov33761132021-05-13 22:51:08 +0000121using content::AttributionSourceState;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700122
Eric Laurent81784c32012-11-19 14:55:58 -0800123// retry counts for buffer fill timeout
124// 50 * ~20msecs = 1 second
125static const int8_t kMaxTrackRetries = 50;
126static const int8_t kMaxTrackStartupRetries = 50;
Andy Hung455982f2021-04-27 17:46:12 -0700127
Eric Laurent81784c32012-11-19 14:55:58 -0800128// allow less retry attempts on direct output thread.
129// direct outputs can be a scarce resource in audio hardware and should
130// be released as quickly as possible.
Andy Hung455982f2021-04-27 17:46:12 -0700131// Notes:
132// 1) The retry duration kMaxTrackRetriesDirectMs may be increased
133// in case the data write is bursty for the AudioTrack. The application
134// should endeavor to write at least once every kMaxTrackRetriesDirectMs
135// to prevent an underrun situation. If the data is bursty, then
136// the application can also throttle the data sent to be even.
137// 2) For compressed audio data, any data present in the AudioTrack buffer
138// will be sent and reset the retry count. This delivers data as
139// it arrives, with approximately kDirectMinSleepTimeUs = 10ms checking interval.
140// 3) For linear PCM or proportional PCM, we wait one period for a period's worth
141// of data to be available, then any remaining data is delivered.
142// This is required to ensure the last bit of data is delivered before underrun.
143//
144// Sleep time per cycle is kDirectMinSleepTimeUs for compressed tracks
145// or the size of the HAL period for proportional / linear PCM tracks.
146static const int32_t kMaxTrackRetriesDirectMs = 200;
Eric Laurent81784c32012-11-19 14:55:58 -0800147
148// don't warn about blocked writes or record buffer overflows more often than this
149static const nsecs_t kWarningThrottleNs = seconds(5);
150
151// RecordThread loop sleep time upon application overrun or audio HAL read error
152static const int kRecordThreadSleepUs = 5000;
153
Eric Laurent10351942014-05-08 18:49:52 -0700154// maximum time to wait in sendConfigEvent_l() for a status to be received
155static const nsecs_t kConfigEventTimeoutNs = seconds(2);
Eric Laurent81784c32012-11-19 14:55:58 -0800156
157// minimum sleep time for the mixer thread loop when tracks are active but in underrun
158static const uint32_t kMinThreadSleepTimeUs = 5000;
159// maximum divider applied to the active sleep time in the mixer thread loop
160static const uint32_t kMaxThreadSleepTimeShift = 2;
161
Andy Hung09a50072014-02-27 14:30:47 -0800162// minimum normal sink buffer size, expressed in milliseconds rather than frames
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700163// FIXME This should be based on experimentally observed scheduling jitter
Andy Hung09a50072014-02-27 14:30:47 -0800164static const uint32_t kMinNormalSinkBufferSizeMs = 20;
165// maximum normal sink buffer size
166static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
Eric Laurent81784c32012-11-19 14:55:58 -0800167
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700168// minimum capture buffer size in milliseconds to _not_ need a fast capture thread
169// FIXME This should be based on experimentally observed scheduling jitter
170static const uint32_t kMinNormalCaptureBufferSizeMs = 12;
171
Eric Laurent972a1732013-09-04 09:42:59 -0700172// Offloaded output thread standby delay: allows track transition without going to standby
173static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
174
Eric Laurent51716182016-02-29 18:00:56 -0800175// Direct output thread minimum sleep time in idle or active(underrun) state
176static const nsecs_t kDirectMinSleepTimeUs = 10000;
177
Glenn Kasten1b291842016-07-18 14:55:21 -0700178// The universal constant for ubiquitous 20ms value. The value of 20ms seems to provide a good
179// balance between power consumption and latency, and allows threads to be scheduled reliably
180// by the CFS scheduler.
181// FIXME Express other hardcoded references to 20ms with references to this constant and move
182// it appropriately.
183#define FMS_20 20
Eric Laurent51716182016-02-29 18:00:56 -0800184
Eric Laurent81784c32012-11-19 14:55:58 -0800185// Whether to use fast mixer
186static const enum {
187 FastMixer_Never, // never initialize or use: for debugging only
188 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
189 // normal mixer multiplier is 1
190 FastMixer_Static, // initialize if needed, then use all the time if initialized,
191 // multiplier is calculated based on min & max normal mixer buffer size
192 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
193 // multiplier is calculated based on min & max normal mixer buffer size
194 // FIXME for FastMixer_Dynamic:
195 // Supporting this option will require fixing HALs that can't handle large writes.
196 // For example, one HAL implementation returns an error from a large write,
197 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
198 // We could either fix the HAL implementations, or provide a wrapper that breaks
199 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
200} kUseFastMixer = FastMixer_Static;
201
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700202// Whether to use fast capture
203static const enum {
204 FastCapture_Never, // never initialize or use: for debugging only
205 FastCapture_Always, // always initialize and use, even if not needed: for debugging only
206 FastCapture_Static, // initialize if needed, then use all the time if initialized
207} kUseFastCapture = FastCapture_Static;
208
Eric Laurent81784c32012-11-19 14:55:58 -0800209// Priorities for requestPriority
210static const int kPriorityAudioApp = 2;
211static const int kPriorityFastMixer = 3;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700212static const int kPriorityFastCapture = 3;
Eric Laurent81784c32012-11-19 14:55:58 -0800213
Glenn Kastenea38ee72016-04-18 11:08:01 -0700214// IAudioFlinger::createTrack() has an in/out parameter 'pFrameCount' for the total size of the
215// track buffer in shared memory. Zero on input means to use a default value. For fast tracks,
216// AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
Glenn Kasten03490092014-05-27 12:30:54 -0700217
218// This is the default value, if not specified by property.
Glenn Kastenb5fed682013-12-03 09:06:43 -0800219static const int kFastTrackMultiplier = 2;
Eric Laurent81784c32012-11-19 14:55:58 -0800220
Glenn Kasten03490092014-05-27 12:30:54 -0700221// The minimum and maximum allowed values
222static const int kFastTrackMultiplierMin = 1;
223static const int kFastTrackMultiplierMax = 2;
224
225// The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
226static int sFastTrackMultiplier = kFastTrackMultiplier;
227
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700228// See Thread::readOnlyHeap().
229// Initially this heap is used to allocate client buffers for "fast" AudioRecord.
230// Eventually it will be the single buffer that FastCapture writes into via HAL read(),
231// and that all "fast" AudioRecord clients read from. In either case, the size can be small.
Mikhail Naganov79a77822018-05-10 15:57:25 -0700232static const size_t kRecordThreadReadOnlyHeapSize = 0xD000;
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700233
Eric Laurent81784c32012-11-19 14:55:58 -0800234// ----------------------------------------------------------------------------
235
Andy Hungb68f5eb2019-12-03 16:49:17 -0800236// TODO: move all toString helpers to audio.h
237// under #ifdef __cplusplus #endif
238static std::string patchSinksToString(const struct audio_patch *patch)
239{
240 std::stringstream ss;
241 for (size_t i = 0; i < patch->num_sinks; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700242 if (i > 0) {
243 ss << "|";
244 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800245 ss << "(" << toString(patch->sinks[i].ext.device.type)
246 << ", " << patch->sinks[i].ext.device.address << ")";
247 }
248 return ss.str();
249}
250
251static std::string patchSourcesToString(const struct audio_patch *patch)
252{
253 std::stringstream ss;
254 for (size_t i = 0; i < patch->num_sources; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700255 if (i > 0) {
256 ss << "|";
257 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800258 ss << "(" << toString(patch->sources[i].ext.device.type)
259 << ", " << patch->sources[i].ext.device.address << ")";
260 }
261 return ss.str();
262}
263
Glenn Kasten03490092014-05-27 12:30:54 -0700264static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
265
266static void sFastTrackMultiplierInit()
267{
268 char value[PROPERTY_VALUE_MAX];
269 if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
270 char *endptr;
271 unsigned long ul = strtoul(value, &endptr, 0);
272 if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
273 sFastTrackMultiplier = (int) ul;
274 }
275 }
276}
277
278// ----------------------------------------------------------------------------
279
Eric Laurent81784c32012-11-19 14:55:58 -0800280#ifdef ADD_BATTERY_DATA
281// To collect the amplifier usage
282static void addBatteryData(uint32_t params) {
283 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
284 if (service == NULL) {
285 // it already logged
286 return;
287 }
288
289 service->addBatteryData(params);
290}
291#endif
292
Andy Hung3f0c9022016-01-15 17:49:46 -0800293// Track the CLOCK_BOOTTIME versus CLOCK_MONOTONIC timebase offset
294struct {
295 // call when you acquire a partial wakelock
296 void acquire(const sp<IBinder> &wakeLockToken) {
297 pthread_mutex_lock(&mLock);
298 if (wakeLockToken.get() == nullptr) {
299 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
300 } else {
301 if (mCount == 0) {
302 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
303 }
304 ++mCount;
305 }
306 pthread_mutex_unlock(&mLock);
307 }
308
309 // call when you release a partial wakelock.
310 void release(const sp<IBinder> &wakeLockToken) {
311 if (wakeLockToken.get() == nullptr) {
312 return;
313 }
314 pthread_mutex_lock(&mLock);
315 if (--mCount < 0) {
316 ALOGE("negative wakelock count");
317 mCount = 0;
318 }
319 pthread_mutex_unlock(&mLock);
320 }
321
322 // retrieves the boottime timebase offset from monotonic.
323 int64_t getBoottimeOffset() {
324 pthread_mutex_lock(&mLock);
325 int64_t boottimeOffset = mBoottimeOffset;
326 pthread_mutex_unlock(&mLock);
327 return boottimeOffset;
328 }
329
330 // Adjusts the timebase offset between TIMEBASE_MONOTONIC
331 // and the selected timebase.
332 // Currently only TIMEBASE_BOOTTIME is allowed.
333 //
334 // This only needs to be called upon acquiring the first partial wakelock
335 // after all other partial wakelocks are released.
336 //
337 // We do an empirical measurement of the offset rather than parsing
338 // /proc/timer_list since the latter is not a formal kernel ABI.
339 static void adjustTimebaseOffset(int64_t *offset, ExtendedTimestamp::Timebase timebase) {
340 int clockbase;
341 switch (timebase) {
342 case ExtendedTimestamp::TIMEBASE_BOOTTIME:
343 clockbase = SYSTEM_TIME_BOOTTIME;
344 break;
345 default:
346 LOG_ALWAYS_FATAL("invalid timebase %d", timebase);
347 break;
348 }
349 // try three times to get the clock offset, choose the one
350 // with the minimum gap in measurements.
351 const int tries = 3;
352 nsecs_t bestGap, measured;
353 for (int i = 0; i < tries; ++i) {
354 const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
355 const nsecs_t tbase = systemTime(clockbase);
356 const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
357 const nsecs_t gap = tmono2 - tmono;
358 if (i == 0 || gap < bestGap) {
359 bestGap = gap;
360 measured = tbase - ((tmono + tmono2) >> 1);
361 }
362 }
363
364 // to avoid micro-adjusting, we don't change the timebase
365 // unless it is significantly different.
366 //
367 // Assumption: It probably takes more than toleranceNs to
368 // suspend and resume the device.
369 static int64_t toleranceNs = 10000; // 10 us
370 if (llabs(*offset - measured) > toleranceNs) {
371 ALOGV("Adjusting timebase offset old: %lld new: %lld",
372 (long long)*offset, (long long)measured);
373 *offset = measured;
374 }
375 }
376
377 pthread_mutex_t mLock;
378 int32_t mCount;
379 int64_t mBoottimeOffset;
380} gBoottime = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; // static, so use POD initialization
Eric Laurent81784c32012-11-19 14:55:58 -0800381
382// ----------------------------------------------------------------------------
383// CPU Stats
384// ----------------------------------------------------------------------------
385
386class CpuStats {
387public:
388 CpuStats();
389 void sample(const String8 &title);
390#ifdef DEBUG_CPU_USAGE
391private:
392 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
Andy Hung16698b82018-08-01 10:48:38 -0700393 audio_utils::Statistics<double> mWcStats; // statistics on thread CPU usage in wall clock ns
Eric Laurent81784c32012-11-19 14:55:58 -0800394
Andy Hung16698b82018-08-01 10:48:38 -0700395 audio_utils::Statistics<double> mHzStats; // statistics on thread CPU usage in cycles
Eric Laurent81784c32012-11-19 14:55:58 -0800396
397 int mCpuNum; // thread's current CPU number
398 int mCpukHz; // frequency of thread's current CPU in kHz
399#endif
400};
401
402CpuStats::CpuStats()
403#ifdef DEBUG_CPU_USAGE
404 : mCpuNum(-1), mCpukHz(-1)
405#endif
406{
407}
408
Glenn Kasten0f11b512014-01-31 16:18:54 -0800409void CpuStats::sample(const String8 &title
410#ifndef DEBUG_CPU_USAGE
411 __unused
412#endif
413 ) {
Eric Laurent81784c32012-11-19 14:55:58 -0800414#ifdef DEBUG_CPU_USAGE
415 // get current thread's delta CPU time in wall clock ns
416 double wcNs;
417 bool valid = mCpuUsage.sampleAndEnable(wcNs);
418
419 // record sample for wall clock statistics
420 if (valid) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700421 mWcStats.add(wcNs);
Eric Laurent81784c32012-11-19 14:55:58 -0800422 }
423
424 // get the current CPU number
425 int cpuNum = sched_getcpu();
426
427 // get the current CPU frequency in kHz
428 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
429
430 // check if either CPU number or frequency changed
431 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
432 mCpuNum = cpuNum;
433 mCpukHz = cpukHz;
434 // ignore sample for purposes of cycles
435 valid = false;
436 }
437
438 // if no change in CPU number or frequency, then record sample for cycle statistics
439 if (valid && mCpukHz > 0) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700440 const double cycles = wcNs * cpukHz * 0.000001;
441 mHzStats.add(cycles);
Eric Laurent81784c32012-11-19 14:55:58 -0800442 }
443
Eric Tan5b13ff82018-07-27 11:20:17 -0700444 const unsigned n = mWcStats.getN();
Eric Laurent81784c32012-11-19 14:55:58 -0800445 // mCpuUsage.elapsed() is expensive, so don't call it every loop
446 if ((n & 127) == 1) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700447 const long long elapsed = mCpuUsage.elapsed();
Eric Laurent81784c32012-11-19 14:55:58 -0800448 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700449 const double perLoop = elapsed / (double) n;
450 const double perLoop100 = perLoop * 0.01;
451 const double perLoop1k = perLoop * 0.001;
452 const double mean = mWcStats.getMean();
453 const double stddev = mWcStats.getStdDev();
454 const double minimum = mWcStats.getMin();
455 const double maximum = mWcStats.getMax();
456 const double meanCycles = mHzStats.getMean();
457 const double stddevCycles = mHzStats.getStdDev();
458 const double minCycles = mHzStats.getMin();
459 const double maxCycles = mHzStats.getMax();
Eric Laurent81784c32012-11-19 14:55:58 -0800460 mCpuUsage.resetElapsed();
461 mWcStats.reset();
462 mHzStats.reset();
463 ALOGD("CPU usage for %s over past %.1f secs\n"
464 " (%u mixer loops at %.1f mean ms per loop):\n"
465 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
466 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
467 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
468 title.string(),
469 elapsed * .000000001, n, perLoop * .000001,
470 mean * .001,
471 stddev * .001,
472 minimum * .001,
473 maximum * .001,
474 mean / perLoop100,
475 stddev / perLoop100,
476 minimum / perLoop100,
477 maximum / perLoop100,
478 meanCycles / perLoop1k,
479 stddevCycles / perLoop1k,
480 minCycles / perLoop1k,
481 maxCycles / perLoop1k);
482
483 }
484 }
485#endif
486};
487
488// ----------------------------------------------------------------------------
489// ThreadBase
490// ----------------------------------------------------------------------------
491
Glenn Kasten97b7b752014-09-28 13:04:24 -0700492// static
493const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
494{
495 switch (type) {
496 case MIXER:
497 return "MIXER";
498 case DIRECT:
499 return "DIRECT";
500 case DUPLICATING:
501 return "DUPLICATING";
502 case RECORD:
503 return "RECORD";
504 case OFFLOAD:
505 return "OFFLOAD";
Andy Hungea840382020-05-05 21:50:17 -0700506 case MMAP_PLAYBACK:
507 return "MMAP_PLAYBACK";
508 case MMAP_CAPTURE:
509 return "MMAP_CAPTURE";
Glenn Kasten97b7b752014-09-28 13:04:24 -0700510 default:
511 return "unknown";
512 }
513}
514
Eric Laurent81784c32012-11-19 14:55:58 -0800515AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -0700516 type_t type, bool systemReady, bool isOut)
Eric Laurent81784c32012-11-19 14:55:58 -0800517 : Thread(false /*canCallJava*/),
518 mType(type),
Glenn Kasten9b58f632013-07-16 11:37:48 -0700519 mAudioFlinger(audioFlinger),
Andy Hungcf10d742020-04-28 15:38:24 -0700520 mThreadMetrics(std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_THREAD) + std::to_string(id),
521 isOut),
522 mIsOut(isOut),
Glenn Kasten70949c42013-08-06 07:40:12 -0700523 // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800524 // are set by PlaybackThread::readOutputParameters_l() or
525 // RecordThread::readInputParameters_l()
Eric Laurentfd477972013-10-25 18:10:40 -0700526 //FIXME: mStandby should be true here. Is this some kind of hack?
jiabinc52b1ff2019-10-31 17:20:42 -0700527 mStandby(false),
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700528 mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
Eric Laurent81784c32012-11-19 14:55:58 -0800529 // mName will be set by concrete (non-virtual) subclass
Eric Laurent72e3f392015-05-20 14:43:50 -0700530 mDeathRecipient(new PMDeathRecipient(this)),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800531 mSystemReady(systemReady),
532 mSignalPending(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800533{
Andy Hungcf10d742020-04-28 15:38:24 -0700534 mThreadMetrics.logConstructor(getpid(), threadTypeToString(type), id);
Eric Laurent296fb132015-05-01 11:38:42 -0700535 memset(&mPatch, 0, sizeof(struct audio_patch));
Eric Laurent81784c32012-11-19 14:55:58 -0800536}
537
538AudioFlinger::ThreadBase::~ThreadBase()
539{
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700540 // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700541 mConfigEvents.clear();
542
Eric Laurent81784c32012-11-19 14:55:58 -0800543 // do not lock the mutex in destructor
544 releaseWakeLock_l();
545 if (mPowerManager != 0) {
Marco Nelissen06b46062014-11-14 07:58:25 -0800546 sp<IBinder> binder = IInterface::asBinder(mPowerManager);
Eric Laurent81784c32012-11-19 14:55:58 -0800547 binder->unlinkToDeath(mDeathRecipient);
548 }
Andy Hungd0979812019-02-21 15:51:44 -0800549
550 sendStatistics(true /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -0800551}
552
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700553status_t AudioFlinger::ThreadBase::readyToRun()
554{
555 status_t status = initCheck();
556 if (status == NO_ERROR) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800557 ALOGI("AudioFlinger's thread %p tid=%d ready to run", this, getTid());
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700558 } else {
559 ALOGE("No working audio driver found.");
560 }
561 return status;
562}
563
Eric Laurent81784c32012-11-19 14:55:58 -0800564void AudioFlinger::ThreadBase::exit()
565{
566 ALOGV("ThreadBase::exit");
567 // do any cleanup required for exit to succeed
568 preExit();
569 {
570 // This lock prevents the following race in thread (uniprocessor for illustration):
571 // if (!exitPending()) {
572 // // context switch from here to exit()
573 // // exit() calls requestExit(), what exitPending() observes
574 // // exit() calls signal(), which is dropped since no waiters
575 // // context switch back from exit() to here
576 // mWaitWorkCV.wait(...);
577 // // now thread is hung
578 // }
579 AutoMutex lock(mLock);
580 requestExit();
581 mWaitWorkCV.broadcast();
582 }
583 // When Thread::requestExitAndWait is made virtual and this method is renamed to
584 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
585 requestExitAndWait();
586}
587
588status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
589{
Eric Laurent81784c32012-11-19 14:55:58 -0800590 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
591 Mutex::Autolock _l(mLock);
592
Eric Laurent10351942014-05-08 18:49:52 -0700593 return sendSetParameterConfigEvent_l(keyValuePairs);
594}
595
596// sendConfigEvent_l() must be called with ThreadBase::mLock held
597// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
598status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
599{
600 status_t status = NO_ERROR;
601
Eric Laurent72e3f392015-05-20 14:43:50 -0700602 if (event->mRequiresSystemReady && !mSystemReady) {
603 event->mWaitStatus = false;
604 mPendingConfigEvents.add(event);
605 return status;
606 }
Eric Laurent10351942014-05-08 18:49:52 -0700607 mConfigEvents.add(event);
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700608 ALOGV("sendConfigEvent_l() num events %zu event %d", mConfigEvents.size(), event->mType);
Eric Laurent81784c32012-11-19 14:55:58 -0800609 mWaitWorkCV.signal();
Eric Laurent10351942014-05-08 18:49:52 -0700610 mLock.unlock();
611 {
612 Mutex::Autolock _l(event->mLock);
613 while (event->mWaitStatus) {
614 if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
615 event->mStatus = TIMED_OUT;
616 event->mWaitStatus = false;
617 }
618 }
619 status = event->mStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800620 }
Eric Laurent10351942014-05-08 18:49:52 -0700621 mLock.lock();
Eric Laurent81784c32012-11-19 14:55:58 -0800622 return status;
623}
624
Eric Laurent09f1ed22019-04-24 17:45:17 -0700625void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event event, pid_t pid,
626 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800627{
628 Mutex::Autolock _l(mLock);
Eric Laurent09f1ed22019-04-24 17:45:17 -0700629 sendIoConfigEvent_l(event, pid, portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800630}
631
632// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
Eric Laurent09f1ed22019-04-24 17:45:17 -0700633void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event event, pid_t pid,
634 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800635{
Andy Hungd0979812019-02-21 15:51:44 -0800636 // The audio statistics history is exponentially weighted to forget events
637 // about five or more seconds in the past. In order to have
638 // crisper statistics for mediametrics, we reset the statistics on
639 // an IoConfigEvent, to reflect different properties for a new device.
640 mIoJitterMs.reset();
641 mLatencyMs.reset();
642 mProcessTimeMs.reset();
Dean Wheatley12473e92021-03-18 23:00:55 +1100643 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS);
Andy Hungd0979812019-02-21 15:51:44 -0800644
Eric Laurent09f1ed22019-04-24 17:45:17 -0700645 sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700646 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800647}
648
Mikhail Naganov83f04272017-02-07 10:45:09 -0800649void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent72e3f392015-05-20 14:43:50 -0700650{
651 Mutex::Autolock _l(mLock);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800652 sendPrioConfigEvent_l(pid, tid, prio, forApp);
Eric Laurent72e3f392015-05-20 14:43:50 -0700653}
654
Eric Laurent81784c32012-11-19 14:55:58 -0800655// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
Mikhail Naganov83f04272017-02-07 10:45:09 -0800656void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(
657 pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent81784c32012-11-19 14:55:58 -0800658{
Mikhail Naganov83f04272017-02-07 10:45:09 -0800659 sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700660 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800661}
662
Eric Laurent10351942014-05-08 18:49:52 -0700663// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
664status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
Eric Laurent81784c32012-11-19 14:55:58 -0800665{
Andy Hung2ddee192015-12-18 17:34:44 -0800666 sp<ConfigEvent> configEvent;
667 AudioParameter param(keyValuePair);
668 int value;
Mikhail Naganov00260b52016-10-13 12:54:24 -0700669 if (param.getInt(String8(AudioParameter::keyMonoOutput), value) == NO_ERROR) {
Andy Hung2ddee192015-12-18 17:34:44 -0800670 setMasterMono_l(value != 0);
671 if (param.size() == 1) {
672 return NO_ERROR; // should be a solo parameter - we don't pass down
673 }
Mikhail Naganov00260b52016-10-13 12:54:24 -0700674 param.remove(String8(AudioParameter::keyMonoOutput));
Andy Hung2ddee192015-12-18 17:34:44 -0800675 configEvent = new SetParameterConfigEvent(param.toString());
676 } else {
677 configEvent = new SetParameterConfigEvent(keyValuePair);
678 }
Eric Laurent10351942014-05-08 18:49:52 -0700679 return sendConfigEvent_l(configEvent);
Glenn Kastenf7773312013-08-13 16:00:42 -0700680}
681
Eric Laurent1c333e22014-05-20 10:48:17 -0700682status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
683 const struct audio_patch *patch,
684 audio_patch_handle_t *handle)
685{
686 Mutex::Autolock _l(mLock);
687 sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
688 status_t status = sendConfigEvent_l(configEvent);
689 if (status == NO_ERROR) {
690 CreateAudioPatchConfigEventData *data =
691 (CreateAudioPatchConfigEventData *)configEvent->mData.get();
692 *handle = data->mHandle;
693 }
694 return status;
695}
696
697status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
698 const audio_patch_handle_t handle)
699{
700 Mutex::Autolock _l(mLock);
701 sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
702 return sendConfigEvent_l(configEvent);
703}
704
jiabinc52b1ff2019-10-31 17:20:42 -0700705status_t AudioFlinger::ThreadBase::sendUpdateOutDeviceConfigEvent(
706 const DeviceDescriptorBaseVector& outDevices)
707{
708 if (type() != RECORD) {
709 // The update out device operation is only for record thread.
710 return INVALID_OPERATION;
711 }
712 Mutex::Autolock _l(mLock);
713 sp<ConfigEvent> configEvent = (ConfigEvent *)new UpdateOutDevicesConfigEvent(outDevices);
714 return sendConfigEvent_l(configEvent);
715}
716
Eric Laurentec376dc2021-04-08 20:41:22 +0200717void AudioFlinger::ThreadBase::sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs)
718{
719 ALOG_ASSERT(type() == RECORD, "sendResizeBufferConfigEvent_l() called on non record thread");
720 sp<ConfigEvent> configEvent =
721 (ConfigEvent *)new ResizeBufferConfigEvent(maxSharedAudioHistoryMs);
722 sendConfigEvent_l(configEvent);
723}
Eric Laurent1c333e22014-05-20 10:48:17 -0700724
Glenn Kasten2cfbf882013-08-14 13:12:11 -0700725// post condition: mConfigEvents.isEmpty()
Eric Laurent021cf962014-05-13 10:18:14 -0700726void AudioFlinger::ThreadBase::processConfigEvents_l()
Glenn Kastenf7773312013-08-13 16:00:42 -0700727{
Eric Laurent10351942014-05-08 18:49:52 -0700728 bool configChanged = false;
729
Eric Laurent81784c32012-11-19 14:55:58 -0800730 while (!mConfigEvents.isEmpty()) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700731 ALOGV("processConfigEvents_l() remaining events %zu", mConfigEvents.size());
Eric Laurent10351942014-05-08 18:49:52 -0700732 sp<ConfigEvent> event = mConfigEvents[0];
Eric Laurent81784c32012-11-19 14:55:58 -0800733 mConfigEvents.removeAt(0);
Eric Laurent10351942014-05-08 18:49:52 -0700734 switch (event->mType) {
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700735 case CFG_EVENT_PRIO: {
Eric Laurent10351942014-05-08 18:49:52 -0700736 PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
737 // FIXME Need to understand why this has to be done asynchronously
Mikhail Naganov83f04272017-02-07 10:45:09 -0800738 int err = requestPriority(data->mPid, data->mTid, data->mPrio, data->mForApp,
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700739 true /*asynchronous*/);
740 if (err != 0) {
741 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
Eric Laurent10351942014-05-08 18:49:52 -0700742 data->mPrio, data->mPid, data->mTid, err);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700743 }
744 } break;
745 case CFG_EVENT_IO: {
Eric Laurent10351942014-05-08 18:49:52 -0700746 IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
Eric Laurent09f1ed22019-04-24 17:45:17 -0700747 ioConfigChanged(data->mEvent, data->mPid, data->mPortId);
Eric Laurent10351942014-05-08 18:49:52 -0700748 } break;
749 case CFG_EVENT_SET_PARAMETER: {
750 SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
751 if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
752 configChanged = true;
Andy Hung293558a2017-03-21 12:19:20 -0700753 mLocalLog.log("CFG_EVENT_SET_PARAMETER: (%s) configuration changed",
754 data->mKeyValuePairs.string());
Glenn Kastend5418eb2013-08-14 13:11:06 -0700755 }
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700756 } break;
Eric Laurent1c333e22014-05-20 10:48:17 -0700757 case CFG_EVENT_CREATE_AUDIO_PATCH: {
jiabinc52b1ff2019-10-31 17:20:42 -0700758 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700759 CreateAudioPatchConfigEventData *data =
760 (CreateAudioPatchConfigEventData *)event->mData.get();
761 event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
jiabinc52b1ff2019-10-31 17:20:42 -0700762 const DeviceTypeSet newDevices = getDeviceTypes();
763 mLocalLog.log("CFG_EVENT_CREATE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
764 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
765 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -0700766 } break;
767 case CFG_EVENT_RELEASE_AUDIO_PATCH: {
jiabinc52b1ff2019-10-31 17:20:42 -0700768 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700769 ReleaseAudioPatchConfigEventData *data =
770 (ReleaseAudioPatchConfigEventData *)event->mData.get();
771 event->mStatus = releaseAudioPatch_l(data->mHandle);
jiabinc52b1ff2019-10-31 17:20:42 -0700772 const DeviceTypeSet newDevices = getDeviceTypes();
773 mLocalLog.log("CFG_EVENT_RELEASE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
774 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
775 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
776 } break;
777 case CFG_EVENT_UPDATE_OUT_DEVICE: {
778 UpdateOutDevicesConfigEventData *data =
779 (UpdateOutDevicesConfigEventData *)event->mData.get();
780 updateOutDevices(data->mOutDevices);
Eric Laurent1c333e22014-05-20 10:48:17 -0700781 } break;
Eric Laurentec376dc2021-04-08 20:41:22 +0200782 case CFG_EVENT_RESIZE_BUFFER: {
783 ResizeBufferConfigEventData *data =
784 (ResizeBufferConfigEventData *)event->mData.get();
785 resizeInputBuffer_l(data->mMaxSharedAudioHistoryMs);
786 } break;
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700787 default:
Eric Laurent10351942014-05-08 18:49:52 -0700788 ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700789 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800790 }
Eric Laurent10351942014-05-08 18:49:52 -0700791 {
792 Mutex::Autolock _l(event->mLock);
793 if (event->mWaitStatus) {
794 event->mWaitStatus = false;
795 event->mCond.signal();
796 }
797 }
798 ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
799 }
800
801 if (configChanged) {
802 cacheParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800803 }
Eric Laurent81784c32012-11-19 14:55:58 -0800804}
805
Marco Nelissenb2208842014-02-07 14:00:50 -0800806String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
807 String8 s;
Glenn Kastene1635ec2015-06-08 15:46:49 -0700808 const audio_channel_representation_t representation =
809 audio_channel_mask_get_representation(mask);
Andy Hungf98ec8d2015-05-19 12:53:24 -0700810
811 switch (representation) {
jiabin245cdd92018-12-07 17:55:15 -0800812 // Travel all single bit channel mask to convert channel mask to string.
Andy Hungf98ec8d2015-05-19 12:53:24 -0700813 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
814 if (output) {
815 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
816 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
817 if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
Andy Hungfba71252021-05-07 11:58:32 -0700818 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low-frequency, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700819 if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
820 if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
821 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
822 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
823 if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
824 if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
825 if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
826 if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
827 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
828 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
829 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
830 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700831 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, ");
832 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, ");
833 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT) s.append("top-side-left, ");
834 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT) s.append("top-side-right, ");
835 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_LEFT) s.append("bottom-front-left, ");
836 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_CENTER) s.append("bottom-front-center, ");
837 if (mask & AUDIO_CHANNEL_OUT_BOTTOM_FRONT_RIGHT) s.append("bottom-front-right, ");
Andy Hungfba71252021-05-07 11:58:32 -0700838 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY_2) s.append("low-frequency-2, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700839 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_B) s.append("haptic-B, ");
840 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_A) s.append("haptic-A, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700841 if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown, ");
842 } else {
843 if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
844 if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
845 if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
846 if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
847 if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
848 if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
849 if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
850 if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
851 if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
852 if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
853 if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
854 if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
Mikhail Naganovc9948492018-05-10 17:25:28 -0700855 if (mask & AUDIO_CHANNEL_IN_BACK_LEFT) s.append("back-left, ");
856 if (mask & AUDIO_CHANNEL_IN_BACK_RIGHT) s.append("back-right, ");
857 if (mask & AUDIO_CHANNEL_IN_CENTER) s.append("center, ");
Andy Hungfba71252021-05-07 11:58:32 -0700858 if (mask & AUDIO_CHANNEL_IN_LOW_FREQUENCY) s.append("low-frequency, ");
Andy Hungae81b4c2021-05-07 08:54:28 -0700859 if (mask & AUDIO_CHANNEL_IN_TOP_LEFT) s.append("top-left, ");
860 if (mask & AUDIO_CHANNEL_IN_TOP_RIGHT) s.append("top-right, ");
Andy Hungf98ec8d2015-05-19 12:53:24 -0700861 if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
862 if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
863 if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown, ");
864 }
865 const int len = s.length();
866 if (len > 2) {
Glenn Kasten57c4e6f2016-03-18 14:54:07 -0700867 (void) s.lockBuffer(len); // needed?
Andy Hungf98ec8d2015-05-19 12:53:24 -0700868 s.unlockBuffer(len - 2); // remove trailing ", "
869 }
870 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800871 }
Andy Hungf98ec8d2015-05-19 12:53:24 -0700872 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
873 s.appendFormat("index mask, bits:%#x", audio_channel_mask_get_bits(mask));
874 return s;
875 default:
876 s.appendFormat("unknown mask, representation:%d bits:%#x",
877 representation, audio_channel_mask_get_bits(mask));
878 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800879 }
Marco Nelissenb2208842014-02-07 14:00:50 -0800880}
881
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700882void AudioFlinger::ThreadBase::dump(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800883{
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800884 dprintf(fd, "\n%s thread %p, name %s, tid %d, type %d (%s):\n", isOutput() ? "Output" : "Input",
885 this, mThreadName, getTid(), type(), threadTypeToString(type()));
886
Eric Laurent81784c32012-11-19 14:55:58 -0800887 bool locked = AudioFlinger::dumpTryLock(mLock);
888 if (!locked) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800889 dprintf(fd, " Thread may be deadlocked\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800890 }
891
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700892 dumpBase_l(fd, args);
893 dumpInternals_l(fd, args);
894 dumpTracks_l(fd, args);
895 dumpEffectChains_l(fd, args);
896
897 if (locked) {
898 mLock.unlock();
899 }
900
901 dprintf(fd, " Local log:\n");
902 mLocalLog.dump(fd, " " /* prefix */, 40 /* lines */);
903}
904
905void AudioFlinger::ThreadBase::dumpBase_l(int fd, const Vector<String16>& args __unused)
906{
Elliott Hughes87cebad2014-05-22 10:14:43 -0700907 dprintf(fd, " I/O handle: %d\n", mId);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700908 dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
Glenn Kasten97b7b752014-09-28 13:04:24 -0700909 dprintf(fd, " Sample rate: %u Hz\n", mSampleRate);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700910 dprintf(fd, " HAL frame count: %zu\n", mFrameCount);
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700911 dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat).c_str());
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700912 dprintf(fd, " HAL buffer size: %zu bytes\n", mBufferSize);
Glenn Kasten97b7b752014-09-28 13:04:24 -0700913 dprintf(fd, " Channel count: %u\n", mChannelCount);
914 dprintf(fd, " Channel mask: 0x%08x (%s)\n", mChannelMask,
Marco Nelissenb2208842014-02-07 14:00:50 -0800915 channelMaskToString(mChannelMask, mType != RECORD).string());
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700916 dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat).c_str());
Glenn Kastenf87c2f52015-08-21 08:03:57 -0700917 dprintf(fd, " Processing frame size: %zu bytes\n", mFrameSize);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700918 dprintf(fd, " Pending config events:");
Marco Nelissenb2208842014-02-07 14:00:50 -0800919 size_t numConfig = mConfigEvents.size();
920 if (numConfig) {
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700921 const size_t SIZE = 256;
922 char buffer[SIZE];
Marco Nelissenb2208842014-02-07 14:00:50 -0800923 for (size_t i = 0; i < numConfig; i++) {
924 mConfigEvents[i]->dump(buffer, SIZE);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700925 dprintf(fd, "\n %s", buffer);
Marco Nelissenb2208842014-02-07 14:00:50 -0800926 }
Elliott Hughes87cebad2014-05-22 10:14:43 -0700927 dprintf(fd, "\n");
Marco Nelissenb2208842014-02-07 14:00:50 -0800928 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -0700929 dprintf(fd, " none\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800930 }
Andy Hung293558a2017-03-21 12:19:20 -0700931 // Note: output device may be used by capture threads for effects such as AEC.
jiabinc52b1ff2019-10-31 17:20:42 -0700932 dprintf(fd, " Output devices: %s (%s)\n",
933 dumpDeviceTypes(outDeviceTypes()).c_str(), toString(outDeviceTypes()).c_str());
934 dprintf(fd, " Input device: %#x (%s)\n",
935 inDeviceType(), toString(inDeviceType()).c_str());
Andy Hung9b181952019-02-25 14:53:36 -0800936 dprintf(fd, " Audio source: %d (%s)\n", mAudioSource, toString(mAudioSource).c_str());
Eric Laurent81784c32012-11-19 14:55:58 -0800937
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700938 // Dump timestamp statistics for the Thread types that support it.
939 if (mType == RECORD
940 || mType == MIXER
941 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -0700942 || mType == DIRECT
943 || mType == OFFLOAD) {
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700944 dprintf(fd, " Timestamp stats: %s\n", mTimestampVerifier.toString().c_str());
Andy Hungc8fddf32018-08-08 18:32:37 -0700945 dprintf(fd, " Timestamp corrected: %s\n", isTimestampCorrectionEnabled() ? "yes" : "no");
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700946 }
947
Andy Hung446f4df2019-02-21 12:26:41 -0800948 if (mLastIoBeginNs > 0) { // MMAP may not set this
949 dprintf(fd, " Last %s occurred (msecs): %lld\n",
950 isOutput() ? "write" : "read",
951 (long long) (systemTime() - mLastIoBeginNs) / NANOS_PER_MILLISECOND);
952 }
953
954 if (mProcessTimeMs.getN() > 0) {
955 dprintf(fd, " Process time ms stats: %s\n", mProcessTimeMs.toString().c_str());
956 }
957
958 if (mIoJitterMs.getN() > 0) {
959 dprintf(fd, " Hal %s jitter ms stats: %s\n",
960 isOutput() ? "write" : "read",
961 mIoJitterMs.toString().c_str());
962 }
963
Andy Hunge6c37112019-02-26 17:38:10 -0800964 if (mLatencyMs.getN() > 0) {
965 dprintf(fd, " Threadloop %s latency stats: %s\n",
966 isOutput() ? "write" : "read",
967 mLatencyMs.toString().c_str());
968 }
Eric Laurent81784c32012-11-19 14:55:58 -0800969}
970
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700971void AudioFlinger::ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800972{
973 const size_t SIZE = 256;
974 char buffer[SIZE];
Eric Laurent81784c32012-11-19 14:55:58 -0800975
Marco Nelissenb2208842014-02-07 14:00:50 -0800976 size_t numEffectChains = mEffectChains.size();
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +0000977 snprintf(buffer, SIZE, " %zu Effect Chains\n", numEffectChains);
Eric Laurent81784c32012-11-19 14:55:58 -0800978 write(fd, buffer, strlen(buffer));
979
Marco Nelissenb2208842014-02-07 14:00:50 -0800980 for (size_t i = 0; i < numEffectChains; ++i) {
Eric Laurent81784c32012-11-19 14:55:58 -0800981 sp<EffectChain> chain = mEffectChains[i];
982 if (chain != 0) {
983 chain->dump(fd, args);
984 }
985 }
986}
987
Andy Hungdae27702016-10-31 14:01:16 -0700988void AudioFlinger::ThreadBase::acquireWakeLock()
Eric Laurent81784c32012-11-19 14:55:58 -0800989{
990 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -0700991 acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800992}
993
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100994String16 AudioFlinger::ThreadBase::getWakeLockTag()
995{
996 switch (mType) {
Glenn Kastenbcb14862015-03-05 17:11:21 -0800997 case MIXER:
998 return String16("AudioMix");
999 case DIRECT:
1000 return String16("AudioDirectOut");
1001 case DUPLICATING:
1002 return String16("AudioDup");
1003 case RECORD:
1004 return String16("AudioIn");
1005 case OFFLOAD:
1006 return String16("AudioOffload");
Andy Hungea840382020-05-05 21:50:17 -07001007 case MMAP_PLAYBACK:
1008 return String16("MmapPlayback");
1009 case MMAP_CAPTURE:
1010 return String16("MmapCapture");
Glenn Kastenbcb14862015-03-05 17:11:21 -08001011 default:
1012 ALOG_ASSERT(false);
1013 return String16("AudioUnknown");
Narayan Kamath014e7fa2013-10-14 15:03:38 +01001014 }
1015}
1016
Andy Hungdae27702016-10-31 14:01:16 -07001017void AudioFlinger::ThreadBase::acquireWakeLock_l()
Eric Laurent81784c32012-11-19 14:55:58 -08001018{
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001019 getPowerManager_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001020 if (mPowerManager != 0) {
1021 sp<IBinder> binder = new BBinder();
Andy Hungdae27702016-10-31 14:01:16 -07001022 // Uses AID_AUDIOSERVER for wakelock. updateWakeLockUids_l() updates with client uids.
Chris Ye6597d732020-02-28 22:38:25 -08001023 binder::Status status = mPowerManager->acquireWakeLockAsync(binder,
1024 POWERMANAGER_PARTIAL_WAKE_LOCK,
Narayan Kamath014e7fa2013-10-14 15:03:38 +01001025 getWakeLockTag(),
Marco Nelissendcb346b2015-09-09 10:47:29 -07001026 String16("audioserver"),
Chris Ye6597d732020-02-28 22:38:25 -08001027 {} /* workSource */,
1028 {} /* historyTag */);
1029 if (status.isOk()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001030 mWakeLockToken = binder;
1031 }
Chris Ye6597d732020-02-28 22:38:25 -08001032 ALOGV("acquireWakeLock_l() %s status %d", mThreadName, status.exceptionCode());
Eric Laurent81784c32012-11-19 14:55:58 -08001033 }
Wei Jia3f273d12015-11-24 09:06:49 -08001034
Andy Hung3f0c9022016-01-15 17:49:46 -08001035 gBoottime.acquire(mWakeLockToken);
Andy Hung818e7a32016-02-16 18:08:07 -08001036 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
1037 gBoottime.getBoottimeOffset();
Eric Laurent81784c32012-11-19 14:55:58 -08001038}
1039
1040void AudioFlinger::ThreadBase::releaseWakeLock()
1041{
1042 Mutex::Autolock _l(mLock);
1043 releaseWakeLock_l();
1044}
1045
1046void AudioFlinger::ThreadBase::releaseWakeLock_l()
1047{
Andy Hung3f0c9022016-01-15 17:49:46 -08001048 gBoottime.release(mWakeLockToken);
Eric Laurent81784c32012-11-19 14:55:58 -08001049 if (mWakeLockToken != 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001050 ALOGV("releaseWakeLock_l() %s", mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001051 if (mPowerManager != 0) {
Chris Ye6597d732020-02-28 22:38:25 -08001052 mPowerManager->releaseWakeLockAsync(mWakeLockToken, 0);
Eric Laurent81784c32012-11-19 14:55:58 -08001053 }
1054 mWakeLockToken.clear();
1055 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001056}
1057
1058void AudioFlinger::ThreadBase::getPowerManager_l() {
Eric Laurent72e3f392015-05-20 14:43:50 -07001059 if (mSystemReady && mPowerManager == 0) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001060 // use checkService() to avoid blocking if power service is not up yet
1061 sp<IBinder> binder =
1062 defaultServiceManager()->checkService(String16("power"));
1063 if (binder == 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001064 ALOGW("Thread %s cannot connect to the power manager service", mThreadName);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001065 } else {
Chris Ye6597d732020-02-28 22:38:25 -08001066 mPowerManager = interface_cast<os::IPowerManager>(binder);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001067 binder->linkToDeath(mDeathRecipient);
1068 }
1069 }
1070}
1071
Andy Hungd01b0f12016-11-07 16:10:30 -08001072void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t> &uids) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001073 getPowerManager_l();
Andy Hungdae27702016-10-31 14:01:16 -07001074
1075#if !LOG_NDEBUG
1076 std::stringstream s;
Andy Hungd01b0f12016-11-07 16:10:30 -08001077 for (uid_t uid : uids) {
Andy Hungdae27702016-10-31 14:01:16 -07001078 s << uid << " ";
1079 }
1080 ALOGD("updateWakeLockUids_l %s uids:%s", mThreadName, s.str().c_str());
1081#endif
1082
Andy Hung438e7572015-12-14 15:51:17 -08001083 if (mWakeLockToken == NULL) { // token may be NULL if AudioFlinger::systemReady() not called.
1084 if (mSystemReady) {
1085 ALOGE("no wake lock to update, but system ready!");
1086 } else {
1087 ALOGW("no wake lock to update, system not ready yet");
1088 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001089 return;
1090 }
1091 if (mPowerManager != 0) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08001092 std::vector<int> uidsAsInt(uids.begin(), uids.end()); // powermanager expects uids as ints
Chris Ye6597d732020-02-28 22:38:25 -08001093 binder::Status status = mPowerManager->updateWakeLockUidsAsync(
1094 mWakeLockToken, uidsAsInt);
1095 ALOGV("updateWakeLockUids_l() %s status %d", mThreadName, status.exceptionCode());
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001096 }
1097}
1098
Eric Laurent81784c32012-11-19 14:55:58 -08001099void AudioFlinger::ThreadBase::clearPowerManager()
1100{
1101 Mutex::Autolock _l(mLock);
1102 releaseWakeLock_l();
1103 mPowerManager.clear();
1104}
1105
jiabinc52b1ff2019-10-31 17:20:42 -07001106void AudioFlinger::ThreadBase::updateOutDevices(
1107 const DeviceDescriptorBaseVector& outDevices __unused)
1108{
1109 ALOGE("%s should only be called in RecordThread", __func__);
1110}
1111
Eric Laurentec376dc2021-04-08 20:41:22 +02001112void AudioFlinger::ThreadBase::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs __unused)
1113{
1114 ALOGE("%s should only be called in RecordThread", __func__);
1115}
1116
Glenn Kasten0f11b512014-01-31 16:18:54 -08001117void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001118{
1119 sp<ThreadBase> thread = mThread.promote();
1120 if (thread != 0) {
1121 thread->clearPowerManager();
1122 }
1123 ALOGW("power manager service died !!!");
1124}
1125
Eric Laurent81784c32012-11-19 14:55:58 -08001126void AudioFlinger::ThreadBase::setEffectSuspended_l(
Glenn Kastend848eb42016-03-08 13:42:11 -08001127 const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001128{
1129 sp<EffectChain> chain = getEffectChain_l(sessionId);
1130 if (chain != 0) {
1131 if (type != NULL) {
1132 chain->setEffectSuspended_l(type, suspend);
1133 } else {
1134 chain->setEffectSuspendedAll_l(suspend);
1135 }
1136 }
1137
1138 updateSuspendedSessions_l(type, suspend, sessionId);
1139}
1140
1141void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1142{
1143 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
1144 if (index < 0) {
1145 return;
1146 }
1147
1148 const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
1149 mSuspendedSessions.valueAt(index);
1150
1151 for (size_t i = 0; i < sessionEffects.size(); i++) {
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001152 const sp<SuspendedSessionDesc>& desc = sessionEffects.valueAt(i);
Eric Laurent81784c32012-11-19 14:55:58 -08001153 for (int j = 0; j < desc->mRefCount; j++) {
1154 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1155 chain->setEffectSuspendedAll_l(true);
1156 } else {
1157 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1158 desc->mType.timeLow);
1159 chain->setEffectSuspended_l(&desc->mType, true);
1160 }
1161 }
1162 }
1163}
1164
1165void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1166 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -08001167 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001168{
1169 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
1170
1171 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1172
1173 if (suspend) {
1174 if (index >= 0) {
1175 sessionEffects = mSuspendedSessions.valueAt(index);
1176 } else {
1177 mSuspendedSessions.add(sessionId, sessionEffects);
1178 }
1179 } else {
1180 if (index < 0) {
1181 return;
1182 }
1183 sessionEffects = mSuspendedSessions.valueAt(index);
1184 }
1185
1186
1187 int key = EffectChain::kKeyForSuspendAll;
1188 if (type != NULL) {
1189 key = type->timeLow;
1190 }
1191 index = sessionEffects.indexOfKey(key);
1192
1193 sp<SuspendedSessionDesc> desc;
1194 if (suspend) {
1195 if (index >= 0) {
1196 desc = sessionEffects.valueAt(index);
1197 } else {
1198 desc = new SuspendedSessionDesc();
1199 if (type != NULL) {
1200 desc->mType = *type;
1201 }
1202 sessionEffects.add(key, desc);
1203 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1204 }
1205 desc->mRefCount++;
1206 } else {
1207 if (index < 0) {
1208 return;
1209 }
1210 desc = sessionEffects.valueAt(index);
1211 if (--desc->mRefCount == 0) {
1212 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1213 sessionEffects.removeItemsAt(index);
1214 if (sessionEffects.isEmpty()) {
1215 ALOGV("updateSuspendedSessions_l() restore removing session %d",
1216 sessionId);
1217 mSuspendedSessions.removeItem(sessionId);
1218 }
1219 }
1220 }
1221 if (!sessionEffects.isEmpty()) {
1222 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1223 }
1224}
1225
Eric Laurent6b446ce2019-12-13 10:56:31 -08001226void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
1227 audio_session_t sessionId,
1228 bool threadLocked) {
1229 if (!threadLocked) {
1230 mLock.lock();
1231 }
Eric Laurent81784c32012-11-19 14:55:58 -08001232
Eric Laurent81784c32012-11-19 14:55:58 -08001233 if (mType != RECORD) {
1234 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1235 // another session. This gives the priority to well behaved effect control panels
1236 // and applications not using global effects.
1237 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1238 // global effects
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001239 if (!audio_is_global_session(sessionId)) {
Eric Laurent81784c32012-11-19 14:55:58 -08001240 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1241 }
1242 }
1243
Eric Laurent6b446ce2019-12-13 10:56:31 -08001244 if (!threadLocked) {
1245 mLock.unlock();
Eric Laurent81784c32012-11-19 14:55:58 -08001246 }
1247}
1248
Eric Laurent4c415062016-06-17 16:14:16 -07001249// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1250status_t AudioFlinger::RecordThread::checkEffectCompatibility_l(
1251 const effect_descriptor_t *desc, audio_session_t sessionId)
1252{
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001253 // No global output effect sessions on record threads
1254 if (sessionId == AUDIO_SESSION_OUTPUT_MIX
1255 || sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Eric Laurent4c415062016-06-17 16:14:16 -07001256 ALOGW("checkEffectCompatibility_l(): global effect %s on record thread %s",
1257 desc->name, mThreadName);
1258 return BAD_VALUE;
1259 }
1260 // only pre processing effects on record thread
1261 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) {
1262 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on record thread %s",
1263 desc->name, mThreadName);
1264 return BAD_VALUE;
1265 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001266
1267 // always allow effects without processing load or latency
1268 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1269 return NO_ERROR;
1270 }
1271
Eric Laurent4c415062016-06-17 16:14:16 -07001272 audio_input_flags_t flags = mInput->flags;
1273 if (hasFastCapture() || (flags & AUDIO_INPUT_FLAG_FAST)) {
1274 if (flags & AUDIO_INPUT_FLAG_RAW) {
1275 ALOGW("checkEffectCompatibility_l(): effect %s on record thread %s in raw mode",
1276 desc->name, mThreadName);
1277 return BAD_VALUE;
1278 }
1279 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1280 ALOGW("checkEffectCompatibility_l(): non HW effect %s on record thread %s in fast mode",
1281 desc->name, mThreadName);
1282 return BAD_VALUE;
1283 }
1284 }
jiabineb3bda02020-06-30 14:07:03 -07001285
1286 if (EffectModule::isHapticGenerator(&desc->type)) {
1287 ALOGE("%s(): HapticGenerator is not supported in RecordThread", __func__);
1288 return BAD_VALUE;
1289 }
Eric Laurent4c415062016-06-17 16:14:16 -07001290 return NO_ERROR;
1291}
1292
1293// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1294status_t AudioFlinger::PlaybackThread::checkEffectCompatibility_l(
1295 const effect_descriptor_t *desc, audio_session_t sessionId)
1296{
1297 // no preprocessing on playback threads
1298 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) {
1299 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback"
1300 " thread %s", desc->name, mThreadName);
1301 return BAD_VALUE;
1302 }
1303
Eric Laurent3e4de772017-07-16 16:55:08 -07001304 // always allow effects without processing load or latency
1305 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1306 return NO_ERROR;
1307 }
1308
jiabineb3bda02020-06-30 14:07:03 -07001309 if (EffectModule::isHapticGenerator(&desc->type) && mHapticChannelCount == 0) {
1310 ALOGW("%s: thread doesn't support haptic playback while the effect is HapticGenerator",
1311 __func__);
1312 return BAD_VALUE;
1313 }
1314
Eric Laurent4c415062016-06-17 16:14:16 -07001315 switch (mType) {
1316 case MIXER: {
Andy Hung9aad48c2017-11-29 10:29:19 -08001317#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001318 // Reject any effect on mixer multichannel sinks.
1319 // TODO: fix both format and multichannel issues with effects.
1320 if (mChannelCount != FCC_2) {
1321 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d) on MIXER"
1322 " thread %s", desc->name, mChannelCount, mThreadName);
1323 return BAD_VALUE;
1324 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001325#endif
Eric Laurent4c415062016-06-17 16:14:16 -07001326 audio_output_flags_t flags = mOutput->flags;
1327 if (hasFastMixer() || (flags & AUDIO_OUTPUT_FLAG_FAST)) {
1328 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1329 // global effects are applied only to non fast tracks if they are SW
1330 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1331 break;
1332 }
1333 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1334 // only post processing on output stage session
1335 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1336 ALOGW("checkEffectCompatibility_l(): non post processing effect %s not allowed"
1337 " on output stage session", desc->name);
1338 return BAD_VALUE;
1339 }
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001340 } else if (sessionId == AUDIO_SESSION_DEVICE) {
1341 // only post processing on output stage session
1342 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1343 ALOGW("checkEffectCompatibility_l(): non post processing effect %s not allowed"
1344 " on device session", desc->name);
1345 return BAD_VALUE;
1346 }
Eric Laurent4c415062016-06-17 16:14:16 -07001347 } else {
1348 // no restriction on effects applied on non fast tracks
1349 if ((hasAudioSession_l(sessionId) & ThreadBase::FAST_SESSION) == 0) {
1350 break;
1351 }
1352 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001353
Eric Laurent4c415062016-06-17 16:14:16 -07001354 if (flags & AUDIO_OUTPUT_FLAG_RAW) {
1355 ALOGW("checkEffectCompatibility_l(): effect %s on playback thread in raw mode",
1356 desc->name);
1357 return BAD_VALUE;
1358 }
1359 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1360 ALOGW("checkEffectCompatibility_l(): non HW effect %s on playback thread"
1361 " in fast mode", desc->name);
1362 return BAD_VALUE;
1363 }
1364 }
1365 } break;
1366 case OFFLOAD:
Jean-Michel Trivi773ee952016-07-11 16:53:18 -07001367 // nothing actionable on offload threads, if the effect:
1368 // - is offloadable: the effect can be created
1369 // - is NOT offloadable: the effect should still be created, but EffectHandle::enable()
1370 // will take care of invalidating the tracks of the thread
Eric Laurent4c415062016-06-17 16:14:16 -07001371 break;
1372 case DIRECT:
1373 // Reject any effect on Direct output threads for now, since the format of
1374 // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
1375 ALOGW("checkEffectCompatibility_l(): effect %s on DIRECT output thread %s",
1376 desc->name, mThreadName);
1377 return BAD_VALUE;
1378 case DUPLICATING:
Andy Hung9aad48c2017-11-29 10:29:19 -08001379#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001380 // Reject any effect on mixer multichannel sinks.
1381 // TODO: fix both format and multichannel issues with effects.
1382 if (mChannelCount != FCC_2) {
1383 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d)"
1384 " on DUPLICATING thread %s", desc->name, mChannelCount, mThreadName);
1385 return BAD_VALUE;
1386 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001387#endif
Eric Laurent3f75a5b2019-11-12 15:55:51 -08001388 if (audio_is_global_session(sessionId)) {
Eric Laurent4c415062016-06-17 16:14:16 -07001389 ALOGW("checkEffectCompatibility_l(): global effect %s on DUPLICATING"
1390 " thread %s", desc->name, mThreadName);
1391 return BAD_VALUE;
1392 }
1393 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
1394 ALOGW("checkEffectCompatibility_l(): post processing effect %s on"
1395 " DUPLICATING thread %s", desc->name, mThreadName);
1396 return BAD_VALUE;
1397 }
1398 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) != 0) {
1399 ALOGW("checkEffectCompatibility_l(): HW tunneled effect %s on"
1400 " DUPLICATING thread %s", desc->name, mThreadName);
1401 return BAD_VALUE;
1402 }
1403 break;
1404 default:
1405 LOG_ALWAYS_FATAL("checkEffectCompatibility_l(): wrong thread type %d", mType);
1406 }
1407
1408 return NO_ERROR;
1409}
1410
Eric Laurent81784c32012-11-19 14:55:58 -08001411// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
1412sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
1413 const sp<AudioFlinger::Client>& client,
1414 const sp<IEffectClient>& effectClient,
1415 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -08001416 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -08001417 effect_descriptor_t *desc,
1418 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001419 status_t *status,
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001420 bool pinned,
1421 bool probe)
Eric Laurent81784c32012-11-19 14:55:58 -08001422{
1423 sp<EffectModule> effect;
1424 sp<EffectHandle> handle;
1425 status_t lStatus;
1426 sp<EffectChain> chain;
1427 bool chainCreated = false;
1428 bool effectCreated = false;
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001429 audio_unique_id_t effectId = AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
Eric Laurent81784c32012-11-19 14:55:58 -08001430
1431 lStatus = initCheck();
1432 if (lStatus != NO_ERROR) {
1433 ALOGW("createEffect_l() Audio driver not initialized.");
1434 goto Exit;
1435 }
1436
Eric Laurent81784c32012-11-19 14:55:58 -08001437 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
1438
1439 { // scope for mLock
1440 Mutex::Autolock _l(mLock);
1441
Eric Laurent4c415062016-06-17 16:14:16 -07001442 lStatus = checkEffectCompatibility_l(desc, sessionId);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001443 if (probe || lStatus != NO_ERROR) {
Eric Laurent4c415062016-06-17 16:14:16 -07001444 goto Exit;
1445 }
1446
Eric Laurent81784c32012-11-19 14:55:58 -08001447 // check for existing effect chain with the requested audio session
1448 chain = getEffectChain_l(sessionId);
1449 if (chain == 0) {
1450 // create a new chain for this session
1451 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
1452 chain = new EffectChain(this, sessionId);
1453 addEffectChain_l(chain);
1454 chain->setStrategy(getStrategyForSession_l(sessionId));
1455 chainCreated = true;
1456 } else {
1457 effect = chain->getEffectFromDesc_l(desc);
1458 }
1459
1460 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
1461
1462 if (effect == 0) {
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001463 effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
Eric Laurent81784c32012-11-19 14:55:58 -08001464 // create a new effect module if none present in the chain
Eric Laurent6b446ce2019-12-13 10:56:31 -08001465 lStatus = chain->createEffect_l(effect, desc, effectId, sessionId, pinned);
Eric Laurent81784c32012-11-19 14:55:58 -08001466 if (lStatus != NO_ERROR) {
1467 goto Exit;
1468 }
1469 effectCreated = true;
1470
jiabinc52b1ff2019-10-31 17:20:42 -07001471 // FIXME: use vector of device and address when effect interface is ready.
jiabin8f278ee2019-11-11 12:16:27 -08001472 effect->setDevices(outDeviceTypeAddrs());
1473 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001474 effect->setMode(mAudioFlinger->getMode());
1475 effect->setAudioSource(mAudioSource);
1476 }
jiabin1319f5a2021-03-30 22:21:24 +00001477 if (effect->isHapticGenerator()) {
1478 // TODO(b/184194057): Use the vibrator information from the vibrator that will be used
1479 // for the HapticGenerator.
Lais Andradebc3f37a2021-07-02 00:13:19 +01001480 const std::optional<media::AudioVibratorInfo> defaultVibratorInfo =
1481 std::move(mAudioFlinger->getDefaultVibratorInfo_l());
1482 if (defaultVibratorInfo) {
jiabin1319f5a2021-03-30 22:21:24 +00001483 // Only set the vibrator info when it is a valid one.
Lais Andradebc3f37a2021-07-02 00:13:19 +01001484 effect->setVibratorInfo(*defaultVibratorInfo);
jiabin1319f5a2021-03-30 22:21:24 +00001485 }
1486 }
Eric Laurent81784c32012-11-19 14:55:58 -08001487 // create effect handle and connect it to effect module
1488 handle = new EffectHandle(effect, client, effectClient, priority);
Glenn Kastene75da402013-11-20 13:54:52 -08001489 lStatus = handle->initCheck();
1490 if (lStatus == OK) {
1491 lStatus = effect->addHandle(handle.get());
1492 }
Eric Laurent81784c32012-11-19 14:55:58 -08001493 if (enabled != NULL) {
1494 *enabled = (int)effect->isEnabled();
1495 }
1496 }
1497
1498Exit:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001499 if (!probe && lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurent81784c32012-11-19 14:55:58 -08001500 Mutex::Autolock _l(mLock);
1501 if (effectCreated) {
1502 chain->removeEffect_l(effect);
1503 }
Eric Laurent81784c32012-11-19 14:55:58 -08001504 if (chainCreated) {
1505 removeEffectChain_l(chain);
1506 }
haobo101735295ff7b0d2017-03-17 17:44:03 +08001507 // handle must be cleared by caller to avoid deadlock.
Eric Laurent81784c32012-11-19 14:55:58 -08001508 }
1509
Glenn Kasten9156ef32013-08-06 15:39:08 -07001510 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08001511 return handle;
1512}
1513
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001514void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
1515 bool unpinIfLast)
1516{
1517 bool remove = false;
1518 sp<EffectModule> effect;
1519 {
1520 Mutex::Autolock _l(mLock);
Eric Laurent41709552019-12-16 19:34:05 -08001521 sp<EffectBase> effectBase = handle->effect().promote();
1522 if (effectBase == nullptr) {
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001523 return;
1524 }
Eric Laurentb82e6b72019-11-22 17:25:04 -08001525 effect = effectBase->asEffectModule();
1526 if (effect == nullptr) {
1527 return;
1528 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001529 // restore suspended effects if the disconnected handle was enabled and the last one.
1530 remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
1531 if (remove) {
1532 removeEffect_l(effect, true);
1533 }
1534 }
1535 if (remove) {
1536 mAudioFlinger->updateOrphanEffectChains(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001537 if (handle->enabled()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001538 effect->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001539 }
1540 }
1541}
1542
Eric Laurent6b446ce2019-12-13 10:56:31 -08001543void AudioFlinger::ThreadBase::onEffectEnable(const sp<EffectModule>& effect) {
Andy Hungea840382020-05-05 21:50:17 -07001544 if (isOffloadOrMmap()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001545 Mutex::Autolock _l(mLock);
1546 broadcast_l();
1547 }
1548 if (!effect->isOffloadable()) {
1549 if (mType == ThreadBase::OFFLOAD) {
1550 PlaybackThread *t = (PlaybackThread *)this;
1551 t->invalidateTracks(AUDIO_STREAM_MUSIC);
1552 }
1553 if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
1554 mAudioFlinger->onNonOffloadableGlobalEffectEnable();
1555 }
1556 }
1557}
1558
1559void AudioFlinger::ThreadBase::onEffectDisable() {
Andy Hungea840382020-05-05 21:50:17 -07001560 if (isOffloadOrMmap()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08001561 Mutex::Autolock _l(mLock);
1562 broadcast_l();
1563 }
1564}
1565
Glenn Kastend848eb42016-03-08 13:42:11 -08001566sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
1567 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001568{
1569 Mutex::Autolock _l(mLock);
1570 return getEffect_l(sessionId, effectId);
1571}
1572
Glenn Kastend848eb42016-03-08 13:42:11 -08001573sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
1574 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001575{
1576 sp<EffectChain> chain = getEffectChain_l(sessionId);
1577 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
1578}
1579
Eric Laurent6c796322019-04-09 14:13:17 -07001580std::vector<int> AudioFlinger::ThreadBase::getEffectIds_l(audio_session_t sessionId)
1581{
1582 sp<EffectChain> chain = getEffectChain_l(sessionId);
1583 return chain != nullptr ? chain->getEffectIds() : std::vector<int>{};
1584}
1585
Eric Laurent81784c32012-11-19 14:55:58 -08001586// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
1587// PlaybackThread::mLock held
1588status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
1589{
1590 // check for existing effect chain with the requested audio session
Glenn Kastend848eb42016-03-08 13:42:11 -08001591 audio_session_t sessionId = effect->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08001592 sp<EffectChain> chain = getEffectChain_l(sessionId);
1593 bool chainCreated = false;
1594
Eric Laurent5baf2af2013-09-12 17:37:00 -07001595 ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001596 "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %#x",
Eric Laurent5baf2af2013-09-12 17:37:00 -07001597 this, effect->desc().name, effect->desc().flags);
1598
Eric Laurent81784c32012-11-19 14:55:58 -08001599 if (chain == 0) {
1600 // create a new chain for this session
1601 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
1602 chain = new EffectChain(this, sessionId);
1603 addEffectChain_l(chain);
1604 chain->setStrategy(getStrategyForSession_l(sessionId));
1605 chainCreated = true;
1606 }
1607 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
1608
1609 if (chain->getEffectFromId_l(effect->id()) != 0) {
1610 ALOGW("addEffect_l() %p effect %s already present in chain %p",
1611 this, effect->desc().name, chain.get());
1612 return BAD_VALUE;
1613 }
1614
Eric Laurent5baf2af2013-09-12 17:37:00 -07001615 effect->setOffloaded(mType == OFFLOAD, mId);
1616
Eric Laurent81784c32012-11-19 14:55:58 -08001617 status_t status = chain->addEffect_l(effect);
1618 if (status != NO_ERROR) {
1619 if (chainCreated) {
1620 removeEffectChain_l(chain);
1621 }
1622 return status;
1623 }
1624
jiabin8f278ee2019-11-11 12:16:27 -08001625 effect->setDevices(outDeviceTypeAddrs());
1626 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001627 effect->setMode(mAudioFlinger->getMode());
1628 effect->setAudioSource(mAudioSource);
Eric Laurentd8365c52017-07-16 15:27:05 -07001629
Eric Laurent81784c32012-11-19 14:55:58 -08001630 return NO_ERROR;
1631}
1632
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001633void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect, bool release) {
Eric Laurent81784c32012-11-19 14:55:58 -08001634
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001635 ALOGV("%s %p effect %p", __FUNCTION__, this, effect.get());
Eric Laurent81784c32012-11-19 14:55:58 -08001636 effect_descriptor_t desc = effect->desc();
1637 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1638 detachAuxEffect_l(effect->id());
1639 }
1640
Andy Hungfda44002021-06-03 17:23:16 -07001641 sp<EffectChain> chain = effect->getCallback()->chain().promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001642 if (chain != 0) {
1643 // remove effect chain if removing last effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001644 if (chain->removeEffect_l(effect, release) == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001645 removeEffectChain_l(chain);
1646 }
1647 } else {
1648 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
1649 }
1650}
1651
1652void AudioFlinger::ThreadBase::lockEffectChains_l(
1653 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1654{
1655 effectChains = mEffectChains;
1656 for (size_t i = 0; i < mEffectChains.size(); i++) {
1657 mEffectChains[i]->lock();
1658 }
1659}
1660
1661void AudioFlinger::ThreadBase::unlockEffectChains(
1662 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1663{
1664 for (size_t i = 0; i < effectChains.size(); i++) {
1665 effectChains[i]->unlock();
1666 }
1667}
1668
Glenn Kastend848eb42016-03-08 13:42:11 -08001669sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001670{
1671 Mutex::Autolock _l(mLock);
1672 return getEffectChain_l(sessionId);
1673}
1674
Glenn Kastend848eb42016-03-08 13:42:11 -08001675sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
1676 const
Eric Laurent81784c32012-11-19 14:55:58 -08001677{
1678 size_t size = mEffectChains.size();
1679 for (size_t i = 0; i < size; i++) {
1680 if (mEffectChains[i]->sessionId() == sessionId) {
1681 return mEffectChains[i];
1682 }
1683 }
1684 return 0;
1685}
1686
1687void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
1688{
1689 Mutex::Autolock _l(mLock);
1690 size_t size = mEffectChains.size();
1691 for (size_t i = 0; i < size; i++) {
1692 mEffectChains[i]->setMode_l(mode);
1693 }
1694}
1695
Mikhail Naganovdc769682018-05-04 15:34:08 -07001696void AudioFlinger::ThreadBase::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07001697{
1698 config->type = AUDIO_PORT_TYPE_MIX;
1699 config->ext.mix.handle = mId;
1700 config->sample_rate = mSampleRate;
1701 config->format = mFormat;
1702 config->channel_mask = mChannelMask;
1703 config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
1704 AUDIO_PORT_CONFIG_FORMAT;
1705}
1706
Eric Laurent72e3f392015-05-20 14:43:50 -07001707void AudioFlinger::ThreadBase::systemReady()
1708{
1709 Mutex::Autolock _l(mLock);
1710 if (mSystemReady) {
1711 return;
1712 }
1713 mSystemReady = true;
1714
1715 for (size_t i = 0; i < mPendingConfigEvents.size(); i++) {
1716 sendConfigEvent_l(mPendingConfigEvents.editItemAt(i));
1717 }
1718 mPendingConfigEvents.clear();
1719}
1720
Andy Hungdae27702016-10-31 14:01:16 -07001721template <typename T>
1722ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::add(const sp<T> &track) {
1723 ssize_t index = mActiveTracks.indexOf(track);
1724 if (index >= 0) {
1725 ALOGW("ActiveTracks<T>::add track %p already there", track.get());
1726 return index;
1727 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001728 logTrack("add", track);
Andy Hungdae27702016-10-31 14:01:16 -07001729 mActiveTracksGeneration++;
1730 mLatestActiveTrack = track;
1731 ++mBatteryCounter[track->uid()].second;
Kevin Rocard069c2712018-03-29 19:09:14 -07001732 mHasChanged = true;
Andy Hungdae27702016-10-31 14:01:16 -07001733 return mActiveTracks.add(track);
1734}
1735
1736template <typename T>
1737ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::remove(const sp<T> &track) {
1738 ssize_t index = mActiveTracks.remove(track);
1739 if (index < 0) {
1740 ALOGW("ActiveTracks<T>::remove nonexistent track %p", track.get());
1741 return index;
1742 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001743 logTrack("remove", track);
Andy Hungdae27702016-10-31 14:01:16 -07001744 mActiveTracksGeneration++;
1745 --mBatteryCounter[track->uid()].second;
1746 // mLatestActiveTrack is not cleared even if is the same as track.
Kevin Rocard069c2712018-03-29 19:09:14 -07001747 mHasChanged = true;
Andy Hung8946a282018-04-19 20:04:56 -07001748#ifdef TEE_SINK
1749 track->dumpTee(-1 /* fd */, "_REMOVE");
1750#endif
Andy Hungc2b11cb2020-04-22 09:04:01 -07001751 track->logEndInterval(); // log to MediaMetrics
Andy Hungdae27702016-10-31 14:01:16 -07001752 return index;
1753}
1754
1755template <typename T>
1756void AudioFlinger::ThreadBase::ActiveTracks<T>::clear() {
1757 for (const sp<T> &track : mActiveTracks) {
1758 BatteryNotifier::getInstance().noteStopAudio(track->uid());
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001759 logTrack("clear", track);
Andy Hungdae27702016-10-31 14:01:16 -07001760 }
1761 mLastActiveTracksGeneration = mActiveTracksGeneration;
Kevin Rocard069c2712018-03-29 19:09:14 -07001762 if (!mActiveTracks.empty()) { mHasChanged = true; }
Andy Hungdae27702016-10-31 14:01:16 -07001763 mActiveTracks.clear();
1764 mLatestActiveTrack.clear();
1765 mBatteryCounter.clear();
1766}
1767
1768template <typename T>
1769void AudioFlinger::ThreadBase::ActiveTracks<T>::updatePowerState(
1770 sp<ThreadBase> thread, bool force) {
1771 // Updates ActiveTracks client uids to the thread wakelock.
1772 if (mActiveTracksGeneration != mLastActiveTracksGeneration || force) {
1773 thread->updateWakeLockUids_l(getWakeLockUids());
1774 mLastActiveTracksGeneration = mActiveTracksGeneration;
1775 }
1776
1777 // Updates BatteryNotifier uids
1778 for (auto it = mBatteryCounter.begin(); it != mBatteryCounter.end();) {
1779 const uid_t uid = it->first;
1780 ssize_t &previous = it->second.first;
1781 ssize_t &current = it->second.second;
1782 if (current > 0) {
1783 if (previous == 0) {
1784 BatteryNotifier::getInstance().noteStartAudio(uid);
1785 }
1786 previous = current;
1787 ++it;
1788 } else if (current == 0) {
1789 if (previous > 0) {
1790 BatteryNotifier::getInstance().noteStopAudio(uid);
1791 }
1792 it = mBatteryCounter.erase(it); // std::map<> is stable on iterator erase.
1793 } else /* (current < 0) */ {
1794 LOG_ALWAYS_FATAL("negative battery count %zd", current);
1795 }
1796 }
1797}
Eric Laurent83b88082014-06-20 18:31:16 -07001798
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001799template <typename T>
Kevin Rocard069c2712018-03-29 19:09:14 -07001800bool AudioFlinger::ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001801 bool hasChanged = mHasChanged;
Kevin Rocard069c2712018-03-29 19:09:14 -07001802 mHasChanged = false;
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001803
1804 for (const sp<T> &track : mActiveTracks) {
1805 // Do not short-circuit as all hasChanged states must be reset
1806 // as all the metadata are going to be sent
1807 hasChanged |= track->readAndClearHasChanged();
1808 }
Kevin Rocard069c2712018-03-29 19:09:14 -07001809 return hasChanged;
1810}
1811
1812template <typename T>
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001813void AudioFlinger::ThreadBase::ActiveTracks<T>::logTrack(
1814 const char *funcName, const sp<T> &track) const {
1815 if (mLocalLog != nullptr) {
1816 String8 result;
1817 track->appendDump(result, false /* active */);
1818 mLocalLog->log("AT::%-10s(%p) %s", funcName, track.get(), result.string());
1819 }
1820}
1821
Eric Laurent6acd1d42017-01-04 14:23:29 -08001822void AudioFlinger::ThreadBase::broadcast_l()
1823{
1824 // Thread could be blocked waiting for async
1825 // so signal it to handle state changes immediately
1826 // If threadLoop is currently unlocked a signal of mWaitWorkCV will
1827 // be lost so we also flag to prevent it blocking on mWaitWorkCV
1828 mSignalPending = true;
1829 mWaitWorkCV.broadcast();
1830}
1831
Andy Hungd0979812019-02-21 15:51:44 -08001832// Call only from threadLoop() or when it is idle.
1833// Do not call from high performance code as this may do binder rpc to the MediaMetrics service.
1834void AudioFlinger::ThreadBase::sendStatistics(bool force)
1835{
1836 // Do not log if we have no stats.
1837 // We choose the timestamp verifier because it is the most likely item to be present.
1838 const int64_t nstats = mTimestampVerifier.getN() - mLastRecordedTimestampVerifierN;
1839 if (nstats == 0) {
1840 return;
1841 }
1842
1843 // Don't log more frequently than once per 12 hours.
1844 // We use BOOTTIME to include suspend time.
1845 const int64_t timeNs = systemTime(SYSTEM_TIME_BOOTTIME);
1846 const int64_t sinceNs = timeNs - mLastRecordedTimeNs; // ok if mLastRecordedTimeNs = 0
1847 if (!force && sinceNs <= 12 * NANOS_PER_HOUR) {
1848 return;
1849 }
1850
1851 mLastRecordedTimestampVerifierN = mTimestampVerifier.getN();
1852 mLastRecordedTimeNs = timeNs;
1853
Ray Essickf27e9872019-12-07 06:28:46 -08001854 std::unique_ptr<mediametrics::Item> item(mediametrics::Item::create("audiothread"));
Andy Hungd0979812019-02-21 15:51:44 -08001855
1856#define MM_PREFIX "android.media.audiothread." // avoid cut-n-paste errors.
1857
1858 // thread configuration
1859 item->setInt32(MM_PREFIX "id", (int32_t)mId); // IO handle
1860 // item->setInt32(MM_PREFIX "portId", (int32_t)mPortId);
1861 item->setCString(MM_PREFIX "type", threadTypeToString(mType));
1862 item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
1863 item->setInt64(MM_PREFIX "channelMask", (int64_t)mChannelMask);
1864 item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
1865 item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
jiabinc52b1ff2019-10-31 17:20:42 -07001866 item->setCString(MM_PREFIX "outDevice", toString(outDeviceTypes()).c_str());
1867 item->setCString(MM_PREFIX "inDevice", toString(inDeviceType()).c_str());
Andy Hungd0979812019-02-21 15:51:44 -08001868
1869 // thread statistics
1870 if (mIoJitterMs.getN() > 0) {
1871 item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
1872 item->setDouble(MM_PREFIX "ioJitterMs.std", mIoJitterMs.getStdDev());
1873 }
1874 if (mProcessTimeMs.getN() > 0) {
1875 item->setDouble(MM_PREFIX "processTimeMs.mean", mProcessTimeMs.getMean());
1876 item->setDouble(MM_PREFIX "processTimeMs.std", mProcessTimeMs.getStdDev());
1877 }
1878 const auto tsjitter = mTimestampVerifier.getJitterMs();
1879 if (tsjitter.getN() > 0) {
1880 item->setDouble(MM_PREFIX "timestampJitterMs.mean", tsjitter.getMean());
1881 item->setDouble(MM_PREFIX "timestampJitterMs.std", tsjitter.getStdDev());
1882 }
1883 if (mLatencyMs.getN() > 0) {
1884 item->setDouble(MM_PREFIX "latencyMs.mean", mLatencyMs.getMean());
1885 item->setDouble(MM_PREFIX "latencyMs.std", mLatencyMs.getStdDev());
1886 }
1887
1888 item->selfrecord();
1889}
1890
Eric Laurent81784c32012-11-19 14:55:58 -08001891// ----------------------------------------------------------------------------
1892// Playback
1893// ----------------------------------------------------------------------------
1894
1895AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1896 AudioStreamOut* output,
1897 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001898 type_t type,
Eric Laurente93cc032016-05-05 10:15:10 -07001899 bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -07001900 : ThreadBase(audioFlinger, id, type, systemReady, true /* isOut */),
Andy Hung2098f272014-02-27 14:00:06 -08001901 mNormalFrameCount(0), mSinkBuffer(NULL),
Andy Hung6146c082014-03-18 11:56:15 -07001902 mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung69aed5f2014-02-25 17:24:40 -08001903 mMixerBuffer(NULL),
1904 mMixerBufferSize(0),
1905 mMixerBufferFormat(AUDIO_FORMAT_INVALID),
1906 mMixerBufferValid(false),
Andy Hung6146c082014-03-18 11:56:15 -07001907 mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung98ef9782014-03-04 14:46:50 -08001908 mEffectBuffer(NULL),
1909 mEffectBufferSize(0),
1910 mEffectBufferFormat(AUDIO_FORMAT_INVALID),
1911 mEffectBufferValid(false),
Glenn Kastenc1fac192013-08-06 07:41:36 -07001912 mSuspended(0), mBytesWritten(0),
Andy Hungc54b1ff2016-02-23 14:07:07 -08001913 mFramesWritten(0),
Andy Hung238fa3d2016-07-28 10:53:22 -07001914 mSuspendedFrames(0),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001915 mActiveTracks(&this->mLocalLog),
Eric Laurent81784c32012-11-19 14:55:58 -08001916 // mStreamTypes[] initialized in constructor body
Andy Hung1bc088a2018-02-09 15:57:31 -08001917 mTracks(type == MIXER),
Eric Laurent81784c32012-11-19 14:55:58 -08001918 mOutput(output),
Andy Hung446f4df2019-02-21 12:26:41 -08001919 mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
Eric Laurent81784c32012-11-19 14:55:58 -08001920 mMixerStatus(MIXER_IDLE),
1921 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001922 mStandbyDelayNs(AudioFlinger::mStandbyTimeInNsecs),
Eric Laurentbfb1b832013-01-07 09:53:42 -08001923 mBytesRemaining(0),
1924 mCurrentWriteLength(0),
1925 mUseAsyncWrite(false),
Eric Laurent3b4529e2013-09-05 18:09:19 -07001926 mWriteAckSequence(0),
1927 mDrainSequence(0),
Eric Laurent81784c32012-11-19 14:55:58 -08001928 mScreenState(AudioFlinger::mScreenState),
1929 // index 0 is reserved for normal mixer's submix
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001930 mFastTrackAvailMask(((1 << FastMixerState::sMaxFastTracks) - 1) & ~1),
Eric Laurent7c29ec92017-09-20 17:54:22 -07001931 mHwSupportsPause(false), mHwPaused(false), mFlushPending(false),
Eric Laurent74c38dc2020-12-23 18:19:44 +01001932 mLeftVolFloat(-1.0), mRightVolFloat(-1.0),
1933 mDownStreamPatch{}
Eric Laurent81784c32012-11-19 14:55:58 -08001934{
Glenn Kastend7dca052015-03-05 16:05:54 -08001935 snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
1936 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001937
1938 // Assumes constructor is called by AudioFlinger with it's mLock held, but
1939 // it would be safer to explicitly pass initial masterVolume/masterMute as
1940 // parameter.
1941 //
1942 // If the HAL we are using has support for master volume or master mute,
1943 // then do not attenuate or mute during mixing (just leave the volume at 1.0
1944 // and the mute set to false).
1945 mMasterVolume = audioFlinger->masterVolume_l();
1946 mMasterMute = audioFlinger->masterMute_l();
George Burgess IV5e4d86f2020-02-18 12:55:36 -08001947 if (mOutput->audioHwDev) {
Eric Laurent81784c32012-11-19 14:55:58 -08001948 if (mOutput->audioHwDev->canSetMasterVolume()) {
1949 mMasterVolume = 1.0;
1950 }
1951
1952 if (mOutput->audioHwDev->canSetMasterMute()) {
1953 mMasterMute = false;
1954 }
Andy Hungc8fddf32018-08-08 18:32:37 -07001955 mIsMsdDevice = strcmp(
1956 mOutput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001957 }
1958
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001959 readOutputParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001960
Andy Hungc8fddf32018-08-08 18:32:37 -07001961 // TODO: We may also match on address as well as device type for
1962 // AUDIO_DEVICE_OUT_BUS, AUDIO_DEVICE_OUT_ALL_A2DP, AUDIO_DEVICE_OUT_REMOTE_SUBMIX
Dean Wheatleyf8726f02019-12-02 14:12:01 +11001963 if (type == MIXER || type == DIRECT || type == OFFLOAD) {
jiabinc52b1ff2019-10-31 17:20:42 -07001964 // TODO: This property should be ensure that only contains one single device type.
1965 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
1966 "audio.timestamp.corrected_output_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07001967 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_OUT_BUS // turn on by default for MSD
1968 : AUDIO_DEVICE_NONE));
1969 }
1970
Mikhail Naganovf33115d2020-09-25 23:03:05 +00001971 for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
1972 const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
Eric Laurent98e38192018-02-15 18:31:53 -08001973 mStreamTypes[stream].volume = 0.0f;
Eric Laurent81784c32012-11-19 14:55:58 -08001974 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
1975 }
Eric Laurent35f8c7c2020-02-08 11:42:35 -08001976 // Audio patch and call assistant volume are always max
Eric Laurent98e38192018-02-15 18:31:53 -08001977 mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
1978 mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
Eric Laurent35f8c7c2020-02-08 11:42:35 -08001979 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].volume = 1.0f;
1980 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001981}
1982
1983AudioFlinger::PlaybackThread::~PlaybackThread()
1984{
Glenn Kasten9e58b552013-01-18 15:09:48 -08001985 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung010a1a12014-03-13 13:57:33 -07001986 free(mSinkBuffer);
Andy Hung69aed5f2014-02-25 17:24:40 -08001987 free(mMixerBuffer);
Andy Hung98ef9782014-03-04 14:46:50 -08001988 free(mEffectBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001989}
1990
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001991// Thread virtuals
1992
1993void AudioFlinger::PlaybackThread::onFirstRef()
Eric Laurent81784c32012-11-19 14:55:58 -08001994{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001995 if (!isStreamInitialized()) {
jiabinf6eb4c32020-02-25 14:06:25 -08001996 ALOGE("The stream is not open yet"); // This should not happen.
1997 } else {
1998 // setEventCallback will need a strong pointer as a parameter. Calling it
1999 // here instead of constructor of PlaybackThread so that the onFirstRef
2000 // callback would not be made on an incompletely constructed object.
2001 if (mOutput->stream->setEventCallback(this) != OK) {
jiabinf1a36052020-08-19 14:33:31 -07002002 ALOGD("Failed to add event callback");
jiabinf6eb4c32020-02-25 14:06:25 -08002003 }
2004 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002005 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08002006}
2007
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002008// ThreadBase virtuals
2009void AudioFlinger::PlaybackThread::preExit()
2010{
2011 ALOGV(" preExit()");
2012 // FIXME this is using hard-coded strings but in the future, this functionality will be
2013 // converted to use audio HAL extensions required to support tunneling
2014 status_t result = mOutput->stream->setParameters(String8("exiting=1"));
2015 ALOGE_IF(result != OK, "Error when setting parameters on exit: %d", result);
2016}
2017
2018void AudioFlinger::PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08002019{
Eric Laurent81784c32012-11-19 14:55:58 -08002020 String8 result;
2021
Marco Nelissenb2208842014-02-07 14:00:50 -08002022 result.appendFormat(" Stream volumes in dB: ");
Eric Laurent81784c32012-11-19 14:55:58 -08002023 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
2024 const stream_type_t *st = &mStreamTypes[i];
2025 if (i > 0) {
2026 result.appendFormat(", ");
2027 }
2028 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
2029 if (st->mute) {
2030 result.append("M");
2031 }
2032 }
2033 result.append("\n");
2034 write(fd, result.string(), result.length());
2035 result.clear();
2036
Eric Laurent81784c32012-11-19 14:55:58 -08002037 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
2038 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
Elliott Hughes87cebad2014-05-22 10:14:43 -07002039 dprintf(fd, " Normal mixer raw underrun counters: partial=%u empty=%u\n",
Eric Laurent81784c32012-11-19 14:55:58 -08002040 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
Marco Nelissenb2208842014-02-07 14:00:50 -08002041
2042 size_t numtracks = mTracks.size();
2043 size_t numactive = mActiveTracks.size();
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002044 dprintf(fd, " %zu Tracks", numtracks);
Marco Nelissenb2208842014-02-07 14:00:50 -08002045 size_t numactiveseen = 0;
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002046 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08002047 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002048 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002049 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07002050 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08002051 for (size_t i = 0; i < numtracks; ++i) {
2052 sp<Track> track = mTracks[i];
2053 if (track != 0) {
2054 bool active = mActiveTracks.indexOf(track) >= 0;
2055 if (active) {
2056 numactiveseen++;
2057 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002058 result.append(prefix);
2059 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08002060 }
2061 }
2062 } else {
2063 result.append("\n");
2064 }
2065 if (numactiveseen != numactive) {
2066 // some tracks in the active list were not in the tracks list
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002067 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08002068 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002069 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07002070 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08002071 for (size_t i = 0; i < numactive; ++i) {
Andy Hungdae27702016-10-31 14:01:16 -07002072 sp<Track> track = mActiveTracks[i];
2073 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002074 result.append(prefix);
2075 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08002076 }
2077 }
2078 }
2079
2080 write(fd, result.string(), result.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002081}
2082
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002083void AudioFlinger::PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08002084{
Andy Hung04cb8f72020-03-20 13:44:33 -07002085 dprintf(fd, " Master volume: %f\n", mMasterVolume);
Mikhail Naganovdfb411f2018-09-11 13:39:56 -07002086 dprintf(fd, " Master mute: %s\n", mMasterMute ? "on" : "off");
jiabin245cdd92018-12-07 17:55:15 -08002087 if (mHapticChannelMask != AUDIO_CHANNEL_NONE) {
2088 dprintf(fd, " Haptic channel mask: %#x (%s)\n", mHapticChannelMask,
2089 channelMaskToString(mHapticChannelMask, true /* output */).c_str());
2090 }
Elliott Hughes87cebad2014-05-22 10:14:43 -07002091 dprintf(fd, " Normal frame count: %zu\n", mNormalFrameCount);
Elliott Hughes87cebad2014-05-22 10:14:43 -07002092 dprintf(fd, " Total writes: %d\n", mNumWrites);
2093 dprintf(fd, " Delayed writes: %d\n", mNumDelayedWrites);
2094 dprintf(fd, " Blocked in write: %s\n", mInWrite ? "yes" : "no");
2095 dprintf(fd, " Suspend count: %d\n", mSuspended);
2096 dprintf(fd, " Sink buffer : %p\n", mSinkBuffer);
2097 dprintf(fd, " Mixer buffer: %p\n", mMixerBuffer);
2098 dprintf(fd, " Effect buffer: %p\n", mEffectBuffer);
2099 dprintf(fd, " Fast track availMask=%#x\n", mFastTrackAvailMask);
Eric Laurent42537be2016-01-08 17:16:42 -08002100 dprintf(fd, " Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
Glenn Kasten97b7b752014-09-28 13:04:24 -07002101 AudioStreamOut *output = mOutput;
2102 audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
Mikhail Naganov913d06c2016-11-01 12:49:22 -07002103 dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08002104 output, flags, toString(flags).c_str());
Andy Hungb54c8542016-09-21 12:55:15 -07002105 dprintf(fd, " Frames written: %lld\n", (long long)mFramesWritten);
2106 dprintf(fd, " Suspended frames: %lld\n", (long long)mSuspendedFrames);
2107 if (mPipeSink.get() != nullptr) {
2108 dprintf(fd, " PipeSink frames written: %lld\n", (long long)mPipeSink->framesWritten());
2109 }
2110 if (output != nullptr) {
2111 dprintf(fd, " Hal stream dump:\n");
2112 (void)output->stream->dump(fd);
2113 }
Eric Laurent81784c32012-11-19 14:55:58 -08002114}
2115
Eric Laurent81784c32012-11-19 14:55:58 -08002116// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
2117sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
2118 const sp<AudioFlinger::Client>& client,
2119 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002120 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -08002121 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08002122 audio_format_t format,
2123 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08002124 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -08002125 size_t *pNotificationFrameCount,
2126 uint32_t notificationsPerBuffer,
2127 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -08002128 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -08002129 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -07002130 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002131 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00002132 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -08002133 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002134 status_t *status,
jiabinf6eb4c32020-02-25 14:06:25 -08002135 audio_port_handle_t portId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002136 const sp<media::IAudioTrackCallback>& callback)
Eric Laurent81784c32012-11-19 14:55:58 -08002137{
Glenn Kasten74935e42013-12-19 08:56:45 -08002138 size_t frameCount = *pFrameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002139 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002140 sp<Track> track;
2141 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07002142 audio_output_flags_t outputFlags = mOutput->flags;
Eric Laurent21da6472017-11-09 16:29:26 -08002143 audio_output_flags_t requestedFlags = *flags;
Eric Laurent9b11c022018-06-06 19:19:22 -07002144 uint32_t sampleRate;
2145
2146 if (sharedBuffer != 0 && checkIMemory(sharedBuffer) != NO_ERROR) {
2147 lStatus = BAD_VALUE;
2148 goto Exit;
2149 }
Eric Laurent21da6472017-11-09 16:29:26 -08002150
2151 if (*pSampleRate == 0) {
2152 *pSampleRate = mSampleRate;
2153 }
Eric Laurent9b11c022018-06-06 19:19:22 -07002154 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07002155
2156 // special case for FAST flag considered OK if fast mixer is present
2157 if (hasFastMixer()) {
2158 outputFlags = (audio_output_flags_t)(outputFlags | AUDIO_OUTPUT_FLAG_FAST);
2159 }
2160
2161 // Check if requested flags are compatible with output stream flags
2162 if ((*flags & outputFlags) != *flags) {
2163 ALOGW("createTrack_l(): mismatch between requested flags (%08x) and output flags (%08x)",
2164 *flags, outputFlags);
2165 *flags = (audio_output_flags_t)(*flags & outputFlags);
2166 }
Eric Laurent81784c32012-11-19 14:55:58 -08002167
Eric Laurent81784c32012-11-19 14:55:58 -08002168 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07002169 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent81784c32012-11-19 14:55:58 -08002170 if (
Eric Laurent81784c32012-11-19 14:55:58 -08002171 // PCM data
2172 audio_is_linear_pcm(format) &&
Andy Hung1f439e12015-05-19 12:57:41 -07002173 // TODO: extract as a data library function that checks that a computationally
2174 // expensive downmixer is not required: isFastOutputChannelConversion()
jiabin245cdd92018-12-07 17:55:15 -08002175 (channelMask == (mChannelMask | mHapticChannelMask) ||
Andy Hung1f439e12015-05-19 12:57:41 -07002176 mChannelMask != AUDIO_CHANNEL_OUT_STEREO ||
2177 (channelMask == AUDIO_CHANNEL_OUT_MONO
2178 /* && mChannelMask == AUDIO_CHANNEL_OUT_STEREO */)) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002179 // hardware sample rate
2180 (sampleRate == mSampleRate) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002181 // normal mixer has an associated fast mixer
2182 hasFastMixer() &&
2183 // there are sufficient fast track slots available
2184 (mFastTrackAvailMask != 0)
2185 // FIXME test that MixerThread for this fast track has a capable output HAL
2186 // FIXME add a permission test also?
2187 ) {
Andy Hunge0a269a2016-03-23 15:13:42 -07002188 // static tracks can have any nonzero framecount, streaming tracks check against minimum.
2189 if (sharedBuffer == 0) {
Glenn Kasten03490092014-05-27 12:30:54 -07002190 // read the fast track multiplier property the first time it is needed
2191 int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
2192 if (ok != 0) {
2193 ALOGE("%s pthread_once failed: %d", __func__, ok);
2194 }
Andy Hunge0a269a2016-03-23 15:13:42 -07002195 frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
Eric Laurent81784c32012-11-19 14:55:58 -08002196 }
Eric Laurent4c415062016-06-17 16:14:16 -07002197
2198 // check compatibility with audio effects.
2199 { // scope for mLock
2200 Mutex::Autolock _l(mLock);
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002201 for (audio_session_t session : {
Eric Laurent3f75a5b2019-11-12 15:55:51 -08002202 AUDIO_SESSION_DEVICE,
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002203 AUDIO_SESSION_OUTPUT_STAGE,
2204 AUDIO_SESSION_OUTPUT_MIX,
2205 sessionId,
2206 }) {
2207 sp<EffectChain> chain = getEffectChain_l(session);
2208 if (chain.get() != nullptr) {
2209 audio_output_flags_t old = *flags;
2210 chain->checkOutputFlagCompatibility(flags);
2211 if (old != *flags) {
2212 ALOGV("AUDIO_OUTPUT_FLAGS denied by effect, session=%d old=%#x new=%#x",
2213 (int)session, (int)old, (int)*flags);
2214 }
Eric Laurent4c415062016-06-17 16:14:16 -07002215 }
2216 }
2217 }
Eric Laurent122f7e72016-06-29 11:53:29 -07002218 ALOGV_IF((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0,
Eric Laurent4c415062016-06-17 16:14:16 -07002219 "AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
2220 frameCount, mFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08002221 } else {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002222 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: sharedBuffer=%p frameCount=%zu "
2223 "mFrameCount=%zu format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
Andy Hung6146c082014-03-18 11:56:15 -07002224 "sampleRate=%u mSampleRate=%u "
Eric Laurent81784c32012-11-19 14:55:58 -08002225 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
Glenn Kastend79072e2016-01-06 08:41:20 -08002226 sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002227 audio_is_linear_pcm(format), channelMask, sampleRate,
2228 mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
Eric Laurent4c415062016-06-17 16:14:16 -07002229 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
Andy Hung0e48d252015-01-26 11:43:15 -08002230 }
2231 }
Eric Laurent21da6472017-11-09 16:29:26 -08002232
2233 if (!audio_has_proportional_frames(format)) {
2234 if (sharedBuffer != 0) {
2235 // Same comment as below about ignoring frameCount parameter for set()
2236 frameCount = sharedBuffer->size();
2237 } else if (frameCount == 0) {
2238 frameCount = mNormalFrameCount;
2239 }
2240 if (notificationFrameCount != frameCount) {
2241 notificationFrameCount = frameCount;
2242 }
2243 } else if (sharedBuffer != 0) {
2244 // FIXME: Ensure client side memory buffers need
2245 // not have additional alignment beyond sample
2246 // (e.g. 16 bit stereo accessed as 32 bit frame).
2247 size_t alignment = audio_bytes_per_sample(format);
2248 if (alignment & 1) {
2249 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
2250 alignment = 1;
2251 }
2252 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
2253 size_t frameSize = channelCount * audio_bytes_per_sample(format);
2254 if (channelCount > 1) {
2255 // More than 2 channels does not require stronger alignment than stereo
2256 alignment <<= 1;
2257 }
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002258 if (((uintptr_t)sharedBuffer->unsecurePointer() & (alignment - 1)) != 0) {
Eric Laurent21da6472017-11-09 16:29:26 -08002259 ALOGE("Invalid buffer alignment: address %p, channel count %u",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002260 sharedBuffer->unsecurePointer(), channelCount);
Eric Laurent21da6472017-11-09 16:29:26 -08002261 lStatus = BAD_VALUE;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002262 goto Exit;
2263 }
Eric Laurent21da6472017-11-09 16:29:26 -08002264
2265 // When initializing a shared buffer AudioTrack via constructors,
2266 // there's no frameCount parameter.
2267 // But when initializing a shared buffer AudioTrack via set(),
2268 // there _is_ a frameCount parameter. We silently ignore it.
2269 frameCount = sharedBuffer->size() / frameSize;
2270 } else {
2271 size_t minFrameCount = 0;
2272 // For fast tracks we try to respect the application's request for notifications per buffer.
2273 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2274 if (notificationsPerBuffer > 0) {
2275 // Avoid possible arithmetic overflow during multiplication.
2276 if (notificationsPerBuffer > SIZE_MAX / mFrameCount) {
2277 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
2278 notificationsPerBuffer, mFrameCount);
2279 } else {
2280 minFrameCount = mFrameCount * notificationsPerBuffer;
2281 }
2282 }
2283 } else {
2284 // For normal PCM streaming tracks, update minimum frame count.
2285 // Buffer depth is forced to be at least 2 x the normal mixer frame count and
2286 // cover audio hardware latency.
2287 // This is probably too conservative, but legacy application code may depend on it.
2288 // If you change this calculation, also review the start threshold which is related.
2289 uint32_t latencyMs = latency_l();
2290 if (latencyMs == 0) {
2291 ALOGE("Error when retrieving output stream latency");
2292 lStatus = UNKNOWN_ERROR;
2293 goto Exit;
2294 }
2295
2296 minFrameCount = AudioSystem::calculateMinFrameCount(latencyMs, mNormalFrameCount,
2297 mSampleRate, sampleRate, speed /*, 0 mNotificationsPerBufferReq*/);
2298
Eric Laurent81784c32012-11-19 14:55:58 -08002299 }
Eric Laurent21da6472017-11-09 16:29:26 -08002300 if (frameCount < minFrameCount) {
Eric Laurent81784c32012-11-19 14:55:58 -08002301 frameCount = minFrameCount;
2302 }
Eric Laurent81784c32012-11-19 14:55:58 -08002303 }
Eric Laurent21da6472017-11-09 16:29:26 -08002304
2305 // Make sure that application is notified with sufficient margin before underrun.
2306 // The client can divide the AudioTrack buffer into sub-buffers,
2307 // and expresses its desire to server as the notification frame count.
2308 if (sharedBuffer == 0 && audio_is_linear_pcm(format)) {
2309 size_t maxNotificationFrames;
2310 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2311 // notify every HAL buffer, regardless of the size of the track buffer
2312 maxNotificationFrames = mFrameCount;
2313 } else {
Andy Hungfa117802019-04-12 13:50:39 -07002314 // Triple buffer the notification period for a triple buffered mixer period;
2315 // otherwise, double buffering for the notification period is fine.
2316 //
2317 // TODO: This should be moved to AudioTrack to modify the notification period
2318 // on AudioTrack::setBufferSizeInFrames() changes.
2319 const int nBuffering =
2320 (uint64_t{frameCount} * mSampleRate)
2321 / (uint64_t{mNormalFrameCount} * sampleRate) == 3 ? 3 : 2;
2322
Eric Laurent21da6472017-11-09 16:29:26 -08002323 maxNotificationFrames = frameCount / nBuffering;
2324 // If client requested a fast track but this was denied, then use the smaller maximum.
2325 if (requestedFlags & AUDIO_OUTPUT_FLAG_FAST) {
2326 size_t maxNotificationFramesFastDenied = FMS_20 * sampleRate / 1000;
2327 if (maxNotificationFrames > maxNotificationFramesFastDenied) {
2328 maxNotificationFrames = maxNotificationFramesFastDenied;
2329 }
2330 }
2331 }
2332 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
2333 if (notificationFrameCount == 0) {
2334 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
2335 maxNotificationFrames, frameCount);
2336 } else {
2337 ALOGW("Client adjusted notificationFrames from %zu to %zu for frameCount %zu",
2338 notificationFrameCount, maxNotificationFrames, frameCount);
2339 }
2340 notificationFrameCount = maxNotificationFrames;
2341 }
2342 }
2343
Glenn Kasten74935e42013-12-19 08:56:45 -08002344 *pFrameCount = frameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002345 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002346
Glenn Kastenc3df8382014-03-13 15:05:25 -07002347 switch (mType) {
2348
2349 case DIRECT:
Phil Burkfdb3c072016-02-09 10:47:02 -08002350 if (audio_is_linear_pcm(format)) { // TODO maybe use audio_has_proportional_frames()?
Eric Laurent81784c32012-11-19 14:55:58 -08002351 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002352 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
2353 "for output %p with format %#x",
Eric Laurent81784c32012-11-19 14:55:58 -08002354 sampleRate, format, channelMask, mOutput, mFormat);
2355 lStatus = BAD_VALUE;
2356 goto Exit;
2357 }
2358 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002359 break;
2360
2361 case OFFLOAD:
Eric Laurentbfb1b832013-01-07 09:53:42 -08002362 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002363 ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
2364 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002365 sampleRate, format, channelMask, mOutput, mFormat);
2366 lStatus = BAD_VALUE;
2367 goto Exit;
2368 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002369 break;
2370
2371 default:
Glenn Kasten993fa062014-05-02 11:14:34 -07002372 if (!audio_is_linear_pcm(format)) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002373 ALOGE("createTrack_l() Bad parameter: format %#x \""
2374 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002375 format, mOutput, mFormat);
2376 lStatus = BAD_VALUE;
2377 goto Exit;
2378 }
Andy Hungcd044842014-08-07 11:04:34 -07002379 if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Eric Laurent81784c32012-11-19 14:55:58 -08002380 ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
2381 lStatus = BAD_VALUE;
2382 goto Exit;
2383 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002384 break;
2385
Eric Laurent81784c32012-11-19 14:55:58 -08002386 }
2387
2388 lStatus = initCheck();
2389 if (lStatus != NO_ERROR) {
Glenn Kasten15e57982013-09-24 11:52:37 -07002390 ALOGE("createTrack_l() audio driver not initialized");
Eric Laurent81784c32012-11-19 14:55:58 -08002391 goto Exit;
2392 }
2393
2394 { // scope for mLock
2395 Mutex::Autolock _l(mLock);
2396
2397 // all tracks in same audio session must share the same routing strategy otherwise
2398 // conflicts will happen when tracks are moved from one output to another by audio policy
2399 // manager
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002400 product_strategy_t strategy = AudioSystem::getStrategyForStream(streamType);
Eric Laurent81784c32012-11-19 14:55:58 -08002401 for (size_t i = 0; i < mTracks.size(); ++i) {
2402 sp<Track> t = mTracks[i];
Eric Laurent83b88082014-06-20 18:31:16 -07002403 if (t != 0 && t->isExternalTrack()) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002404 product_strategy_t actual = AudioSystem::getStrategyForStream(t->streamType());
Eric Laurent81784c32012-11-19 14:55:58 -08002405 if (sessionId == t->sessionId() && strategy != actual) {
2406 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
2407 strategy, actual);
2408 lStatus = BAD_VALUE;
2409 goto Exit;
2410 }
2411 }
2412 }
2413
yucliuc9c49cd2020-07-13 16:25:21 -07002414 // Set DIRECT flag if current thread is DirectOutputThread. This can
2415 // happen when the playback is rerouted to direct output thread by
2416 // dynamic audio policy.
2417 // Do NOT report the flag changes back to client, since the client
2418 // doesn't explicitly request a direct flag.
2419 audio_output_flags_t trackFlags = *flags;
2420 if (mType == DIRECT) {
2421 trackFlags = static_cast<audio_output_flags_t>(trackFlags | AUDIO_OUTPUT_FLAG_DIRECT);
2422 }
2423
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002424 track = new Track(this, client, streamType, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002425 channelMask, frameCount,
2426 nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
Svet Ganov33761132021-05-13 22:51:08 +00002427 sessionId, creatorPid, attributionSource, trackFlags,
2428 TrackBase::TYPE_DEFAULT, portId, SIZE_MAX /*frameCountToBeReady*/, speed);
Glenn Kasten03003332013-08-06 15:40:54 -07002429
Glenn Kasten03003332013-08-06 15:40:54 -07002430 lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
2431 if (lStatus != NO_ERROR) {
Glenn Kasten0cde0762014-01-16 15:06:36 -08002432 ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002433 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08002434 goto Exit;
2435 }
2436 mTracks.add(track);
jiabinf6eb4c32020-02-25 14:06:25 -08002437 {
2438 Mutex::Autolock _atCbL(mAudioTrackCbLock);
2439 if (callback.get() != nullptr) {
jiabin18a4b1c2020-09-17 11:40:42 -07002440 mAudioTrackCallbacks.emplace(track, callback);
jiabinf6eb4c32020-02-25 14:06:25 -08002441 }
2442 }
Eric Laurent81784c32012-11-19 14:55:58 -08002443
2444 sp<EffectChain> chain = getEffectChain_l(sessionId);
2445 if (chain != 0) {
2446 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
2447 track->setMainBuffer(chain->inBuffer());
2448 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
2449 chain->incTrackCnt();
2450 }
2451
Eric Laurent05067782016-06-01 18:27:28 -07002452 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) && (tid != -1)) {
Eric Laurent81784c32012-11-19 14:55:58 -08002453 pid_t callingPid = IPCThreadState::self()->getCallingPid();
2454 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
2455 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07002456 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08002457 }
2458 }
2459
2460 lStatus = NO_ERROR;
2461
2462Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07002463 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08002464 return track;
2465}
2466
Andy Hung1bc088a2018-02-09 15:57:31 -08002467template<typename T>
Andy Hung1bc088a2018-02-09 15:57:31 -08002468ssize_t AudioFlinger::PlaybackThread::Tracks<T>::remove(const sp<T> &track)
2469{
Andy Hungc0691382018-09-12 18:01:57 -07002470 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08002471 const ssize_t index = mTracks.remove(track);
2472 if (index >= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07002473 if (mSaveDeletedTrackIds) {
Andy Hung1bc088a2018-02-09 15:57:31 -08002474 // We can't directly access mAudioMixer since the caller may be outside of threadLoop.
Andy Hungc0691382018-09-12 18:01:57 -07002475 // Instead, we add to mDeletedTrackIds which is solely used for mAudioMixer update,
Andy Hung1bc088a2018-02-09 15:57:31 -08002476 // to be handled when MixerThread::prepareTracks_l() next changes mAudioMixer.
Andy Hungc0691382018-09-12 18:01:57 -07002477 mDeletedTrackIds.emplace(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08002478 }
Andy Hung1bc088a2018-02-09 15:57:31 -08002479 }
2480 return index;
2481}
2482
Eric Laurent81784c32012-11-19 14:55:58 -08002483uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
2484{
2485 return latency;
2486}
2487
2488uint32_t AudioFlinger::PlaybackThread::latency() const
2489{
2490 Mutex::Autolock _l(mLock);
2491 return latency_l();
2492}
2493uint32_t AudioFlinger::PlaybackThread::latency_l() const
2494{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002495 uint32_t latency;
2496 if (initCheck() == NO_ERROR && mOutput->stream->getLatency(&latency) == OK) {
2497 return correctLatency_l(latency);
Eric Laurent81784c32012-11-19 14:55:58 -08002498 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002499 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002500}
2501
2502void AudioFlinger::PlaybackThread::setMasterVolume(float value)
2503{
2504 Mutex::Autolock _l(mLock);
2505 // Don't apply master volume in SW if our HAL can do it for us.
2506 if (mOutput && mOutput->audioHwDev &&
2507 mOutput->audioHwDev->canSetMasterVolume()) {
2508 mMasterVolume = 1.0;
2509 } else {
2510 mMasterVolume = value;
2511 }
2512}
2513
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002514void AudioFlinger::PlaybackThread::setMasterBalance(float balance)
2515{
2516 mMasterBalance.store(balance);
2517}
2518
Eric Laurent81784c32012-11-19 14:55:58 -08002519void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
2520{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002521 if (isDuplicating()) {
2522 return;
2523 }
Eric Laurent81784c32012-11-19 14:55:58 -08002524 Mutex::Autolock _l(mLock);
2525 // Don't apply master mute in SW if our HAL can do it for us.
2526 if (mOutput && mOutput->audioHwDev &&
2527 mOutput->audioHwDev->canSetMasterMute()) {
2528 mMasterMute = false;
2529 } else {
2530 mMasterMute = muted;
2531 }
2532}
2533
2534void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
2535{
2536 Mutex::Autolock _l(mLock);
2537 mStreamTypes[stream].volume = value;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002538 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002539}
2540
2541void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
2542{
2543 Mutex::Autolock _l(mLock);
2544 mStreamTypes[stream].mute = muted;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002545 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002546}
2547
2548float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
2549{
2550 Mutex::Autolock _l(mLock);
2551 return mStreamTypes[stream].volume;
2552}
2553
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09002554void AudioFlinger::PlaybackThread::setVolumeForOutput_l(float left, float right) const
2555{
2556 mOutput->stream->setVolume(left, right);
2557}
2558
Eric Laurent81784c32012-11-19 14:55:58 -08002559// addTrack_l() must be called with ThreadBase::mLock held
2560status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
2561{
2562 status_t status = ALREADY_EXISTS;
2563
Eric Laurent81784c32012-11-19 14:55:58 -08002564 if (mActiveTracks.indexOf(track) < 0) {
2565 // the track is newly added, make sure it fills up all its
2566 // buffers before playing. This is to ensure the client will
2567 // effectively get the latency it requested.
Eric Laurent83b88082014-06-20 18:31:16 -07002568 if (track->isExternalTrack()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002569 TrackBase::track_state state = track->mState;
2570 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002571 status = AudioSystem::startOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002572 mLock.lock();
2573 // abort track was stopped/paused while we released the lock
2574 if (state != track->mState) {
2575 if (status == NO_ERROR) {
2576 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002577 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002578 mLock.lock();
2579 }
2580 return INVALID_OPERATION;
2581 }
2582 // abort if start is rejected by audio policy manager
2583 if (status != NO_ERROR) {
2584 return PERMISSION_DENIED;
2585 }
2586#ifdef ADD_BATTERY_DATA
2587 // to track the speaker usage
2588 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
2589#endif
Eric Laurent09f1ed22019-04-24 17:45:17 -07002590 sendIoConfigEvent_l(AUDIO_CLIENT_STARTED, track->creatorPid(), track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002591 }
2592
Eric Laurent51716182016-02-29 18:00:56 -08002593 // set retry count for buffer fill
2594 if (track->isOffloaded()) {
Eric Laurente93cc032016-05-05 10:15:10 -07002595 if (track->isStopping_1()) {
2596 track->mRetryCount = kMaxTrackStopRetriesOffload;
2597 } else {
2598 track->mRetryCount = kMaxTrackStartupRetriesOffload;
2599 }
2600 track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
Eric Laurent51716182016-02-29 18:00:56 -08002601 } else {
2602 track->mRetryCount = kMaxTrackStartupRetries;
Eric Laurente93cc032016-05-05 10:15:10 -07002603 track->mFillingUpStatus =
2604 track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
Eric Laurent51716182016-02-29 18:00:56 -08002605 }
2606
jiabineb3bda02020-06-30 14:07:03 -07002607 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2608 if (mHapticChannelMask != AUDIO_CHANNEL_NONE
2609 && ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
2610 || (chain != nullptr && chain->containsHapticGeneratingEffect_l()))) {
jiabin57303cc2018-12-18 15:45:57 -08002611 // Unlock due to VibratorService will lock for this call and will
2612 // call Tracks.mute/unmute which also require thread's lock.
2613 mLock.unlock();
2614 const int intensity = AudioFlinger::onExternalVibrationStart(
2615 track->getExternalVibration());
Lais Andradebc3f37a2021-07-02 00:13:19 +01002616 std::optional<media::AudioVibratorInfo> vibratorInfo;
2617 {
2618 // TODO(b/184194780): Use the vibrator information from the vibrator that will be
2619 // used to play this track.
2620 Mutex::Autolock _l(mAudioFlinger->mLock);
2621 vibratorInfo = std::move(mAudioFlinger->getDefaultVibratorInfo_l());
2622 }
jiabin57303cc2018-12-18 15:45:57 -08002623 mLock.lock();
jiabine70bc7f2020-06-30 22:07:55 -07002624 track->setHapticIntensity(static_cast<os::HapticScale>(intensity));
Lais Andradebc3f37a2021-07-02 00:13:19 +01002625 if (vibratorInfo) {
2626 track->setHapticMaxAmplitude(vibratorInfo->maxAmplitude);
2627 }
2628
jiabin57303cc2018-12-18 15:45:57 -08002629 // Haptic playback should be enabled by vibrator service.
2630 if (track->getHapticPlaybackEnabled()) {
2631 // Disable haptic playback of all active track to ensure only
2632 // one track playing haptic if current track should play haptic.
2633 for (const auto &t : mActiveTracks) {
2634 t->setHapticPlaybackEnabled(false);
2635 }
jiabin245cdd92018-12-07 17:55:15 -08002636 }
jiabine70bc7f2020-06-30 22:07:55 -07002637
2638 // Set haptic intensity for effect
2639 if (chain != nullptr) {
2640 chain->setHapticIntensity_l(track->id(), intensity);
2641 }
jiabin245cdd92018-12-07 17:55:15 -08002642 }
2643
Eric Laurent81784c32012-11-19 14:55:58 -08002644 track->mResetDone = false;
Andy Hung59de4262021-06-14 10:53:54 -07002645 track->resetPresentationComplete();
Eric Laurent81784c32012-11-19 14:55:58 -08002646 mActiveTracks.add(track);
Eric Laurentd0107bc2013-06-11 14:38:48 -07002647 if (chain != 0) {
2648 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2649 track->sessionId());
2650 chain->incActiveTrackCnt();
Eric Laurent81784c32012-11-19 14:55:58 -08002651 }
2652
Andy Hungc2b11cb2020-04-22 09:04:01 -07002653 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent81784c32012-11-19 14:55:58 -08002654 status = NO_ERROR;
2655 }
2656
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08002657 onAddNewTrack_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002658 return status;
2659}
2660
Eric Laurentbfb1b832013-01-07 09:53:42 -08002661bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
Eric Laurent81784c32012-11-19 14:55:58 -08002662{
Eric Laurentbfb1b832013-01-07 09:53:42 -08002663 track->terminate();
Eric Laurent81784c32012-11-19 14:55:58 -08002664 // active tracks are removed by threadLoop()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002665 bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2666 track->mState = TrackBase::STOPPED;
2667 if (!trackActive) {
Eric Laurent81784c32012-11-19 14:55:58 -08002668 removeTrack_l(track);
Eric Laurentab5cdba2014-06-09 17:22:27 -07002669 } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002670 track->mState = TrackBase::STOPPING_1;
Eric Laurent81784c32012-11-19 14:55:58 -08002671 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002672
2673 return trackActive;
Eric Laurent81784c32012-11-19 14:55:58 -08002674}
2675
2676void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2677{
2678 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Andy Hung2148bf02016-11-28 19:01:02 -08002679
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002680 String8 result;
2681 track->appendDump(result, false /* active */);
2682 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
Andy Hung2148bf02016-11-28 19:01:02 -08002683
Eric Laurent81784c32012-11-19 14:55:58 -08002684 mTracks.remove(track);
jiabin18a4b1c2020-09-17 11:40:42 -07002685 {
2686 Mutex::Autolock _atCbL(mAudioTrackCbLock);
2687 mAudioTrackCallbacks.erase(track);
2688 }
Eric Laurent81784c32012-11-19 14:55:58 -08002689 if (track->isFastTrack()) {
2690 int index = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07002691 ALOG_ASSERT(0 < index && index < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08002692 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
2693 mFastTrackAvailMask |= 1 << index;
2694 // redundant as track is about to be destroyed, for dumpsys only
2695 track->mFastIndex = -1;
2696 }
2697 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2698 if (chain != 0) {
2699 chain->decTrackCnt();
2700 }
2701}
2702
2703String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
2704{
Eric Laurent81784c32012-11-19 14:55:58 -08002705 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002706 String8 out_s8;
2707 if (initCheck() == NO_ERROR && mOutput->stream->getParameters(keys, &out_s8) == OK) {
2708 return out_s8;
Eric Laurent81784c32012-11-19 14:55:58 -08002709 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002710 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08002711}
2712
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002713status_t AudioFlinger::DirectOutputThread::selectPresentation(int presentationId, int programId) {
2714 Mutex::Autolock _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002715 if (!isStreamInitialized()) {
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002716 return NO_INIT;
2717 }
2718 return mOutput->stream->selectPresentation(presentationId, programId);
2719}
2720
Eric Laurent09f1ed22019-04-24 17:45:17 -07002721void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
2722 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002723 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
2724 ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
Eric Laurent81784c32012-11-19 14:55:58 -08002725
Eric Laurent73e26b62015-04-27 16:55:58 -07002726 desc->mIoHandle = mId;
Eric Laurent74c38dc2020-12-23 18:19:44 +01002727 struct audio_patch patch = mPatch;
2728 if (isMsdDevice()) {
2729 patch = mDownStreamPatch;
2730 }
Eric Laurent81784c32012-11-19 14:55:58 -08002731
2732 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002733 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002734 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07002735 case AUDIO_OUTPUT_CONFIG_CHANGED:
Eric Laurent74c38dc2020-12-23 18:19:44 +01002736 desc->mPatch = patch;
Eric Laurent73e26b62015-04-27 16:55:58 -07002737 desc->mChannelMask = mChannelMask;
2738 desc->mSamplingRate = mSampleRate;
2739 desc->mFormat = mFormat;
2740 desc->mFrameCount = mNormalFrameCount; // FIXME see
Eric Laurent81784c32012-11-19 14:55:58 -08002741 // AudioFlinger::frameCount(audio_io_handle_t)
Glenn Kasten4a8308b2016-04-18 14:10:01 -07002742 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07002743 desc->mLatency = latency_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002744 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07002745 case AUDIO_CLIENT_STARTED:
Eric Laurent74c38dc2020-12-23 18:19:44 +01002746 desc->mPatch = patch;
Eric Laurent09f1ed22019-04-24 17:45:17 -07002747 desc->mPortId = portId;
2748 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07002749 case AUDIO_OUTPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08002750 default:
2751 break;
2752 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002753 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08002754}
2755
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002756void AudioFlinger::PlaybackThread::onWriteReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002757{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002758 mCallbackThread->resetWriteBlocked();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002759}
2760
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002761void AudioFlinger::PlaybackThread::onDrainReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002762{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002763 mCallbackThread->resetDraining();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002764}
2765
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002766void AudioFlinger::PlaybackThread::onError()
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002767{
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002768 mCallbackThread->setAsyncError();
2769}
2770
jiabinf6eb4c32020-02-25 14:06:25 -08002771void AudioFlinger::PlaybackThread::onCodecFormatChanged(
2772 const std::basic_string<uint8_t>& metadataBs)
2773{
2774 std::thread([this, metadataBs]() {
2775 audio_utils::metadata::Data metadata =
2776 audio_utils::metadata::dataFromByteString(metadataBs);
2777 if (metadata.empty()) {
2778 ALOGW("Can not transform the buffer to audio metadata, %s, %d",
2779 reinterpret_cast<char*>(const_cast<uint8_t*>(metadataBs.data())),
2780 (int)metadataBs.size());
2781 return;
2782 }
2783
2784 audio_utils::metadata::ByteString metaDataStr =
2785 audio_utils::metadata::byteStringFromData(metadata);
2786 std::vector metadataVec(metaDataStr.begin(), metaDataStr.end());
2787 Mutex::Autolock _l(mAudioTrackCbLock);
jiabin18a4b1c2020-09-17 11:40:42 -07002788 for (const auto& callbackPair : mAudioTrackCallbacks) {
2789 callbackPair.second->onCodecFormatChanged(metadataVec);
jiabinf6eb4c32020-02-25 14:06:25 -08002790 }
2791 }).detach();
2792}
2793
Eric Laurent3b4529e2013-09-05 18:09:19 -07002794void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002795{
2796 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002797 // reject out of sequence requests
2798 if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
2799 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002800 mWaitWorkCV.signal();
2801 }
2802}
2803
Eric Laurent3b4529e2013-09-05 18:09:19 -07002804void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002805{
2806 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002807 // reject out of sequence requests
2808 if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
Andy Hungf3234512018-07-03 14:51:47 -07002809 // Register discontinuity when HW drain is completed because that can cause
2810 // the timestamp frame position to reset to 0 for direct and offload threads.
2811 // (Out of sequence requests are ignored, since the discontinuity would be handled
2812 // elsewhere, e.g. in flush).
Dean Wheatley12473e92021-03-18 23:00:55 +11002813 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002814 mDrainSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002815 mWaitWorkCV.signal();
2816 }
2817}
2818
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002819void AudioFlinger::PlaybackThread::readOutputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08002820{
Glenn Kastenadad3d72014-02-21 14:51:43 -08002821 // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
Mikhail Naganov560637e2021-03-31 22:40:13 +00002822 const audio_config_base_t audioConfig = mOutput->getAudioProperties();
2823 mSampleRate = audioConfig.sample_rate;
2824 mChannelMask = audioConfig.channel_mask;
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002825 if (!audio_is_output_channel(mChannelMask)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002826 LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002827 }
Andy Hung9a592762014-07-21 21:56:01 -07002828 if ((mType == MIXER || mType == DUPLICATING)
2829 && !isValidPcmSinkChannelMask(mChannelMask)) {
2830 LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
2831 mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002832 }
Andy Hunge5412692014-05-16 11:25:07 -07002833 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002834 mBalance.setChannelMask(mChannelMask);
Phil Burkca5e6142015-07-14 09:42:29 -07002835
2836 // Get actual HAL format.
Mikhail Naganov560637e2021-03-31 22:40:13 +00002837 status_t result = mOutput->stream->getAudioProperties(nullptr, nullptr, &mHALFormat);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002838 LOG_ALWAYS_FATAL_IF(result != OK, "Error when retrieving output stream format: %d", result);
Phil Burkca5e6142015-07-14 09:42:29 -07002839 // Get format from the shim, which will be different than the HAL format
2840 // if playing compressed audio over HDMI passthrough.
Mikhail Naganov560637e2021-03-31 22:40:13 +00002841 mFormat = audioConfig.format;
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002842 if (!audio_is_valid_format(mFormat)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002843 LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002844 }
Andy Hung6146c082014-03-18 11:56:15 -07002845 if ((mType == MIXER || mType == DUPLICATING)
2846 && !isValidPcmSinkFormat(mFormat)) {
2847 LOG_FATAL("HAL format %#x not supported for mixed output",
2848 mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002849 }
Phil Burk062e67a2015-02-11 13:40:50 -08002850 mFrameSize = mOutput->getFrameSize();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002851 result = mOutput->stream->getBufferSize(&mBufferSize);
2852 LOG_ALWAYS_FATAL_IF(result != OK,
2853 "Error when retrieving output stream buffer size: %d", result);
Glenn Kasten70949c42013-08-06 07:40:12 -07002854 mFrameCount = mBufferSize / mFrameSize;
Dean Wheatley77cbebd2019-04-23 14:18:44 +10002855 if ((mType == MIXER || mType == DUPLICATING) && (mFrameCount & 15)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002856 ALOGW("HAL output buffer size is %zu frames but AudioMixer requires multiples of 16 frames",
Eric Laurent81784c32012-11-19 14:55:58 -08002857 mFrameCount);
2858 }
2859
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002860 if (mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) {
2861 if (mOutput->stream->setCallback(this) == OK) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002862 mUseAsyncWrite = true;
Eric Laurent4de95592013-09-26 15:28:21 -07002863 mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002864 }
2865 }
2866
Eric Laurentd1f69b02014-12-15 14:33:13 -08002867 mHwSupportsPause = false;
2868 if (mOutput->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002869 bool supportsPause = false, supportsResume = false;
2870 if (mOutput->stream->supportsPauseAndResume(&supportsPause, &supportsResume) == OK) {
2871 if (supportsPause && supportsResume) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002872 mHwSupportsPause = true;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002873 } else if (supportsPause) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002874 ALOGW("direct output implements pause but not resume");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002875 } else if (supportsResume) {
2876 ALOGW("direct output implements resume but not pause");
Eric Laurentd1f69b02014-12-15 14:33:13 -08002877 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002878 }
2879 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07002880 if (!mHwSupportsPause && mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
2881 LOG_ALWAYS_FATAL("HW_AV_SYNC requested but HAL does not implement pause and resume");
2882 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002883
Andy Hungfbfc3952015-01-15 13:33:51 -08002884 if (mType == DUPLICATING && mMixerBufferEnabled && mEffectBufferEnabled) {
2885 // For best precision, we use float instead of the associated output
2886 // device format (typically PCM 16 bit).
2887
2888 mFormat = AUDIO_FORMAT_PCM_FLOAT;
2889 mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
2890 mBufferSize = mFrameSize * mFrameCount;
2891
2892 // TODO: We currently use the associated output device channel mask and sample rate.
2893 // (1) Perhaps use the ORed channel mask of all downstream MixerThreads
2894 // (if a valid mask) to avoid premature downmix.
2895 // (2) Perhaps use the maximum sample rate of all downstream MixerThreads
2896 // instead of the output device sample rate to avoid loss of high frequency information.
2897 // This may need to be updated as MixerThread/OutputTracks are added and not here.
2898 }
2899
Andy Hung09a50072014-02-27 14:30:47 -08002900 // Calculate size of normal sink buffer relative to the HAL output buffer size
Eric Laurent81784c32012-11-19 14:55:58 -08002901 double multiplier = 1.0;
2902 if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
2903 kUseFastMixer == FastMixer_Dynamic)) {
Andy Hung09a50072014-02-27 14:30:47 -08002904 size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
2905 size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002906
Eric Laurent81784c32012-11-19 14:55:58 -08002907 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
2908 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
2909 maxNormalFrameCount = maxNormalFrameCount & ~15;
2910 if (maxNormalFrameCount < minNormalFrameCount) {
2911 maxNormalFrameCount = minNormalFrameCount;
2912 }
2913 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
2914 if (multiplier <= 1.0) {
2915 multiplier = 1.0;
2916 } else if (multiplier <= 2.0) {
2917 if (2 * mFrameCount <= maxNormalFrameCount) {
2918 multiplier = 2.0;
2919 } else {
2920 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
2921 }
2922 } else {
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002923 multiplier = floor(multiplier);
Eric Laurent81784c32012-11-19 14:55:58 -08002924 }
2925 }
2926 mNormalFrameCount = multiplier * mFrameCount;
2927 // round up to nearest 16 frames to satisfy AudioMixer
Eric Laurentab5cdba2014-06-09 17:22:27 -07002928 if (mType == MIXER || mType == DUPLICATING) {
2929 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
2930 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002931 ALOGI("HAL output buffer size %zu frames, normal sink buffer size %zu frames", mFrameCount,
Eric Laurent81784c32012-11-19 14:55:58 -08002932 mNormalFrameCount);
2933
Andy Hung08fb1742015-05-31 23:22:10 -07002934 // Check if we want to throttle the processing to no more than 2x normal rate
2935 mThreadThrottle = property_get_bool("af.thread.throttle", true /* default_value */);
Andy Hung40eb1a12015-06-18 13:42:02 -07002936 mThreadThrottleTimeMs = 0;
2937 mThreadThrottleEndMs = 0;
Andy Hung08fb1742015-05-31 23:22:10 -07002938 mHalfBufferMs = mNormalFrameCount * 1000 / (2 * mSampleRate);
2939
Andy Hung010a1a12014-03-13 13:57:33 -07002940 // mSinkBuffer is the sink buffer. Size is always multiple-of-16 frames.
2941 // Originally this was int16_t[] array, need to remove legacy implications.
2942 free(mSinkBuffer);
2943 mSinkBuffer = NULL;
Andy Hung5b10a202014-03-13 13:59:29 -07002944 // For sink buffer size, we use the frame size from the downstream sink to avoid problems
2945 // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
2946 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
Andy Hung010a1a12014-03-13 13:57:33 -07002947 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002948
Andy Hung69aed5f2014-02-25 17:24:40 -08002949 // We resize the mMixerBuffer according to the requirements of the sink buffer which
2950 // drives the output.
2951 free(mMixerBuffer);
2952 mMixerBuffer = NULL;
2953 if (mMixerBufferEnabled) {
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002954 mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // no longer valid: AUDIO_FORMAT_PCM_16_BIT.
Andy Hung69aed5f2014-02-25 17:24:40 -08002955 mMixerBufferSize = mNormalFrameCount * mChannelCount
2956 * audio_bytes_per_sample(mMixerBufferFormat);
2957 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
2958 }
Andy Hung98ef9782014-03-04 14:46:50 -08002959 free(mEffectBuffer);
2960 mEffectBuffer = NULL;
2961 if (mEffectBufferEnabled) {
rago94a1ee82017-07-21 15:11:02 -07002962 mEffectBufferFormat = EFFECT_BUFFER_FORMAT;
Andy Hung98ef9782014-03-04 14:46:50 -08002963 mEffectBufferSize = mNormalFrameCount * mChannelCount
2964 * audio_bytes_per_sample(mEffectBufferFormat);
2965 (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
2966 }
Andy Hung69aed5f2014-02-25 17:24:40 -08002967
Mikhail Naganov55773032020-10-01 15:08:13 -07002968 mHapticChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & AUDIO_CHANNEL_HAPTIC_ALL);
2969 mChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & ~mHapticChannelMask);
jiabin245cdd92018-12-07 17:55:15 -08002970 mHapticChannelCount = audio_channel_count_from_out_mask(mHapticChannelMask);
2971 mChannelCount -= mHapticChannelCount;
2972
Eric Laurent81784c32012-11-19 14:55:58 -08002973 // force reconfiguration of effect chains and engines to take new buffer size and audio
2974 // parameters into account
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002975 // Note that mLock is not held when readOutputParameters_l() is called from the constructor
Eric Laurent81784c32012-11-19 14:55:58 -08002976 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
2977 // matter.
2978 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
2979 Vector< sp<EffectChain> > effectChains = mEffectChains;
2980 for (size_t i = 0; i < effectChains.size(); i ++) {
Eric Laurent6c796322019-04-09 14:13:17 -07002981 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(),
2982 this/* srcThread */, this/* dstThread */);
Eric Laurent81784c32012-11-19 14:55:58 -08002983 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08002984
George Burgess IV5e4d86f2020-02-18 12:55:36 -08002985 audio_output_flags_t flags = mOutput->flags;
Andy Hungcf10d742020-04-28 15:38:24 -07002986 mediametrics::LogItem item(mThreadMetrics.getMetricsId()); // TODO: method in ThreadMetrics?
Andy Hungb68f5eb2019-12-03 16:49:17 -08002987 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
2988 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
2989 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
2990 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
2991 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
2992 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mNormalFrameCount)
2993 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
2994 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
2995 (int32_t)mHapticChannelMask)
2996 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
2997 (int32_t)mHapticChannelCount)
2998 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
2999 formatToString(mHALFormat).c_str())
3000 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
3001 (int32_t)mFrameCount) // sic - added HAL
3002 ;
3003 uint32_t latencyMs;
3004 if (mOutput->stream->getLatency(&latencyMs) == NO_ERROR) {
3005 item.set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_LATENCYMS, (double)latencyMs);
3006 }
3007 item.record();
Eric Laurent81784c32012-11-19 14:55:58 -08003008}
3009
Kevin Rocard069c2712018-03-29 19:09:14 -07003010void AudioFlinger::PlaybackThread::updateMetadata_l()
3011{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08003012 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
Kevin Rocard12381092018-04-11 09:19:59 -07003013 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07003014 }
3015 StreamOutHalInterface::SourceMetadata metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07003016 auto backInserter = std::back_inserter(metadata.tracks);
Kevin Rocard069c2712018-03-29 19:09:14 -07003017 for (const sp<Track> &track : mActiveTracks) {
3018 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurentb9cc0ab2021-01-29 11:46:52 +01003019 // Do not forward metadata for PatchTrack with unspecified stream type
3020 if (track->streamType() != AUDIO_STREAM_PATCH) {
3021 track->copyMetadataTo(backInserter);
3022 }
Kevin Rocard069c2712018-03-29 19:09:14 -07003023 }
Kevin Rocard12381092018-04-11 09:19:59 -07003024 sendMetadataToBackend_l(metadata);
Kevin Rocard80ee2722018-04-11 15:53:48 +00003025}
Kevin Rocardc86a7f72018-04-03 09:00:09 -07003026
Kevin Rocard12381092018-04-11 09:19:59 -07003027void AudioFlinger::PlaybackThread::sendMetadataToBackend_l(
3028 const StreamOutHalInterface::SourceMetadata& metadata)
3029{
3030 mOutput->stream->updateSourceMetadata(metadata);
3031};
3032
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003033status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08003034{
3035 if (halFrames == NULL || dspFrames == NULL) {
3036 return BAD_VALUE;
3037 }
3038 Mutex::Autolock _l(mLock);
3039 if (initCheck() != NO_ERROR) {
3040 return INVALID_OPERATION;
3041 }
Andy Hung818e7a32016-02-16 18:08:07 -08003042 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08003043 *halFrames = framesWritten;
3044
3045 if (isSuspended()) {
3046 // return an estimation of rendered frames when the output is suspended
3047 size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08003048 *dspFrames = (uint32_t)
3049 (framesWritten >= (int64_t)latencyFrames ? framesWritten - latencyFrames : 0);
Eric Laurent81784c32012-11-19 14:55:58 -08003050 return NO_ERROR;
3051 } else {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003052 status_t status;
3053 uint32_t frames;
Phil Burk062e67a2015-02-11 13:40:50 -08003054 status = mOutput->getRenderPosition(&frames);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00003055 *dspFrames = (size_t)frames;
3056 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08003057 }
3058}
3059
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08003060product_strategy_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08003061{
3062 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
3063 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
3064 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
3065 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
3066 }
3067 for (size_t i = 0; i < mTracks.size(); i++) {
3068 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08003069 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003070 return AudioSystem::getStrategyForStream(track->streamType());
3071 }
3072 }
3073 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
3074}
3075
3076
Phil Burk062e67a2015-02-11 13:40:50 -08003077AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
Eric Laurent81784c32012-11-19 14:55:58 -08003078{
3079 Mutex::Autolock _l(mLock);
3080 return mOutput;
3081}
3082
Phil Burk062e67a2015-02-11 13:40:50 -08003083AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
Eric Laurent81784c32012-11-19 14:55:58 -08003084{
3085 Mutex::Autolock _l(mLock);
3086 AudioStreamOut *output = mOutput;
3087 mOutput = NULL;
3088 // FIXME FastMixer might also have a raw ptr to mOutputSink;
3089 // must push a NULL and wait for ack
3090 mOutputSink.clear();
3091 mPipeSink.clear();
3092 mNormalSink.clear();
3093 return output;
3094}
3095
3096// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003097sp<StreamHalInterface> AudioFlinger::PlaybackThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08003098{
3099 if (mOutput == NULL) {
3100 return NULL;
3101 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003102 return mOutput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08003103}
3104
3105uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
3106{
3107 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
3108}
3109
3110status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
3111{
3112 if (!isValidSyncEvent(event)) {
3113 return BAD_VALUE;
3114 }
3115
3116 Mutex::Autolock _l(mLock);
3117
3118 for (size_t i = 0; i < mTracks.size(); ++i) {
3119 sp<Track> track = mTracks[i];
3120 if (event->triggerSession() == track->sessionId()) {
3121 (void) track->setSyncEvent(event);
3122 return NO_ERROR;
3123 }
3124 }
3125
3126 return NAME_NOT_FOUND;
3127}
3128
3129bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
3130{
3131 return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
3132}
3133
3134void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
3135 const Vector< sp<Track> >& tracksToRemove)
3136{
Andy Hungfe726a62018-09-27 15:17:25 -07003137 // Miscellaneous track cleanup when removed from the active list,
3138 // called without Thread lock but synchronized with threadLoop processing.
Eric Laurentbfb1b832013-01-07 09:53:42 -08003139#ifdef ADD_BATTERY_DATA
Andy Hungfe726a62018-09-27 15:17:25 -07003140 for (const auto& track : tracksToRemove) {
3141 if (track->isExternalTrack()) {
3142 // to track the speaker usage
3143 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Eric Laurent81784c32012-11-19 14:55:58 -08003144 }
3145 }
Andy Hungfe726a62018-09-27 15:17:25 -07003146#else
3147 (void)tracksToRemove; // suppress unused warning
3148#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003149}
3150
3151void AudioFlinger::PlaybackThread::checkSilentMode_l()
3152{
3153 if (!mMasterMute) {
3154 char value[PROPERTY_VALUE_MAX];
jiabin0a957d32020-04-29 10:56:20 -07003155 if (mOutDeviceTypeAddrs.empty()) {
3156 ALOGD("ro.audio.silent is ignored since no output device is set");
3157 return;
3158 }
jiabinc52b1ff2019-10-31 17:20:42 -07003159 if (isSingleDeviceType(outDeviceTypes(), AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) {
Jean-Michel Trivi32f37c22016-03-31 16:00:32 -07003160 ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
3161 return;
3162 }
Eric Laurent81784c32012-11-19 14:55:58 -08003163 if (property_get("ro.audio.silent", value, "0") > 0) {
3164 char *endptr;
3165 unsigned long ul = strtoul(value, &endptr, 0);
3166 if (*endptr == '\0' && ul != 0) {
3167 ALOGD("Silence is golden");
3168 // The setprop command will not allow a property to be changed after
3169 // the first time it is set, so we don't have to worry about un-muting.
3170 setMasterMute_l(true);
3171 }
3172 }
3173 }
3174}
3175
3176// shared by MIXER and DIRECT, overridden by DUPLICATING
Eric Laurentbfb1b832013-01-07 09:53:42 -08003177ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08003178{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003179 LOG_HIST_TS();
Eric Laurent81784c32012-11-19 14:55:58 -08003180 mInWrite = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003181 ssize_t bytesWritten;
Andy Hung010a1a12014-03-13 13:57:33 -07003182 const size_t offset = mCurrentWriteLength - mBytesRemaining;
Eric Laurent81784c32012-11-19 14:55:58 -08003183
3184 // If an NBAIO sink is present, use it to write the normal mixer's submix
3185 if (mNormalSink != 0) {
Glenn Kasten4c053ea2014-09-28 14:41:07 -07003186
Andy Hung010a1a12014-03-13 13:57:33 -07003187 const size_t count = mBytesRemaining / mFrameSize;
3188
Simon Wilson2d590962012-11-29 15:18:50 -08003189 ATRACE_BEGIN("write");
Eric Laurent81784c32012-11-19 14:55:58 -08003190 // update the setpoint when AudioFlinger::mScreenState changes
3191 uint32_t screenState = AudioFlinger::mScreenState;
3192 if (screenState != mScreenState) {
3193 mScreenState = screenState;
3194 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
3195 if (pipe != NULL) {
3196 pipe->setAvgFrames((mScreenState & 1) ?
3197 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
3198 }
3199 }
Andy Hung010a1a12014-03-13 13:57:33 -07003200 ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
Simon Wilson2d590962012-11-29 15:18:50 -08003201 ATRACE_END();
Eric Laurent81784c32012-11-19 14:55:58 -08003202 if (framesWritten > 0) {
Andy Hung010a1a12014-03-13 13:57:33 -07003203 bytesWritten = framesWritten * mFrameSize;
Andy Hung8946a282018-04-19 20:04:56 -07003204#ifdef TEE_SINK
3205 mTee.write((char *)mSinkBuffer + offset, framesWritten);
3206#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003207 } else {
3208 bytesWritten = framesWritten;
3209 }
3210 // otherwise use the HAL / AudioStreamOut directly
3211 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003212 // Direct output and offload threads
Andy Hung010a1a12014-03-13 13:57:33 -07003213
Eric Laurentbfb1b832013-01-07 09:53:42 -08003214 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003215 ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
3216 mWriteAckSequence += 2;
3217 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003218 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003219 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003220 }
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07003221 ATRACE_BEGIN("write");
Glenn Kasten767094d2013-08-23 13:51:43 -07003222 // FIXME We should have an implementation of timestamps for direct output threads.
3223 // They are used e.g for multichannel PCM playback over HDMI.
Phil Burk062e67a2015-02-11 13:40:50 -08003224 bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07003225 ATRACE_END();
Eric Laurent51716182016-02-29 18:00:56 -08003226
Eric Laurentbfb1b832013-01-07 09:53:42 -08003227 if (mUseAsyncWrite &&
3228 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
3229 // do not wait for async callback in case of error of full write
Eric Laurent3b4529e2013-09-05 18:09:19 -07003230 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003231 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003232 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003233 }
Eric Laurent81784c32012-11-19 14:55:58 -08003234 }
3235
Eric Laurent81784c32012-11-19 14:55:58 -08003236 mNumWrites++;
3237 mInWrite = false;
Andy Hungcf10d742020-04-28 15:38:24 -07003238 if (mStandby) {
3239 mThreadMetrics.logBeginInterval();
3240 mStandby = false;
3241 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003242 return bytesWritten;
3243}
3244
3245void AudioFlinger::PlaybackThread::threadLoop_drain()
3246{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003247 bool supportsDrain = false;
3248 if (mOutput->stream->supportsDrain(&supportsDrain) == OK && supportsDrain) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003249 ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
3250 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003251 ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
3252 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003253 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003254 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003255 }
Mikhail Naganovcbc8f612016-10-11 18:05:13 -07003256 status_t result = mOutput->stream->drain(mMixerStatus == MIXER_DRAIN_TRACK);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003257 ALOGE_IF(result != OK, "Error when draining stream: %d", result);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003258 }
3259}
3260
3261void AudioFlinger::PlaybackThread::threadLoop_exit()
3262{
Eric Laurent275e8e92014-11-30 15:14:47 -08003263 {
3264 Mutex::Autolock _l(mLock);
3265 for (size_t i = 0; i < mTracks.size(); i++) {
3266 sp<Track> track = mTracks[i];
3267 track->invalidate();
3268 }
Andy Hungdae27702016-10-31 14:01:16 -07003269 // Clear ActiveTracks to update BatteryNotifier in case active tracks remain.
3270 // After we exit there are no more track changes sent to BatteryNotifier
3271 // because that requires an active threadLoop.
3272 // TODO: should we decActiveTrackCnt() of the cleared track effect chain?
3273 mActiveTracks.clear();
Eric Laurent275e8e92014-11-30 15:14:47 -08003274 }
Eric Laurent81784c32012-11-19 14:55:58 -08003275}
3276
3277/*
3278The derived values that are cached:
Andy Hung25c2dac2014-02-27 14:56:00 -08003279 - mSinkBufferSize from frame count * frame size
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003280 - mActiveSleepTimeUs from activeSleepTimeUs()
3281 - mIdleSleepTimeUs from idleSleepTimeUs()
Eric Laurent42537be2016-01-08 17:16:42 -08003282 - mStandbyDelayNs from mActiveSleepTimeUs (DIRECT only) or forced to at least
3283 kDefaultStandbyTimeInNsecs when connected to an A2DP device.
Eric Laurent81784c32012-11-19 14:55:58 -08003284 - maxPeriod from frame count and sample rate (MIXER only)
3285
3286The parameters that affect these derived values are:
3287 - frame count
3288 - frame size
3289 - sample rate
3290 - device type: A2DP or not
3291 - device latency
3292 - format: PCM or not
3293 - active sleep time
3294 - idle sleep time
3295*/
3296
3297void AudioFlinger::PlaybackThread::cacheParameters_l()
3298{
Andy Hung25c2dac2014-02-27 14:56:00 -08003299 mSinkBufferSize = mNormalFrameCount * mFrameSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003300 mActiveSleepTimeUs = activeSleepTimeUs();
3301 mIdleSleepTimeUs = idleSleepTimeUs();
Eric Laurent42537be2016-01-08 17:16:42 -08003302
3303 // make sure standby delay is not too short when connected to an A2DP sink to avoid
3304 // truncating audio when going to standby.
3305 mStandbyDelayNs = AudioFlinger::mStandbyTimeInNsecs;
jiabinc52b1ff2019-10-31 17:20:42 -07003306 if (!Intersection(outDeviceTypes(), getAudioDeviceOutAllA2dpSet()).empty()) {
Eric Laurent42537be2016-01-08 17:16:42 -08003307 if (mStandbyDelayNs < kDefaultStandbyTimeInNsecs) {
3308 mStandbyDelayNs = kDefaultStandbyTimeInNsecs;
3309 }
3310 }
Eric Laurent81784c32012-11-19 14:55:58 -08003311}
3312
Eric Laurent13084622016-05-17 10:51:49 -07003313bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
Eric Laurent81784c32012-11-19 14:55:58 -08003314{
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003315 ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
Eric Laurent81784c32012-11-19 14:55:58 -08003316 this, streamType, mTracks.size());
Eric Laurent13084622016-05-17 10:51:49 -07003317 bool trackMatch = false;
Eric Laurent81784c32012-11-19 14:55:58 -08003318 size_t size = mTracks.size();
3319 for (size_t i = 0; i < size; i++) {
3320 sp<Track> t = mTracks[i];
Eric Laurentd60560a2015-04-10 11:31:20 -07003321 if (t->streamType() == streamType && t->isExternalTrack()) {
Glenn Kasten5736c352012-12-04 12:12:34 -08003322 t->invalidate();
Eric Laurent13084622016-05-17 10:51:49 -07003323 trackMatch = true;
Eric Laurent81784c32012-11-19 14:55:58 -08003324 }
3325 }
Eric Laurent13084622016-05-17 10:51:49 -07003326 return trackMatch;
Eric Laurent81784c32012-11-19 14:55:58 -08003327}
3328
Haynes Mathew George05317d22016-05-03 16:34:26 -07003329void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
3330{
3331 Mutex::Autolock _l(mLock);
3332 invalidateTracks_l(streamType);
3333}
3334
jiabinf042b9b2021-05-07 23:46:28 +00003335// getTrackById_l must be called with holding thread lock
3336AudioFlinger::PlaybackThread::Track* AudioFlinger::PlaybackThread::getTrackById_l(
3337 audio_port_handle_t trackPortId) {
3338 for (size_t i = 0; i < mTracks.size(); i++) {
3339 if (mTracks[i]->portId() == trackPortId) {
3340 return mTracks[i].get();
3341 }
3342 }
3343 return nullptr;
3344}
3345
Eric Laurent81784c32012-11-19 14:55:58 -08003346status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
3347{
Glenn Kastend848eb42016-03-08 13:42:11 -08003348 audio_session_t session = chain->sessionId();
Mikhail Naganov022b9952017-01-04 16:36:51 -08003349 sp<EffectBufferHalInterface> halInBuffer, halOutBuffer;
Kevin Rocard7588ff42018-01-08 11:11:30 -08003350 status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
Mikhail Naganov022b9952017-01-04 16:36:51 -08003351 mEffectBufferEnabled ? mEffectBuffer : mSinkBuffer,
3352 mEffectBufferEnabled ? mEffectBufferSize : mSinkBufferSize,
3353 &halInBuffer);
3354 if (result != OK) return result;
3355 halOutBuffer = halInBuffer;
rago94a1ee82017-07-21 15:11:02 -07003356 effect_buffer_t *buffer = reinterpret_cast<effect_buffer_t*>(halInBuffer->externalData());
Eric Laurent81784c32012-11-19 14:55:58 -08003357 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003358 if (!audio_is_global_session(session)) {
Eric Laurent81784c32012-11-19 14:55:58 -08003359 // Only one effect chain can be present in direct output thread and it uses
Andy Hung2098f272014-02-27 14:00:06 -08003360 // the sink buffer as input
Eric Laurent81784c32012-11-19 14:55:58 -08003361 if (mType != DIRECT) {
jiabin245cdd92018-12-07 17:55:15 -08003362 size_t numSamples = mNormalFrameCount * (mChannelCount + mHapticChannelCount);
Kevin Rocard7588ff42018-01-08 11:11:30 -08003363 status_t result = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
rago94a1ee82017-07-21 15:11:02 -07003364 numSamples * sizeof(effect_buffer_t),
Mikhail Naganov022b9952017-01-04 16:36:51 -08003365 &halInBuffer);
3366 if (result != OK) return result;
rago94a1ee82017-07-21 15:11:02 -07003367#ifdef FLOAT_EFFECT_CHAIN
3368 buffer = halInBuffer->audioBuffer()->f32;
3369#else
Mikhail Naganov022b9952017-01-04 16:36:51 -08003370 buffer = halInBuffer->audioBuffer()->s16;
rago94a1ee82017-07-21 15:11:02 -07003371#endif
Mikhail Naganov022b9952017-01-04 16:36:51 -08003372 ALOGV("addEffectChain_l() creating new input buffer %p session %d",
3373 buffer, session);
Eric Laurent81784c32012-11-19 14:55:58 -08003374 }
3375
3376 // Attach all tracks with same session ID to this chain.
3377 for (size_t i = 0; i < mTracks.size(); ++i) {
3378 sp<Track> track = mTracks[i];
3379 if (session == track->sessionId()) {
3380 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
3381 buffer);
3382 track->setMainBuffer(buffer);
3383 chain->incTrackCnt();
3384 }
3385 }
3386
3387 // indicate all active tracks in the chain
Andy Hungdae27702016-10-31 14:01:16 -07003388 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003389 if (session == track->sessionId()) {
3390 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
3391 chain->incActiveTrackCnt();
3392 }
3393 }
3394 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003395 chain->setThread(this);
Mikhail Naganov022b9952017-01-04 16:36:51 -08003396 chain->setInBuffer(halInBuffer);
3397 chain->setOutBuffer(halOutBuffer);
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003398 // Effect chain for session AUDIO_SESSION_DEVICE is inserted at end of effect
3399 // chains list in order to be processed last as it contains output device effects.
3400 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted just before to apply post
3401 // processing effects specific to an output stream before effects applied to all streams
3402 // routed to a given device.
Eric Laurent81784c32012-11-19 14:55:58 -08003403 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
3404 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
Glenn Kastend848eb42016-03-08 13:42:11 -08003405 // after track specific effects and before output stage.
Eric Laurent81784c32012-11-19 14:55:58 -08003406 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
Glenn Kastend848eb42016-03-08 13:42:11 -08003407 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX.
Eric Laurent81784c32012-11-19 14:55:58 -08003408 // Effect chain for other sessions are inserted at beginning of effect
3409 // chains list to be processed before output mix effects. Relative order between other
Glenn Kastend848eb42016-03-08 13:42:11 -08003410 // sessions is not important.
3411 static_assert(AUDIO_SESSION_OUTPUT_MIX == 0 &&
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003412 AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX &&
3413 AUDIO_SESSION_DEVICE < AUDIO_SESSION_OUTPUT_STAGE,
Glenn Kastend848eb42016-03-08 13:42:11 -08003414 "audio_session_t constants misdefined");
Eric Laurent81784c32012-11-19 14:55:58 -08003415 size_t size = mEffectChains.size();
3416 size_t i = 0;
3417 for (i = 0; i < size; i++) {
3418 if (mEffectChains[i]->sessionId() < session) {
3419 break;
3420 }
3421 }
3422 mEffectChains.insertAt(chain, i);
3423 checkSuspendOnAddEffectChain_l(chain);
3424
3425 return NO_ERROR;
3426}
3427
3428size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
3429{
Glenn Kastend848eb42016-03-08 13:42:11 -08003430 audio_session_t session = chain->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08003431
3432 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
3433
3434 for (size_t i = 0; i < mEffectChains.size(); i++) {
3435 if (chain == mEffectChains[i]) {
3436 mEffectChains.removeAt(i);
3437 // detach all active tracks from the chain
Andy Hungdae27702016-10-31 14:01:16 -07003438 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003439 if (session == track->sessionId()) {
3440 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
3441 chain.get(), session);
3442 chain->decActiveTrackCnt();
3443 }
3444 }
3445
3446 // detach all tracks with same session ID from this chain
3447 for (size_t i = 0; i < mTracks.size(); ++i) {
3448 sp<Track> track = mTracks[i];
3449 if (session == track->sessionId()) {
rago94a1ee82017-07-21 15:11:02 -07003450 track->setMainBuffer(reinterpret_cast<effect_buffer_t*>(mSinkBuffer));
Eric Laurent81784c32012-11-19 14:55:58 -08003451 chain->decTrackCnt();
3452 }
3453 }
3454 break;
3455 }
3456 }
3457 return mEffectChains.size();
3458}
3459
3460status_t AudioFlinger::PlaybackThread::attachAuxEffect(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003461 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003462{
3463 Mutex::Autolock _l(mLock);
3464 return attachAuxEffect_l(track, EffectId);
3465}
3466
3467status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003468 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003469{
3470 status_t status = NO_ERROR;
3471
3472 if (EffectId == 0) {
3473 track->setAuxBuffer(0, NULL);
3474 } else {
3475 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
3476 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
3477 if (effect != 0) {
3478 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
3479 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
3480 } else {
3481 status = INVALID_OPERATION;
3482 }
3483 } else {
3484 status = BAD_VALUE;
3485 }
3486 }
3487 return status;
3488}
3489
3490void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
3491{
3492 for (size_t i = 0; i < mTracks.size(); ++i) {
3493 sp<Track> track = mTracks[i];
3494 if (track->auxEffectId() == effectId) {
3495 attachAuxEffect_l(track, 0);
3496 }
3497 }
3498}
3499
3500bool AudioFlinger::PlaybackThread::threadLoop()
3501{
Glenn Kasten388d5712017-04-07 14:38:41 -07003502 tlNBLogWriter = mNBLogWriter.get();
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003503
Eric Laurent81784c32012-11-19 14:55:58 -08003504 Vector< sp<Track> > tracksToRemove;
3505
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003506 mStandbyTimeNs = systemTime();
Andy Hung446f4df2019-02-21 12:26:41 -08003507 int64_t lastLoopCountWritten = -2; // never matches "previous" loop, when loopCount = 0.
Eric Laurent81784c32012-11-19 14:55:58 -08003508
3509 // MIXER
3510 nsecs_t lastWarning = 0;
3511
3512 // DUPLICATING
3513 // FIXME could this be made local to while loop?
3514 writeFrames = 0;
3515
3516 cacheParameters_l();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003517 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003518
3519 if (mType == MIXER) {
3520 sleepTimeShift = 0;
3521 }
3522
3523 CpuStats cpuStats;
3524 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
3525
3526 acquireWakeLock();
3527
Glenn Kasteneef598c2017-04-03 14:41:13 -07003528 // mNBLogWriter logging APIs can only be called by a single thread, typically the
3529 // thread associated with this PlaybackThread.
3530 // If you want to share the mNBLogWriter with other threads (for example, binder threads)
3531 // then all such threads must agree to hold a common mutex before logging.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003532 // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
3533 // and then that string will be logged at the next convenient opportunity.
Glenn Kasteneef598c2017-04-03 14:41:13 -07003534 // See reference to logString below.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003535 const char *logString = NULL;
3536
rago1bb90822017-05-02 18:31:48 -07003537 // Estimated time for next buffer to be written to hal. This is used only on
3538 // suspended mode (for now) to help schedule the wait time until next iteration.
3539 nsecs_t timeLoopNextNs = 0;
3540
Eric Laurent664539d2013-09-23 18:24:31 -07003541 checkSilentMode_l();
Glenn Kasteneef598c2017-04-03 14:41:13 -07003542
Andy Hung2dbffc22018-08-08 18:50:41 -07003543 audio_patch_handle_t lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Andy Hungf3234512018-07-03 14:51:47 -07003544
Andy Hung446f4df2019-02-21 12:26:41 -08003545 // loopCount is used for statistics and diagnostics.
3546 for (int64_t loopCount = 0; !exitPending(); ++loopCount)
Eric Laurent81784c32012-11-19 14:55:58 -08003547 {
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08003548 // Log merge requests are performed during AudioFlinger binder transactions, but
3549 // that does not cover audio playback. It's requested here for that reason.
3550 mAudioFlinger->requestLogMerge();
3551
Eric Laurent81784c32012-11-19 14:55:58 -08003552 cpuStats.sample(myName);
3553
3554 Vector< sp<EffectChain> > effectChains;
Andy Hung6e6a2e62019-04-30 16:38:41 -07003555 audio_session_t activeHapticSessionId = AUDIO_SESSION_NONE;
Andy Hungc1646382019-04-30 16:12:10 -07003556 std::vector<sp<Track>> activeTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08003557
Andy Hung2dbffc22018-08-08 18:50:41 -07003558 // If the device is AUDIO_DEVICE_OUT_BUS, check for downstream latency.
3559 //
jiabinc52b1ff2019-10-31 17:20:42 -07003560 // Note: we access outDeviceTypes() outside of mLock.
3561 if (isMsdDevice() && outDeviceTypes().count(AUDIO_DEVICE_OUT_BUS) != 0) {
Andy Hung2dbffc22018-08-08 18:50:41 -07003562 // Here, we try for the AF lock, but do not block on it as the latency
3563 // is more informational.
3564 if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
3565 std::vector<PatchPanel::SoftwarePatch> swPatches;
3566 double latencyMs;
3567 status_t status = INVALID_OPERATION;
3568 audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3569 if (mAudioFlinger->mPatchPanel.getDownstreamSoftwarePatches(id(), &swPatches) == OK
3570 && swPatches.size() > 0) {
3571 status = swPatches[0].getLatencyMs_l(&latencyMs);
3572 downstreamPatchHandle = swPatches[0].getPatchHandle();
3573 }
3574 if (downstreamPatchHandle != lastDownstreamPatchHandle) {
Dean Wheatley30d28422018-11-06 10:27:40 +11003575 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003576 lastDownstreamPatchHandle = downstreamPatchHandle;
3577 }
3578 if (status == OK) {
3579 // verify downstream latency (we assume a max reasonable
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003580 // latency of 5 seconds).
3581 const double minLatency = 0., maxLatency = 5000.;
3582 if (latencyMs >= minLatency && latencyMs <= maxLatency) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10003583 ALOGVV("new downstream latency %lf ms", latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003584 } else {
3585 ALOGD("out of range downstream latency %lf ms", latencyMs);
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003586 if (latencyMs < minLatency) latencyMs = minLatency;
3587 else if (latencyMs > maxLatency) latencyMs = maxLatency;
Andy Hung2dbffc22018-08-08 18:50:41 -07003588 }
Dean Wheatley30d28422018-11-06 10:27:40 +11003589 mDownstreamLatencyStatMs.add(latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003590 }
3591 mAudioFlinger->mLock.unlock();
3592 }
3593 } else {
3594 if (lastDownstreamPatchHandle != AUDIO_PATCH_HANDLE_NONE) {
3595 // our device is no longer AUDIO_DEVICE_OUT_BUS, reset patch handle and stats.
Dean Wheatley30d28422018-11-06 10:27:40 +11003596 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003597 lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3598 }
3599 }
3600
Eric Laurent81784c32012-11-19 14:55:58 -08003601 { // scope for mLock
3602
3603 Mutex::Autolock _l(mLock);
3604
Eric Laurent021cf962014-05-13 10:18:14 -07003605 processConfigEvents_l();
Eric Laurent10351942014-05-08 18:49:52 -07003606
Glenn Kasteneef598c2017-04-03 14:41:13 -07003607 // See comment at declaration of logString for why this is done under mLock
Glenn Kasten9e58b552013-01-18 15:09:48 -08003608 if (logString != NULL) {
3609 mNBLogWriter->logTimestamp();
3610 mNBLogWriter->log(logString);
3611 logString = NULL;
3612 }
3613
Dean Wheatley12473e92021-03-18 23:00:55 +11003614 collectTimestamps_l();
Andy Hungc8fddf32018-08-08 18:32:37 -07003615
Eric Laurent81784c32012-11-19 14:55:58 -08003616 saveOutputTracks();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003617 if (mSignalPending) {
3618 // A signal was raised while we were unlocked
3619 mSignalPending = false;
3620 } else if (waitingAsyncCallback_l()) {
3621 if (exitPending()) {
3622 break;
3623 }
Marco Nelissen078538c2015-05-12 09:17:57 -07003624 bool released = false;
Eric Laurent64667972016-03-30 18:19:46 -07003625 if (!keepWakeLock()) {
Marco Nelissen078538c2015-05-12 09:17:57 -07003626 releaseWakeLock_l();
3627 released = true;
3628 }
Andy Hung10cbff12017-02-21 17:30:14 -08003629
3630 const int64_t waitNs = computeWaitTimeNs_l();
3631 ALOGV("wait async completion (wait time: %lld)", (long long)waitNs);
3632 status_t status = mWaitWorkCV.waitRelative(mLock, waitNs);
3633 if (status == TIMED_OUT) {
3634 mSignalPending = true; // if timeout recheck everything
3635 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003636 ALOGV("async completion/wake");
Marco Nelissen078538c2015-05-12 09:17:57 -07003637 if (released) {
3638 acquireWakeLock_l();
3639 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003640 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3641 mSleepTimeUs = 0;
Eric Laurentede6c3b2013-09-19 14:37:46 -07003642
3643 continue;
3644 }
Eric Tan39ec8d62018-07-24 09:49:29 -07003645 if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
Eric Laurentbfb1b832013-01-07 09:53:42 -08003646 isSuspended()) {
3647 // put audio hardware into standby after short delay
3648 if (shouldStandby_l()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003649
3650 threadLoop_standby();
3651
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003652 // This is where we go into standby
3653 if (!mStandby) {
3654 LOG_AUDIO_STATE();
Andy Hungcf10d742020-04-28 15:38:24 -07003655 mThreadMetrics.logEndInterval();
3656 mStandby = true;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003657 }
Andy Hungd0979812019-02-21 15:51:44 -08003658 sendStatistics(false /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -08003659 }
3660
Eric Tan39ec8d62018-07-24 09:49:29 -07003661 if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003662 // we're about to wait, flush the binder command buffer
3663 IPCThreadState::self()->flushCommands();
3664
3665 clearOutputTracks();
3666
3667 if (exitPending()) {
3668 break;
3669 }
3670
3671 releaseWakeLock_l();
3672 // wait until we have something to do...
3673 ALOGV("%s going to sleep", myName.string());
3674 mWaitWorkCV.wait(mLock);
3675 ALOGV("%s waking up", myName.string());
3676 acquireWakeLock_l();
3677
3678 mMixerStatus = MIXER_IDLE;
3679 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
3680 mBytesWritten = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003681 mBytesRemaining = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08003682 checkSilentMode_l();
3683
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003684 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3685 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003686 if (mType == MIXER) {
3687 sleepTimeShift = 0;
3688 }
3689
3690 continue;
3691 }
3692 }
Eric Laurent81784c32012-11-19 14:55:58 -08003693 // mMixerStatusIgnoringFastTracks is also updated internally
3694 mMixerStatus = prepareTracks_l(&tracksToRemove);
3695
Andy Hungdae27702016-10-31 14:01:16 -07003696 mActiveTracks.updatePowerState(this);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003697
Kevin Rocard069c2712018-03-29 19:09:14 -07003698 updateMetadata_l();
3699
Eric Laurent81784c32012-11-19 14:55:58 -08003700 // prevent any changes in effect chain list and in each effect chain
3701 // during mixing and effect process as the audio buffers could be deleted
3702 // or modified if an effect is created or deleted
3703 lockEffectChains_l(effectChains);
Andy Hung6e6a2e62019-04-30 16:38:41 -07003704
3705 // Determine which session to pick up haptic data.
3706 // This must be done under the same lock as prepareTracks_l().
jiabineb3bda02020-06-30 14:07:03 -07003707 // The haptic data from the effect is at a higher priority than the one from track.
Andy Hung6e6a2e62019-04-30 16:38:41 -07003708 // TODO: Write haptic data directly to sink buffer when mixing.
3709 if (mHapticChannelCount > 0 && effectChains.size() > 0) {
3710 for (const auto& track : mActiveTracks) {
jiabineb3bda02020-06-30 14:07:03 -07003711 sp<EffectChain> effectChain = getEffectChain_l(track->sessionId());
3712 if (effectChain != nullptr && effectChain->containsHapticGeneratingEffect_l()) {
3713 activeHapticSessionId = track->sessionId();
3714 break;
3715 }
Andy Hung6e6a2e62019-04-30 16:38:41 -07003716 if (track->getHapticPlaybackEnabled()) {
3717 activeHapticSessionId = track->sessionId();
3718 break;
3719 }
3720 }
3721 }
3722
Andy Hungc1646382019-04-30 16:12:10 -07003723 // Acquire a local copy of active tracks with lock (release w/o lock).
3724 //
3725 // Control methods on the track acquire the ThreadBase lock (e.g. start()
3726 // stop(), pause(), etc.), but the threadLoop is entitled to call audio
3727 // data / buffer methods on tracks from activeTracks without the ThreadBase lock.
3728 activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003729 } // mLock scope ends
Eric Laurent81784c32012-11-19 14:55:58 -08003730
Eric Laurentbfb1b832013-01-07 09:53:42 -08003731 if (mBytesRemaining == 0) {
3732 mCurrentWriteLength = 0;
3733 if (mMixerStatus == MIXER_TRACKS_READY) {
3734 // threadLoop_mix() sets mCurrentWriteLength
3735 threadLoop_mix();
3736 } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
3737 && (mMixerStatus != MIXER_DRAIN_ALL)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003738 // threadLoop_sleepTime sets mSleepTimeUs to 0 if data
Eric Laurentbfb1b832013-01-07 09:53:42 -08003739 // must be written to HAL
3740 threadLoop_sleepTime();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003741 if (mSleepTimeUs == 0) {
Andy Hung25c2dac2014-02-27 14:56:00 -08003742 mCurrentWriteLength = mSinkBufferSize;
Andy Hungc1646382019-04-30 16:12:10 -07003743
3744 // Tally underrun frames as we are inserting 0s here.
3745 for (const auto& track : activeTracks) {
Andy Hunge2e830f2019-12-03 12:54:46 -08003746 if (track->mFillingUpStatus == Track::FS_ACTIVE
3747 && !track->isStopped()
3748 && !track->isPaused()
3749 && !track->isTerminated()) {
3750 ALOGV("%s: track(%d) %s underrun due to thread sleep of %zu frames",
3751 __func__, track->id(), track->getTrackStateAsString(),
3752 mNormalFrameCount);
Andy Hungc1646382019-04-30 16:12:10 -07003753 track->mAudioTrackServerProxy->tallyUnderrunFrames(mNormalFrameCount);
3754 }
3755 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003756 }
3757 }
Andy Hung98ef9782014-03-04 14:46:50 -08003758 // Either threadLoop_mix() or threadLoop_sleepTime() should have set
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003759 // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
Andy Hung98ef9782014-03-04 14:46:50 -08003760 // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
3761 // or mSinkBuffer (if there are no effects).
3762 //
3763 // This is done pre-effects computation; if effects change to
3764 // support higher precision, this needs to move.
3765 //
3766 // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003767 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003768 if (mMixerBufferValid) {
3769 void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
3770 audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
3771
Andy Hung2ddee192015-12-18 17:34:44 -08003772 // mono blend occurs for mixer threads only (not direct or offloaded)
3773 // and is handled here if we're going directly to the sink.
3774 if (requireMonoBlend() && !mEffectBufferValid) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003775 mono_blend(mMixerBuffer, mMixerBufferFormat, mChannelCount, mNormalFrameCount,
3776 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003777 }
3778
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003779 if (!hasFastMixer()) {
3780 // Balance must take effect after mono conversion.
3781 // We do it here if there is no FastMixer.
3782 // mBalance detects zero balance within the class for speed (not needed here).
3783 mBalance.setBalance(mMasterBalance.load());
3784 mBalance.process((float *)mMixerBuffer, mNormalFrameCount);
3785 }
3786
Andy Hung98ef9782014-03-04 14:46:50 -08003787 memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003788 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3789
3790 // If we're going directly to the sink and there are haptic channels,
3791 // we should adjust channels as the sample data is partially interleaved
3792 // in this case.
3793 if (!mEffectBufferValid && mHapticChannelCount > 0) {
3794 adjust_channels_non_destructive(buffer, mChannelCount, buffer,
3795 mChannelCount + mHapticChannelCount,
3796 audio_bytes_per_sample(format),
3797 audio_bytes_per_frame(mChannelCount, format) * mNormalFrameCount);
3798 }
Andy Hung98ef9782014-03-04 14:46:50 -08003799 }
3800
Eric Laurentbfb1b832013-01-07 09:53:42 -08003801 mBytesRemaining = mCurrentWriteLength;
3802 if (isSuspended()) {
Andy Hung238fa3d2016-07-28 10:53:22 -07003803 // Simulate write to HAL when suspended (e.g. BT SCO phone call).
3804 mSleepTimeUs = suspendSleepTimeUs(); // assumes full buffer.
3805 const size_t framesRemaining = mBytesRemaining / mFrameSize;
3806 mBytesWritten += mBytesRemaining;
3807 mFramesWritten += framesRemaining;
3808 mSuspendedFrames += framesRemaining; // to adjust kernel HAL position
Eric Laurentbfb1b832013-01-07 09:53:42 -08003809 mBytesRemaining = 0;
3810 }
Eric Laurent81784c32012-11-19 14:55:58 -08003811
Eric Laurentbfb1b832013-01-07 09:53:42 -08003812 // only process effects if we're going to write
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003813 if (mSleepTimeUs == 0 && mType != OFFLOAD) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003814 for (size_t i = 0; i < effectChains.size(); i ++) {
3815 effectChains[i]->process_l();
jiabin47affe52019-04-04 18:02:07 -07003816 // TODO: Write haptic data directly to sink buffer when mixing.
Andy Hung6e6a2e62019-04-30 16:38:41 -07003817 if (activeHapticSessionId != AUDIO_SESSION_NONE
3818 && activeHapticSessionId == effectChains[i]->sessionId()) {
jiabin47affe52019-04-04 18:02:07 -07003819 // Haptic data is active in this case, copy it directly from
3820 // in buffer to out buffer.
3821 const size_t audioBufferSize = mNormalFrameCount
3822 * audio_bytes_per_frame(mChannelCount, EFFECT_BUFFER_FORMAT);
3823 memcpy_by_audio_format(
3824 (uint8_t*)effectChains[i]->outBuffer() + audioBufferSize,
3825 EFFECT_BUFFER_FORMAT,
3826 (const uint8_t*)effectChains[i]->inBuffer() + audioBufferSize,
3827 EFFECT_BUFFER_FORMAT, mNormalFrameCount * mHapticChannelCount);
3828 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003829 }
Eric Laurent81784c32012-11-19 14:55:58 -08003830 }
3831 }
Eric Laurent59fe0102013-09-27 18:48:26 -07003832 // Process effect chains for offloaded thread even if no audio
3833 // was read from audio track: process only updates effect state
3834 // and thus does have to be synchronized with audio writes but may have
3835 // to be called while waiting for async write callback
3836 if (mType == OFFLOAD) {
3837 for (size_t i = 0; i < effectChains.size(); i ++) {
3838 effectChains[i]->process_l();
3839 }
3840 }
Eric Laurent81784c32012-11-19 14:55:58 -08003841
Andy Hung98ef9782014-03-04 14:46:50 -08003842 // Only if the Effects buffer is enabled and there is data in the
3843 // Effects buffer (buffer valid), we need to
3844 // copy into the sink buffer.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003845 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003846 if (mEffectBufferValid) {
3847 //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
Andy Hung2ddee192015-12-18 17:34:44 -08003848
3849 if (requireMonoBlend()) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003850 mono_blend(mEffectBuffer, mEffectBufferFormat, mChannelCount, mNormalFrameCount,
3851 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003852 }
3853
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003854 if (!hasFastMixer()) {
3855 // Balance must take effect after mono conversion.
3856 // We do it here if there is no FastMixer.
3857 // mBalance detects zero balance within the class for speed (not needed here).
3858 mBalance.setBalance(mMasterBalance.load());
3859 mBalance.process((float *)mEffectBuffer, mNormalFrameCount);
3860 }
3861
Andy Hung98ef9782014-03-04 14:46:50 -08003862 memcpy_by_audio_format(mSinkBuffer, mFormat, mEffectBuffer, mEffectBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003863 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3864 // The sample data is partially interleaved when haptic channels exist,
3865 // we need to adjust channels here.
3866 if (mHapticChannelCount > 0) {
3867 adjust_channels_non_destructive(mSinkBuffer, mChannelCount, mSinkBuffer,
3868 mChannelCount + mHapticChannelCount,
3869 audio_bytes_per_sample(mFormat),
3870 audio_bytes_per_frame(mChannelCount, mFormat) * mNormalFrameCount);
3871 }
Andy Hung98ef9782014-03-04 14:46:50 -08003872 }
3873
Eric Laurent81784c32012-11-19 14:55:58 -08003874 // enable changes in effect chain
3875 unlockEffectChains(effectChains);
3876
Eric Laurentbfb1b832013-01-07 09:53:42 -08003877 if (!waitingAsyncCallback()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003878 // mSleepTimeUs == 0 means we must write to audio hardware
3879 if (mSleepTimeUs == 0) {
Andy Hung08fb1742015-05-31 23:22:10 -07003880 ssize_t ret = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003881 // writePeriodNs is updated >= 0 when ret > 0.
3882 int64_t writePeriodNs = -1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003883 if (mBytesRemaining) {
Andy Hung69488c42016-05-16 18:43:33 -07003884 // FIXME rewrite to reduce number of system calls
Andy Hung446f4df2019-02-21 12:26:41 -08003885 const int64_t lastIoBeginNs = systemTime();
Andy Hung08fb1742015-05-31 23:22:10 -07003886 ret = threadLoop_write();
Andy Hung446f4df2019-02-21 12:26:41 -08003887 const int64_t lastIoEndNs = systemTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003888 if (ret < 0) {
3889 mBytesRemaining = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003890 } else if (ret > 0) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003891 mBytesWritten += ret;
3892 mBytesRemaining -= ret;
Andy Hung446f4df2019-02-21 12:26:41 -08003893 const int64_t frames = ret / mFrameSize;
3894 mFramesWritten += frames;
3895
3896 writePeriodNs = lastIoEndNs - mLastIoEndNs;
3897 // process information relating to write time.
3898 if (audio_has_proportional_frames(mFormat)) {
3899 // we are in a continuous mixing cycle
3900 if (mMixerStatus == MIXER_TRACKS_READY &&
3901 loopCount == lastLoopCountWritten + 1) {
3902
3903 const double jitterMs =
3904 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
3905 {frames, writePeriodNs},
3906 {0, 0} /* lastTimestamp */, mSampleRate);
3907 const double processMs =
3908 (lastIoBeginNs - mLastIoEndNs) * 1e-6;
3909
3910 Mutex::Autolock _l(mLock);
3911 mIoJitterMs.add(jitterMs);
3912 mProcessTimeMs.add(processMs);
3913 }
3914
3915 // write blocked detection
3916 const int64_t deltaWriteNs = lastIoEndNs - lastIoBeginNs;
3917 if (mType == MIXER && deltaWriteNs > maxPeriod) {
3918 mNumDelayedWrites++;
3919 if ((lastIoEndNs - lastWarning) > kWarningThrottleNs) {
3920 ATRACE_NAME("underrun");
3921 ALOGW("write blocked for %lld msecs, "
3922 "%d delayed writes, thread %d",
3923 (long long)deltaWriteNs / NANOS_PER_MILLISECOND,
3924 mNumDelayedWrites, mId);
3925 lastWarning = lastIoEndNs;
3926 }
3927 }
3928 }
3929 // update timing info.
3930 mLastIoBeginNs = lastIoBeginNs;
3931 mLastIoEndNs = lastIoEndNs;
3932 lastLoopCountWritten = loopCount;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003933 }
3934 } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
3935 (mMixerStatus == MIXER_DRAIN_ALL)) {
3936 threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -08003937 }
Andy Hung08fb1742015-05-31 23:22:10 -07003938 if (mType == MIXER && !mStandby) {
Andy Hung08fb1742015-05-31 23:22:10 -07003939
3940 if (mThreadThrottle
3941 && mMixerStatus == MIXER_TRACKS_READY // we are mixing (active tracks)
Andy Hung446f4df2019-02-21 12:26:41 -08003942 && writePeriodNs > 0) { // we have write period info
Andy Hung08fb1742015-05-31 23:22:10 -07003943 // Limit MixerThread data processing to no more than twice the
3944 // expected processing rate.
3945 //
3946 // This helps prevent underruns with NuPlayer and other applications
3947 // which may set up buffers that are close to the minimum size, or use
3948 // deep buffers, and rely on a double-buffering sleep strategy to fill.
3949 //
3950 // The throttle smooths out sudden large data drains from the device,
3951 // e.g. when it comes out of standby, which often causes problems with
3952 // (1) mixer threads without a fast mixer (which has its own warm-up)
3953 // (2) minimum buffer sized tracks (even if the track is full,
3954 // the app won't fill fast enough to handle the sudden draw).
Haynes Mathew Georgef92b2172016-05-09 11:34:15 -07003955 //
3956 // Total time spent in last processing cycle equals time spent in
3957 // 1. threadLoop_write, as well as time spent in
3958 // 2. threadLoop_mix (significant for heavy mixing, especially
3959 // on low tier processors)
Andy Hung08fb1742015-05-31 23:22:10 -07003960
Andy Hung446f4df2019-02-21 12:26:41 -08003961 // it's OK if deltaMs is an overestimate.
3962
3963 const int32_t deltaMs = writePeriodNs / NANOS_PER_MILLISECOND;
Ivan Lozanoe02bc542017-10-26 09:51:54 -07003964
Ivan Lozanoea04d392017-11-07 14:37:07 -08003965 const int32_t throttleMs = (int32_t)mHalfBufferMs - deltaMs;
Andy Hung08fb1742015-05-31 23:22:10 -07003966 if ((signed)mHalfBufferMs >= throttleMs && throttleMs > 0) {
Andy Hungcf10d742020-04-28 15:38:24 -07003967 mThreadMetrics.logThrottleMs((double)throttleMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08003968
Andy Hung08fb1742015-05-31 23:22:10 -07003969 usleep(throttleMs * 1000);
Andy Hung40eb1a12015-06-18 13:42:02 -07003970 // notify of throttle start on verbose log
3971 ALOGV_IF(mThreadThrottleEndMs == mThreadThrottleTimeMs,
3972 "mixer(%p) throttle begin:"
3973 " ret(%zd) deltaMs(%d) requires sleep %d ms",
Andy Hung08fb1742015-05-31 23:22:10 -07003974 this, ret, deltaMs, throttleMs);
Andy Hung40eb1a12015-06-18 13:42:02 -07003975 mThreadThrottleTimeMs += throttleMs;
Andy Hung0a31ddd2016-07-06 19:10:29 -07003976 // Throttle must be attributed to the previous mixer loop's write time
3977 // to allow back-to-back throttling.
Andy Hung446f4df2019-02-21 12:26:41 -08003978 // This also ensures proper timing statistics.
3979 mLastIoEndNs = systemTime(); // we fetch the write end time again.
Andy Hung40eb1a12015-06-18 13:42:02 -07003980 } else {
3981 uint32_t diff = mThreadThrottleTimeMs - mThreadThrottleEndMs;
3982 if (diff > 0) {
3983 // notify of throttle end on debug log
Andy Hung3ea004d2016-05-05 16:48:37 -07003984 // but prevent spamming for bluetooth
jiabinc52b1ff2019-10-31 17:20:42 -07003985 ALOGD_IF(!isSingleDeviceType(
3986 outDeviceTypes(), audio_is_a2dp_out_device) &&
3987 !isSingleDeviceType(
3988 outDeviceTypes(), audio_is_hearing_aid_out_device),
Andy Hung3ea004d2016-05-05 16:48:37 -07003989 "mixer(%p) throttle end: throttle time(%u)", this, diff);
Andy Hung40eb1a12015-06-18 13:42:02 -07003990 mThreadThrottleEndMs = mThreadThrottleTimeMs;
3991 }
Andy Hung08fb1742015-05-31 23:22:10 -07003992 }
3993 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003994 }
Eric Laurent81784c32012-11-19 14:55:58 -08003995
Eric Laurentbfb1b832013-01-07 09:53:42 -08003996 } else {
Glenn Kastene7754022014-10-31 12:11:26 -07003997 ATRACE_BEGIN("sleep");
Eric Laurente93cc032016-05-05 10:15:10 -07003998 Mutex::Autolock _l(mLock);
rago1bb90822017-05-02 18:31:48 -07003999 // suspended requires accurate metering of sleep time.
4000 if (isSuspended()) {
4001 // advance by expected sleepTime
4002 timeLoopNextNs += microseconds((nsecs_t)mSleepTimeUs);
4003 const nsecs_t nowNs = systemTime();
4004
4005 // compute expected next time vs current time.
4006 // (negative deltas are treated as delays).
4007 nsecs_t deltaNs = timeLoopNextNs - nowNs;
4008 if (deltaNs < -kMaxNextBufferDelayNs) {
4009 // Delays longer than the max allowed trigger a reset.
4010 ALOGV("DelayNs: %lld, resetting timeLoopNextNs", (long long) deltaNs);
4011 deltaNs = microseconds((nsecs_t)mSleepTimeUs);
4012 timeLoopNextNs = nowNs + deltaNs;
4013 } else if (deltaNs < 0) {
4014 // Delays within the max delay allowed: zero the delta/sleepTime
4015 // to help the system catch up in the next iteration(s)
4016 ALOGV("DelayNs: %lld, catching-up", (long long) deltaNs);
4017 deltaNs = 0;
4018 }
4019 // update sleep time (which is >= 0)
4020 mSleepTimeUs = deltaNs / 1000;
4021 }
Eric Laurente93cc032016-05-05 10:15:10 -07004022 if (!mSignalPending && mConfigEvents.isEmpty() && !exitPending()) {
4023 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)mSleepTimeUs));
Eric Laurent51716182016-02-29 18:00:56 -08004024 }
Glenn Kastene7754022014-10-31 12:11:26 -07004025 ATRACE_END();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004026 }
Eric Laurent81784c32012-11-19 14:55:58 -08004027 }
4028
4029 // Finally let go of removed track(s), without the lock held
4030 // since we can't guarantee the destructors won't acquire that
4031 // same lock. This will also mutate and push a new fast mixer state.
4032 threadLoop_removeTracks(tracksToRemove);
4033 tracksToRemove.clear();
4034
4035 // FIXME I don't understand the need for this here;
4036 // it was in the original code but maybe the
4037 // assignment in saveOutputTracks() makes this unnecessary?
4038 clearOutputTracks();
4039
4040 // Effect chains will be actually deleted here if they were removed from
4041 // mEffectChains list during mixing or effects processing
4042 effectChains.clear();
4043
4044 // FIXME Note that the above .clear() is no longer necessary since effectChains
4045 // is now local to this block, but will keep it for now (at least until merge done).
4046 }
4047
Eric Laurentbfb1b832013-01-07 09:53:42 -08004048 threadLoop_exit();
4049
Eric Laurentcf817a22014-08-04 20:36:31 -07004050 if (!mStandby) {
4051 threadLoop_standby();
4052 mStandby = true;
Eric Laurent81784c32012-11-19 14:55:58 -08004053 }
4054
4055 releaseWakeLock();
4056
4057 ALOGV("Thread %p type %d exiting", this, mType);
4058 return false;
4059}
4060
Dean Wheatley12473e92021-03-18 23:00:55 +11004061void AudioFlinger::PlaybackThread::collectTimestamps_l()
4062{
4063 // Collect timestamp statistics for the Playback Thread types that support it.
4064 if (mType != MIXER
4065 && mType != DUPLICATING
4066 && mType != DIRECT
4067 && mType != OFFLOAD) {
4068 return;
4069 }
4070 if (mStandby) {
4071 mTimestampVerifier.discontinuity(discontinuityForStandbyOrFlush());
4072 return;
4073 } else if (mHwPaused) {
4074 mTimestampVerifier.discontinuity(mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS);
4075 return;
4076 }
4077
4078 // Gather the framesReleased counters for all active tracks,
4079 // and associate with the sink frames written out. We need
4080 // this to convert the sink timestamp to the track timestamp.
4081 bool kernelLocationUpdate = false;
4082 ExtendedTimestamp timestamp; // use private copy to fetch
4083
4084 // Always query HAL timestamp and update timestamp verifier. In standby or pause,
4085 // HAL may be draining some small duration buffered data for fade out.
4086 if (threadloop_getHalTimestamp_l(&timestamp) == OK) {
4087 mTimestampVerifier.add(timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
4088 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4089 mSampleRate);
4090
4091 if (isTimestampCorrectionEnabled()) {
4092 ALOGVV("TS_BEFORE: %d %lld %lld", id(),
4093 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4094 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
4095 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
4096 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4097 = correctedTimestamp.mFrames;
4098 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
4099 = correctedTimestamp.mTimeNs;
4100 ALOGVV("TS_AFTER: %d %lld %lld", id(),
4101 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
4102 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
4103
4104 // Note: Downstream latency only added if timestamp correction enabled.
4105 if (mDownstreamLatencyStatMs.getN() > 0) { // we have latency info.
4106 const int64_t newPosition =
4107 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4108 - int64_t(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
4109 // prevent retrograde
4110 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = max(
4111 newPosition,
4112 (mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4113 - mSuspendedFrames));
4114 }
4115 }
4116
4117 // We always fetch the timestamp here because often the downstream
4118 // sink will block while writing.
4119
4120 // We keep track of the last valid kernel position in case we are in underrun
4121 // and the normal mixer period is the same as the fast mixer period, or there
4122 // is some error from the HAL.
4123 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
4124 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
4125 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
4126 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
4127 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4128
4129 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
4130 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER];
4131 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
4132 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER];
4133 }
4134
4135 if (timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
4136 kernelLocationUpdate = true;
4137 } else {
4138 ALOGVV("getTimestamp error - no valid kernel position");
4139 }
4140
4141 // copy over kernel info
4142 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
4143 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
4144 + mSuspendedFrames; // add frames discarded when suspended
4145 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
4146 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4147 } else {
4148 mTimestampVerifier.error();
4149 }
4150
4151 // mFramesWritten for non-offloaded tracks are contiguous
4152 // even after standby() is called. This is useful for the track frame
4153 // to sink frame mapping.
4154 bool serverLocationUpdate = false;
4155 if (mFramesWritten != mLastFramesWritten) {
4156 serverLocationUpdate = true;
4157 mLastFramesWritten = mFramesWritten;
4158 }
4159 // Only update timestamps if there is a meaningful change.
4160 // Either the kernel timestamp must be valid or we have written something.
4161 if (kernelLocationUpdate || serverLocationUpdate) {
4162 if (serverLocationUpdate) {
4163 // use the time before we called the HAL write - it is a bit more accurate
4164 // to when the server last read data than the current time here.
4165 //
4166 // If we haven't written anything, mLastIoBeginNs will be -1
4167 // and we use systemTime().
4168 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = mFramesWritten;
4169 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = mLastIoBeginNs == -1
4170 ? systemTime() : mLastIoBeginNs;
4171 }
4172
4173 for (const sp<Track> &t : mActiveTracks) {
4174 if (!t->isFastTrack()) {
4175 t->updateTrackFrameInfo(
4176 t->mAudioTrackServerProxy->framesReleased(),
4177 mFramesWritten,
4178 mSampleRate,
4179 mTimestamp);
4180 }
4181 }
4182 }
4183
4184 if (audio_has_proportional_frames(mFormat)) {
4185 const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
4186 if (latencyMs != 0.) { // note 0. means timestamp is empty.
4187 mLatencyMs.add(latencyMs);
4188 }
4189 }
4190#if 0
4191 // logFormat example
4192 if (z % 100 == 0) {
4193 timespec ts;
4194 clock_gettime(CLOCK_MONOTONIC, &ts);
4195 LOGT("This is an integer %d, this is a float %f, this is my "
4196 "pid %p %% %s %t", 42, 3.14, "and this is a timestamp", ts);
4197 LOGT("A deceptive null-terminated string %\0");
4198 }
4199 ++z;
4200#endif
4201}
4202
Eric Laurentbfb1b832013-01-07 09:53:42 -08004203// removeTracks_l() must be called with ThreadBase::mLock held
4204void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
4205{
Andy Hungfe726a62018-09-27 15:17:25 -07004206 for (const auto& track : tracksToRemove) {
4207 mActiveTracks.remove(track);
4208 ALOGV("%s(%d): removing track on session %d", __func__, track->id(), track->sessionId());
4209 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
4210 if (chain != 0) {
4211 ALOGV("%s(%d): stopping track on chain %p for session Id: %d",
4212 __func__, track->id(), chain.get(), track->sessionId());
4213 chain->decActiveTrackCnt();
4214 }
4215 // If an external client track, inform APM we're no longer active, and remove if needed.
4216 // We do this under lock so that the state is consistent if the Track is destroyed.
4217 if (track->isExternalTrack()) {
4218 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004219 if (track->isTerminated()) {
Andy Hungfe726a62018-09-27 15:17:25 -07004220 AudioSystem::releaseOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004221 }
4222 }
Andy Hungfe726a62018-09-27 15:17:25 -07004223 if (track->isTerminated()) {
4224 // remove from our tracks vector
4225 removeTrack_l(track);
4226 }
jiabineb3bda02020-06-30 14:07:03 -07004227 if (mHapticChannelCount > 0 &&
4228 ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
4229 || (chain != nullptr && chain->containsHapticGeneratingEffect_l()))) {
jiabin57303cc2018-12-18 15:45:57 -08004230 mLock.unlock();
4231 // Unlock due to VibratorService will lock for this call and will
4232 // call Tracks.mute/unmute which also require thread's lock.
4233 AudioFlinger::onExternalVibrationStop(track->getExternalVibration());
4234 mLock.lock();
jiabine70bc7f2020-06-30 22:07:55 -07004235
4236 // When the track is stop, set the haptic intensity as MUTE
4237 // for the HapticGenerator effect.
4238 if (chain != nullptr) {
4239 chain->setHapticIntensity_l(track->id(), static_cast<int>(os::HapticScale::MUTE));
4240 }
jiabin245cdd92018-12-07 17:55:15 -08004241 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004242 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004243}
Eric Laurent81784c32012-11-19 14:55:58 -08004244
Eric Laurentaccc1472013-09-20 09:36:34 -07004245status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
4246{
4247 if (mNormalSink != 0) {
Andy Hung818e7a32016-02-16 18:08:07 -08004248 ExtendedTimestamp ets;
4249 status_t status = mNormalSink->getTimestamp(ets);
4250 if (status == NO_ERROR) {
4251 status = ets.getBestTimestamp(&timestamp);
4252 }
4253 return status;
Eric Laurentaccc1472013-09-20 09:36:34 -07004254 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004255 if ((mType == OFFLOAD || mType == DIRECT) && mOutput != NULL) {
Dean Wheatley12473e92021-03-18 23:00:55 +11004256 collectTimestamps_l();
4257 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] <= 0) {
4258 return INVALID_OPERATION;
Eric Laurentaccc1472013-09-20 09:36:34 -07004259 }
Dean Wheatley12473e92021-03-18 23:00:55 +11004260 timestamp.mPosition = mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
4261 const int64_t timeNs = mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
4262 timestamp.mTime.tv_sec = timeNs / NANOS_PER_SECOND;
4263 timestamp.mTime.tv_nsec = timeNs - (timestamp.mTime.tv_sec * NANOS_PER_SECOND);
4264 return NO_ERROR;
Eric Laurentaccc1472013-09-20 09:36:34 -07004265 }
4266 return INVALID_OPERATION;
4267}
Eric Laurent1c333e22014-05-20 10:48:17 -07004268
Eric Laurenteab90452019-06-24 15:17:46 -07004269// For dedicated VoIP outputs, let the HAL apply the stream volume. Track volume is
4270// still applied by the mixer.
4271// All tracks attached to a mixer with flag VOIP_RX are tied to the same
4272// stream type STREAM_VOICE_CALL so this will only change the HAL volume once even
4273// if more than one track are active
4274status_t AudioFlinger::PlaybackThread::handleVoipVolume_l(float *volume)
4275{
4276 status_t result = NO_ERROR;
4277 if ((mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
4278 if (*volume != mLeftVolFloat) {
4279 result = mOutput->stream->setVolume(*volume, *volume);
4280 ALOGE_IF(result != OK,
4281 "Error when setting output stream volume: %d", result);
4282 if (result == NO_ERROR) {
4283 mLeftVolFloat = *volume;
4284 }
4285 }
4286 // if stream volume was successfully sent to the HAL, mLeftVolFloat == v here and we
4287 // remove stream volume contribution from software volume.
4288 if (mLeftVolFloat == *volume) {
4289 *volume = 1.0f;
4290 }
4291 }
4292 return result;
4293}
4294
Eric Laurent054d9d32015-04-24 08:48:48 -07004295status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
4296 audio_patch_handle_t *handle)
4297{
Andy Hungf60abce2016-08-26 11:37:54 -07004298 status_t status;
4299 if (property_get_bool("af.patch_park", false /* default_value */)) {
4300 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4301 // or if HAL does not properly lock against access.
4302 AutoPark<FastMixer> park(mFastMixer);
4303 status = PlaybackThread::createAudioPatch_l(patch, handle);
4304 } else {
4305 status = PlaybackThread::createAudioPatch_l(patch, handle);
4306 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004307 return status;
4308}
4309
Eric Laurent1c333e22014-05-20 10:48:17 -07004310status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
4311 audio_patch_handle_t *handle)
4312{
4313 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004314
4315 // store new device and send to effects
4316 audio_devices_t type = AUDIO_DEVICE_NONE;
jiabinc52b1ff2019-10-31 17:20:42 -07004317 AudioDeviceTypeAddrVector deviceTypeAddrs;
Eric Laurent054d9d32015-04-24 08:48:48 -07004318 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabinc52b1ff2019-10-31 17:20:42 -07004319 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
4320 && !mOutput->audioHwDev->supportsAudioPatches(),
4321 "Enumerated device type(%#x) must not be used "
4322 "as it does not support audio patches",
4323 patch->sinks[i].ext.device.type);
Mikhail Naganov55773032020-10-01 15:08:13 -07004324 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
jiabinc52b1ff2019-10-31 17:20:42 -07004325 deviceTypeAddrs.push_back(AudioDeviceTypeAddr(patch->sinks[i].ext.device.type,
4326 patch->sinks[i].ext.device.address));
Eric Laurent054d9d32015-04-24 08:48:48 -07004327 }
4328
François Gaffie0c280aa2018-07-25 10:02:15 +02004329 audio_port_handle_t sinkPortId = patch->sinks[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07004330#ifdef ADD_BATTERY_DATA
4331 // when changing the audio output device, call addBatteryData to notify
4332 // the change
jiabinc52b1ff2019-10-31 17:20:42 -07004333 if (outDeviceTypes() != deviceTypes) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004334 uint32_t params = 0;
4335 // check whether speaker is on
jiabinc52b1ff2019-10-31 17:20:42 -07004336 if (deviceTypes.count(AUDIO_DEVICE_OUT_SPEAKER) > 0) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004337 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
Eric Laurent1c333e22014-05-20 10:48:17 -07004338 }
4339
Eric Laurent054d9d32015-04-24 08:48:48 -07004340 // check if any other device (except speaker) is on
jiabinc52b1ff2019-10-31 17:20:42 -07004341 if (!isSingleDeviceType(deviceTypes, AUDIO_DEVICE_OUT_SPEAKER)) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004342 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
4343 }
4344
4345 if (params != 0) {
4346 addBatteryData(params);
4347 }
4348 }
4349#endif
4350
4351 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08004352 mEffectChains[i]->setDevices_l(deviceTypeAddrs);
Eric Laurent054d9d32015-04-24 08:48:48 -07004353 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07004354
jiabinc52b1ff2019-10-31 17:20:42 -07004355 // mPatch.num_sinks is not set when the thread is created so that
4356 // the first patch creation triggers an ioConfigChanged callback
4357 bool configChanged = (mPatch.num_sinks == 0) ||
4358 (mPatch.sinks[0].id != sinkPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07004359 mPatch = *patch;
jiabinc52b1ff2019-10-31 17:20:42 -07004360 mOutDeviceTypeAddrs = deviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -07004361 checkSilentMode_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07004362
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004363 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004364 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4365 status = hwDevice->createAudioPatch(patch->num_sources,
4366 patch->sources,
4367 patch->num_sinks,
4368 patch->sinks,
4369 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004370 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004371 char *address;
4372 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
4373 //FIXME: we only support address on first sink with HAL version < 3.0
4374 address = audio_device_address_to_parameter(
4375 patch->sinks[0].ext.device.type,
4376 patch->sinks[0].ext.device.address);
4377 } else {
4378 address = (char *)calloc(1, 1);
4379 }
4380 AudioParameter param = AudioParameter(String8(address));
4381 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07004382 param.addInt(String8(AudioParameter::keyRouting), (int)type);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004383 status = mOutput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07004384 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07004385 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07004386 const std::string patchSinksAsString = patchSinksToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07004387
4388 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07004389 mThreadMetrics.logCreatePatch(/* inDevices */ {}, patchSinksAsString);
Andy Hungcf10d742020-04-28 15:38:24 -07004390 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07004391 // also dispatch to active AudioTracks for MediaMetrics
4392 for (const auto &track : mActiveTracks) {
4393 track->logEndInterval();
4394 track->logBeginInterval(patchSinksAsString);
4395 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08004396
Eric Laurente8726fe2015-06-26 09:39:24 -07004397 if (configChanged) {
4398 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
4399 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004400 return status;
4401}
4402
Eric Laurent054d9d32015-04-24 08:48:48 -07004403status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4404{
Andy Hungf60abce2016-08-26 11:37:54 -07004405 status_t status;
4406 if (property_get_bool("af.patch_park", false /* default_value */)) {
4407 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4408 // or if HAL does not properly lock against access.
4409 AutoPark<FastMixer> park(mFastMixer);
4410 status = PlaybackThread::releaseAudioPatch_l(handle);
4411 } else {
4412 status = PlaybackThread::releaseAudioPatch_l(handle);
4413 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004414 return status;
4415}
4416
Eric Laurent1c333e22014-05-20 10:48:17 -07004417status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4418{
4419 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004420
jiabinc52b1ff2019-10-31 17:20:42 -07004421 mPatch = audio_patch{};
4422 mOutDeviceTypeAddrs.clear();
Eric Laurent054d9d32015-04-24 08:48:48 -07004423
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004424 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004425 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4426 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004427 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004428 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07004429 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004430 status = mOutput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07004431 }
4432 return status;
4433}
4434
Eric Laurent83b88082014-06-20 18:31:16 -07004435void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
4436{
4437 Mutex::Autolock _l(mLock);
4438 mTracks.add(track);
4439}
4440
4441void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
4442{
4443 Mutex::Autolock _l(mLock);
4444 destroyTrack_l(track);
4445}
4446
Mikhail Naganovdc769682018-05-04 15:34:08 -07004447void AudioFlinger::PlaybackThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07004448{
Mikhail Naganovdc769682018-05-04 15:34:08 -07004449 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07004450 config->role = AUDIO_PORT_ROLE_SOURCE;
4451 config->ext.mix.hw_module = mOutput->audioHwDev->handle();
4452 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07004453 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
4454 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
4455 config->flags.output = mOutput->flags;
4456 }
Eric Laurent83b88082014-06-20 18:31:16 -07004457}
4458
Eric Laurent81784c32012-11-19 14:55:58 -08004459// ----------------------------------------------------------------------------
4460
4461AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
jiabinc52b1ff2019-10-31 17:20:42 -07004462 audio_io_handle_t id, bool systemReady, type_t type)
4463 : PlaybackThread(audioFlinger, output, id, type, systemReady),
Eric Laurent81784c32012-11-19 14:55:58 -08004464 // mAudioMixer below
4465 // mFastMixer below
Andy Hung2ddee192015-12-18 17:34:44 -08004466 mFastMixerFutex(0),
4467 mMasterMono(false)
Eric Laurent81784c32012-11-19 14:55:58 -08004468 // mOutputSink below
4469 // mPipeSink below
4470 // mNormalSink below
4471{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004472 setMasterBalance(audioFlinger->getMasterBalance_l());
jiabinc52b1ff2019-10-31 17:20:42 -07004473 ALOGV("MixerThread() id=%d type=%d", id, type);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004474 ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004475 "mFrameCount=%zu, mNormalFrameCount=%zu",
Eric Laurent81784c32012-11-19 14:55:58 -08004476 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
4477 mNormalFrameCount);
4478 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
4479
Andy Hungfbfc3952015-01-15 13:33:51 -08004480 if (type == DUPLICATING) {
4481 // The Duplicating thread uses the AudioMixer and delivers data to OutputTracks
4482 // (downstream MixerThreads) in DuplicatingThread::threadLoop_write().
4483 // Do not create or use mFastMixer, mOutputSink, mPipeSink, or mNormalSink.
4484 return;
4485 }
Eric Laurent81784c32012-11-19 14:55:58 -08004486 // create an NBAIO sink for the HAL output stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07004487 mOutputSink = new AudioStreamOutSink(output->stream);
Eric Laurent81784c32012-11-19 14:55:58 -08004488 size_t numCounterOffers = 0;
jiabin245cdd92018-12-07 17:55:15 -08004489 const NBAIO_Format offers[1] = {Format_from_SR_C(
4490 mSampleRate, mChannelCount + mHapticChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004491#if !LOG_NDEBUG
4492 ssize_t index =
4493#else
4494 (void)
4495#endif
4496 mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004497 ALOG_ASSERT(index == 0);
4498
4499 // initialize fast mixer depending on configuration
4500 bool initFastMixer;
4501 switch (kUseFastMixer) {
4502 case FastMixer_Never:
4503 initFastMixer = false;
4504 break;
4505 case FastMixer_Always:
4506 initFastMixer = true;
4507 break;
4508 case FastMixer_Static:
4509 case FastMixer_Dynamic:
Andy Hungfda69402017-02-15 14:33:12 -08004510 // FastMixer was designed to operate with a HAL that pulls at a regular rate,
4511 // where the period is less than an experimentally determined threshold that can be
4512 // scheduled reliably with CFS. However, the BT A2DP HAL is
4513 // bursty (does not pull at a regular rate) and so cannot operate with FastMixer.
4514 initFastMixer = mFrameCount < mNormalFrameCount
jiabinc52b1ff2019-10-31 17:20:42 -07004515 && Intersection(outDeviceTypes(), getAudioDeviceOutAllA2dpSet()).empty();
Eric Laurent81784c32012-11-19 14:55:58 -08004516 break;
4517 }
Andy Hungfda69402017-02-15 14:33:12 -08004518 ALOGW_IF(initFastMixer == false && mFrameCount < mNormalFrameCount,
4519 "FastMixer is preferred for this sink as frameCount %zu is less than threshold %zu",
4520 mFrameCount, mNormalFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08004521 if (initFastMixer) {
Andy Hung1258c1a2014-05-23 21:22:17 -07004522 audio_format_t fastMixerFormat;
4523 if (mMixerBufferEnabled && mEffectBufferEnabled) {
4524 fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
4525 } else {
4526 fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
4527 }
4528 if (mFormat != fastMixerFormat) {
4529 // change our Sink format to accept our intermediate precision
4530 mFormat = fastMixerFormat;
4531 free(mSinkBuffer);
jiabin245cdd92018-12-07 17:55:15 -08004532 mFrameSize = audio_bytes_per_frame(mChannelCount + mHapticChannelCount, mFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004533 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
4534 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
4535 }
Eric Laurent81784c32012-11-19 14:55:58 -08004536
4537 // create a MonoPipe to connect our submix to FastMixer
4538 NBAIO_Format format = mOutputSink->format();
Andy Hung8946a282018-04-19 20:04:56 -07004539
Andy Hung1258c1a2014-05-23 21:22:17 -07004540 // adjust format to match that of the Fast Mixer
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004541 ALOGV("format changed from %#x to %#x", format.mFormat, fastMixerFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004542 format.mFormat = fastMixerFormat;
4543 format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
4544
Eric Laurent81784c32012-11-19 14:55:58 -08004545 // This pipe depth compensates for scheduling latency of the normal mixer thread.
4546 // When it wakes up after a maximum latency, it runs a few cycles quickly before
4547 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
4548 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
4549 const NBAIO_Format offers[1] = {format};
4550 size_t numCounterOffers = 0;
Andy Hung8946a282018-04-19 20:04:56 -07004551#if !LOG_NDEBUG
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004552 ssize_t index =
4553#else
4554 (void)
4555#endif
4556 monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004557 ALOG_ASSERT(index == 0);
4558 monoPipe->setAvgFrames((mScreenState & 1) ?
4559 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
4560 mPipeSink = monoPipe;
4561
Eric Laurent81784c32012-11-19 14:55:58 -08004562 // create fast mixer and configure it initially with just one fast track for our submix
Andy Hung8946a282018-04-19 20:04:56 -07004563 mFastMixer = new FastMixer(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08004564 FastMixerStateQueue *sq = mFastMixer->sq();
4565#ifdef STATE_QUEUE_DUMP
4566 sq->setObserverDump(&mStateQueueObserverDump);
4567 sq->setMutatorDump(&mStateQueueMutatorDump);
4568#endif
4569 FastMixerState *state = sq->begin();
4570 FastTrack *fastTrack = &state->mFastTracks[0];
4571 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
4572 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
4573 fastTrack->mVolumeProvider = NULL;
Mikhail Naganov55773032020-10-01 15:08:13 -07004574 fastTrack->mChannelMask = static_cast<audio_channel_mask_t>(
4575 mChannelMask | mHapticChannelMask); // mPipeSink channel mask for
4576 // audio to FastMixer
Andy Hunge8a1ced2014-05-09 15:02:21 -07004577 fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer
jiabin245cdd92018-12-07 17:55:15 -08004578 fastTrack->mHapticPlaybackEnabled = mHapticChannelMask != AUDIO_CHANNEL_NONE;
jiabine70bc7f2020-06-30 22:07:55 -07004579 fastTrack->mHapticIntensity = os::HapticScale::NONE;
Lais Andradebc3f37a2021-07-02 00:13:19 +01004580 fastTrack->mHapticMaxAmplitude = NAN;
Eric Laurent81784c32012-11-19 14:55:58 -08004581 fastTrack->mGeneration++;
4582 state->mFastTracksGen++;
4583 state->mTrackMask = 1;
4584 // fast mixer will use the HAL output sink
4585 state->mOutputSink = mOutputSink.get();
4586 state->mOutputSinkGen++;
4587 state->mFrameCount = mFrameCount;
jiabin245cdd92018-12-07 17:55:15 -08004588 // specify sink channel mask when haptic channel mask present as it can not
4589 // be calculated directly from channel count
4590 state->mSinkChannelMask = mHapticChannelMask == AUDIO_CHANNEL_NONE
Mikhail Naganov55773032020-10-01 15:08:13 -07004591 ? AUDIO_CHANNEL_NONE
4592 : static_cast<audio_channel_mask_t>(mChannelMask | mHapticChannelMask);
Eric Laurent81784c32012-11-19 14:55:58 -08004593 state->mCommand = FastMixerState::COLD_IDLE;
4594 // already done in constructor initialization list
4595 //mFastMixerFutex = 0;
4596 state->mColdFutexAddr = &mFastMixerFutex;
4597 state->mColdGen++;
4598 state->mDumpState = &mFastMixerDumpState;
Glenn Kasten9e58b552013-01-18 15:09:48 -08004599 mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
4600 state->mNBLogWriter = mFastMixerNBLogWriter.get();
Eric Laurent81784c32012-11-19 14:55:58 -08004601 sq->end();
4602 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4603
Eric Tan0513b5d2018-09-17 10:32:48 -07004604 NBLog::thread_info_t info;
4605 info.id = mId;
4606 info.type = NBLog::FASTMIXER;
4607 mFastMixerNBLogWriter->log<NBLog::EVENT_THREAD_INFO>(info);
4608
Eric Laurent81784c32012-11-19 14:55:58 -08004609 // start the fast mixer
4610 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
4611 pid_t tid = mFastMixer->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004612 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08004613 stream()->setHalThreadPriority(kPriorityFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08004614
4615#ifdef AUDIO_WATCHDOG
4616 // create and start the watchdog
4617 mAudioWatchdog = new AudioWatchdog();
4618 mAudioWatchdog->setDump(&mAudioWatchdogDump);
4619 mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
4620 tid = mAudioWatchdog->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004621 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08004622#endif
Andy Hung8946a282018-04-19 20:04:56 -07004623 } else {
4624#ifdef TEE_SINK
4625 // Only use the MixerThread tee if there is no FastMixer.
4626 mTee.set(mOutputSink->format(), NBAIO_Tee::TEE_FLAG_OUTPUT_THREAD);
4627 mTee.setId(std::string("_") + std::to_string(mId) + "_M");
4628#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004629 }
4630
4631 switch (kUseFastMixer) {
4632 case FastMixer_Never:
4633 case FastMixer_Dynamic:
4634 mNormalSink = mOutputSink;
4635 break;
4636 case FastMixer_Always:
4637 mNormalSink = mPipeSink;
4638 break;
4639 case FastMixer_Static:
4640 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
4641 break;
4642 }
4643}
4644
4645AudioFlinger::MixerThread::~MixerThread()
4646{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004647 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004648 FastMixerStateQueue *sq = mFastMixer->sq();
4649 FastMixerState *state = sq->begin();
4650 if (state->mCommand == FastMixerState::COLD_IDLE) {
4651 int32_t old = android_atomic_inc(&mFastMixerFutex);
4652 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004653 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004654 }
4655 }
4656 state->mCommand = FastMixerState::EXIT;
4657 sq->end();
4658 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4659 mFastMixer->join();
4660 // Though the fast mixer thread has exited, it's state queue is still valid.
4661 // We'll use that extract the final state which contains one remaining fast track
4662 // corresponding to our sub-mix.
4663 state = sq->begin();
4664 ALOG_ASSERT(state->mTrackMask == 1);
4665 FastTrack *fastTrack = &state->mFastTracks[0];
4666 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
4667 delete fastTrack->mBufferProvider;
4668 sq->end(false /*didModify*/);
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004669 mFastMixer.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08004670#ifdef AUDIO_WATCHDOG
4671 if (mAudioWatchdog != 0) {
4672 mAudioWatchdog->requestExit();
4673 mAudioWatchdog->requestExitAndWait();
4674 mAudioWatchdog.clear();
4675 }
4676#endif
4677 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08004678 mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -08004679 delete mAudioMixer;
4680}
4681
4682
4683uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
4684{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004685 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004686 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
4687 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
4688 }
4689 return latency;
4690}
4691
Eric Laurentbfb1b832013-01-07 09:53:42 -08004692ssize_t AudioFlinger::MixerThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08004693{
4694 // FIXME we should only do one push per cycle; confirm this is true
4695 // Start the fast mixer if it's not already running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004696 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004697 FastMixerStateQueue *sq = mFastMixer->sq();
4698 FastMixerState *state = sq->begin();
4699 if (state->mCommand != FastMixerState::MIX_WRITE &&
4700 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
4701 if (state->mCommand == FastMixerState::COLD_IDLE) {
Eric Laurenta2ab4502015-09-09 12:25:51 -07004702
4703 // FIXME workaround for first HAL write being CPU bound on some devices
4704 ATRACE_BEGIN("write");
4705 mOutput->write((char *)mSinkBuffer, 0);
4706 ATRACE_END();
4707
Eric Laurent81784c32012-11-19 14:55:58 -08004708 int32_t old = android_atomic_inc(&mFastMixerFutex);
4709 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004710 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004711 }
4712#ifdef AUDIO_WATCHDOG
4713 if (mAudioWatchdog != 0) {
4714 mAudioWatchdog->resume();
4715 }
4716#endif
4717 }
4718 state->mCommand = FastMixerState::MIX_WRITE;
Glenn Kastend797a9d2015-03-02 14:19:25 -08004719#ifdef FAST_THREAD_STATISTICS
Glenn Kasten4182c4e2013-07-15 14:45:07 -07004720 mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08004721 FastThreadDumpState::kSamplingNforLowRamDevice : FastThreadDumpState::kSamplingN);
Glenn Kastend797a9d2015-03-02 14:19:25 -08004722#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004723 sq->end();
4724 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4725 if (kUseFastMixer == FastMixer_Dynamic) {
4726 mNormalSink = mPipeSink;
4727 }
4728 } else {
4729 sq->end(false /*didModify*/);
4730 }
4731 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004732 return PlaybackThread::threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08004733}
4734
4735void AudioFlinger::MixerThread::threadLoop_standby()
4736{
4737 // Idle the fast mixer if it's currently running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004738 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004739 FastMixerStateQueue *sq = mFastMixer->sq();
4740 FastMixerState *state = sq->begin();
4741 if (!(state->mCommand & FastMixerState::IDLE)) {
Andy Hung2148bf02016-11-28 19:01:02 -08004742 // Report any frames trapped in the Monopipe
4743 MonoPipe *monoPipe = (MonoPipe *)mPipeSink.get();
4744 const long long pipeFrames = monoPipe->maxFrames() - monoPipe->availableToWrite();
4745 mLocalLog.log("threadLoop_standby: framesWritten:%lld suspendedFrames:%lld "
4746 "monoPipeWritten:%lld monoPipeLeft:%lld",
4747 (long long)mFramesWritten, (long long)mSuspendedFrames,
4748 (long long)mPipeSink->framesWritten(), pipeFrames);
4749 mLocalLog.log("threadLoop_standby: %s", mTimestamp.toString().c_str());
4750
Eric Laurent81784c32012-11-19 14:55:58 -08004751 state->mCommand = FastMixerState::COLD_IDLE;
4752 state->mColdFutexAddr = &mFastMixerFutex;
4753 state->mColdGen++;
4754 mFastMixerFutex = 0;
4755 sq->end();
4756 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
4757 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
4758 if (kUseFastMixer == FastMixer_Dynamic) {
4759 mNormalSink = mOutputSink;
4760 }
4761#ifdef AUDIO_WATCHDOG
4762 if (mAudioWatchdog != 0) {
4763 mAudioWatchdog->pause();
4764 }
4765#endif
4766 } else {
4767 sq->end(false /*didModify*/);
4768 }
4769 }
4770 PlaybackThread::threadLoop_standby();
4771}
4772
Eric Laurentbfb1b832013-01-07 09:53:42 -08004773bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
4774{
4775 return false;
4776}
4777
4778bool AudioFlinger::PlaybackThread::shouldStandby_l()
4779{
4780 return !mStandby;
4781}
4782
4783bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
4784{
4785 Mutex::Autolock _l(mLock);
4786 return waitingAsyncCallback_l();
4787}
4788
Eric Laurent81784c32012-11-19 14:55:58 -08004789// shared by MIXER and DIRECT, overridden by DUPLICATING
4790void AudioFlinger::PlaybackThread::threadLoop_standby()
4791{
4792 ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
Phil Burk062e67a2015-02-11 13:40:50 -08004793 mOutput->standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004794 if (mUseAsyncWrite != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07004795 // discard any pending drain or write ack by incrementing sequence
4796 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
4797 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004798 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07004799 mCallbackThread->setWriteBlocked(mWriteAckSequence);
4800 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08004801 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08004802 mHwPaused = false;
Eric Laurent81784c32012-11-19 14:55:58 -08004803}
4804
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08004805void AudioFlinger::PlaybackThread::onAddNewTrack_l()
4806{
4807 ALOGV("signal playback thread");
4808 broadcast_l();
4809}
4810
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07004811void AudioFlinger::PlaybackThread::onAsyncError()
4812{
4813 for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
4814 invalidateTracks((audio_stream_type_t)i);
4815 }
4816}
4817
Eric Laurent81784c32012-11-19 14:55:58 -08004818void AudioFlinger::MixerThread::threadLoop_mix()
4819{
Eric Laurent81784c32012-11-19 14:55:58 -08004820 // mix buffers...
Glenn Kastend79072e2016-01-06 08:41:20 -08004821 mAudioMixer->process();
Andy Hung25c2dac2014-02-27 14:56:00 -08004822 mCurrentWriteLength = mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08004823 // increase sleep time progressively when application underrun condition clears.
4824 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
4825 // that a steady state of alternating ready/not ready conditions keeps the sleep time
4826 // such that we would underrun the audio HAL.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004827 if ((mSleepTimeUs == 0) && (sleepTimeShift > 0)) {
Eric Laurent81784c32012-11-19 14:55:58 -08004828 sleepTimeShift--;
4829 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004830 mSleepTimeUs = 0;
4831 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08004832 //TODO: delay standby when effects have a tail
Glenn Kasten4c053ea2014-09-28 14:41:07 -07004833
Eric Laurent81784c32012-11-19 14:55:58 -08004834}
4835
4836void AudioFlinger::MixerThread::threadLoop_sleepTime()
4837{
4838 // If no tracks are ready, sleep once for the duration of an output
4839 // buffer size, then write 0s to the output
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004840 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004841 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Andy Hung06d13222018-05-03 20:13:31 -07004842 if (mPipeSink.get() != nullptr && mPipeSink == mNormalSink) {
4843 // Using the Monopipe availableToWrite, we estimate the
4844 // sleep time to retry for more data (before we underrun).
4845 MonoPipe *monoPipe = static_cast<MonoPipe *>(mPipeSink.get());
4846 const ssize_t availableToWrite = mPipeSink->availableToWrite();
4847 const size_t pipeFrames = monoPipe->maxFrames();
4848 const size_t framesLeft = pipeFrames - max(availableToWrite, 0);
4849 // HAL_framecount <= framesDelay ~ framesLeft / 2 <= Normal_Mixer_framecount
4850 const size_t framesDelay = std::min(
4851 mNormalFrameCount, max(framesLeft / 2, mFrameCount));
4852 ALOGV("pipeFrames:%zu framesLeft:%zu framesDelay:%zu",
4853 pipeFrames, framesLeft, framesDelay);
4854 mSleepTimeUs = framesDelay * MICROS_PER_SECOND / mSampleRate;
4855 } else {
4856 mSleepTimeUs = mActiveSleepTimeUs >> sleepTimeShift;
4857 if (mSleepTimeUs < kMinThreadSleepTimeUs) {
4858 mSleepTimeUs = kMinThreadSleepTimeUs;
4859 }
4860 // reduce sleep time in case of consecutive application underruns to avoid
4861 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
4862 // duration we would end up writing less data than needed by the audio HAL if
4863 // the condition persists.
4864 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
4865 sleepTimeShift++;
4866 }
Eric Laurent81784c32012-11-19 14:55:58 -08004867 }
4868 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004869 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08004870 }
4871 } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
Andy Hung98ef9782014-03-04 14:46:50 -08004872 // clear out mMixerBuffer or mSinkBuffer, to ensure buffers are cleared
4873 // before effects processing or output.
4874 if (mMixerBufferValid) {
4875 memset(mMixerBuffer, 0, mMixerBufferSize);
4876 } else {
4877 memset(mSinkBuffer, 0, mSinkBufferSize);
4878 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004879 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08004880 ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
4881 "anticipated start");
4882 }
4883 // TODO add standby time extension fct of effect tail
4884}
4885
4886// prepareTracks_l() must be called with ThreadBase::mLock held
4887AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
4888 Vector< sp<Track> > *tracksToRemove)
4889{
Andy Hungc0691382018-09-12 18:01:57 -07004890 // clean up deleted track ids in AudioMixer before allocating new tracks
4891 (void)mTracks.processDeletedTrackIds([this](int trackId) {
4892 // for each trackId, destroy it in the AudioMixer
4893 if (mAudioMixer->exists(trackId)) {
4894 mAudioMixer->destroy(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08004895 }
4896 });
Andy Hungc0691382018-09-12 18:01:57 -07004897 mTracks.clearDeletedTrackIds();
Eric Laurent81784c32012-11-19 14:55:58 -08004898
4899 mixer_state mixerStatus = MIXER_IDLE;
4900 // find out which tracks need to be processed
4901 size_t count = mActiveTracks.size();
4902 size_t mixedTracks = 0;
4903 size_t tracksWithEffect = 0;
4904 // counts only _active_ fast tracks
4905 size_t fastTracks = 0;
4906 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
4907
4908 float masterVolume = mMasterVolume;
4909 bool masterMute = mMasterMute;
4910
4911 if (masterMute) {
4912 masterVolume = 0;
4913 }
4914 // Delegate master volume control to effect in output mix effect chain if needed
4915 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4916 if (chain != 0) {
4917 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
4918 chain->setVolume_l(&v, &v);
4919 masterVolume = (float)((v + (1 << 23)) >> 24);
4920 chain.clear();
4921 }
4922
4923 // prepare a new state to push
4924 FastMixerStateQueue *sq = NULL;
4925 FastMixerState *state = NULL;
4926 bool didModify = false;
4927 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
Andy Hungf2285312017-02-14 18:31:59 -08004928 bool coldIdle = false;
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004929 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004930 sq = mFastMixer->sq();
4931 state = sq->begin();
Andy Hungf2285312017-02-14 18:31:59 -08004932 coldIdle = state->mCommand == FastMixerState::COLD_IDLE;
Eric Laurent81784c32012-11-19 14:55:58 -08004933 }
4934
Andy Hung69aed5f2014-02-25 17:24:40 -08004935 mMixerBufferValid = false; // mMixerBuffer has no valid data until appropriate tracks found.
Andy Hung98ef9782014-03-04 14:46:50 -08004936 mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found.
Andy Hung69aed5f2014-02-25 17:24:40 -08004937
Andy Hungbd3b2b02018-05-21 10:53:11 -07004938 // DeferredOperations handles statistics after setting mixerStatus.
4939 class DeferredOperations {
4940 public:
Andy Hungea840382020-05-05 21:50:17 -07004941 DeferredOperations(mixer_state *mixerStatus, ThreadMetrics *threadMetrics)
4942 : mMixerStatus(mixerStatus)
4943 , mThreadMetrics(threadMetrics) {}
Andy Hungbd3b2b02018-05-21 10:53:11 -07004944
4945 // when leaving scope, tally frames properly.
4946 ~DeferredOperations() {
4947 // Tally underrun frames only if we are actually mixing (MIXER_TRACKS_READY)
4948 // because that is when the underrun occurs.
4949 // We do not distinguish between FastTracks and NormalTracks here.
Andy Hungea840382020-05-05 21:50:17 -07004950 size_t maxUnderrunFrames = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08004951 if (*mMixerStatus == MIXER_TRACKS_READY && mUnderrunFrames.size() > 0) {
Andy Hungbd3b2b02018-05-21 10:53:11 -07004952 for (const auto &underrun : mUnderrunFrames) {
Andy Hungc2b11cb2020-04-22 09:04:01 -07004953 underrun.first->tallyUnderrunFrames(underrun.second);
Andy Hungea840382020-05-05 21:50:17 -07004954 maxUnderrunFrames = max(underrun.second, maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07004955 }
4956 }
Andy Hungea840382020-05-05 21:50:17 -07004957 // send the max underrun frames for this mixer period
4958 mThreadMetrics->logUnderrunFrames(maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07004959 }
4960
4961 // tallyUnderrunFrames() is called to update the track counters
4962 // with the number of underrun frames for a particular mixer period.
4963 // We defer tallying until we know the final mixer status.
4964 void tallyUnderrunFrames(sp<Track> track, size_t underrunFrames) {
4965 mUnderrunFrames.emplace_back(track, underrunFrames);
4966 }
4967
4968 private:
4969 const mixer_state * const mMixerStatus;
Andy Hungea840382020-05-05 21:50:17 -07004970 ThreadMetrics * const mThreadMetrics;
Andy Hungbd3b2b02018-05-21 10:53:11 -07004971 std::vector<std::pair<sp<Track>, size_t>> mUnderrunFrames;
Andy Hungea840382020-05-05 21:50:17 -07004972 } deferredOperations(&mixerStatus, &mThreadMetrics);
Andy Hungb68f5eb2019-12-03 16:49:17 -08004973 // implicit nested scope for variable capture
Andy Hungbd3b2b02018-05-21 10:53:11 -07004974
jiabin245cdd92018-12-07 17:55:15 -08004975 bool noFastHapticTrack = true;
Eric Laurent81784c32012-11-19 14:55:58 -08004976 for (size_t i=0 ; i<count ; i++) {
Andy Hungdae27702016-10-31 14:01:16 -07004977 const sp<Track> t = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08004978
4979 // this const just means the local variable doesn't change
4980 Track* const track = t.get();
4981
4982 // process fast tracks
4983 if (track->isFastTrack()) {
Andy Hungae22b482019-05-09 15:38:55 -07004984 LOG_ALWAYS_FATAL_IF(mFastMixer.get() == nullptr,
4985 "%s(%d): FastTrack(%d) present without FastMixer",
4986 __func__, id(), track->id());
4987
jiabin245cdd92018-12-07 17:55:15 -08004988 if (track->getHapticPlaybackEnabled()) {
4989 noFastHapticTrack = false;
4990 }
Eric Laurent81784c32012-11-19 14:55:58 -08004991
4992 // It's theoretically possible (though unlikely) for a fast track to be created
4993 // and then removed within the same normal mix cycle. This is not a problem, as
4994 // the track never becomes active so it's fast mixer slot is never touched.
4995 // The converse, of removing an (active) track and then creating a new track
4996 // at the identical fast mixer slot within the same normal mix cycle,
4997 // is impossible because the slot isn't marked available until the end of each cycle.
4998 int j = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07004999 ALOG_ASSERT(0 < j && j < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08005000 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
5001 FastTrack *fastTrack = &state->mFastTracks[j];
5002
5003 // Determine whether the track is currently in underrun condition,
5004 // and whether it had a recent underrun.
5005 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
5006 FastTrackUnderruns underruns = ftDump->mUnderruns;
5007 uint32_t recentFull = (underruns.mBitFields.mFull -
5008 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
5009 uint32_t recentPartial = (underruns.mBitFields.mPartial -
5010 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
5011 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
5012 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
5013 uint32_t recentUnderruns = recentPartial + recentEmpty;
5014 track->mObservedUnderruns = underruns;
5015 // don't count underruns that occur while stopping or pausing
5016 // or stopped which can occur when flush() is called while active
Andy Hungbd3b2b02018-05-21 10:53:11 -07005017 size_t underrunFrames = 0;
Glenn Kasten82aaf942013-07-17 16:05:07 -07005018 if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
5019 recentUnderruns > 0) {
5020 // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun
Andy Hungbd3b2b02018-05-21 10:53:11 -07005021 underrunFrames = recentUnderruns * mFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08005022 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005023 // Immediately account for FastTrack underruns.
5024 track->mAudioTrackServerProxy->tallyUnderrunFrames(underrunFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08005025
5026 // This is similar to the state machine for normal tracks,
5027 // with a few modifications for fast tracks.
5028 bool isActive = true;
5029 switch (track->mState) {
5030 case TrackBase::STOPPING_1:
5031 // track stays active in STOPPING_1 state until first underrun
Eric Laurentbfb1b832013-01-07 09:53:42 -08005032 if (recentUnderruns > 0 || track->isTerminated()) {
Eric Laurent81784c32012-11-19 14:55:58 -08005033 track->mState = TrackBase::STOPPING_2;
5034 }
5035 break;
5036 case TrackBase::PAUSING:
5037 // ramp down is not yet implemented
5038 track->setPaused();
5039 break;
5040 case TrackBase::RESUMING:
5041 // ramp up is not yet implemented
5042 track->mState = TrackBase::ACTIVE;
5043 break;
5044 case TrackBase::ACTIVE:
5045 if (recentFull > 0 || recentPartial > 0) {
5046 // track has provided at least some frames recently: reset retry count
5047 track->mRetryCount = kMaxTrackRetries;
5048 }
5049 if (recentUnderruns == 0) {
5050 // no recent underruns: stay active
5051 break;
5052 }
5053 // there has recently been an underrun of some kind
5054 if (track->sharedBuffer() == 0) {
5055 // were any of the recent underruns "empty" (no frames available)?
5056 if (recentEmpty == 0) {
5057 // no, then ignore the partial underruns as they are allowed indefinitely
5058 break;
5059 }
5060 // there has recently been an "empty" underrun: decrement the retry counter
5061 if (--(track->mRetryCount) > 0) {
5062 break;
5063 }
5064 // indicate to client process that the track was disabled because of underrun;
5065 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005066 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08005067 // remove from active list, but state remains ACTIVE [confusing but true]
5068 isActive = false;
5069 break;
5070 }
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07005071 FALLTHROUGH_INTENDED;
Eric Laurent81784c32012-11-19 14:55:58 -08005072 case TrackBase::STOPPING_2:
5073 case TrackBase::PAUSED:
Eric Laurent81784c32012-11-19 14:55:58 -08005074 case TrackBase::STOPPED:
5075 case TrackBase::FLUSHED: // flush() while active
5076 // Check for presentation complete if track is inactive
5077 // We have consumed all the buffers of this track.
5078 // This would be incomplete if we auto-paused on underrun
5079 {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005080 uint32_t latency = 0;
5081 status_t result = mOutput->stream->getLatency(&latency);
5082 ALOGE_IF(result != OK,
5083 "Error when retrieving output stream latency: %d", result);
5084 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005085 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005086 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
5087 // track stays in active list until presentation is complete
5088 break;
5089 }
5090 }
5091 if (track->isStopping_2()) {
5092 track->mState = TrackBase::STOPPED;
5093 }
5094 if (track->isStopped()) {
5095 // Can't reset directly, as fast mixer is still polling this track
5096 // track->reset();
5097 // So instead mark this track as needing to be reset after push with ack
5098 resetMask |= 1 << i;
5099 }
5100 isActive = false;
5101 break;
5102 case TrackBase::IDLE:
5103 default:
Glenn Kastenadad3d72014-02-21 14:51:43 -08005104 LOG_ALWAYS_FATAL("unexpected track state %d", track->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08005105 }
5106
5107 if (isActive) {
5108 // was it previously inactive?
5109 if (!(state->mTrackMask & (1 << j))) {
5110 ExtendedAudioBufferProvider *eabp = track;
5111 VolumeProvider *vp = track;
5112 fastTrack->mBufferProvider = eabp;
5113 fastTrack->mVolumeProvider = vp;
Eric Laurent81784c32012-11-19 14:55:58 -08005114 fastTrack->mChannelMask = track->mChannelMask;
Andy Hunge8a1ced2014-05-09 15:02:21 -07005115 fastTrack->mFormat = track->mFormat;
jiabin245cdd92018-12-07 17:55:15 -08005116 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
jiabin77270b82018-12-18 15:41:29 -08005117 fastTrack->mHapticIntensity = track->getHapticIntensity();
Lais Andradebc3f37a2021-07-02 00:13:19 +01005118 fastTrack->mHapticMaxAmplitude = track->getHapticMaxAmplitude();
Eric Laurent81784c32012-11-19 14:55:58 -08005119 fastTrack->mGeneration++;
5120 state->mTrackMask |= 1 << j;
5121 didModify = true;
5122 // no acknowledgement required for newly active tracks
5123 }
Kevin Rocard12381092018-04-11 09:19:59 -07005124 sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
Eric Laurenteab90452019-06-24 15:17:46 -07005125 float volume;
5126 if (track->isPlaybackRestricted() || mStreamTypes[track->streamType()].mute) {
5127 volume = 0.f;
5128 } else {
5129 volume = masterVolume * mStreamTypes[track->streamType()].volume;
5130 }
5131
5132 handleVoipVolume_l(&volume);
5133
Eric Laurent81784c32012-11-19 14:55:58 -08005134 // cache the combined master volume and stream type volume for fast mixer; this
5135 // lacks any synchronization or barrier so VolumeProvider may read a stale value
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005136 const float vh = track->getVolumeHandler()->getVolume(
Eric Laurenteab90452019-06-24 15:17:46 -07005137 proxy->framesReleased()).first;
5138 volume *= vh;
Kevin Rocardb0eeaf122018-04-11 08:30:16 -07005139 track->mCachedVolume = volume;
Kevin Rocard12381092018-04-11 09:19:59 -07005140 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
5141 float vlf = volume * float_from_gain(gain_minifloat_unpack_left(vlr));
5142 float vrf = volume * float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurenteab90452019-06-24 15:17:46 -07005143
Kevin Rocard12381092018-04-11 09:19:59 -07005144 track->setFinalVolume((vlf + vrf) / 2.f);
Eric Laurent81784c32012-11-19 14:55:58 -08005145 ++fastTracks;
5146 } else {
5147 // was it previously active?
5148 if (state->mTrackMask & (1 << j)) {
5149 fastTrack->mBufferProvider = NULL;
5150 fastTrack->mGeneration++;
5151 state->mTrackMask &= ~(1 << j);
5152 didModify = true;
5153 // If any fast tracks were removed, we must wait for acknowledgement
5154 // because we're about to decrement the last sp<> on those tracks.
5155 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5156 } else {
Glenn Kastenbf848af2017-12-22 11:55:01 -08005157 // ALOGW rather than LOG_ALWAYS_FATAL because it seems there are cases where an
5158 // AudioTrack may start (which may not be with a start() but with a write()
5159 // after underrun) and immediately paused or released. In that case the
5160 // FastTrack state hasn't had time to update.
5161 // TODO Remove the ALOGW when this theory is confirmed.
5162 ALOGW("fast track %d should have been active; "
Glenn Kastenf7d65ee2015-12-02 13:45:01 -08005163 "mState=%d, mTrackMask=%#x, recentUnderruns=%u, isShared=%d",
5164 j, track->mState, state->mTrackMask, recentUnderruns,
5165 track->sharedBuffer() != 0);
Glenn Kastenbf848af2017-12-22 11:55:01 -08005166 // Since the FastMixer state already has the track inactive, do nothing here.
Eric Laurent81784c32012-11-19 14:55:58 -08005167 }
5168 tracksToRemove->add(track);
5169 // Avoids a misleading display in dumpsys
5170 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
5171 }
jiabin245cdd92018-12-07 17:55:15 -08005172 if (fastTrack->mHapticPlaybackEnabled != track->getHapticPlaybackEnabled()) {
5173 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
5174 didModify = true;
5175 }
Eric Laurent81784c32012-11-19 14:55:58 -08005176 continue;
5177 }
5178
5179 { // local variable scope to avoid goto warning
5180
5181 audio_track_cblk_t* cblk = track->cblk();
5182
5183 // The first time a track is added we wait
5184 // for all its buffers to be filled before processing it
Andy Hungc0691382018-09-12 18:01:57 -07005185 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005186
5187 // if an active track doesn't exist in the AudioMixer, create it.
Andy Hungc0691382018-09-12 18:01:57 -07005188 // use the trackId as the AudioMixer name.
5189 if (!mAudioMixer->exists(trackId)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005190 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005191 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005192 track->mChannelMask,
5193 track->mFormat,
5194 track->mSessionId);
5195 if (status != OK) {
Andy Hungc0691382018-09-12 18:01:57 -07005196 ALOGW("%s(): AudioMixer cannot create track(%d)"
5197 " mask %#x, format %#x, sessionId %d",
5198 __func__, trackId,
5199 track->mChannelMask, track->mFormat, track->mSessionId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005200 tracksToRemove->add(track);
5201 track->invalidate(); // consider it dead.
5202 continue;
5203 }
5204 }
5205
Eric Laurent81784c32012-11-19 14:55:58 -08005206 // make sure that we have enough frames to mix one full buffer.
5207 // enforce this condition only once to enable draining the buffer in case the client
5208 // app does not call stop() and relies on underrun to stop:
5209 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
5210 // during last round
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005211 size_t desiredFrames;
Andy Hung8edb8dc2015-03-26 19:13:55 -07005212 const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate();
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005213 AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005214
5215 desiredFrames = sourceFramesNeededWithTimestretch(
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005216 sampleRate, mNormalFrameCount, mSampleRate, playbackRate.mSpeed);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005217 // TODO: ONLY USED FOR LEGACY RESAMPLERS, remove when they are removed.
5218 // add frames already consumed but not yet released by the resampler
5219 // because mAudioTrackServerProxy->framesReady() will include these frames
Andy Hungc0691382018-09-12 18:01:57 -07005220 desiredFrames += mAudioMixer->getUnreleasedFrames(trackId);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005221
Eric Laurent81784c32012-11-19 14:55:58 -08005222 uint32_t minFrames = 1;
5223 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
5224 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005225 minFrames = desiredFrames;
Eric Laurent81784c32012-11-19 14:55:58 -08005226 }
Eric Laurent13e4c962013-12-20 17:36:01 -08005227
5228 size_t framesReady = track->framesReady();
Glenn Kastene7754022014-10-31 12:11:26 -07005229 if (ATRACE_ENABLED()) {
5230 // I wish we had formatted trace names
Andy Hung1bc088a2018-02-09 15:57:31 -08005231 std::string traceName("nRdy");
Andy Hungc0691382018-09-12 18:01:57 -07005232 traceName += std::to_string(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005233 ATRACE_INT(traceName.c_str(), framesReady);
Glenn Kastene7754022014-10-31 12:11:26 -07005234 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005235 if ((framesReady >= minFrames) && track->isReady() &&
Eric Laurent81784c32012-11-19 14:55:58 -08005236 !track->isPaused() && !track->isTerminated())
5237 {
Andy Hungc0691382018-09-12 18:01:57 -07005238 ALOGVV("track(%d) s=%08x [OK] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005239
5240 mixedTracks++;
5241
Andy Hung69aed5f2014-02-25 17:24:40 -08005242 // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
5243 // there is an effect chain connected to the track
Eric Laurent81784c32012-11-19 14:55:58 -08005244 chain.clear();
Andy Hung69aed5f2014-02-25 17:24:40 -08005245 if (track->mainBuffer() != mSinkBuffer &&
5246 track->mainBuffer() != mMixerBuffer) {
Andy Hung98ef9782014-03-04 14:46:50 -08005247 if (mEffectBufferEnabled) {
5248 mEffectBufferValid = true; // Later can set directly.
5249 }
Eric Laurent81784c32012-11-19 14:55:58 -08005250 chain = getEffectChain_l(track->sessionId());
5251 // Delegate volume control to effect in track effect chain if needed
5252 if (chain != 0) {
5253 tracksWithEffect++;
5254 } else {
Andy Hungc0691382018-09-12 18:01:57 -07005255 ALOGW("prepareTracks_l(): track(%d) attached to effect but no chain found on "
Eric Laurent81784c32012-11-19 14:55:58 -08005256 "session %d",
Andy Hungc0691382018-09-12 18:01:57 -07005257 trackId, track->sessionId());
Eric Laurent81784c32012-11-19 14:55:58 -08005258 }
5259 }
5260
5261
5262 int param = AudioMixer::VOLUME;
5263 if (track->mFillingUpStatus == Track::FS_FILLED) {
5264 // no ramp for the first volume setting
5265 track->mFillingUpStatus = Track::FS_ACTIVE;
5266 if (track->mState == TrackBase::RESUMING) {
5267 track->mState = TrackBase::ACTIVE;
Revathi Uddaraju453bcb52017-08-14 14:19:40 +08005268 // If a new track is paused immediately after start, do not ramp on resume.
5269 if (cblk->mServer != 0) {
5270 param = AudioMixer::RAMP_VOLUME;
5271 }
Eric Laurent81784c32012-11-19 14:55:58 -08005272 }
Andy Hungc0691382018-09-12 18:01:57 -07005273 mAudioMixer->setParameter(trackId, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
Eric Laurent7c29ec92017-09-20 17:54:22 -07005274 mLeftVolFloat = -1.0;
Glenn Kastenf20e1d82013-07-12 09:45:18 -07005275 // FIXME should not make a decision based on mServer
5276 } else if (cblk->mServer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005277 // If the track is stopped before the first frame was mixed,
5278 // do not apply ramp
5279 param = AudioMixer::RAMP_VOLUME;
5280 }
5281
5282 // compute volume for this track
Andy Hung6be49402014-05-30 10:42:03 -07005283 uint32_t vl, vr; // in U8.24 integer format
5284 float vlf, vrf, vaf; // in [0.0, 1.0] float format
Eric Laurent7c29ec92017-09-20 17:54:22 -07005285 // read original volumes with volume control
Eric Laurenteab90452019-06-24 15:17:46 -07005286 float v = masterVolume * mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005287 // Always fetch volumeshaper volume to ensure state is updated.
5288 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5289 const float vh = track->getVolumeHandler()->getVolume(
5290 track->mAudioTrackServerProxy->framesReleased()).first;
Eric Laurent7c29ec92017-09-20 17:54:22 -07005291
Eric Laurenteab90452019-06-24 15:17:46 -07005292 if (mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
5293 v = 0;
5294 }
5295
5296 handleVoipVolume_l(&v);
5297
5298 if (track->isPausing()) {
Andy Hung6be49402014-05-30 10:42:03 -07005299 vl = vr = 0;
5300 vlf = vrf = vaf = 0.;
Eric Laurenteab90452019-06-24 15:17:46 -07005301 track->setPaused();
Eric Laurent81784c32012-11-19 14:55:58 -08005302 } else {
Glenn Kastenc56f3422014-03-21 17:53:17 -07005303 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
Andy Hung6be49402014-05-30 10:42:03 -07005304 vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
5305 vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08005306 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07005307 if (vlf > GAIN_FLOAT_UNITY) {
5308 ALOGV("Track left volume out of range: %.3g", vlf);
5309 vlf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005310 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07005311 if (vrf > GAIN_FLOAT_UNITY) {
5312 ALOGV("Track right volume out of range: %.3g", vrf);
5313 vrf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005314 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005315 // now apply the master volume and stream type volume and shaper volume
5316 vlf *= v * vh;
5317 vrf *= v * vh;
Eric Laurent81784c32012-11-19 14:55:58 -08005318 // assuming master volume and stream type volume each go up to 1.0,
Andy Hung6be49402014-05-30 10:42:03 -07005319 // then derive vl and vr as U8.24 versions for the effect chain
5320 const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT;
5321 vl = (uint32_t) (scaleto8_24 * vlf);
5322 vr = (uint32_t) (scaleto8_24 * vrf);
5323 // vl and vr are now in U8.24 format
Glenn Kastene3aa6592012-12-04 12:22:46 -08005324 uint16_t sendLevel = proxy->getSendLevel_U4_12();
Eric Laurent81784c32012-11-19 14:55:58 -08005325 // send level comes from shared memory and so may be corrupt
5326 if (sendLevel > MAX_GAIN_INT) {
5327 ALOGV("Track send level out of range: %04X", sendLevel);
5328 sendLevel = MAX_GAIN_INT;
5329 }
Andy Hung6be49402014-05-30 10:42:03 -07005330 // vaf is represented as [0.0, 1.0] float by rescaling sendLevel
5331 vaf = v * sendLevel * (1. / MAX_GAIN_INT);
Eric Laurent81784c32012-11-19 14:55:58 -08005332 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005333
Kevin Rocard12381092018-04-11 09:19:59 -07005334 track->setFinalVolume((vrf + vlf) / 2.f);
5335
Eric Laurent81784c32012-11-19 14:55:58 -08005336 // Delegate volume control to effect in track effect chain if needed
5337 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
5338 // Do not ramp volume if volume is controlled by effect
5339 param = AudioMixer::VOLUME;
Bryant Liub6be7f22014-06-12 22:02:41 +08005340 // Update remaining floating point volume levels
5341 vlf = (float)vl / (1 << 24);
5342 vrf = (float)vr / (1 << 24);
Eric Laurent81784c32012-11-19 14:55:58 -08005343 track->mHasVolumeController = true;
5344 } else {
5345 // force no volume ramp when volume controller was just disabled or removed
5346 // from effect chain to avoid volume spike
5347 if (track->mHasVolumeController) {
5348 param = AudioMixer::VOLUME;
5349 }
5350 track->mHasVolumeController = false;
5351 }
5352
Eric Laurent81784c32012-11-19 14:55:58 -08005353 // XXX: these things DON'T need to be done each time
Andy Hungc0691382018-09-12 18:01:57 -07005354 mAudioMixer->setBufferProvider(trackId, track);
5355 mAudioMixer->enable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005356
Andy Hungc0691382018-09-12 18:01:57 -07005357 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME0, &vlf);
5358 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME1, &vrf);
5359 mAudioMixer->setParameter(trackId, param, AudioMixer::AUXLEVEL, &vaf);
Eric Laurent81784c32012-11-19 14:55:58 -08005360 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005361 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005362 AudioMixer::TRACK,
5363 AudioMixer::FORMAT, (void *)track->format());
5364 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005365 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005366 AudioMixer::TRACK,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005367 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
Andy Hung9a592762014-07-21 21:56:01 -07005368 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005369 trackId,
Andy Hung9a592762014-07-21 21:56:01 -07005370 AudioMixer::TRACK,
jiabin245cdd92018-12-07 17:55:15 -08005371 AudioMixer::MIXER_CHANNEL_MASK,
5372 (void *)(uintptr_t)(mChannelMask | mHapticChannelMask));
Glenn Kastene3aa6592012-12-04 12:22:46 -08005373 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
Andy Hungcd044842014-08-07 11:04:34 -07005374 uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX;
Andy Hung333ab962019-05-28 20:23:35 -07005375 uint32_t reqSampleRate = proxy->getSampleRate();
Glenn Kastene3aa6592012-12-04 12:22:46 -08005376 if (reqSampleRate == 0) {
5377 reqSampleRate = mSampleRate;
5378 } else if (reqSampleRate > maxSampleRate) {
5379 reqSampleRate = maxSampleRate;
5380 }
Eric Laurent81784c32012-11-19 14:55:58 -08005381 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005382 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005383 AudioMixer::RESAMPLE,
5384 AudioMixer::SAMPLE_RATE,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005385 (void *)(uintptr_t)reqSampleRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005386
Andy Hung333ab962019-05-28 20:23:35 -07005387 AudioPlaybackRate playbackRate = proxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005388 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005389 trackId,
Andy Hung8edb8dc2015-03-26 19:13:55 -07005390 AudioMixer::TIMESTRETCH,
5391 AudioMixer::PLAYBACK_RATE,
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005392 &playbackRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005393
Andy Hung69aed5f2014-02-25 17:24:40 -08005394 /*
5395 * Select the appropriate output buffer for the track.
5396 *
Andy Hung98ef9782014-03-04 14:46:50 -08005397 * Tracks with effects go into their own effects chain buffer
5398 * and from there into either mEffectBuffer or mSinkBuffer.
Andy Hung69aed5f2014-02-25 17:24:40 -08005399 *
5400 * Other tracks can use mMixerBuffer for higher precision
5401 * channel accumulation. If this buffer is enabled
5402 * (mMixerBufferEnabled true), then selected tracks will accumulate
5403 * into it.
5404 *
5405 */
5406 if (mMixerBufferEnabled
5407 && (track->mainBuffer() == mSinkBuffer
5408 || track->mainBuffer() == mMixerBuffer)) {
5409 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005410 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005411 AudioMixer::TRACK,
Andy Hung78820702014-02-28 16:23:02 -08005412 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
Andy Hung69aed5f2014-02-25 17:24:40 -08005413 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005414 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005415 AudioMixer::TRACK,
5416 AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer);
5417 // TODO: override track->mainBuffer()?
5418 mMixerBufferValid = true;
5419 } else {
5420 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005421 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005422 AudioMixer::TRACK,
rago94a1ee82017-07-21 15:11:02 -07005423 AudioMixer::MIXER_FORMAT, (void *)EFFECT_BUFFER_FORMAT);
Andy Hung69aed5f2014-02-25 17:24:40 -08005424 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005425 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005426 AudioMixer::TRACK,
5427 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
5428 }
Eric Laurent81784c32012-11-19 14:55:58 -08005429 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005430 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005431 AudioMixer::TRACK,
5432 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
jiabin245cdd92018-12-07 17:55:15 -08005433 mAudioMixer->setParameter(
5434 trackId,
5435 AudioMixer::TRACK,
5436 AudioMixer::HAPTIC_ENABLED, (void *)(uintptr_t)track->getHapticPlaybackEnabled());
jiabin77270b82018-12-18 15:41:29 -08005437 mAudioMixer->setParameter(
5438 trackId,
5439 AudioMixer::TRACK,
5440 AudioMixer::HAPTIC_INTENSITY, (void *)(uintptr_t)track->getHapticIntensity());
Lais Andradebc3f37a2021-07-02 00:13:19 +01005441 mAudioMixer->setParameter(
5442 trackId,
5443 AudioMixer::TRACK,
5444 AudioMixer::HAPTIC_MAX_AMPLITUDE, (void *)(&(track->mHapticMaxAmplitude)));
Eric Laurent81784c32012-11-19 14:55:58 -08005445
5446 // reset retry count
5447 track->mRetryCount = kMaxTrackRetries;
5448
5449 // If one track is ready, set the mixer ready if:
5450 // - the mixer was not ready during previous round OR
5451 // - no other track is not ready
5452 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
5453 mixerStatus != MIXER_TRACKS_ENABLED) {
5454 mixerStatus = MIXER_TRACKS_READY;
5455 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08005456
5457 // Enable the next few lines to instrument a test for underrun log handling.
5458 // TODO: Remove when we have a better way of testing the underrun log.
5459#if 0
5460 static int i;
5461 if ((++i & 0xf) == 0) {
5462 deferredOperations.tallyUnderrunFrames(track, 10 /* underrunFrames */);
5463 }
5464#endif
Eric Laurent81784c32012-11-19 14:55:58 -08005465 } else {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005466 size_t underrunFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005467 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
Andy Hungb68f5eb2019-12-03 16:49:17 -08005468 ALOGV("track(%d) underrun, track state %s framesReady(%zu) < framesDesired(%zd)",
5469 trackId, track->getTrackStateAsString(), framesReady, desiredFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005470 underrunFrames = desiredFrames;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005471 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005472 deferredOperations.tallyUnderrunFrames(track, underrunFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08005473
Eric Laurent81784c32012-11-19 14:55:58 -08005474 // clear effect chain input buffer if an active track underruns to avoid sending
5475 // previous audio buffer again to effects
5476 chain = getEffectChain_l(track->sessionId());
5477 if (chain != 0) {
5478 chain->clearInputBuffer();
5479 }
5480
Andy Hungc0691382018-09-12 18:01:57 -07005481 ALOGVV("track(%d) s=%08x [NOT READY] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005482 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
5483 track->isStopped() || track->isPaused()) {
5484 // We have consumed all the buffers of this track.
5485 // Remove it from the list of active tracks.
5486 // TODO: use actual buffer filling status instead of latency when available from
5487 // audio HAL
5488 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005489 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005490 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
5491 if (track->isStopped()) {
5492 track->reset();
5493 }
5494 tracksToRemove->add(track);
5495 }
5496 } else {
Eric Laurent81784c32012-11-19 14:55:58 -08005497 // No buffers for this track. Give it a few chances to
5498 // fill a buffer, then remove it from active list.
5499 if (--(track->mRetryCount) <= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07005500 ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p",
5501 trackId, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005502 tracksToRemove->add(track);
5503 // indicate to client process that the track was disabled because of underrun;
5504 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005505 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08005506 // If one track is not ready, mark the mixer also not ready if:
5507 // - the mixer was ready during previous round OR
5508 // - no other track is ready
5509 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
5510 mixerStatus != MIXER_TRACKS_READY) {
5511 mixerStatus = MIXER_TRACKS_ENABLED;
5512 }
5513 }
Andy Hungc0691382018-09-12 18:01:57 -07005514 mAudioMixer->disable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005515 }
5516
5517 } // local variable scope to avoid goto warning
Eric Laurent81784c32012-11-19 14:55:58 -08005518
5519 }
5520
jiabin245cdd92018-12-07 17:55:15 -08005521 if (mHapticChannelMask != AUDIO_CHANNEL_NONE && sq != NULL) {
5522 // When there is no fast track playing haptic and FastMixer exists,
5523 // enabling the first FastTrack, which provides mixed data from normal
5524 // tracks, to play haptic data.
5525 FastTrack *fastTrack = &state->mFastTracks[0];
5526 if (fastTrack->mHapticPlaybackEnabled != noFastHapticTrack) {
5527 fastTrack->mHapticPlaybackEnabled = noFastHapticTrack;
5528 didModify = true;
5529 }
5530 }
5531
Eric Laurent81784c32012-11-19 14:55:58 -08005532 // Push the new FastMixer state if necessary
5533 bool pauseAudioWatchdog = false;
5534 if (didModify) {
5535 state->mFastTracksGen++;
5536 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
5537 if (kUseFastMixer == FastMixer_Dynamic &&
5538 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
5539 state->mCommand = FastMixerState::COLD_IDLE;
5540 state->mColdFutexAddr = &mFastMixerFutex;
5541 state->mColdGen++;
5542 mFastMixerFutex = 0;
5543 if (kUseFastMixer == FastMixer_Dynamic) {
5544 mNormalSink = mOutputSink;
5545 }
5546 // If we go into cold idle, need to wait for acknowledgement
5547 // so that fast mixer stops doing I/O.
5548 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5549 pauseAudioWatchdog = true;
5550 }
Eric Laurent81784c32012-11-19 14:55:58 -08005551 }
5552 if (sq != NULL) {
5553 sq->end(didModify);
Andy Hungf2285312017-02-14 18:31:59 -08005554 // No need to block if the FastMixer is in COLD_IDLE as the FastThread
5555 // is not active. (We BLOCK_UNTIL_ACKED when entering COLD_IDLE
5556 // when bringing the output sink into standby.)
5557 //
5558 // We will get the latest FastMixer state when we come out of COLD_IDLE.
5559 //
5560 // This occurs with BT suspend when we idle the FastMixer with
5561 // active tracks, which may be added or removed.
5562 sq->push(coldIdle ? FastMixerStateQueue::BLOCK_NEVER : block);
Eric Laurent81784c32012-11-19 14:55:58 -08005563 }
5564#ifdef AUDIO_WATCHDOG
5565 if (pauseAudioWatchdog && mAudioWatchdog != 0) {
5566 mAudioWatchdog->pause();
5567 }
5568#endif
5569
5570 // Now perform the deferred reset on fast tracks that have stopped
5571 while (resetMask != 0) {
5572 size_t i = __builtin_ctz(resetMask);
5573 ALOG_ASSERT(i < count);
5574 resetMask &= ~(1 << i);
Andy Hungdae27702016-10-31 14:01:16 -07005575 sp<Track> track = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08005576 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
5577 track->reset();
5578 }
5579
Andy Hung80d03d22018-04-10 10:32:11 -07005580 // Track destruction may occur outside of threadLoop once it is removed from active tracks.
5581 // Ensure the AudioMixer doesn't have a raw "buffer provider" pointer to the track if
5582 // it ceases to be active, to allow safe removal from the AudioMixer at the start
5583 // of prepareTracks_l(); this releases any outstanding buffer back to the track.
5584 // See also the implementation of destroyTrack_l().
5585 for (const auto &track : *tracksToRemove) {
Andy Hungc0691382018-09-12 18:01:57 -07005586 const int trackId = track->id();
5587 if (mAudioMixer->exists(trackId)) { // Normal tracks here, fast tracks in FastMixer.
5588 mAudioMixer->setBufferProvider(trackId, nullptr /* bufferProvider */);
Andy Hung80d03d22018-04-10 10:32:11 -07005589 }
5590 }
5591
Eric Laurent81784c32012-11-19 14:55:58 -08005592 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08005593 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08005594
Eric Laurent97d547d2014-09-02 14:45:53 -07005595 if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0) {
5596 mEffectBufferValid = true;
Marco Nelissenac302142014-10-20 13:15:38 -07005597 }
5598
5599 if (mEffectBufferValid) {
Marco Nelissen57088b52014-10-17 16:39:39 -07005600 // as long as there are effects we should clear the effects buffer, to avoid
5601 // passing a non-clean buffer to the effect chain
5602 memset(mEffectBuffer, 0, mEffectBufferSize);
Eric Laurent97d547d2014-09-02 14:45:53 -07005603 }
Andy Hung69aed5f2014-02-25 17:24:40 -08005604 // sink or mix buffer must be cleared if all tracks are connected to an
5605 // effect chain as in this case the mixer will not write to the sink or mix buffer
5606 // and track effects will accumulate into it
Eric Laurentbfb1b832013-01-07 09:53:42 -08005607 if ((mBytesRemaining == 0) && ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5608 (mixedTracks == 0 && fastTracks > 0))) {
Eric Laurent81784c32012-11-19 14:55:58 -08005609 // FIXME as a performance optimization, should remember previous zero status
Andy Hung69aed5f2014-02-25 17:24:40 -08005610 if (mMixerBufferValid) {
5611 memset(mMixerBuffer, 0, mMixerBufferSize);
5612 // TODO: In testing, mSinkBuffer below need not be cleared because
5613 // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer
5614 // after mixing.
5615 //
5616 // To enforce this guarantee:
5617 // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5618 // (mixedTracks == 0 && fastTracks > 0))
5619 // must imply MIXER_TRACKS_READY.
5620 // Later, we may clear buffers regardless, and skip much of this logic.
5621 }
Andy Hung98ef9782014-03-04 14:46:50 -08005622 // FIXME as a performance optimization, should remember previous zero status
Andy Hung5567aaf2014-07-17 14:00:07 -07005623 memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08005624 }
5625
5626 // if any fast tracks, then status is ready
5627 mMixerStatusIgnoringFastTracks = mixerStatus;
5628 if (fastTracks > 0) {
5629 mixerStatus = MIXER_TRACKS_READY;
5630 }
5631 return mixerStatus;
5632}
5633
Eric Laurentad7dd962016-09-22 12:38:37 -07005634// trackCountForUid_l() must be called with ThreadBase::mLock held
Andy Hung1bc088a2018-02-09 15:57:31 -08005635uint32_t AudioFlinger::PlaybackThread::trackCountForUid_l(uid_t uid) const
Eric Laurentad7dd962016-09-22 12:38:37 -07005636{
5637 uint32_t trackCount = 0;
5638 for (size_t i = 0; i < mTracks.size() ; i++) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08005639 if (mTracks[i]->uid() == uid) {
Eric Laurentad7dd962016-09-22 12:38:37 -07005640 trackCount++;
5641 }
5642 }
5643 return trackCount;
5644}
5645
Andy Hung1bc088a2018-02-09 15:57:31 -08005646// isTrackAllowed_l() must be called with ThreadBase::mLock held
5647bool AudioFlinger::MixerThread::isTrackAllowed_l(
5648 audio_channel_mask_t channelMask, audio_format_t format,
5649 audio_session_t sessionId, uid_t uid) const
Eric Laurent81784c32012-11-19 14:55:58 -08005650{
Andy Hung1bc088a2018-02-09 15:57:31 -08005651 if (!PlaybackThread::isTrackAllowed_l(channelMask, format, sessionId, uid)) {
5652 return false;
Eric Laurentad7dd962016-09-22 12:38:37 -07005653 }
Andy Hung1bc088a2018-02-09 15:57:31 -08005654 // Check validity as we don't call AudioMixer::create() here.
Mikhail Naganov7ad7a252019-07-30 14:42:32 -07005655 if (!mAudioMixer->isValidFormat(format)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005656 ALOGW("%s: invalid format: %#x", __func__, format);
5657 return false;
5658 }
Mikhail Naganov7ad7a252019-07-30 14:42:32 -07005659 if (!mAudioMixer->isValidChannelMask(channelMask)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005660 ALOGW("%s: invalid channelMask: %#x", __func__, channelMask);
5661 return false;
5662 }
5663 return true;
Eric Laurent81784c32012-11-19 14:55:58 -08005664}
5665
Eric Laurent10351942014-05-08 18:49:52 -07005666// checkForNewParameter_l() must be called with ThreadBase::mLock held
5667bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
5668 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08005669{
Eric Laurent81784c32012-11-19 14:55:58 -08005670 bool reconfig = false;
Eric Laurent10351942014-05-08 18:49:52 -07005671 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08005672
Glenn Kastenc05b8d72016-03-24 09:48:17 -07005673 AutoPark<FastMixer> park(mFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08005674
Eric Laurent10351942014-05-08 18:49:52 -07005675 AudioParameter param = AudioParameter(keyValuePair);
5676 int value;
5677 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
5678 reconfig = true;
5679 }
5680 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005681 if (!isValidPcmSinkFormat((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005682 status = BAD_VALUE;
5683 } else {
5684 // no need to save value, since it's constant
Eric Laurent81784c32012-11-19 14:55:58 -08005685 reconfig = true;
5686 }
Eric Laurent10351942014-05-08 18:49:52 -07005687 }
5688 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005689 if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005690 status = BAD_VALUE;
5691 } else {
5692 // no need to save value, since it's constant
5693 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005694 }
Eric Laurent10351942014-05-08 18:49:52 -07005695 }
5696 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
5697 // do not accept frame count changes if tracks are open as the track buffer
5698 // size depends on frame count and correct behavior would not be guaranteed
5699 // if frame count is changed after track creation
5700 if (!mTracks.isEmpty()) {
5701 status = INVALID_OPERATION;
5702 } else {
5703 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005704 }
Eric Laurent10351942014-05-08 18:49:52 -07005705 }
5706 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07005707 LOG_FATAL("Should not set routing device in MixerThread");
Eric Laurent10351942014-05-08 18:49:52 -07005708 }
Eric Laurent81784c32012-11-19 14:55:58 -08005709
Eric Laurent10351942014-05-08 18:49:52 -07005710 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005711 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07005712 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08005713 mOutput->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07005714 if (!mStandby) {
5715 mThreadMetrics.logEndInterval();
5716 mStandby = true;
5717 }
Eric Laurent10351942014-05-08 18:49:52 -07005718 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005719 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent81784c32012-11-19 14:55:58 -08005720 }
Eric Laurent10351942014-05-08 18:49:52 -07005721 if (status == NO_ERROR && reconfig) {
5722 readOutputParameters_l();
5723 delete mAudioMixer;
5724 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
Andy Hung1bc088a2018-02-09 15:57:31 -08005725 for (const auto &track : mTracks) {
Andy Hungc0691382018-09-12 18:01:57 -07005726 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005727 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005728 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005729 track->mChannelMask,
5730 track->mFormat,
5731 track->mSessionId);
5732 ALOGW_IF(status != NO_ERROR,
Andy Hungc0691382018-09-12 18:01:57 -07005733 "%s(): AudioMixer cannot create track(%d)"
5734 " mask %#x, format %#x, sessionId %d",
Andy Hung1bc088a2018-02-09 15:57:31 -08005735 __func__,
Andy Hungc0691382018-09-12 18:01:57 -07005736 trackId, track->mChannelMask, track->mFormat, track->mSessionId);
Eric Laurent10351942014-05-08 18:49:52 -07005737 }
Eric Laurent73e26b62015-04-27 16:55:58 -07005738 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07005739 }
Eric Laurent81784c32012-11-19 14:55:58 -08005740 }
5741
Dean Wheatley68918102021-03-19 22:09:19 +11005742 return reconfig;
Eric Laurent81784c32012-11-19 14:55:58 -08005743}
5744
5745
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005746void AudioFlinger::MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08005747{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005748 PlaybackThread::dumpInternals_l(fd, args);
Andy Hung40eb1a12015-06-18 13:42:02 -07005749 dprintf(fd, " Thread throttle time (msecs): %u\n", mThreadThrottleTimeMs);
Andy Hung8ed196a2018-01-05 13:21:11 -08005750 dprintf(fd, " AudioMixer tracks: %s\n", mAudioMixer->trackNames().c_str());
Andy Hung2ddee192015-12-18 17:34:44 -08005751 dprintf(fd, " Master mono: %s\n", mMasterMono ? "on" : "off");
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005752 dprintf(fd, " Master balance: %f (%s)\n", mMasterBalance.load(),
5753 (hasFastMixer() ? std::to_string(mFastMixer->getMasterBalance())
5754 : mBalance.toString()).c_str());
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005755 if (hasFastMixer()) {
5756 dprintf(fd, " FastMixer thread %p tid=%d", mFastMixer.get(), mFastMixer->getTid());
5757
5758 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
5759 // while we are dumping it. It may be inconsistent, but it won't mutate!
5760 // This is a large object so we place it on the heap.
5761 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07005762 const std::unique_ptr<FastMixerDumpState> copy =
5763 std::make_unique<FastMixerDumpState>(mFastMixerDumpState);
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005764 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005765
5766#ifdef STATE_QUEUE_DUMP
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005767 // Similar for state queue
5768 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
5769 observerCopy.dump(fd);
5770 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
5771 mutatorCopy.dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005772#endif
5773
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005774#ifdef AUDIO_WATCHDOG
5775 if (mAudioWatchdog != 0) {
5776 // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
5777 AudioWatchdogDump wdCopy = mAudioWatchdogDump;
5778 wdCopy.dump(fd);
5779 }
5780#endif
5781
5782 } else {
5783 dprintf(fd, " No FastMixer\n");
5784 }
Eric Laurent81784c32012-11-19 14:55:58 -08005785}
5786
5787uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
5788{
5789 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
5790}
5791
5792uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
5793{
5794 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
5795}
5796
5797void AudioFlinger::MixerThread::cacheParameters_l()
5798{
5799 PlaybackThread::cacheParameters_l();
5800
5801 // FIXME: Relaxed timing because of a certain device that can't meet latency
5802 // Should be reduced to 2x after the vendor fixes the driver issue
5803 // increase threshold again due to low power audio mode. The way this warning
5804 // threshold is calculated and its usefulness should be reconsidered anyway.
5805 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
5806}
5807
5808// ----------------------------------------------------------------------------
5809
5810AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
jiabinc52b1ff2019-10-31 17:20:42 -07005811 AudioStreamOut* output, audio_io_handle_t id, ThreadBase::type_t type, bool systemReady)
5812 : PlaybackThread(audioFlinger, output, id, type, systemReady)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005813{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005814 setMasterBalance(audioFlinger->getMasterBalance_l());
Eric Laurentbfb1b832013-01-07 09:53:42 -08005815}
5816
Eric Laurent81784c32012-11-19 14:55:58 -08005817AudioFlinger::DirectOutputThread::~DirectOutputThread()
5818{
5819}
5820
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005821void AudioFlinger::DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005822{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005823 PlaybackThread::dumpInternals_l(fd, args);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005824 dprintf(fd, " Master balance: %f Left: %f Right: %f\n",
5825 mMasterBalance.load(), mMasterBalanceLeft, mMasterBalanceRight);
5826}
5827
5828void AudioFlinger::DirectOutputThread::setMasterBalance(float balance)
5829{
5830 Mutex::Autolock _l(mLock);
5831 if (mMasterBalance != balance) {
5832 mMasterBalance.store(balance);
5833 mBalance.computeStereoBalance(balance, &mMasterBalanceLeft, &mMasterBalanceRight);
5834 broadcast_l();
5835 }
5836}
5837
Eric Laurent5850c4c2016-11-10 13:04:31 -08005838void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005839{
Eric Laurentbfb1b832013-01-07 09:53:42 -08005840 float left, right;
5841
Andy Hung333ab962019-05-28 20:23:35 -07005842 // Ensure volumeshaper state always advances even when muted.
5843 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5844 const auto [shaperVolume, shaperActive] = track->getVolumeHandler()->getVolume(
5845 proxy->framesReleased());
5846 mVolumeShaperActive = shaperActive;
5847
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08005848 if (mMasterMute || mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08005849 left = right = 0;
5850 } else {
5851 float typeVolume = mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005852 const float v = mMasterVolume * typeVolume * shaperVolume;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005853
Glenn Kastenc56f3422014-03-21 17:53:17 -07005854 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
5855 left = float_from_gain(gain_minifloat_unpack_left(vlr));
5856 if (left > GAIN_FLOAT_UNITY) {
5857 left = GAIN_FLOAT_UNITY;
5858 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005859 left *= v * mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
Glenn Kastenc56f3422014-03-21 17:53:17 -07005860 right = float_from_gain(gain_minifloat_unpack_right(vlr));
5861 if (right > GAIN_FLOAT_UNITY) {
5862 right = GAIN_FLOAT_UNITY;
5863 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005864 right *= v * mMasterBalanceRight;
Eric Laurentbfb1b832013-01-07 09:53:42 -08005865 }
5866
5867 if (lastTrack) {
Kevin Rocard12381092018-04-11 09:19:59 -07005868 track->setFinalVolume((left + right) / 2.f);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005869 if (left != mLeftVolFloat || right != mRightVolFloat) {
5870 mLeftVolFloat = left;
5871 mRightVolFloat = right;
5872
Eric Laurentbfb1b832013-01-07 09:53:42 -08005873 // Delegate volume control to effect in track effect chain if needed
5874 // only one effect chain can be present on DirectOutputThread, so if
5875 // there is one, the track is connected to it
5876 if (!mEffectChains.isEmpty()) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09005877 // if effect chain exists, volume is handled by it.
5878 // Convert volumes from float to 8.24
5879 uint32_t vl = (uint32_t)(left * (1 << 24));
5880 uint32_t vr = (uint32_t)(right * (1 << 24));
5881 // Direct/Offload effect chains set output volume in setVolume_l().
5882 (void)mEffectChains[0]->setVolume_l(&vl, &vr);
5883 } else {
5884 // otherwise we directly set the volume.
5885 setVolumeForOutput_l(left, right);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005886 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005887 }
5888 }
5889}
5890
Phil Burk43b4dcc2015-06-09 16:53:44 -07005891void AudioFlinger::DirectOutputThread::onAddNewTrack_l()
5892{
5893 sp<Track> previousTrack = mPreviousTrack.promote();
Andy Hungdae27702016-10-31 14:01:16 -07005894 sp<Track> latestTrack = mActiveTracks.getLatest();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005895
Eric Laurent0f0631e2015-07-06 18:01:25 -07005896 if (previousTrack != 0 && latestTrack != 0) {
5897 if (mType == DIRECT) {
5898 if (previousTrack.get() != latestTrack.get()) {
5899 mFlushPending = true;
5900 }
5901 } else /* mType == OFFLOAD */ {
5902 if (previousTrack->sessionId() != latestTrack->sessionId()) {
5903 mFlushPending = true;
5904 }
5905 }
Revathi Uddaraju20413a92016-10-13 17:16:14 +08005906 } else if (previousTrack == 0) {
5907 // there could be an old track added back during track transition for direct
5908 // output, so always issues flush to flush data of the previous track if it
5909 // was already destroyed with HAL paused, then flush can resume the playback
5910 mFlushPending = true;
Phil Burk43b4dcc2015-06-09 16:53:44 -07005911 }
5912 PlaybackThread::onAddNewTrack_l();
5913}
Eric Laurentbfb1b832013-01-07 09:53:42 -08005914
Eric Laurent81784c32012-11-19 14:55:58 -08005915AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
5916 Vector< sp<Track> > *tracksToRemove
5917)
5918{
Eric Laurentd595b7c2013-04-03 17:27:56 -07005919 size_t count = mActiveTracks.size();
Eric Laurent81784c32012-11-19 14:55:58 -08005920 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005921 bool doHwPause = false;
5922 bool doHwResume = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005923
5924 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07005925 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08005926 if (t->isInvalid()) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005927 ALOGW("An invalidated track shouldn't be in active list");
Eric Laurent5850c4c2016-11-10 13:04:31 -08005928 tracksToRemove->add(t);
Phil Burk43b4dcc2015-06-09 16:53:44 -07005929 continue;
5930 }
5931
Eric Laurent5850c4c2016-11-10 13:04:31 -08005932 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005933#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurent81784c32012-11-19 14:55:58 -08005934 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005935#endif
Eric Laurentfd477972013-10-25 18:10:40 -07005936 // Only consider last track started for volume and mixer state control.
5937 // In theory an older track could underrun and restart after the new one starts
5938 // but as we only care about the transition phase between two tracks on a
5939 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07005940 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08005941 bool last = l.get() == track;
Eric Laurent81784c32012-11-19 14:55:58 -08005942
Kuowei Li23666472021-01-20 10:23:25 +08005943 if (track->isPausePending()) {
5944 track->pauseAck();
5945 // It is possible a track might have been flushed or stopped.
5946 // Other operations such as flush pending might occur on the next prepare.
5947 if (track->isPausing()) {
5948 track->setPaused();
5949 }
5950 // Always perform pause, as an immediate flush will change
5951 // the pause state to be no longer isPausing().
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005952 if (mHwSupportsPause && last && !mHwPaused) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005953 doHwPause = true;
5954 mHwPaused = true;
5955 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005956 } else if (track->isFlushPending()) {
5957 track->flushAck();
5958 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005959 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005960 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005961 } else if (track->isResumePending()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005962 track->resumeAck();
Eric Laurent3df841a2016-07-15 15:15:40 -07005963 if (last) {
5964 mLeftVolFloat = mRightVolFloat = -1.0;
5965 if (mHwPaused) {
5966 doHwResume = true;
5967 mHwPaused = false;
5968 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005969 }
5970 }
5971
Eric Laurent81784c32012-11-19 14:55:58 -08005972 // The first time a track is added we wait
Phil Burk99adee32014-12-10 16:46:30 -08005973 // for all its buffers to be filled before processing it.
5974 // Allow draining the buffer in case the client
5975 // app does not call stop() and relies on underrun to stop:
5976 // hence the test on (track->mRetryCount > 1).
Andy Hung455982f2021-04-27 17:46:12 -07005977 // If track->mRetryCount <= 1 then track is about to be disabled, paused, removed,
5978 // so we accept any nonzero amount of data delivered by the AudioTrack (which will
5979 // reset the retry counter).
Phil Burkca5e6142015-07-14 09:42:29 -07005980 // Do not use a high threshold for compressed audio.
Andy Hung455982f2021-04-27 17:46:12 -07005981
5982 // target retry count that we will use is based on the time we wait for retries.
5983 const int32_t targetRetryCount = kMaxTrackRetriesDirectMs * 1000 / mActiveSleepTimeUs;
5984 // the retry threshold is when we accept any size for PCM data. This is slightly
5985 // smaller than the retry count so we can push small bits of data without a glitch.
5986 const int32_t retryThreshold = targetRetryCount > 2 ? targetRetryCount - 1 : 1;
Eric Laurent81784c32012-11-19 14:55:58 -08005987 uint32_t minFrames;
Phil Burk99adee32014-12-10 16:46:30 -08005988 if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
Andy Hung455982f2021-04-27 17:46:12 -07005989 && (track->mRetryCount > retryThreshold) && audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005990 minFrames = mNormalFrameCount;
5991 } else {
5992 minFrames = 1;
5993 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005994
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07005995 const size_t framesReady = track->framesReady();
5996 const int trackId = track->id();
5997 if (ATRACE_ENABLED()) {
5998 std::string traceName("nRdy");
5999 traceName += std::to_string(trackId);
6000 ATRACE_INT(traceName.c_str(), framesReady);
6001 }
6002 if ((framesReady >= minFrames) && track->isReady() && !track->isPaused() &&
Eric Laurentab5cdba2014-06-09 17:22:27 -07006003 !track->isStopping_2() && !track->isStopped())
Eric Laurent81784c32012-11-19 14:55:58 -08006004 {
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07006005 ALOGVV("track(%d) s=%08x [OK]", trackId, cblk->mServer);
Eric Laurent81784c32012-11-19 14:55:58 -08006006
6007 if (track->mFillingUpStatus == Track::FS_FILLED) {
6008 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07006009 if (last) {
6010 // make sure processVolume_l() will apply new volume even if 0
6011 mLeftVolFloat = mRightVolFloat = -1.0;
6012 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08006013 if (!mHwSupportsPause) {
6014 track->resumeAck();
Eric Laurent81784c32012-11-19 14:55:58 -08006015 }
6016 }
6017
6018 // compute volume for this track
Eric Laurentbfb1b832013-01-07 09:53:42 -08006019 processVolume_l(track, last);
6020 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07006021 sp<Track> previousTrack = mPreviousTrack.promote();
6022 if (previousTrack != 0) {
6023 if (track != previousTrack.get()) {
6024 // Flush any data still being written from last track
6025 mBytesRemaining = 0;
Eric Laurent0f0631e2015-07-06 18:01:25 -07006026 // Invalidate previous track to force a seek when resuming.
6027 previousTrack->invalidate();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006028 }
6029 }
6030 mPreviousTrack = track;
6031
Eric Laurentd595b7c2013-04-03 17:27:56 -07006032 // reset retry count
Andy Hung455982f2021-04-27 17:46:12 -07006033 track->mRetryCount = targetRetryCount;
Eric Laurent5850c4c2016-11-10 13:04:31 -08006034 mActiveTrack = t;
Eric Laurentd595b7c2013-04-03 17:27:56 -07006035 mixerStatus = MIXER_TRACKS_READY;
Eric Laurent5cff4032015-05-26 13:49:58 -07006036 if (mHwPaused) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006037 doHwResume = true;
6038 mHwPaused = false;
6039 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07006040 }
Eric Laurent81784c32012-11-19 14:55:58 -08006041 } else {
Eric Laurentd595b7c2013-04-03 17:27:56 -07006042 // clear effect chain input buffer if the last active track started underruns
6043 // to avoid sending previous audio buffer again to effects
Eric Laurentfd477972013-10-25 18:10:40 -07006044 if (!mEffectChains.isEmpty() && last) {
Eric Laurent81784c32012-11-19 14:55:58 -08006045 mEffectChains[0]->clearInputBuffer();
6046 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07006047 if (track->isStopping_1()) {
6048 track->mState = TrackBase::STOPPING_2;
Eric Laurentb369caf2015-03-30 20:51:47 -07006049 if (last && mHwPaused) {
6050 doHwResume = true;
6051 mHwPaused = false;
6052 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07006053 }
6054 if ((track->sharedBuffer() != 0) || track->isStopped() ||
6055 track->isStopping_2() || track->isPaused()) {
Eric Laurent81784c32012-11-19 14:55:58 -08006056 // We have consumed all the buffers of this track.
6057 // Remove it from the list of active tracks.
Eric Laurentfd477972013-10-25 18:10:40 -07006058 if (mStandby || !last ||
Andy Hung59de4262021-06-14 10:53:54 -07006059 track->presentationComplete(latency_l()) ||
Jindong32dc26e2019-11-11 18:10:01 +08006060 track->isPaused() || mHwPaused) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07006061 if (track->isStopping_2()) {
6062 track->mState = TrackBase::STOPPED;
6063 }
Eric Laurent81784c32012-11-19 14:55:58 -08006064 if (track->isStopped()) {
6065 track->reset();
6066 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07006067 tracksToRemove->add(track);
Eric Laurent81784c32012-11-19 14:55:58 -08006068 }
6069 } else {
6070 // No buffers for this track. Give it a few chances to
6071 // fill a buffer, then remove it from active list.
Eric Laurentd595b7c2013-04-03 17:27:56 -07006072 // Only consider last track started for mixer state control
Eric Laurent81784c32012-11-19 14:55:58 -08006073 if (--(track->mRetryCount) <= 0) {
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07006074 ALOGV("BUFFER TIMEOUT: remove track(%d) from active list", trackId);
Eric Laurentd595b7c2013-04-03 17:27:56 -07006075 tracksToRemove->add(track);
Eric Laurenta23f17a2013-11-05 18:22:08 -08006076 // indicate to client process that the track was disabled because of underrun;
6077 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08006078 track->disable();
Haynes Mathew George5c6daae2017-01-24 20:06:05 -08006079 // only do hw pause when track is going to be removed due to BUFFER TIMEOUT.
6080 // unlike mixerthread, HAL can be paused for direct output
Phil Burkca5e6142015-07-14 09:42:29 -07006081 ALOGW("pause because of UNDERRUN, framesReady = %zu,"
6082 "minFrames = %u, mFormat = %#x",
Mikhail Naganovddb07bc2019-08-15 20:18:47 -07006083 framesReady, minFrames, mFormat);
Haynes Mathew George5c6daae2017-01-24 20:06:05 -08006084 if (last && mHwSupportsPause && !mHwPaused && !mStandby) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006085 doHwPause = true;
6086 mHwPaused = true;
6087 }
Haynes Mathew George5c6daae2017-01-24 20:06:05 -08006088 } else if (last) {
6089 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurent81784c32012-11-19 14:55:58 -08006090 }
6091 }
6092 }
6093 }
6094
Eric Laurentd1f69b02014-12-15 14:33:13 -08006095 // if an active track did not command a flush, check for pending flush on stopped tracks
Phil Burk43b4dcc2015-06-09 16:53:44 -07006096 if (!mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006097 for (size_t i = 0; i < mTracks.size(); i++) {
6098 if (mTracks[i]->isFlushPending()) {
6099 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006100 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006101 }
6102 }
6103 }
6104
6105 // make sure the pause/flush/resume sequence is executed in the right order.
6106 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
6107 // before flush and then resume HW. This can happen in case of pause/flush/resume
6108 // if resume is received before pause is executed.
6109 if (mHwSupportsPause && !mStandby &&
Phil Burk43b4dcc2015-06-09 16:53:44 -07006110 (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006111 status_t result = mOutput->stream->pause();
6112 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006113 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07006114 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006115 flushHw_l();
6116 }
6117 if (mHwSupportsPause && !mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006118 status_t result = mOutput->stream->resume();
6119 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006120 }
Eric Laurent81784c32012-11-19 14:55:58 -08006121 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08006122 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08006123
6124 return mixerStatus;
6125}
6126
6127void AudioFlinger::DirectOutputThread::threadLoop_mix()
6128{
Eric Laurent81784c32012-11-19 14:55:58 -08006129 size_t frameCount = mFrameCount;
Andy Hung2098f272014-02-27 14:00:06 -08006130 int8_t *curBuf = (int8_t *)mSinkBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08006131 // output audio to hardware
6132 while (frameCount) {
Glenn Kasten34542ac2013-06-26 11:29:02 -07006133 AudioBufferProvider::Buffer buffer;
Eric Laurent81784c32012-11-19 14:55:58 -08006134 buffer.frameCount = frameCount;
Phil Burk062e67a2015-02-11 13:40:50 -08006135 status_t status = mActiveTrack->getNextBuffer(&buffer);
6136 if (status != NO_ERROR || buffer.raw == NULL) {
Eric Laurent51716182016-02-29 18:00:56 -08006137 // no need to pad with 0 for compressed audio
6138 if (audio_has_proportional_frames(mFormat)) {
6139 memset(curBuf, 0, frameCount * mFrameSize);
6140 }
Eric Laurent81784c32012-11-19 14:55:58 -08006141 break;
6142 }
6143 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
6144 frameCount -= buffer.frameCount;
6145 curBuf += buffer.frameCount * mFrameSize;
6146 mActiveTrack->releaseBuffer(&buffer);
6147 }
Andy Hung2098f272014-02-27 14:00:06 -08006148 mCurrentWriteLength = curBuf - (int8_t *)mSinkBuffer;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006149 mSleepTimeUs = 0;
6150 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006151 mActiveTrack.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08006152}
6153
6154void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
6155{
Eric Laurentd1f69b02014-12-15 14:33:13 -08006156 // do not write to HAL when paused
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006157 if (mHwPaused || (usesHwAvSync() && mStandby)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006158 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006159 return;
6160 }
Andy Hung85ba3332021-04-27 17:40:26 -07006161 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
6162 mSleepTimeUs = mActiveSleepTimeUs;
6163 } else {
6164 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006165 }
Andy Hung85ba3332021-04-27 17:40:26 -07006166 // Note: In S or later, we do not write zeroes for
6167 // linear or proportional PCM direct tracks in underrun.
Eric Laurent81784c32012-11-19 14:55:58 -08006168}
6169
Eric Laurentd1f69b02014-12-15 14:33:13 -08006170void AudioFlinger::DirectOutputThread::threadLoop_exit()
6171{
6172 {
6173 Mutex::Autolock _l(mLock);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006174 for (size_t i = 0; i < mTracks.size(); i++) {
6175 if (mTracks[i]->isFlushPending()) {
6176 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006177 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006178 }
6179 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07006180 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006181 flushHw_l();
6182 }
6183 }
6184 PlaybackThread::threadLoop_exit();
6185}
6186
6187// must be called with thread mutex locked
6188bool AudioFlinger::DirectOutputThread::shouldStandby_l()
6189{
6190 bool trackPaused = false;
Eric Laurentb369caf2015-03-30 20:51:47 -07006191 bool trackStopped = false;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006192
6193 // do not put the HAL in standby when paused. AwesomePlayer clear the offloaded AudioTrack
6194 // after a timeout and we will enter standby then.
6195 if (mTracks.size() > 0) {
6196 trackPaused = mTracks[mTracks.size() - 1]->isPaused();
Eric Laurentb369caf2015-03-30 20:51:47 -07006197 trackStopped = mTracks[mTracks.size() - 1]->isStopped() ||
6198 mTracks[mTracks.size() - 1]->mState == TrackBase::IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006199 }
6200
Eric Laurent5cff4032015-05-26 13:49:58 -07006201 return !mStandby && !(trackPaused || (mHwPaused && !trackStopped));
Eric Laurentd1f69b02014-12-15 14:33:13 -08006202}
6203
Eric Laurent10351942014-05-08 18:49:52 -07006204// checkForNewParameter_l() must be called with ThreadBase::mLock held
6205bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
6206 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08006207{
6208 bool reconfig = false;
Eric Laurent10351942014-05-08 18:49:52 -07006209 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08006210
Eric Laurent10351942014-05-08 18:49:52 -07006211 AudioParameter param = AudioParameter(keyValuePair);
6212 int value;
6213 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07006214 LOG_FATAL("Should not set routing device in DirectOutputThread");
Eric Laurent81784c32012-11-19 14:55:58 -08006215 }
Eric Laurent10351942014-05-08 18:49:52 -07006216 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
6217 // do not accept frame count changes if tracks are open as the track buffer
6218 // size depends on frame count and correct behavior would not be garantied
6219 // if frame count is changed after track creation
6220 if (!mTracks.isEmpty()) {
6221 status = INVALID_OPERATION;
6222 } else {
6223 reconfig = true;
6224 }
6225 }
6226 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006227 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006228 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08006229 mOutput->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07006230 if (!mStandby) {
6231 mThreadMetrics.logEndInterval();
6232 mStandby = true;
6233 }
Eric Laurent10351942014-05-08 18:49:52 -07006234 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006235 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006236 }
6237 if (status == NO_ERROR && reconfig) {
6238 readOutputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07006239 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07006240 }
6241 }
6242
Dean Wheatley68918102021-03-19 22:09:19 +11006243 return reconfig;
Eric Laurent81784c32012-11-19 14:55:58 -08006244}
6245
6246uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
6247{
6248 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006249 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006250 time = PlaybackThread::activeSleepTimeUs();
6251 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006252 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006253 }
6254 return time;
6255}
6256
6257uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
6258{
6259 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006260 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006261 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
6262 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006263 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006264 }
6265 return time;
6266}
6267
6268uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
6269{
6270 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006271 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006272 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
6273 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006274 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006275 }
6276 return time;
6277}
6278
6279void AudioFlinger::DirectOutputThread::cacheParameters_l()
6280{
6281 PlaybackThread::cacheParameters_l();
6282
6283 // use shorter standby delay as on normal output to release
6284 // hardware resources as soon as possible
Eric Laurentb369caf2015-03-30 20:51:47 -07006285 // no delay on outputs with HW A/V sync
6286 if (usesHwAvSync()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006287 mStandbyDelayNs = 0;
Phil Burkfdb3c072016-02-09 10:47:02 -08006288 } else if ((mType == OFFLOAD) && !audio_has_proportional_frames(mFormat)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006289 mStandbyDelayNs = kOffloadStandbyDelayNs;
Eric Laurent5cff4032015-05-26 13:49:58 -07006290 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006291 mStandbyDelayNs = microseconds(mActiveSleepTimeUs*2);
Eric Laurent972a1732013-09-04 09:42:59 -07006292 }
Eric Laurent81784c32012-11-19 14:55:58 -08006293}
6294
Eric Laurente659ef42014-09-29 13:06:46 -07006295void AudioFlinger::DirectOutputThread::flushHw_l()
6296{
Phil Burk062e67a2015-02-11 13:40:50 -08006297 mOutput->flush();
Eric Laurentd1f69b02014-12-15 14:33:13 -08006298 mHwPaused = false;
Phil Burk43b4dcc2015-06-09 16:53:44 -07006299 mFlushPending = false;
Dean Wheatley12473e92021-03-18 23:00:55 +11006300 mTimestampVerifier.discontinuity(discontinuityForStandbyOrFlush());
Sampath Shetty999f0e82020-01-15 10:19:06 +11006301 mTimestamp.clear();
Eric Laurente659ef42014-09-29 13:06:46 -07006302}
6303
Andy Hung10cbff12017-02-21 17:30:14 -08006304int64_t AudioFlinger::DirectOutputThread::computeWaitTimeNs_l() const {
6305 // If a VolumeShaper is active, we must wake up periodically to update volume.
6306 const int64_t NS_PER_MS = 1000000;
6307 return mVolumeShaperActive ?
6308 kMinNormalSinkBufferSizeMs * NS_PER_MS : PlaybackThread::computeWaitTimeNs_l();
6309}
6310
Eric Laurent81784c32012-11-19 14:55:58 -08006311// ----------------------------------------------------------------------------
6312
Eric Laurentbfb1b832013-01-07 09:53:42 -08006313AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
Eric Laurent4de95592013-09-26 15:28:21 -07006314 const wp<AudioFlinger::PlaybackThread>& playbackThread)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006315 : Thread(false /*canCallJava*/),
Eric Laurent4de95592013-09-26 15:28:21 -07006316 mPlaybackThread(playbackThread),
Eric Laurent3b4529e2013-09-05 18:09:19 -07006317 mWriteAckSequence(0),
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006318 mDrainSequence(0),
6319 mAsyncError(false)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006320{
6321}
6322
6323AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
6324{
6325}
6326
6327void AudioFlinger::AsyncCallbackThread::onFirstRef()
6328{
6329 run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
6330}
6331
6332bool AudioFlinger::AsyncCallbackThread::threadLoop()
6333{
6334 while (!exitPending()) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006335 uint32_t writeAckSequence;
6336 uint32_t drainSequence;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006337 bool asyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006338
6339 {
6340 Mutex::Autolock _l(mLock);
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006341 while (!((mWriteAckSequence & 1) ||
6342 (mDrainSequence & 1) ||
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006343 mAsyncError ||
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006344 exitPending())) {
6345 mWaitWorkCV.wait(mLock);
6346 }
6347
Eric Laurentbfb1b832013-01-07 09:53:42 -08006348 if (exitPending()) {
6349 break;
6350 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006351 ALOGV("AsyncCallbackThread mWriteAckSequence %d mDrainSequence %d",
6352 mWriteAckSequence, mDrainSequence);
6353 writeAckSequence = mWriteAckSequence;
6354 mWriteAckSequence &= ~1;
6355 drainSequence = mDrainSequence;
6356 mDrainSequence &= ~1;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006357 asyncError = mAsyncError;
6358 mAsyncError = false;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006359 }
6360 {
Eric Laurent4de95592013-09-26 15:28:21 -07006361 sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
6362 if (playbackThread != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006363 if (writeAckSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006364 playbackThread->resetWriteBlocked(writeAckSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006365 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006366 if (drainSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006367 playbackThread->resetDraining(drainSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006368 }
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006369 if (asyncError) {
6370 playbackThread->onAsyncError();
6371 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006372 }
6373 }
6374 }
6375 return false;
6376}
6377
6378void AudioFlinger::AsyncCallbackThread::exit()
6379{
6380 ALOGV("AsyncCallbackThread::exit");
6381 Mutex::Autolock _l(mLock);
6382 requestExit();
6383 mWaitWorkCV.broadcast();
6384}
6385
Eric Laurent3b4529e2013-09-05 18:09:19 -07006386void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006387{
6388 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006389 // bit 0 is cleared
6390 mWriteAckSequence = sequence << 1;
6391}
6392
6393void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
6394{
6395 Mutex::Autolock _l(mLock);
6396 // ignore unexpected callbacks
6397 if (mWriteAckSequence & 2) {
6398 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006399 mWaitWorkCV.signal();
6400 }
6401}
6402
Eric Laurent3b4529e2013-09-05 18:09:19 -07006403void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006404{
6405 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006406 // bit 0 is cleared
6407 mDrainSequence = sequence << 1;
6408}
6409
6410void AudioFlinger::AsyncCallbackThread::resetDraining()
6411{
6412 Mutex::Autolock _l(mLock);
6413 // ignore unexpected callbacks
6414 if (mDrainSequence & 2) {
6415 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006416 mWaitWorkCV.signal();
6417 }
6418}
6419
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006420void AudioFlinger::AsyncCallbackThread::setAsyncError()
6421{
6422 Mutex::Autolock _l(mLock);
6423 mAsyncError = true;
6424 mWaitWorkCV.signal();
6425}
6426
Eric Laurentbfb1b832013-01-07 09:53:42 -08006427
6428// ----------------------------------------------------------------------------
6429AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
jiabinc52b1ff2019-10-31 17:20:42 -07006430 AudioStreamOut* output, audio_io_handle_t id, bool systemReady)
6431 : DirectOutputThread(audioFlinger, output, id, OFFLOAD, systemReady),
Andy Hungf8044752016-07-27 14:58:11 -07006432 mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true),
6433 mOffloadUnderrunPosition(~0LL)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006434{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07006435 //FIXME: mStandby should be set to true by ThreadBase constructo
Eric Laurentfd477972013-10-25 18:10:40 -07006436 mStandby = true;
Eric Laurent64667972016-03-30 18:19:46 -07006437 mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006438}
6439
Eric Laurentbfb1b832013-01-07 09:53:42 -08006440void AudioFlinger::OffloadThread::threadLoop_exit()
6441{
6442 if (mFlushPending || mHwPaused) {
6443 // If a flush is pending or track was paused, just discard buffered data
6444 flushHw_l();
6445 } else {
6446 mMixerStatus = MIXER_DRAIN_ALL;
6447 threadLoop_drain();
6448 }
Uday Gupta56604aa2014-05-13 11:19:17 -07006449 if (mUseAsyncWrite) {
6450 ALOG_ASSERT(mCallbackThread != 0);
6451 mCallbackThread->exit();
6452 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006453 PlaybackThread::threadLoop_exit();
6454}
6455
6456AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
6457 Vector< sp<Track> > *tracksToRemove
6458)
6459{
Eric Laurentbfb1b832013-01-07 09:53:42 -08006460 size_t count = mActiveTracks.size();
6461
6462 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurent972a1732013-09-04 09:42:59 -07006463 bool doHwPause = false;
6464 bool doHwResume = false;
6465
Glenn Kastenc42e9b42016-03-21 11:35:03 -07006466 ALOGV("OffloadThread::prepareTracks_l active tracks %zu", count);
Eric Laurentede6c3b2013-09-19 14:37:46 -07006467
Eric Laurentbfb1b832013-01-07 09:53:42 -08006468 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07006469 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08006470 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006471#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurentbfb1b832013-01-07 09:53:42 -08006472 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006473#endif
Eric Laurentfd477972013-10-25 18:10:40 -07006474 // Only consider last track started for volume and mixer state control.
6475 // In theory an older track could underrun and restart after the new one starts
6476 // but as we only care about the transition phase between two tracks on a
6477 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07006478 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08006479 bool last = l.get() == track;
Eric Laurentfd477972013-10-25 18:10:40 -07006480
Haynes Mathew George7844f672014-01-15 12:32:55 -08006481 if (track->isInvalid()) {
6482 ALOGW("An invalidated track shouldn't be in active list");
6483 tracksToRemove->add(track);
6484 continue;
6485 }
6486
6487 if (track->mState == TrackBase::IDLE) {
6488 ALOGW("An idle track shouldn't be in active list");
6489 continue;
6490 }
6491
Kuowei Li23666472021-01-20 10:23:25 +08006492 if (track->isPausePending()) {
6493 track->pauseAck();
6494 // It is possible a track might have been flushed or stopped.
6495 // Other operations such as flush pending might occur on the next prepare.
6496 if (track->isPausing()) {
6497 track->setPaused();
6498 }
6499 // Always perform pause if last, as an immediate flush will change
6500 // the pause state to be no longer isPausing().
Eric Laurentbfb1b832013-01-07 09:53:42 -08006501 if (last) {
Eric Laurent5cff4032015-05-26 13:49:58 -07006502 if (mHwSupportsPause && !mHwPaused) {
Eric Laurent972a1732013-09-04 09:42:59 -07006503 doHwPause = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006504 mHwPaused = true;
6505 }
6506 // If we were part way through writing the mixbuffer to
6507 // the HAL we must save this until we resume
6508 // BUG - this will be wrong if a different track is made active,
6509 // in that case we want to discard the pending data in the
6510 // mixbuffer and tell the client to present it again when the
6511 // track is resumed
6512 mPausedWriteLength = mCurrentWriteLength;
6513 mPausedBytesRemaining = mBytesRemaining;
6514 mBytesRemaining = 0; // stop writing
6515 }
6516 tracksToRemove->add(track);
Haynes Mathew George7844f672014-01-15 12:32:55 -08006517 } else if (track->isFlushPending()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006518 if (track->isStopping_1()) {
6519 track->mRetryCount = kMaxTrackStopRetriesOffload;
6520 } else {
6521 track->mRetryCount = kMaxTrackRetriesOffload;
6522 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08006523 track->flushAck();
6524 if (last) {
6525 mFlushPending = true;
6526 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006527 } else if (track->isResumePending()){
6528 track->resumeAck();
6529 if (last) {
6530 if (mPausedBytesRemaining) {
6531 // Need to continue write that was interrupted
6532 mCurrentWriteLength = mPausedWriteLength;
6533 mBytesRemaining = mPausedBytesRemaining;
6534 mPausedBytesRemaining = 0;
6535 }
6536 if (mHwPaused) {
6537 doHwResume = true;
6538 mHwPaused = false;
6539 // threadLoop_mix() will handle the case that we need to
6540 // resume an interrupted write
6541 }
6542 // enable write to audio HAL
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006543 mSleepTimeUs = 0;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006544
Eric Laurent3df841a2016-07-15 15:15:40 -07006545 mLeftVolFloat = mRightVolFloat = -1.0;
6546
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006547 // Do not handle new data in this iteration even if track->framesReady()
6548 mixerStatus = MIXER_TRACKS_ENABLED;
6549 }
6550 } else if (track->framesReady() && track->isReady() &&
Eric Laurent3b4529e2013-09-05 18:09:19 -07006551 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
Andy Hungc0691382018-09-12 18:01:57 -07006552 ALOGVV("OffloadThread: track(%d) s=%08x [OK]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006553 if (track->mFillingUpStatus == Track::FS_FILLED) {
6554 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07006555 if (last) {
6556 // make sure processVolume_l() will apply new volume even if 0
6557 mLeftVolFloat = mRightVolFloat = -1.0;
6558 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006559 }
6560
6561 if (last) {
Eric Laurentd7e59222013-11-15 12:02:28 -08006562 sp<Track> previousTrack = mPreviousTrack.promote();
6563 if (previousTrack != 0) {
6564 if (track != previousTrack.get()) {
Eric Laurent9da3d952013-11-12 19:25:43 -08006565 // Flush any data still being written from last track
6566 mBytesRemaining = 0;
6567 if (mPausedBytesRemaining) {
6568 // Last track was paused so we also need to flush saved
6569 // mixbuffer state and invalidate track so that it will
6570 // re-submit that unwritten data when it is next resumed
6571 mPausedBytesRemaining = 0;
6572 // Invalidate is a bit drastic - would be more efficient
6573 // to have a flag to tell client that some of the
6574 // previously written data was lost
Eric Laurentd7e59222013-11-15 12:02:28 -08006575 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006576 }
6577 // flush data already sent to the DSP if changing audio session as audio
6578 // comes from a different source. Also invalidate previous track to force a
6579 // seek when resuming.
Eric Laurentd7e59222013-11-15 12:02:28 -08006580 if (previousTrack->sessionId() != track->sessionId()) {
6581 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006582 }
6583 }
6584 }
6585 mPreviousTrack = track;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006586 // reset retry count
Eric Laurente93cc032016-05-05 10:15:10 -07006587 if (track->isStopping_1()) {
6588 track->mRetryCount = kMaxTrackStopRetriesOffload;
6589 } else {
6590 track->mRetryCount = kMaxTrackRetriesOffload;
6591 }
Eric Laurent5850c4c2016-11-10 13:04:31 -08006592 mActiveTrack = t;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006593 mixerStatus = MIXER_TRACKS_READY;
6594 }
6595 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006596 ALOGVV("OffloadThread: track(%d) s=%08x [NOT READY]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006597 if (track->isStopping_1()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006598 if (--(track->mRetryCount) <= 0) {
6599 // Hardware buffer can hold a large amount of audio so we must
6600 // wait for all current track's data to drain before we say
6601 // that the track is stopped.
6602 if (mBytesRemaining == 0) {
6603 // Only start draining when all data in mixbuffer
6604 // has been written
6605 ALOGV("OffloadThread: underrun and STOPPING_1 -> draining, STOPPING_2");
6606 track->mState = TrackBase::STOPPING_2; // so presentation completes after
6607 // drain do not drain if no data was ever sent to HAL (mStandby == true)
6608 if (last && !mStandby) {
6609 // do not modify drain sequence if we are already draining. This happens
6610 // when resuming from pause after drain.
6611 if ((mDrainSequence & 1) == 0) {
6612 mSleepTimeUs = 0;
6613 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
6614 mixerStatus = MIXER_DRAIN_TRACK;
6615 mDrainSequence += 2;
6616 }
6617 if (mHwPaused) {
6618 // It is possible to move from PAUSED to STOPPING_1 without
6619 // a resume so we must ensure hardware is running
6620 doHwResume = true;
6621 mHwPaused = false;
6622 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006623 }
6624 }
Eric Laurente93cc032016-05-05 10:15:10 -07006625 } else if (last) {
6626 ALOGV("stopping1 underrun retries left %d", track->mRetryCount);
6627 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006628 }
6629 } else if (track->isStopping_2()) {
Eric Laurent6a51d7e2013-10-17 18:59:26 -07006630 // Drain has completed or we are in standby, signal presentation complete
6631 if (!(mDrainSequence & 1) || !last || mStandby) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006632 track->mState = TrackBase::STOPPED;
Andy Hung59de4262021-06-14 10:53:54 -07006633 track->presentationComplete(latency_l());
Eric Laurentbfb1b832013-01-07 09:53:42 -08006634 track->reset();
6635 tracksToRemove->add(track);
Dean Wheatley12473e92021-03-18 23:00:55 +11006636 // OFFLOADED stop resets frame counts.
Andy Hungf3234512018-07-03 14:51:47 -07006637 if (!mUseAsyncWrite) {
6638 // If we don't get explicit drain notification we must
6639 // register discontinuity regardless of whether this is
6640 // the previous (!last) or the upcoming (last) track
6641 // to avoid skipping the discontinuity.
Dean Wheatley12473e92021-03-18 23:00:55 +11006642 mTimestampVerifier.discontinuity(
6643 mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Andy Hungf3234512018-07-03 14:51:47 -07006644 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006645 }
6646 } else {
6647 // No buffers for this track. Give it a few chances to
6648 // fill a buffer, then remove it from active list.
6649 if (--(track->mRetryCount) <= 0) {
Andy Hungf8044752016-07-27 14:58:11 -07006650 bool running = false;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006651 uint64_t position = 0;
6652 struct timespec unused;
6653 // The running check restarts the retry counter at least once.
6654 status_t ret = mOutput->stream->getPresentationPosition(&position, &unused);
6655 if (ret == NO_ERROR && position != mOffloadUnderrunPosition) {
6656 running = true;
6657 mOffloadUnderrunPosition = position;
6658 }
6659 if (ret == NO_ERROR) {
Andy Hungf8044752016-07-27 14:58:11 -07006660 ALOGVV("underrun counter, running(%d): %lld vs %lld", running,
6661 (long long)position, (long long)mOffloadUnderrunPosition);
6662 }
6663 if (running) { // still running, give us more time.
6664 track->mRetryCount = kMaxTrackRetriesOffload;
6665 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006666 ALOGV("OffloadThread: BUFFER TIMEOUT: remove track(%d) from active list",
6667 track->id());
Andy Hungf8044752016-07-27 14:58:11 -07006668 tracksToRemove->add(track);
Glenn Kastend3bb6452016-12-05 18:14:37 -08006669 // tell client process that the track was disabled because of underrun;
Andy Hungf8044752016-07-27 14:58:11 -07006670 // it will then automatically call start() when data is available
6671 track->disable();
6672 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006673 } else if (last){
6674 mixerStatus = MIXER_TRACKS_ENABLED;
6675 }
6676 }
6677 }
6678 // compute volume for this track
Wenfeng Sun79458332019-05-29 20:12:43 +08006679 if (track->isReady()) { // check ready to prevent premature start.
6680 processVolume_l(track, last);
6681 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006682 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006683
Eric Laurentea0fade2013-10-04 16:23:48 -07006684 // make sure the pause/flush/resume sequence is executed in the right order.
6685 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
6686 // before flush and then resume HW. This can happen in case of pause/flush/resume
6687 // if resume is received before pause is executed.
Eric Laurentfd477972013-10-25 18:10:40 -07006688 if (!mStandby && (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006689 status_t result = mOutput->stream->pause();
6690 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006691 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006692 if (mFlushPending) {
6693 flushHw_l();
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006694 }
Eric Laurentfd477972013-10-25 18:10:40 -07006695 if (!mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006696 status_t result = mOutput->stream->resume();
6697 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006698 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006699
Eric Laurentbfb1b832013-01-07 09:53:42 -08006700 // remove all the tracks that need to be...
6701 removeTracks_l(*tracksToRemove);
6702
6703 return mixerStatus;
6704}
6705
Eric Laurentbfb1b832013-01-07 09:53:42 -08006706// must be called with thread mutex locked
6707bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
6708{
Eric Laurent3b4529e2013-09-05 18:09:19 -07006709 ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
6710 mWriteAckSequence, mDrainSequence);
6711 if (mUseAsyncWrite && ((mWriteAckSequence & 1) || (mDrainSequence & 1))) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006712 return true;
6713 }
6714 return false;
6715}
6716
Eric Laurentbfb1b832013-01-07 09:53:42 -08006717bool AudioFlinger::OffloadThread::waitingAsyncCallback()
6718{
6719 Mutex::Autolock _l(mLock);
6720 return waitingAsyncCallback_l();
6721}
6722
6723void AudioFlinger::OffloadThread::flushHw_l()
6724{
Eric Laurente659ef42014-09-29 13:06:46 -07006725 DirectOutputThread::flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08006726 // Flush anything still waiting in the mixbuffer
6727 mCurrentWriteLength = 0;
6728 mBytesRemaining = 0;
6729 mPausedWriteLength = 0;
6730 mPausedBytesRemaining = 0;
Eric Laurent3eaf66b2016-04-01 14:44:17 -07006731 // reset bytes written count to reflect that DSP buffers are empty after flush.
6732 mBytesWritten = 0;
Andy Hungf8044752016-07-27 14:58:11 -07006733 mOffloadUnderrunPosition = ~0LL;
Haynes Mathew George0f02f262014-01-11 13:03:57 -08006734
Eric Laurentbfb1b832013-01-07 09:53:42 -08006735 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006736 // discard any pending drain or write ack by incrementing sequence
6737 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
6738 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006739 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006740 mCallbackThread->setWriteBlocked(mWriteAckSequence);
6741 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006742 }
6743}
6744
Haynes Mathew George05317d22016-05-03 16:34:26 -07006745void AudioFlinger::OffloadThread::invalidateTracks(audio_stream_type_t streamType)
6746{
6747 Mutex::Autolock _l(mLock);
Eric Laurent13084622016-05-17 10:51:49 -07006748 if (PlaybackThread::invalidateTracks_l(streamType)) {
6749 mFlushPending = true;
6750 }
Haynes Mathew George05317d22016-05-03 16:34:26 -07006751}
6752
Eric Laurentbfb1b832013-01-07 09:53:42 -08006753// ----------------------------------------------------------------------------
6754
Eric Laurent81784c32012-11-19 14:55:58 -08006755AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurent72e3f392015-05-20 14:43:50 -07006756 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id, bool systemReady)
jiabinc52b1ff2019-10-31 17:20:42 -07006757 : MixerThread(audioFlinger, mainThread->getOutput(), id,
Eric Laurent72e3f392015-05-20 14:43:50 -07006758 systemReady, DUPLICATING),
Eric Laurent81784c32012-11-19 14:55:58 -08006759 mWaitTimeMs(UINT_MAX)
6760{
6761 addOutputTrack(mainThread);
6762}
6763
6764AudioFlinger::DuplicatingThread::~DuplicatingThread()
6765{
6766 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6767 mOutputTracks[i]->destroy();
6768 }
6769}
6770
6771void AudioFlinger::DuplicatingThread::threadLoop_mix()
6772{
6773 // mix buffers...
6774 if (outputsReady(outputTracks)) {
Glenn Kastend79072e2016-01-06 08:41:20 -08006775 mAudioMixer->process();
Eric Laurent81784c32012-11-19 14:55:58 -08006776 } else {
Eric Laurent02b57082014-11-07 17:28:28 -08006777 if (mMixerBufferValid) {
6778 memset(mMixerBuffer, 0, mMixerBufferSize);
6779 } else {
6780 memset(mSinkBuffer, 0, mSinkBufferSize);
6781 }
Eric Laurent81784c32012-11-19 14:55:58 -08006782 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006783 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006784 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006785 mCurrentWriteLength = mSinkBufferSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006786 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006787}
6788
6789void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
6790{
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006791 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08006792 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006793 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006794 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006795 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006796 }
6797 } else if (mBytesWritten != 0) {
6798 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
6799 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006800 memset(mSinkBuffer, 0, mSinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08006801 } else {
6802 // flush remaining overflow buffers in output tracks
6803 writeFrames = 0;
6804 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006805 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006806 }
6807}
6808
Eric Laurentbfb1b832013-01-07 09:53:42 -08006809ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08006810{
6811 for (size_t i = 0; i < outputTracks.size(); i++) {
Andy Hung1c86ebe2018-05-29 20:29:08 -07006812 const ssize_t actualWritten = outputTracks[i]->write(mSinkBuffer, writeFrames);
6813
6814 // Consider the first OutputTrack for timestamp and frame counting.
6815
6816 // The threadLoop() generally assumes writing a full sink buffer size at a time.
6817 // Here, we correct for writeFrames of 0 (a stop) or underruns because
6818 // we always claim success.
6819 if (i == 0) {
6820 const ssize_t correction = mSinkBufferSize / mFrameSize - actualWritten;
6821 ALOGD_IF(correction != 0 && writeFrames != 0,
6822 "%s: writeFrames:%u actualWritten:%zd correction:%zd mFramesWritten:%lld",
6823 __func__, writeFrames, actualWritten, correction, (long long)mFramesWritten);
6824 mFramesWritten -= correction;
6825 }
6826
6827 // TODO: Report correction for the other output tracks and show in the dump.
Eric Laurent81784c32012-11-19 14:55:58 -08006828 }
Andy Hungcf10d742020-04-28 15:38:24 -07006829 if (mStandby) {
6830 mThreadMetrics.logBeginInterval();
6831 mStandby = false;
6832 }
Andy Hung25c2dac2014-02-27 14:56:00 -08006833 return (ssize_t)mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08006834}
6835
6836void AudioFlinger::DuplicatingThread::threadLoop_standby()
6837{
6838 // DuplicatingThread implements standby by stopping all tracks
6839 for (size_t i = 0; i < outputTracks.size(); i++) {
6840 outputTracks[i]->stop();
6841 }
6842}
6843
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006844void AudioFlinger::DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Andy Hung1bc088a2018-02-09 15:57:31 -08006845{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006846 MixerThread::dumpInternals_l(fd, args);
Andy Hung1bc088a2018-02-09 15:57:31 -08006847
6848 std::stringstream ss;
6849 const size_t numTracks = mOutputTracks.size();
6850 ss << " " << numTracks << " OutputTracks";
6851 if (numTracks > 0) {
6852 ss << ":";
6853 for (const auto &track : mOutputTracks) {
6854 const sp<ThreadBase> thread = track->thread().promote();
Andy Hungc0691382018-09-12 18:01:57 -07006855 ss << " (" << track->id() << " : ";
Andy Hung1bc088a2018-02-09 15:57:31 -08006856 if (thread.get() != nullptr) {
6857 ss << thread.get() << ", " << thread->id();
6858 } else {
6859 ss << "null";
6860 }
6861 ss << ")";
6862 }
6863 }
6864 ss << "\n";
6865 std::string result = ss.str();
6866 write(fd, result.c_str(), result.size());
6867}
6868
Eric Laurent81784c32012-11-19 14:55:58 -08006869void AudioFlinger::DuplicatingThread::saveOutputTracks()
6870{
6871 outputTracks = mOutputTracks;
6872}
6873
6874void AudioFlinger::DuplicatingThread::clearOutputTracks()
6875{
6876 outputTracks.clear();
6877}
6878
6879void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
6880{
6881 Mutex::Autolock _l(mLock);
Andy Hungc25b84a2015-01-14 19:04:10 -08006882 // The downstream MixerThread consumes thread->frameCount() amount of frames per mix pass.
6883 // Adjust for thread->sampleRate() to determine minimum buffer frame count.
6884 // Then triple buffer because Threads do not run synchronously and may not be clock locked.
6885 const size_t frameCount =
6886 3 * sourceFramesNeeded(mSampleRate, thread->frameCount(), thread->sampleRate());
6887 // TODO: Consider asynchronous sample rate conversion to handle clock disparity
6888 // from different OutputTracks and their associated MixerThreads (e.g. one may
6889 // nearly empty and the other may be dropping data).
6890
Svet Ganov33761132021-05-13 22:51:08 +00006891 // TODO b/182392769: use attribution source util, move to server edge
6892 AttributionSourceState attributionSource = AttributionSourceState();
6893 attributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
Philip P. Moltmannbda45752020-07-17 16:41:18 -07006894 IPCThreadState::self()->getCallingUid()));
Svet Ganov33761132021-05-13 22:51:08 +00006895 attributionSource.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(
Philip P. Moltmannbda45752020-07-17 16:41:18 -07006896 IPCThreadState::self()->getCallingPid()));
Svet Ganov33761132021-05-13 22:51:08 +00006897 attributionSource.token = sp<BBinder>::make();
Andy Hungc25b84a2015-01-14 19:04:10 -08006898 sp<OutputTrack> outputTrack = new OutputTrack(thread,
Eric Laurent81784c32012-11-19 14:55:58 -08006899 this,
6900 mSampleRate,
Andy Hungc25b84a2015-01-14 19:04:10 -08006901 mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08006902 mChannelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08006903 frameCount,
Svet Ganov33761132021-05-13 22:51:08 +00006904 attributionSource);
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006905 status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
6906 if (status != NO_ERROR) {
6907 ALOGE("addOutputTrack() initCheck failed %d", status);
6908 return;
Eric Laurent81784c32012-11-19 14:55:58 -08006909 }
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006910 thread->setStreamVolume(AUDIO_STREAM_PATCH, 1.0f);
6911 mOutputTracks.add(outputTrack);
6912 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
6913 updateWaitTime_l();
Eric Laurent81784c32012-11-19 14:55:58 -08006914}
6915
6916void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
6917{
6918 Mutex::Autolock _l(mLock);
6919 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6920 if (mOutputTracks[i]->thread() == thread) {
6921 mOutputTracks[i]->destroy();
6922 mOutputTracks.removeAt(i);
6923 updateWaitTime_l();
Eric Laurentf6870ae2015-05-08 10:50:03 -07006924 if (thread->getOutput() == mOutput) {
6925 mOutput = NULL;
6926 }
Eric Laurent81784c32012-11-19 14:55:58 -08006927 return;
6928 }
6929 }
Eric Laurentf6870ae2015-05-08 10:50:03 -07006930 ALOGV("removeOutputTrack(): unknown thread: %p", thread);
Eric Laurent81784c32012-11-19 14:55:58 -08006931}
6932
6933// caller must hold mLock
6934void AudioFlinger::DuplicatingThread::updateWaitTime_l()
6935{
6936 mWaitTimeMs = UINT_MAX;
6937 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6938 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
6939 if (strong != 0) {
6940 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
6941 if (waitTimeMs < mWaitTimeMs) {
6942 mWaitTimeMs = waitTimeMs;
6943 }
6944 }
6945 }
6946}
6947
6948
6949bool AudioFlinger::DuplicatingThread::outputsReady(
6950 const SortedVector< sp<OutputTrack> > &outputTracks)
6951{
6952 for (size_t i = 0; i < outputTracks.size(); i++) {
6953 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
6954 if (thread == 0) {
6955 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
6956 outputTracks[i].get());
6957 return false;
6958 }
6959 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
6960 // see note at standby() declaration
6961 if (playbackThread->standby() && !playbackThread->isSuspended()) {
6962 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
6963 thread.get());
6964 return false;
6965 }
6966 }
6967 return true;
6968}
6969
Kevin Rocard12381092018-04-11 09:19:59 -07006970void AudioFlinger::DuplicatingThread::sendMetadataToBackend_l(
6971 const StreamOutHalInterface::SourceMetadata& metadata)
Kevin Rocard069c2712018-03-29 19:09:14 -07006972{
Kevin Rocard12381092018-04-11 09:19:59 -07006973 for (auto& outputTrack : outputTracks) { // not mOutputTracks
6974 outputTrack->setMetadatas(metadata.tracks);
6975 }
Kevin Rocard069c2712018-03-29 19:09:14 -07006976}
6977
Eric Laurent81784c32012-11-19 14:55:58 -08006978uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
6979{
6980 return (mWaitTimeMs * 1000) / 2;
6981}
6982
6983void AudioFlinger::DuplicatingThread::cacheParameters_l()
6984{
6985 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
6986 updateWaitTime_l();
6987
6988 MixerThread::cacheParameters_l();
6989}
6990
Eric Laurent6acd1d42017-01-04 14:23:29 -08006991
Eric Laurent81784c32012-11-19 14:55:58 -08006992// ----------------------------------------------------------------------------
6993// Record
6994// ----------------------------------------------------------------------------
6995
6996AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
6997 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08006998 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07006999 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08007000 ) :
Andy Hungcf10d742020-04-28 15:38:24 -07007001 ThreadBase(audioFlinger, id, RECORD, systemReady, false /* isOut */),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007002 mInput(input),
Mikhail Naganov2534b382019-09-25 13:05:02 -07007003 mSource(mInput),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007004 mActiveTracks(&this->mLocalLog),
7005 mRsmpInBuffer(NULL),
Glenn Kasten1b291842016-07-18 14:55:21 -07007006 // mRsmpInFrames, mRsmpInFramesP2, and mRsmpInFramesOA are set by readInputParameters_l()
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007007 mRsmpInRear(0)
Glenn Kastenb880f5e2014-05-07 08:43:45 -07007008 , mReadOnlyHeap(new MemoryDealer(kRecordThreadReadOnlyHeapSize,
7009 "RecordThreadRO", MemoryHeapBase::READ_ONLY))
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007010 // mFastCapture below
7011 , mFastCaptureFutex(0)
7012 // mInputSource
7013 // mPipeSink
7014 // mPipeSource
7015 , mPipeFramesP2(0)
7016 // mPipeMemory
7017 // mFastCaptureNBLogWriter
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007018 , mFastTrackAvail(false)
Eric Laurentd8365c52017-07-16 15:27:05 -07007019 , mBtNrecSuspended(false)
Eric Laurent81784c32012-11-19 14:55:58 -08007020{
Glenn Kastend7dca052015-03-05 16:05:54 -08007021 snprintf(mThreadName, kThreadNameLength, "AudioIn_%X", id);
7022 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08007023
George Burgess IVa8f90c12020-05-14 11:27:19 -07007024 if (mInput->audioHwDev != nullptr) {
Andy Hungc8fddf32018-08-08 18:32:37 -07007025 mIsMsdDevice = strcmp(
7026 mInput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
7027 }
7028
Glenn Kastendeca2ae2014-02-07 10:25:56 -08007029 readInputParameters_l();
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007030
Andy Hungc8fddf32018-08-08 18:32:37 -07007031 // TODO: We may also match on address as well as device type for
7032 // AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_IN_REMOTE_SUBMIX
jiabinc52b1ff2019-10-31 17:20:42 -07007033 // TODO: This property should be ensure that only contains one single device type.
7034 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
7035 "audio.timestamp.corrected_input_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07007036 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_IN_BUS // turn on by default for MSD
7037 : AUDIO_DEVICE_NONE));
7038
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007039 // create an NBAIO source for the HAL input stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07007040 mInputSource = new AudioStreamInSource(input->stream);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007041 size_t numCounterOffers = 0;
7042 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07007043#if !LOG_NDEBUG
7044 ssize_t index =
7045#else
7046 (void)
7047#endif
7048 mInputSource->negotiate(offers, 1, NULL, numCounterOffers);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007049 ALOG_ASSERT(index == 0);
7050
7051 // initialize fast capture depending on configuration
7052 bool initFastCapture;
7053 switch (kUseFastCapture) {
7054 case FastCapture_Never:
7055 initFastCapture = false;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007056 ALOGV("%p kUseFastCapture = Never, initFastCapture = false", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007057 break;
7058 case FastCapture_Always:
7059 initFastCapture = true;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007060 ALOGV("%p kUseFastCapture = Always, initFastCapture = true", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007061 break;
7062 case FastCapture_Static:
Glenn Kasteneb9487e2015-07-22 09:15:17 -07007063 initFastCapture = (mFrameCount * 1000) / mSampleRate < kMinNormalCaptureBufferSizeMs;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007064 ALOGV("%p kUseFastCapture = Static, (%lld * 1000) / %u vs %u, initFastCapture = %d",
7065 this, (long long)mFrameCount, mSampleRate, kMinNormalCaptureBufferSizeMs,
7066 initFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007067 break;
7068 // case FastCapture_Dynamic:
7069 }
7070
7071 if (initFastCapture) {
Glenn Kastend198b852015-03-16 14:55:53 -07007072 // create a Pipe for FastCapture to write to, and for us and fast tracks to read from
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007073 NBAIO_Format format = mInputSource->format();
Glenn Kasten1b291842016-07-18 14:55:21 -07007074 // quadruple-buffering of 20 ms each; this ensures we can sleep for 20ms in RecordThread
7075 size_t pipeFramesP2 = roundup(4 * FMS_20 * mSampleRate / 1000);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007076 size_t pipeSize = pipeFramesP2 * Format_frameSize(format);
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007077 void *pipeBuffer = nullptr;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007078 const sp<MemoryDealer> roHeap(readOnlyHeap());
7079 sp<IMemory> pipeMemory;
7080 if ((roHeap == 0) ||
7081 (pipeMemory = roHeap->allocate(pipeSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07007082 (pipeBuffer = pipeMemory->unsecurePointer()) == nullptr) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007083 ALOGE("not enough memory for pipe buffer size=%zu; "
7084 "roHeap=%p, pipeMemory=%p, pipeBuffer=%p; roHeapSize: %lld",
7085 pipeSize, roHeap.get(), pipeMemory.get(), pipeBuffer,
7086 (long long)kRecordThreadReadOnlyHeapSize);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007087 goto failed;
7088 }
7089 // pipe will be shared directly with fast clients, so clear to avoid leaking old information
7090 memset(pipeBuffer, 0, pipeSize);
7091 Pipe *pipe = new Pipe(pipeFramesP2, format, pipeBuffer);
7092 const NBAIO_Format offers[1] = {format};
7093 size_t numCounterOffers = 0;
7094 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
7095 ALOG_ASSERT(index == 0);
7096 mPipeSink = pipe;
7097 PipeReader *pipeReader = new PipeReader(*pipe);
7098 numCounterOffers = 0;
7099 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
7100 ALOG_ASSERT(index == 0);
7101 mPipeSource = pipeReader;
7102 mPipeFramesP2 = pipeFramesP2;
7103 mPipeMemory = pipeMemory;
7104
7105 // create fast capture
7106 mFastCapture = new FastCapture();
7107 FastCaptureStateQueue *sq = mFastCapture->sq();
7108#ifdef STATE_QUEUE_DUMP
7109 // FIXME
7110#endif
7111 FastCaptureState *state = sq->begin();
7112 state->mCblk = NULL;
7113 state->mInputSource = mInputSource.get();
7114 state->mInputSourceGen++;
7115 state->mPipeSink = pipe;
7116 state->mPipeSinkGen++;
7117 state->mFrameCount = mFrameCount;
7118 state->mCommand = FastCaptureState::COLD_IDLE;
7119 // already done in constructor initialization list
7120 //mFastCaptureFutex = 0;
7121 state->mColdFutexAddr = &mFastCaptureFutex;
7122 state->mColdGen++;
7123 state->mDumpState = &mFastCaptureDumpState;
7124#ifdef TEE_SINK
7125 // FIXME
7126#endif
7127 mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
7128 state->mNBLogWriter = mFastCaptureNBLogWriter.get();
7129 sq->end();
7130 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
7131
7132 // start the fast capture
7133 mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
7134 pid_t tid = mFastCapture->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07007135 sendPrioConfigEvent(getpid(), tid, kPriorityFastCapture, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08007136 stream()->setHalThreadPriority(kPriorityFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007137#ifdef AUDIO_WATCHDOG
7138 // FIXME
7139#endif
7140
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007141 mFastTrackAvail = true;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007142 }
Andy Hung8946a282018-04-19 20:04:56 -07007143#ifdef TEE_SINK
7144 mTee.set(mInputSource->format(), NBAIO_Tee::TEE_FLAG_INPUT_THREAD);
7145 mTee.setId(std::string("_") + std::to_string(mId) + "_C");
7146#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007147failed: ;
7148
7149 // FIXME mNormalSource
Eric Laurent81784c32012-11-19 14:55:58 -08007150}
7151
Eric Laurent81784c32012-11-19 14:55:58 -08007152AudioFlinger::RecordThread::~RecordThread()
7153{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007154 if (mFastCapture != 0) {
7155 FastCaptureStateQueue *sq = mFastCapture->sq();
7156 FastCaptureState *state = sq->begin();
7157 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7158 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7159 if (old == -1) {
7160 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7161 }
7162 }
7163 state->mCommand = FastCaptureState::EXIT;
7164 sq->end();
7165 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
7166 mFastCapture->join();
7167 mFastCapture.clear();
7168 }
7169 mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
Glenn Kasten481fb672013-09-30 14:39:28 -07007170 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung57446612015-04-19 23:56:46 -07007171 free(mRsmpInBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08007172}
7173
7174void AudioFlinger::RecordThread::onFirstRef()
7175{
Glenn Kastend7dca052015-03-05 16:05:54 -08007176 run(mThreadName, PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08007177}
7178
Eric Laurent555530a2017-02-07 18:17:24 -08007179void AudioFlinger::RecordThread::preExit()
7180{
7181 ALOGV(" preExit()");
7182 Mutex::Autolock _l(mLock);
7183 for (size_t i = 0; i < mTracks.size(); i++) {
7184 sp<RecordTrack> track = mTracks[i];
7185 track->invalidate();
7186 }
7187 mActiveTracks.clear();
7188 mStartStopCond.broadcast();
7189}
7190
Eric Laurent81784c32012-11-19 14:55:58 -08007191bool AudioFlinger::RecordThread::threadLoop()
7192{
Eric Laurent81784c32012-11-19 14:55:58 -08007193 nsecs_t lastWarning = 0;
7194
7195 inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08007196
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007197reacquire_wakelock:
7198 sp<RecordTrack> activeTrack;
7199 {
7200 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -07007201 acquireWakeLock_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007202 }
7203
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007204 // used to request a deferred sleep, to be executed later while mutex is unlocked
7205 uint32_t sleepUs = 0;
7206
Andy Hung446f4df2019-02-21 12:26:41 -08007207 int64_t lastLoopCountRead = -2; // never matches "previous" loop, when loopCount = 0.
7208
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007209 // loop while there is work to do
Andy Hung446f4df2019-02-21 12:26:41 -08007210 for (int64_t loopCount = 0;; ++loopCount) { // loopCount used for statistics tracking
Glenn Kastenc527a7c2013-08-13 15:43:49 -07007211 Vector< sp<EffectChain> > effectChains;
Glenn Kasten2cfbf882013-08-14 13:12:11 -07007212
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007213 // activeTracks accumulates a copy of a subset of mActiveTracks
7214 Vector< sp<RecordTrack> > activeTracks;
7215
Glenn Kasten735f45f2014-08-18 15:51:59 -07007216 // reference to the (first and only) active fast track
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007217 sp<RecordTrack> fastTrack;
Eric Laurent10351942014-05-08 18:49:52 -07007218
Glenn Kasten735f45f2014-08-18 15:51:59 -07007219 // reference to a fast track which is about to be removed
7220 sp<RecordTrack> fastTrackToRemove;
7221
Eric Laurent33403f02020-05-29 18:35:06 -07007222 bool silenceFastCapture = false;
7223
Eric Laurent81784c32012-11-19 14:55:58 -08007224 { // scope for mLock
7225 Mutex::Autolock _l(mLock);
Eric Laurent000a4192014-01-29 15:17:32 -08007226
Eric Laurent021cf962014-05-13 10:18:14 -07007227 processConfigEvents_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007228
Eric Laurent000a4192014-01-29 15:17:32 -08007229 // check exitPending here because checkForNewParameters_l() and
7230 // checkForNewParameters_l() can temporarily release mLock
7231 if (exitPending()) {
7232 break;
7233 }
7234
Eric Laurent5c25d562016-07-13 17:17:45 -07007235 // sleep with mutex unlocked
7236 if (sleepUs > 0) {
Glenn Kastenf9715e42016-07-13 14:02:03 -07007237 ATRACE_BEGIN("sleepC");
Eric Laurent5c25d562016-07-13 17:17:45 -07007238 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)sleepUs));
7239 ATRACE_END();
7240 sleepUs = 0;
7241 continue;
7242 }
7243
Glenn Kasten2b806402013-11-20 16:37:38 -08007244 // if no active track(s), then standby and release wakelock
7245 size_t size = mActiveTracks.size();
7246 if (size == 0) {
Glenn Kasten93e471f2013-08-19 08:40:07 -07007247 standbyIfNotAlreadyInStandby();
Glenn Kasten4ef0b462013-08-14 13:52:27 -07007248 // exitPending() can't become true here
Eric Laurent81784c32012-11-19 14:55:58 -08007249 releaseWakeLock_l();
7250 ALOGV("RecordThread: loop stopping");
7251 // go to sleep
7252 mWaitWorkCV.wait(mLock);
7253 ALOGV("RecordThread: loop starting");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007254 goto reacquire_wakelock;
7255 }
7256
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007257 bool doBroadcast = false;
Eric Laurent5c25d562016-07-13 17:17:45 -07007258 bool allStopped = true;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007259 for (size_t i = 0; i < size; ) {
Glenn Kasten9e982352013-08-14 14:39:50 -07007260
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007261 activeTrack = mActiveTracks[i];
7262 if (activeTrack->isTerminated()) {
Glenn Kasten735f45f2014-08-18 15:51:59 -07007263 if (activeTrack->isFastTrack()) {
7264 ALOG_ASSERT(fastTrackToRemove == 0);
7265 fastTrackToRemove = activeTrack;
7266 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007267 removeTrack_l(activeTrack);
Glenn Kasten2b806402013-11-20 16:37:38 -08007268 mActiveTracks.remove(activeTrack);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007269 size--;
Glenn Kasten9e982352013-08-14 14:39:50 -07007270 continue;
7271 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007272
7273 TrackBase::track_state activeTrackState = activeTrack->mState;
7274 switch (activeTrackState) {
7275
7276 case TrackBase::PAUSING:
7277 mActiveTracks.remove(activeTrack);
Andy Hungce685402018-10-05 17:23:27 -07007278 activeTrack->mState = TrackBase::PAUSED;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007279 doBroadcast = true;
7280 size--;
7281 continue;
7282
7283 case TrackBase::STARTING_1:
7284 sleepUs = 10000;
7285 i++;
Eric Laurent5c25d562016-07-13 17:17:45 -07007286 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007287 continue;
7288
7289 case TrackBase::STARTING_2:
7290 doBroadcast = true;
Andy Hungcf10d742020-04-28 15:38:24 -07007291 if (mStandby) {
7292 mThreadMetrics.logBeginInterval();
7293 mStandby = false;
7294 }
Glenn Kasten9e982352013-08-14 14:39:50 -07007295 activeTrack->mState = TrackBase::ACTIVE;
Eric Laurent5c25d562016-07-13 17:17:45 -07007296 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007297 break;
7298
7299 case TrackBase::ACTIVE:
Eric Laurent5c25d562016-07-13 17:17:45 -07007300 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007301 break;
7302
Andy Hungce685402018-10-05 17:23:27 -07007303 case TrackBase::IDLE: // cannot be on ActiveTracks if idle
7304 case TrackBase::PAUSED: // cannot be on ActiveTracks if paused
7305 case TrackBase::STOPPED: // cannot be on ActiveTracks if destroyed/terminated
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007306 default:
Andy Hungce685402018-10-05 17:23:27 -07007307 LOG_ALWAYS_FATAL("%s: Unexpected active track state:%d, id:%d, tracks:%zu",
7308 __func__, activeTrackState, activeTrack->id(), size);
Glenn Kasten9e982352013-08-14 14:39:50 -07007309 }
Glenn Kasten9e982352013-08-14 14:39:50 -07007310
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007311 if (activeTrack->isFastTrack()) {
7312 ALOG_ASSERT(!mFastTrackAvail);
7313 ALOG_ASSERT(fastTrack == 0);
Eric Laurent33403f02020-05-29 18:35:06 -07007314 // if the active fast track is silenced either:
7315 // 1) silence the whole capture from fast capture buffer if this is
7316 // the only active track
7317 // 2) invalidate this track: this will cause the client to reconnect and possibly
7318 // be invalidated again until unsilenced
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02007319 bool invalidate = false;
Eric Laurent33403f02020-05-29 18:35:06 -07007320 if (activeTrack->isSilenced()) {
7321 if (size > 1) {
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02007322 invalidate = true;
Eric Laurent33403f02020-05-29 18:35:06 -07007323 } else {
7324 silenceFastCapture = true;
7325 }
7326 }
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02007327 // Invalidate fast tracks if access to audio history is required as this is not
7328 // possible with fast tracks. Once the fast track has been invalidated, no new
7329 // fast track will be created until mMaxSharedAudioHistoryMs is cleared.
7330 if (mMaxSharedAudioHistoryMs != 0) {
7331 invalidate = true;
7332 }
7333 if (invalidate) {
7334 activeTrack->invalidate();
7335 ALOG_ASSERT(fastTrackToRemove == 0);
7336 fastTrackToRemove = activeTrack;
7337 removeTrack_l(activeTrack);
7338 mActiveTracks.remove(activeTrack);
7339 size--;
7340 continue;
7341 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007342 fastTrack = activeTrack;
7343 }
Eric Laurent33403f02020-05-29 18:35:06 -07007344
7345 activeTracks.add(activeTrack);
7346 i++;
7347
Glenn Kasten9e982352013-08-14 14:39:50 -07007348 }
Eric Laurent5c25d562016-07-13 17:17:45 -07007349
Andy Hungdae27702016-10-31 14:01:16 -07007350 mActiveTracks.updatePowerState(this);
7351
Kevin Rocard069c2712018-03-29 19:09:14 -07007352 updateMetadata_l();
7353
Eric Laurent5c25d562016-07-13 17:17:45 -07007354 if (allStopped) {
7355 standbyIfNotAlreadyInStandby();
7356 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007357 if (doBroadcast) {
7358 mStartStopCond.broadcast();
7359 }
7360
7361 // sleep if there are no active tracks to process
Eric Tan39ec8d62018-07-24 09:49:29 -07007362 if (activeTracks.isEmpty()) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007363 if (sleepUs == 0) {
7364 sleepUs = kRecordThreadSleepUs;
7365 }
7366 continue;
7367 }
7368 sleepUs = 0;
Glenn Kasten9e982352013-08-14 14:39:50 -07007369
Eric Laurent81784c32012-11-19 14:55:58 -08007370 lockEffectChains_l(effectChains);
7371 }
7372
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007373 // thread mutex is now unlocked, mActiveTracks unknown, activeTracks.size() > 0
Glenn Kasten71652682013-08-14 15:17:55 -07007374
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007375 size_t size = effectChains.size();
7376 for (size_t i = 0; i < size; i++) {
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007377 // thread mutex is not locked, but effect chain is locked
7378 effectChains[i]->process_l();
7379 }
7380
Glenn Kasten735f45f2014-08-18 15:51:59 -07007381 // Push a new fast capture state if fast capture is not already running, or cblk change
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007382 if (mFastCapture != 0) {
7383 FastCaptureStateQueue *sq = mFastCapture->sq();
7384 FastCaptureState *state = sq->begin();
Glenn Kasten735f45f2014-08-18 15:51:59 -07007385 bool didModify = false;
7386 FastCaptureStateQueue::block_t block = FastCaptureStateQueue::BLOCK_UNTIL_PUSHED;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007387 if (state->mCommand != FastCaptureState::READ_WRITE /* FIXME &&
7388 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)*/) {
7389 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7390 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7391 if (old == -1) {
7392 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7393 }
7394 }
7395 state->mCommand = FastCaptureState::READ_WRITE;
7396#if 0 // FIXME
7397 mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08007398 FastThreadDumpState::kSamplingNforLowRamDevice :
7399 FastThreadDumpState::kSamplingN);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007400#endif
Glenn Kasten735f45f2014-08-18 15:51:59 -07007401 didModify = true;
7402 }
7403 audio_track_cblk_t *cblkOld = state->mCblk;
7404 audio_track_cblk_t *cblkNew = fastTrack != 0 ? fastTrack->cblk() : NULL;
7405 if (cblkNew != cblkOld) {
7406 state->mCblk = cblkNew;
7407 // block until acked if removing a fast track
7408 if (cblkOld != NULL) {
7409 block = FastCaptureStateQueue::BLOCK_UNTIL_ACKED;
7410 }
7411 didModify = true;
7412 }
jiabin01c8f562018-07-19 17:47:28 -07007413 AudioBufferProvider* abp = (fastTrack != 0 && fastTrack->isPatchTrack()) ?
7414 reinterpret_cast<AudioBufferProvider*>(fastTrack.get()) : nullptr;
7415 if (state->mFastPatchRecordBufferProvider != abp) {
7416 state->mFastPatchRecordBufferProvider = abp;
7417 state->mFastPatchRecordFormat = fastTrack == 0 ?
7418 AUDIO_FORMAT_INVALID : fastTrack->format();
7419 didModify = true;
7420 }
Eric Laurent33403f02020-05-29 18:35:06 -07007421 if (state->mSilenceCapture != silenceFastCapture) {
7422 state->mSilenceCapture = silenceFastCapture;
7423 didModify = true;
7424 }
Glenn Kasten735f45f2014-08-18 15:51:59 -07007425 sq->end(didModify);
7426 if (didModify) {
7427 sq->push(block);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007428#if 0
7429 if (kUseFastCapture == FastCapture_Dynamic) {
7430 mNormalSource = mPipeSource;
7431 }
7432#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007433 }
7434 }
7435
Glenn Kasten735f45f2014-08-18 15:51:59 -07007436 // now run the fast track destructor with thread mutex unlocked
7437 fastTrackToRemove.clear();
7438
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007439 // Read from HAL to keep up with fastest client if multiple active tracks, not slowest one.
7440 // Only the client(s) that are too slow will overrun. But if even the fastest client is too
7441 // slow, then this RecordThread will overrun by not calling HAL read often enough.
7442 // If destination is non-contiguous, first read past the nominal end of buffer, then
7443 // copy to the right place. Permitted because mRsmpInBuffer was over-allocated.
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007444
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007445 int32_t rear = mRsmpInRear & (mRsmpInFramesP2 - 1);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007446 ssize_t framesRead;
Andy Hung446f4df2019-02-21 12:26:41 -08007447 const int64_t lastIoBeginNs = systemTime(); // start IO timing
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007448
7449 // If an NBAIO source is present, use it to read the normal capture's data
7450 if (mPipeSource != 0) {
Andy Hung156317a2018-08-02 11:49:29 -07007451 size_t framesToRead = min(mRsmpInFramesOA - rear, mRsmpInFramesP2 / 2);
Andy Hungd5b638f2018-04-30 13:56:10 -07007452
7453 // The audio fifo read() returns OVERRUN on overflow, and advances the read pointer
7454 // to the full buffer point (clearing the overflow condition). Upon OVERRUN error,
7455 // we immediately retry the read() to get data and prevent another overflow.
7456 for (int retries = 0; retries <= 2; ++retries) {
7457 ALOGW_IF(retries > 0, "overrun on read from pipe, retry #%d", retries);
7458 framesRead = mPipeSource->read((uint8_t*)mRsmpInBuffer + rear * mFrameSize,
7459 framesToRead);
7460 if (framesRead != OVERRUN) break;
7461 }
7462
Andy Hung7a3dc6b2018-05-01 16:39:51 -07007463 const ssize_t availableToRead = mPipeSource->availableToRead();
7464 if (availableToRead >= 0) {
Glenn Kastena2f59b32020-08-03 16:37:24 -07007465 // PipeSource is the primary clock. It is up to the AudioRecord client to keep up.
Andy Hung7a3dc6b2018-05-01 16:39:51 -07007466 LOG_ALWAYS_FATAL_IF((size_t)availableToRead > mPipeFramesP2,
7467 "more frames to read than fifo size, %zd > %zu",
7468 availableToRead, mPipeFramesP2);
7469 const size_t pipeFramesFree = mPipeFramesP2 - availableToRead;
7470 const size_t sleepFrames = min(pipeFramesFree, mRsmpInFramesP2) / 2;
7471 ALOGVV("mPipeFramesP2:%zu mRsmpInFramesP2:%zu sleepFrames:%zu availableToRead:%zd",
7472 mPipeFramesP2, mRsmpInFramesP2, sleepFrames, availableToRead);
Glenn Kasten1b291842016-07-18 14:55:21 -07007473 sleepUs = (sleepFrames * 1000000LL) / mSampleRate;
7474 }
7475 if (framesRead < 0) {
7476 status_t status = (status_t) framesRead;
7477 switch (status) {
7478 case OVERRUN:
7479 ALOGW("overrun on read from pipe");
7480 framesRead = 0;
7481 break;
7482 case NEGOTIATE:
7483 ALOGE("re-negotiation is needed");
7484 framesRead = -1; // Will cause an attempt to recover.
7485 break;
7486 default:
7487 ALOGE("unknown error %d on read from pipe", status);
7488 break;
7489 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007490 }
7491 // otherwise use the HAL / AudioStreamIn directly
7492 } else {
Glenn Kastenec6a7032016-03-14 07:40:23 -07007493 ATRACE_BEGIN("read");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007494 size_t bytesRead;
Mikhail Naganov2534b382019-09-25 13:05:02 -07007495 status_t result = mSource->read(
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007496 (uint8_t*)mRsmpInBuffer + rear * mFrameSize, mBufferSize, &bytesRead);
Glenn Kastenec6a7032016-03-14 07:40:23 -07007497 ATRACE_END();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007498 if (result < 0) {
7499 framesRead = result;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007500 } else {
7501 framesRead = bytesRead / mFrameSize;
7502 }
7503 }
7504
Andy Hung446f4df2019-02-21 12:26:41 -08007505 const int64_t lastIoEndNs = systemTime(); // end IO timing
7506
Andy Hung3f0c9022016-01-15 17:49:46 -08007507 // Update server timestamp with server stats
7508 // systemTime() is optional if the hardware supports timestamps.
Andy Hung743f6402020-06-03 13:17:04 -07007509 if (framesRead >= 0) {
7510 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += framesRead;
7511 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = lastIoEndNs;
7512 }
Andy Hung3f0c9022016-01-15 17:49:46 -08007513
7514 // Update server timestamp with kernel stats
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007515 if (mPipeSource.get() == nullptr /* don't obtain for FastCapture, could block */) {
Andy Hung3f0c9022016-01-15 17:49:46 -08007516 int64_t position, time;
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007517 if (mStandby) {
Dean Wheatley12473e92021-03-18 23:00:55 +11007518 mTimestampVerifier.discontinuity(audio_is_linear_pcm(mFormat) ?
7519 mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS :
7520 mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
Mikhail Naganov2534b382019-09-25 13:05:02 -07007521 } else if (mSource->getCapturePosition(&position, &time) == NO_ERROR
Andy Hungc8fddf32018-08-08 18:32:37 -07007522 && time > mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]) {
7523
7524 mTimestampVerifier.add(position, time, mSampleRate);
7525
7526 // Correct timestamps
7527 if (isTimestampCorrectionEnabled()) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10007528 ALOGVV("TS_BEFORE: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07007529 id(), (long long)time, (long long)position);
7530 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
7531 position = correctedTimestamp.mFrames;
7532 time = correctedTimestamp.mTimeNs;
Dean Wheatley56a583e2020-05-08 15:12:17 +10007533 ALOGVV("TS_AFTER: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07007534 id(), (long long)time, (long long)position);
7535 }
7536
Andy Hung3f0c9022016-01-15 17:49:46 -08007537 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = position;
7538 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = time;
7539 // Note: In general record buffers should tend to be empty in
7540 // a properly running pipeline.
7541 //
7542 // Also, it is not advantageous to call get_presentation_position during the read
7543 // as the read obtains a lock, preventing the timestamp call from executing.
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007544 } else {
7545 mTimestampVerifier.error();
Andy Hung3f0c9022016-01-15 17:49:46 -08007546 }
7547 }
Andy Hunge6c37112019-02-26 17:38:10 -08007548
7549 // From the timestamp, input read latency is negative output write latency.
7550 const audio_input_flags_t flags = mInput != NULL ? mInput->flags : AUDIO_INPUT_FLAG_NONE;
7551 const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
7552 ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
7553 if (latencyMs != 0.) { // note 0. means timestamp is empty.
7554 mLatencyMs.add(latencyMs);
7555 }
7556
Andy Hung3f0c9022016-01-15 17:49:46 -08007557 // Use this to track timestamp information
7558 // ALOGD("%s", mTimestamp.toString().c_str());
7559
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007560 if (framesRead < 0 || (framesRead == 0 && mPipeSource == 0)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007561 ALOGE("read failed: framesRead=%zd", framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007562 // Force input into standby so that it tries to recover at next read attempt
7563 inputStandBy();
7564 sleepUs = kRecordThreadSleepUs;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007565 }
7566 if (framesRead <= 0) {
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007567 goto unlock;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007568 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007569 ALOG_ASSERT(framesRead > 0);
Andy Hung6427e442018-08-09 12:51:02 -07007570 mFramesRead += framesRead;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007571
Andy Hung8946a282018-04-19 20:04:56 -07007572#ifdef TEE_SINK
7573 (void)mTee.write((uint8_t*)mRsmpInBuffer + rear * mFrameSize, framesRead);
7574#endif
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007575 // If destination is non-contiguous, we now correct for reading past end of buffer.
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007576 {
7577 size_t part1 = mRsmpInFramesP2 - rear;
7578 if ((size_t) framesRead > part1) {
Andy Hung57446612015-04-19 23:56:46 -07007579 memcpy(mRsmpInBuffer, (uint8_t*)mRsmpInBuffer + mRsmpInFramesP2 * mFrameSize,
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007580 (framesRead - part1) * mFrameSize);
7581 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007582 }
Dean Wheatleyfd56e812020-11-06 22:32:21 +11007583 mRsmpInRear = audio_utils::safe_add_overflow(mRsmpInRear, (int32_t)framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007584
7585 size = activeTracks.size();
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007586
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007587 // loop over each active track
7588 for (size_t i = 0; i < size; i++) {
7589 activeTrack = activeTracks[i];
7590
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007591 // skip fast tracks, as those are handled directly by FastCapture
7592 if (activeTrack->isFastTrack()) {
7593 continue;
7594 }
7595
Andy Hung73c02e42015-03-29 01:13:58 -07007596 // TODO: This code probably should be moved to RecordTrack.
Andy Hung97a893e2015-03-29 01:03:07 -07007597 // TODO: Update the activeTrack buffer converter in case of reconfigure.
7598
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007599 enum {
7600 OVERRUN_UNKNOWN,
7601 OVERRUN_TRUE,
7602 OVERRUN_FALSE
7603 } overrun = OVERRUN_UNKNOWN;
7604
7605 // loop over getNextBuffer to handle circular sink
7606 for (;;) {
7607
7608 activeTrack->mSink.frameCount = ~0;
7609 status_t status = activeTrack->getNextBuffer(&activeTrack->mSink);
7610 size_t framesOut = activeTrack->mSink.frameCount;
7611 LOG_ALWAYS_FATAL_IF((status == OK) != (framesOut > 0));
7612
Andy Hung73c02e42015-03-29 01:13:58 -07007613 // check available frames and handle overrun conditions
7614 // if the record track isn't draining fast enough.
7615 bool hasOverrun;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007616 size_t framesIn;
Andy Hung73c02e42015-03-29 01:13:58 -07007617 activeTrack->mResamplerBufferProvider->sync(&framesIn, &hasOverrun);
7618 if (hasOverrun) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007619 overrun = OVERRUN_TRUE;
7620 }
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007621 if (framesOut == 0 || framesIn == 0) {
7622 break;
7623 }
7624
Andy Hung6770c6f2015-04-07 13:43:36 -07007625 // Don't allow framesOut to be larger than what is possible with resampling
7626 // from framesIn.
7627 // This isn't strictly necessary but helps limit buffer resizing in
7628 // RecordBufferConverter. TODO: remove when no longer needed.
7629 framesOut = min(framesOut,
7630 destinationFramesPossible(
7631 framesIn, mSampleRate, activeTrack->mSampleRate));
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007632
7633 if (activeTrack->isDirect()) {
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007634 // No RecordBufferConverter used for direct streams. Pass
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007635 // straight from RecordThread buffer to RecordTrack buffer.
7636 AudioBufferProvider::Buffer buffer;
7637 buffer.frameCount = framesOut;
7638 status_t status = activeTrack->mResamplerBufferProvider->getNextBuffer(&buffer);
7639 if (status == OK && buffer.frameCount != 0) {
7640 ALOGV_IF(buffer.frameCount != framesOut,
7641 "%s() read less than expected (%zu vs %zu)",
7642 __func__, buffer.frameCount, framesOut);
7643 framesOut = buffer.frameCount;
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007644 memcpy(activeTrack->mSink.raw, buffer.raw, buffer.frameCount * mFrameSize);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007645 activeTrack->mResamplerBufferProvider->releaseBuffer(&buffer);
7646 } else {
7647 framesOut = 0;
7648 ALOGE("%s() cannot fill request, status: %d, frameCount: %zu",
7649 __func__, status, buffer.frameCount);
7650 }
7651 } else {
7652 // process frames from the RecordThread buffer provider to the RecordTrack
7653 // buffer
7654 framesOut = activeTrack->mRecordBufferConverter->convert(
7655 activeTrack->mSink.raw,
7656 activeTrack->mResamplerBufferProvider,
7657 framesOut);
7658 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007659
7660 if (framesOut > 0 && (overrun == OVERRUN_UNKNOWN)) {
7661 overrun = OVERRUN_FALSE;
7662 }
7663
7664 if (activeTrack->mFramesToDrop == 0) {
7665 if (framesOut > 0) {
7666 activeTrack->mSink.frameCount = framesOut;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007667 // Sanitize before releasing if the track has no access to the source data
7668 // An idle UID receives silence from non virtual devices until active
7669 if (activeTrack->isSilenced()) {
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -07007670 memset(activeTrack->mSink.raw, 0, framesOut * activeTrack->frameSize());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007671 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007672 activeTrack->releaseBuffer(&activeTrack->mSink);
7673 }
7674 } else {
7675 // FIXME could do a partial drop of framesOut
7676 if (activeTrack->mFramesToDrop > 0) {
Mikhail Naganov6d91ba52019-03-26 14:35:28 -07007677 activeTrack->mFramesToDrop -= (ssize_t)framesOut;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007678 if (activeTrack->mFramesToDrop <= 0) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007679 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007680 }
7681 } else {
7682 activeTrack->mFramesToDrop += framesOut;
7683 if (activeTrack->mFramesToDrop >= 0 || activeTrack->mSyncStartEvent == 0 ||
7684 activeTrack->mSyncStartEvent->isCancelled()) {
7685 ALOGW("Synced record %s, session %d, trigger session %d",
7686 (activeTrack->mFramesToDrop >= 0) ? "timed out" : "cancelled",
7687 activeTrack->sessionId(),
7688 (activeTrack->mSyncStartEvent != 0) ?
Glenn Kastend848eb42016-03-08 13:42:11 -08007689 activeTrack->mSyncStartEvent->triggerSession() :
7690 AUDIO_SESSION_NONE);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007691 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007692 }
7693 }
7694 }
7695
7696 if (framesOut == 0) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007697 break;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007698 }
7699 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007700
7701 switch (overrun) {
7702 case OVERRUN_TRUE:
7703 // client isn't retrieving buffers fast enough
7704 if (!activeTrack->setOverflow()) {
7705 nsecs_t now = systemTime();
7706 // FIXME should lastWarning per track?
7707 if ((now - lastWarning) > kWarningThrottleNs) {
7708 ALOGW("RecordThread: buffer overflow");
7709 lastWarning = now;
7710 }
7711 }
7712 break;
7713 case OVERRUN_FALSE:
7714 activeTrack->clearOverflow();
7715 break;
7716 case OVERRUN_UNKNOWN:
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007717 break;
7718 }
7719
Andy Hung3f0c9022016-01-15 17:49:46 -08007720 // update frame information and push timestamp out
7721 activeTrack->updateTrackFrameInfo(
Andy Hung6ae58432016-02-16 18:32:24 -08007722 activeTrack->mServerProxy->framesReleased(),
Andy Hung3f0c9022016-01-15 17:49:46 -08007723 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER],
7724 mSampleRate, mTimestamp);
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007725 }
7726
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007727unlock:
Eric Laurent81784c32012-11-19 14:55:58 -08007728 // enable changes in effect chain
7729 unlockEffectChains(effectChains);
Glenn Kastenc527a7c2013-08-13 15:43:49 -07007730 // effectChains doesn't need to be cleared, since it is cleared by destructor at scope end
Eric Laurentcccbc762019-04-05 14:20:05 -07007731 if (audio_has_proportional_frames(mFormat)
7732 && loopCount == lastLoopCountRead + 1) {
7733 const int64_t readPeriodNs = lastIoEndNs - mLastIoEndNs;
7734 const double jitterMs =
7735 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
7736 {framesRead, readPeriodNs},
7737 {0, 0} /* lastTimestamp */, mSampleRate);
7738 const double processMs = (lastIoBeginNs - mLastIoEndNs) * 1e-6;
7739
7740 Mutex::Autolock _l(mLock);
7741 mIoJitterMs.add(jitterMs);
7742 mProcessTimeMs.add(processMs);
7743 }
7744 // update timing info.
7745 mLastIoBeginNs = lastIoBeginNs;
7746 mLastIoEndNs = lastIoEndNs;
7747 lastLoopCountRead = loopCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007748 }
7749
Glenn Kasten93e471f2013-08-19 08:40:07 -07007750 standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08007751
7752 {
7753 Mutex::Autolock _l(mLock);
Eric Laurent9a54bc22013-09-09 09:08:44 -07007754 for (size_t i = 0; i < mTracks.size(); i++) {
7755 sp<RecordTrack> track = mTracks[i];
7756 track->invalidate();
7757 }
Glenn Kasten2b806402013-11-20 16:37:38 -08007758 mActiveTracks.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08007759 mStartStopCond.broadcast();
7760 }
7761
7762 releaseWakeLock();
7763
7764 ALOGV("RecordThread %p exiting", this);
7765 return false;
7766}
7767
Glenn Kasten93e471f2013-08-19 08:40:07 -07007768void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
Eric Laurent81784c32012-11-19 14:55:58 -08007769{
7770 if (!mStandby) {
7771 inputStandBy();
Andy Hungcf10d742020-04-28 15:38:24 -07007772 mThreadMetrics.logEndInterval();
Eric Laurent81784c32012-11-19 14:55:58 -08007773 mStandby = true;
7774 }
7775}
7776
7777void AudioFlinger::RecordThread::inputStandBy()
7778{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007779 // Idle the fast capture if it's currently running
7780 if (mFastCapture != 0) {
7781 FastCaptureStateQueue *sq = mFastCapture->sq();
7782 FastCaptureState *state = sq->begin();
7783 if (!(state->mCommand & FastCaptureState::IDLE)) {
7784 state->mCommand = FastCaptureState::COLD_IDLE;
7785 state->mColdFutexAddr = &mFastCaptureFutex;
7786 state->mColdGen++;
7787 mFastCaptureFutex = 0;
7788 sq->end();
7789 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
7790 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_ACKED);
7791#if 0
7792 if (kUseFastCapture == FastCapture_Dynamic) {
7793 // FIXME
7794 }
7795#endif
7796#ifdef AUDIO_WATCHDOG
7797 // FIXME
7798#endif
7799 } else {
7800 sq->end(false /*didModify*/);
7801 }
7802 }
Mikhail Naganov2534b382019-09-25 13:05:02 -07007803 status_t result = mSource->standby();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007804 ALOGE_IF(result != OK, "Error when putting input stream into standby: %d", result);
Andy Hungad6d52d2016-07-18 13:42:03 -07007805
7806 // If going into standby, flush the pipe source.
7807 if (mPipeSource.get() != nullptr) {
7808 const ssize_t flushed = mPipeSource->flush();
7809 if (flushed > 0) {
7810 ALOGV("Input standby flushed PipeSource %zd frames", flushed);
7811 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += flushed;
7812 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = systemTime();
7813 }
7814 }
Eric Laurent81784c32012-11-19 14:55:58 -08007815}
7816
Glenn Kasten05997e22014-03-13 15:08:33 -07007817// RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
Glenn Kastene198c362013-08-13 09:13:36 -07007818sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
Eric Laurent81784c32012-11-19 14:55:58 -08007819 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007820 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007821 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08007822 audio_format_t format,
7823 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08007824 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08007825 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007826 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07007827 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00007828 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07007829 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08007830 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08007831 status_t *status,
Eric Laurentec376dc2021-04-08 20:41:22 +02007832 audio_port_handle_t portId,
7833 int32_t maxSharedAudioHistoryMs)
Eric Laurent81784c32012-11-19 14:55:58 -08007834{
Glenn Kasten74935e42013-12-19 08:56:45 -08007835 size_t frameCount = *pFrameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007836 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007837 sp<RecordTrack> track;
7838 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07007839 audio_input_flags_t inputFlags = mInput->flags;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007840 audio_input_flags_t requestedFlags = *flags;
7841 uint32_t sampleRate;
Svet Ganov33761132021-05-13 22:51:08 +00007842 AttributionSourceState checkedAttributionSource = AudioFlinger::checkAttributionSourcePackage(
7843 attributionSource);
Eric Laurentf14db3c2017-12-08 14:20:36 -08007844
7845 lStatus = initCheck();
7846 if (lStatus != NO_ERROR) {
7847 ALOGE("createRecordTrack_l() audio driver not initialized");
7848 goto Exit;
7849 }
7850
Mikhail Naganovce9f2652018-07-16 11:09:24 -07007851 if (!audio_is_linear_pcm(mFormat) && (*flags & AUDIO_INPUT_FLAG_DIRECT) == 0) {
7852 ALOGE("createRecordTrack_l() on an encoded stream requires AUDIO_INPUT_FLAG_DIRECT");
7853 lStatus = BAD_VALUE;
7854 goto Exit;
7855 }
7856
Eric Laurentec376dc2021-04-08 20:41:22 +02007857 if (maxSharedAudioHistoryMs != 0) {
Svet Ganov33761132021-05-13 22:51:08 +00007858 if (!captureHotwordAllowed(checkedAttributionSource)) {
Eric Laurentec376dc2021-04-08 20:41:22 +02007859 lStatus = PERMISSION_DENIED;
7860 goto Exit;
7861 }
Eric Laurentec376dc2021-04-08 20:41:22 +02007862 if (maxSharedAudioHistoryMs < 0
7863 || maxSharedAudioHistoryMs > AudioFlinger::kMaxSharedAudioHistoryMs) {
7864 lStatus = BAD_VALUE;
7865 goto Exit;
7866 }
7867 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08007868 if (*pSampleRate == 0) {
7869 *pSampleRate = mSampleRate;
7870 }
7871 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07007872
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02007873 // special case for FAST flag considered OK if fast capture is present and access to
7874 // audio history is not required
7875 if (hasFastCapture() && mMaxSharedAudioHistoryMs == 0) {
Eric Laurent05067782016-06-01 18:27:28 -07007876 inputFlags = (audio_input_flags_t)(inputFlags | AUDIO_INPUT_FLAG_FAST);
7877 }
7878
Eric Laurentf14db3c2017-12-08 14:20:36 -08007879 // Check if requested flags are compatible with input stream flags
Eric Laurent05067782016-06-01 18:27:28 -07007880 if ((*flags & inputFlags) != *flags) {
7881 ALOGW("createRecordTrack_l(): mismatch between requested flags (%08x) and"
7882 " input flags (%08x)",
7883 *flags, inputFlags);
7884 *flags = (audio_input_flags_t)(*flags & inputFlags);
7885 }
Eric Laurent81784c32012-11-19 14:55:58 -08007886
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02007887 // client expresses a preference for FAST and no access to audio history,
7888 // but we get the final say
7889 if (*flags & AUDIO_INPUT_FLAG_FAST && maxSharedAudioHistoryMs == 0) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07007890 if (
Glenn Kastenb7fbf7e2015-03-18 12:57:28 -07007891 // we formerly checked for a callback handler (non-0 tid),
7892 // but that is no longer required for TRANSFER_OBTAIN mode
7893 //
Phil Burk7ed66a12019-04-18 13:20:30 -07007894 // Frame count is not specified (0), or is less than or equal the pipe depth.
7895 // It is OK to provide a higher capacity than requested.
7896 // We will force it to mPipeFramesP2 below.
7897 (frameCount <= mPipeFramesP2) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007898 // PCM data
7899 audio_is_linear_pcm(format) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007900 // hardware format
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007901 (format == mFormat) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007902 // hardware channel mask
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007903 (channelMask == mChannelMask) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007904 // hardware sample rate
Glenn Kasten90e58b12013-07-31 16:16:02 -07007905 (sampleRate == mSampleRate) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007906 // record thread has an associated fast capture
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007907 hasFastCapture() &&
7908 // there are sufficient fast track slots available
7909 mFastTrackAvail
Glenn Kasten90e58b12013-07-31 16:16:02 -07007910 ) {
Eric Laurent4c415062016-06-17 16:14:16 -07007911 // check compatibility with audio effects.
7912 Mutex::Autolock _l(mLock);
7913 // Do not accept FAST flag if the session has software effects
7914 sp<EffectChain> chain = getEffectChain_l(sessionId);
7915 if (chain != 0) {
Andy Hungd3bb0ad2016-10-11 17:16:43 -07007916 audio_input_flags_t old = *flags;
7917 chain->checkInputFlagCompatibility(flags);
7918 if (old != *flags) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007919 ALOGV("%p AUDIO_INPUT_FLAGS denied by effect old=%#x new=%#x",
7920 this, (int)old, (int)*flags);
Eric Laurent4c415062016-06-17 16:14:16 -07007921 }
7922 }
Eric Laurent122f7e72016-06-29 11:53:29 -07007923 ALOGV_IF((*flags & AUDIO_INPUT_FLAG_FAST) != 0,
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007924 "%p AUDIO_INPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
7925 this, frameCount, mFrameCount);
Glenn Kasten90e58b12013-07-31 16:16:02 -07007926 } else {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007927 ALOGV("%p AUDIO_INPUT_FLAG_FAST denied: frameCount=%zu mFrameCount=%zu mPipeFramesP2=%zu "
7928 "format=%#x isLinear=%d mFormat=%#x channelMask=%#x sampleRate=%u mSampleRate=%u "
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007929 "hasFastCapture=%d tid=%d mFastTrackAvail=%d",
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007930 this, frameCount, mFrameCount, mPipeFramesP2,
7931 format, audio_is_linear_pcm(format), mFormat, channelMask, sampleRate, mSampleRate,
Glenn Kasten74105912014-07-03 12:28:53 -07007932 hasFastCapture(), tid, mFastTrackAvail);
Eric Laurent05067782016-06-01 18:27:28 -07007933 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
Glenn Kasten74105912014-07-03 12:28:53 -07007934 }
7935 }
7936
Eric Laurentf14db3c2017-12-08 14:20:36 -08007937 // If FAST or RAW flags were corrected, ask caller to request new input from audio policy
7938 if ((*flags & AUDIO_INPUT_FLAG_FAST) !=
7939 (requestedFlags & AUDIO_INPUT_FLAG_FAST)) {
7940 *flags = (audio_input_flags_t) (*flags & ~(AUDIO_INPUT_FLAG_FAST | AUDIO_INPUT_FLAG_RAW));
7941 lStatus = BAD_TYPE;
7942 goto Exit;
7943 }
7944
Glenn Kasten74105912014-07-03 12:28:53 -07007945 // compute track buffer size in frames, and suggest the notification frame count
Eric Laurent05067782016-06-01 18:27:28 -07007946 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten74105912014-07-03 12:28:53 -07007947 // fast track: frame count is exactly the pipe depth
7948 frameCount = mPipeFramesP2;
7949 // ignore requested notificationFrames, and always notify exactly once every HAL buffer
Eric Laurentf14db3c2017-12-08 14:20:36 -08007950 notificationFrameCount = mFrameCount;
Glenn Kasten74105912014-07-03 12:28:53 -07007951 } else {
Glenn Kasten49d00ad2014-07-21 11:22:03 -07007952 // not fast track: max notification period is resampled equivalent of one HAL buffer time
7953 // or 20 ms if there is a fast capture
7954 // TODO This could be a roundupRatio inline, and const
7955 size_t maxNotificationFrames = ((int64_t) (hasFastCapture() ? mSampleRate/50 : mFrameCount)
7956 * sampleRate + mSampleRate - 1) / mSampleRate;
7957 // minimum number of notification periods is at least kMinNotifications,
7958 // and at least kMinMs rounded up to a whole notification period (minNotificationsByMs)
7959 static const size_t kMinNotifications = 3;
7960 static const uint32_t kMinMs = 30;
7961 // TODO This could be a roundupRatio inline
7962 const size_t minFramesByMs = (sampleRate * kMinMs + 1000 - 1) / 1000;
7963 // TODO This could be a roundupRatio inline
7964 const size_t minNotificationsByMs = (minFramesByMs + maxNotificationFrames - 1) /
7965 maxNotificationFrames;
7966 const size_t minFrameCount = maxNotificationFrames *
7967 max(kMinNotifications, minNotificationsByMs);
7968 frameCount = max(frameCount, minFrameCount);
Eric Laurentf14db3c2017-12-08 14:20:36 -08007969 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
7970 notificationFrameCount = maxNotificationFrames;
Glenn Kasten74105912014-07-03 12:28:53 -07007971 }
Glenn Kasten90e58b12013-07-31 16:16:02 -07007972 }
Glenn Kasten74935e42013-12-19 08:56:45 -08007973 *pFrameCount = frameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007974 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007975
7976 { // scope for mLock
7977 Mutex::Autolock _l(mLock);
Eric Laurent2407ce32021-04-26 14:56:03 +02007978 int32_t startFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02007979 if (!mSharedAudioPackageName.empty()
Svet Ganov33761132021-05-13 22:51:08 +00007980 && mSharedAudioPackageName == checkedAttributionSource.packageName
Eric Laurentec376dc2021-04-08 20:41:22 +02007981 && mSharedAudioSessionId == sessionId
Svet Ganov33761132021-05-13 22:51:08 +00007982 && captureHotwordAllowed(checkedAttributionSource)) {
Eric Laurent2407ce32021-04-26 14:56:03 +02007983 startFrames = mSharedAudioStartFrames;
Eric Laurentec376dc2021-04-08 20:41:22 +02007984 }
Eric Laurent81784c32012-11-19 14:55:58 -08007985
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007986 track = new RecordTrack(this, client, attr, sampleRate,
Andy Hung8fe68032017-06-05 16:17:51 -07007987 format, channelMask, frameCount,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07007988 nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00007989 checkedAttributionSource, *flags, TrackBase::TYPE_DEFAULT, portId,
7990 startFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08007991
Glenn Kasten03003332013-08-06 15:40:54 -07007992 lStatus = track->initCheck();
7993 if (lStatus != NO_ERROR) {
Glenn Kasten35295072013-10-07 09:27:06 -07007994 ALOGE("createRecordTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08007995 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08007996 goto Exit;
7997 }
7998 mTracks.add(track);
7999
Eric Laurent05067782016-06-01 18:27:28 -07008000 if ((*flags & AUDIO_INPUT_FLAG_FAST) && (tid != -1)) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07008001 pid_t callingPid = IPCThreadState::self()->getCallingPid();
8002 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
8003 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07008004 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Glenn Kasten90e58b12013-07-31 16:16:02 -07008005 }
Eric Laurentec376dc2021-04-08 20:41:22 +02008006
8007 if (maxSharedAudioHistoryMs != 0) {
8008 sendResizeBufferConfigEvent_l(maxSharedAudioHistoryMs);
8009 }
Eric Laurent81784c32012-11-19 14:55:58 -08008010 }
Glenn Kasten05997e22014-03-13 15:08:33 -07008011
Eric Laurent81784c32012-11-19 14:55:58 -08008012 lStatus = NO_ERROR;
8013
8014Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07008015 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08008016 return track;
8017}
8018
8019status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
8020 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08008021 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08008022{
8023 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
8024 sp<ThreadBase> strongMe = this;
8025 status_t status = NO_ERROR;
8026
8027 if (event == AudioSystem::SYNC_EVENT_NONE) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008028 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08008029 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008030 recordTrack->mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
Eric Laurent81784c32012-11-19 14:55:58 -08008031 triggerSession,
8032 recordTrack->sessionId(),
8033 syncStartEventCallback,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008034 recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08008035 // Sync event can be cancelled by the trigger session if the track is not in a
8036 // compatible state in which case we start record immediately
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008037 if (recordTrack->mSyncStartEvent->isCancelled()) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08008038 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08008039 } else {
8040 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
Ivan Lozano1b35dd62017-12-06 16:55:10 -08008041 recordTrack->mFramesToDrop = -(ssize_t)
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008042 ((AudioSystem::kSyncRecordStartTimeOutMs * recordTrack->mSampleRate) / 1000);
Eric Laurent81784c32012-11-19 14:55:58 -08008043 }
8044 }
8045
8046 {
Glenn Kasten47c20702013-08-13 15:37:35 -07008047 // This section is a rendezvous between binder thread executing start() and RecordThread
Eric Laurent81784c32012-11-19 14:55:58 -08008048 AutoMutex lock(mLock);
Andy Hungce685402018-10-05 17:23:27 -07008049 if (recordTrack->isInvalid()) {
8050 recordTrack->clearSyncStartEvent();
Eric Laurentd52a28c2020-08-21 17:10:39 -07008051 ALOGW("%s track %d: invalidated before startInput", __func__, recordTrack->portId());
8052 return DEAD_OBJECT;
Andy Hungce685402018-10-05 17:23:27 -07008053 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008054 if (mActiveTracks.indexOf(recordTrack) >= 0) {
8055 if (recordTrack->mState == TrackBase::PAUSING) {
Andy Hungce685402018-10-05 17:23:27 -07008056 // We haven't stopped yet (moved to PAUSED and not in mActiveTracks)
8057 // so no need to startInput().
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008058 ALOGV("active record track PAUSING -> ACTIVE");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08008059 recordTrack->mState = TrackBase::ACTIVE;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008060 } else {
8061 ALOGV("active record track state %d", recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08008062 }
8063 return status;
8064 }
8065
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008066 // TODO consider other ways of handling this, such as changing the state to :STARTING and
8067 // adding the track to mActiveTracks after returning from AudioSystem::startInput(),
8068 // or using a separate command thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008069 recordTrack->mState = TrackBase::STARTING_1;
Glenn Kasten2b806402013-11-20 16:37:38 -08008070 mActiveTracks.add(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07008071 status_t status = NO_ERROR;
8072 if (recordTrack->isExternalTrack()) {
8073 mLock.unlock();
Eric Laurent4eb58f12018-12-07 16:41:02 -08008074 status = AudioSystem::startInput(recordTrack->portId());
Eric Laurent83b88082014-06-20 18:31:16 -07008075 mLock.lock();
Andy Hungce685402018-10-05 17:23:27 -07008076 if (recordTrack->isInvalid()) {
8077 recordTrack->clearSyncStartEvent();
8078 if (status == NO_ERROR && recordTrack->mState == TrackBase::STARTING_1) {
8079 recordTrack->mState = TrackBase::STARTING_2;
8080 // STARTING_2 forces destroy to call stopInput.
8081 }
Eric Laurentd52a28c2020-08-21 17:10:39 -07008082 ALOGW("%s track %d: invalidated after startInput", __func__, recordTrack->portId());
8083 return DEAD_OBJECT;
Andy Hungce685402018-10-05 17:23:27 -07008084 }
8085 if (recordTrack->mState != TrackBase::STARTING_1) {
8086 ALOGW("%s(%d): unsynchronized mState:%d change",
8087 __func__, recordTrack->id(), recordTrack->mState);
8088 // Someone else has changed state, let them take over,
8089 // leave mState in the new state.
8090 recordTrack->clearSyncStartEvent();
8091 return INVALID_OPERATION;
8092 }
8093 // we're ok, but perhaps startInput has failed
Eric Laurent83b88082014-06-20 18:31:16 -07008094 if (status != NO_ERROR) {
Andy Hungce685402018-10-05 17:23:27 -07008095 ALOGW("%s(%d): startInput failed, status %d",
8096 __func__, recordTrack->id(), status);
8097 // We are in ActiveTracks if STARTING_1 and valid, so remove from ActiveTracks,
8098 // leave in STARTING_1, so destroy() will not call stopInput.
Eric Laurent83b88082014-06-20 18:31:16 -07008099 mActiveTracks.remove(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07008100 recordTrack->clearSyncStartEvent();
Eric Laurent83b88082014-06-20 18:31:16 -07008101 return status;
8102 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07008103 sendIoConfigEvent_l(
8104 AUDIO_CLIENT_STARTED, recordTrack->creatorPid(), recordTrack->portId());
Eric Laurent81784c32012-11-19 14:55:58 -08008105 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07008106
8107 recordTrack->logBeginInterval(patchSourcesToString(&mPatch)); // log to MediaMetrics
8108
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008109 // Catch up with current buffer indices if thread is already running.
8110 // This is what makes a new client discard all buffered data. If the track's mRsmpInFront
8111 // was initialized to some value closer to the thread's mRsmpInFront, then the track could
8112 // see previously buffered data before it called start(), but with greater risk of overrun.
8113
Andy Hung73c02e42015-03-29 01:13:58 -07008114 recordTrack->mResamplerBufferProvider->reset();
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07008115 if (!recordTrack->isDirect()) {
8116 // clear any converter state as new data will be discontinuous
8117 recordTrack->mRecordBufferConverter->reset();
8118 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008119 recordTrack->mState = TrackBase::STARTING_2;
Eric Laurent81784c32012-11-19 14:55:58 -08008120 // signal thread to start
Eric Laurent81784c32012-11-19 14:55:58 -08008121 mWaitWorkCV.broadcast();
Eric Laurent81784c32012-11-19 14:55:58 -08008122 return status;
8123 }
Eric Laurent81784c32012-11-19 14:55:58 -08008124}
8125
Eric Laurent81784c32012-11-19 14:55:58 -08008126void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
8127{
8128 sp<SyncEvent> strongEvent = event.promote();
8129
8130 if (strongEvent != 0) {
Eric Laurent8ea16e42014-02-20 16:26:11 -08008131 sp<RefBase> ptr = strongEvent->cookie().promote();
8132 if (ptr != 0) {
8133 RecordTrack *recordTrack = (RecordTrack *)ptr.get();
8134 recordTrack->handleSyncStartEvent(strongEvent);
8135 }
Eric Laurent81784c32012-11-19 14:55:58 -08008136 }
8137}
8138
Glenn Kastena8356f62013-07-25 14:37:52 -07008139bool AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
Eric Laurent81784c32012-11-19 14:55:58 -08008140 ALOGV("RecordThread::stop");
Glenn Kastena8356f62013-07-25 14:37:52 -07008141 AutoMutex _l(mLock);
Andy Hungce685402018-10-05 17:23:27 -07008142 // if we're invalid, we can't be on the ActiveTracks.
Jean-Michel Trivi38f86712017-04-11 14:10:17 -07008143 if (mActiveTracks.indexOf(recordTrack) < 0 || recordTrack->mState == TrackBase::PAUSING) {
Eric Laurent81784c32012-11-19 14:55:58 -08008144 return false;
8145 }
Glenn Kasten47c20702013-08-13 15:37:35 -07008146 // note that threadLoop may still be processing the track at this point [without lock]
Eric Laurent81784c32012-11-19 14:55:58 -08008147 recordTrack->mState = TrackBase::PAUSING;
Andy Hungce685402018-10-05 17:23:27 -07008148
Andy Hungabfab202019-03-07 19:45:54 -08008149 // NOTE: Waiting here is important to keep stop synchronous.
8150 // This is needed for proper patchRecord peer release.
Andy Hungce685402018-10-05 17:23:27 -07008151 while (recordTrack->mState == TrackBase::PAUSING && !recordTrack->isInvalid()) {
8152 mWaitWorkCV.broadcast(); // signal thread to stop
8153 mStartStopCond.wait(mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08008154 }
Andy Hungce685402018-10-05 17:23:27 -07008155
8156 if (recordTrack->mState == TrackBase::PAUSED) { // successful stop
Eric Laurent81784c32012-11-19 14:55:58 -08008157 ALOGV("Record stopped OK");
8158 return true;
8159 }
Andy Hungce685402018-10-05 17:23:27 -07008160
8161 // don't handle anything - we've been invalidated or restarted and in a different state
8162 ALOGW_IF("%s(%d): unsynchronized stop, state: %d",
8163 __func__, recordTrack->id(), recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08008164 return false;
8165}
8166
Glenn Kasten0f11b512014-01-31 16:18:54 -08008167bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08008168{
8169 return false;
8170}
8171
Glenn Kasten0f11b512014-01-31 16:18:54 -08008172status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008173{
8174#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
8175 if (!isValidSyncEvent(event)) {
8176 return BAD_VALUE;
8177 }
8178
Glenn Kastend848eb42016-03-08 13:42:11 -08008179 audio_session_t eventSession = event->triggerSession();
Eric Laurent81784c32012-11-19 14:55:58 -08008180 status_t ret = NAME_NOT_FOUND;
8181
8182 Mutex::Autolock _l(mLock);
8183
8184 for (size_t i = 0; i < mTracks.size(); i++) {
8185 sp<RecordTrack> track = mTracks[i];
8186 if (eventSession == track->sessionId()) {
8187 (void) track->setSyncEvent(event);
8188 ret = NO_ERROR;
8189 }
8190 }
8191 return ret;
8192#else
8193 return BAD_VALUE;
8194#endif
8195}
8196
jiabin653cc0a2018-01-17 17:54:10 -08008197status_t AudioFlinger::RecordThread::getActiveMicrophones(
8198 std::vector<media::MicrophoneInfo>* activeMicrophones)
8199{
8200 ALOGV("RecordThread::getActiveMicrophones");
8201 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08008202 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06008203 return NO_INIT;
8204 }
jiabin9ff780e2018-03-19 18:19:52 -07008205 status_t status = mInput->stream->getActiveMicrophones(activeMicrophones);
8206 return status;
jiabin653cc0a2018-01-17 17:54:10 -08008207}
8208
Paul McLean12340082019-03-19 09:35:05 -06008209status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
8210 audio_microphone_direction_t direction)
Paul McLean03a6e6a2018-12-04 10:54:13 -07008211{
Paul McLean12340082019-03-19 09:35:05 -06008212 ALOGV("setPreferredMicrophoneDirection(%d)", direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008213 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08008214 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06008215 return NO_INIT;
8216 }
Paul McLean12340082019-03-19 09:35:05 -06008217 return mInput->stream->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008218}
8219
Paul McLean12340082019-03-19 09:35:05 -06008220status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
Paul McLean03a6e6a2018-12-04 10:54:13 -07008221{
Paul McLean12340082019-03-19 09:35:05 -06008222 ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008223 AutoMutex _l(mLock);
Jasmine Chaeaa10e42021-05-11 10:11:14 +08008224 if (!isStreamInitialized()) {
Paul McLean8a661a32021-04-12 10:21:42 -06008225 return NO_INIT;
8226 }
Paul McLean12340082019-03-19 09:35:05 -06008227 return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008228}
8229
Eric Laurentec376dc2021-04-08 20:41:22 +02008230status_t AudioFlinger::RecordThread::shareAudioHistory(
8231 const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
8232 int64_t sharedAudioStartMs) {
8233 AutoMutex _l(mLock);
8234 return shareAudioHistory_l(sharedAudioPackageName, sharedSessionId, sharedAudioStartMs);
8235}
8236
8237status_t AudioFlinger::RecordThread::shareAudioHistory_l(
8238 const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
8239 int64_t sharedAudioStartMs) {
Eric Laurentec376dc2021-04-08 20:41:22 +02008240 if ((hasAudioSession_l(sharedSessionId) & ThreadBase::TRACK_SESSION) == 0) {
8241 return BAD_VALUE;
8242 }
Eric Laurent2407ce32021-04-26 14:56:03 +02008243
8244 if (sharedAudioStartMs < 0
8245 || sharedAudioStartMs > INT64_MAX / mSampleRate) {
Eric Laurentec376dc2021-04-08 20:41:22 +02008246 return BAD_VALUE;
8247 }
8248
Eric Laurent2407ce32021-04-26 14:56:03 +02008249 // Current implementation of the input resampling buffer wraps around indexes at 32 bit.
8250 // As we cannot detect more than one wraparound, only accept values up current write position
8251 // after one wraparound
8252 // We assume recent wraparounds on mRsmpInRear only given it is unlikely that the requesting
8253 // app waits several hours after the start time was computed.
8254 const int64_t sharedAudioStartFrames = sharedAudioStartMs * mSampleRate / 1000;
8255 const int32_t sharedOffset = audio_utils::safe_sub_overflow(mRsmpInRear,
8256 (int32_t)sharedAudioStartFrames);
8257 if (sharedOffset < 0
8258 || sharedOffset > mRsmpInFrames) {
8259 return BAD_VALUE;
8260 }
8261
Eric Laurentec376dc2021-04-08 20:41:22 +02008262 mSharedAudioPackageName = sharedAudioPackageName;
8263 if (mSharedAudioPackageName.empty()) {
8264 mSharedAudioSessionId = AUDIO_SESSION_NONE;
Eric Laurent2407ce32021-04-26 14:56:03 +02008265 mSharedAudioStartFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02008266 } else {
8267 mSharedAudioSessionId = sharedSessionId;
Eric Laurent2407ce32021-04-26 14:56:03 +02008268 mSharedAudioStartFrames = (int32_t)sharedAudioStartFrames;
Eric Laurentec376dc2021-04-08 20:41:22 +02008269 }
8270 return NO_ERROR;
8271}
8272
Kevin Rocard069c2712018-03-29 19:09:14 -07008273void AudioFlinger::RecordThread::updateMetadata_l()
8274{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08008275 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
8276 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07008277 }
8278 StreamInHalInterface::SinkMetadata metadata;
8279 for (const sp<RecordTrack> &track : mActiveTracks) {
Eric Laurentb9cc0ab2021-01-29 11:46:52 +01008280 // Do not forward PatchRecord metadata to audio HAL
8281 if (track->isPatchTrack()) {
8282 continue;
8283 }
Kevin Rocard069c2712018-03-29 19:09:14 -07008284 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent94579172020-11-20 18:41:04 +01008285 record_track_metadata_v7_t trackMetadata;
8286 trackMetadata.base = {
Kevin Rocard069c2712018-03-29 19:09:14 -07008287 .source = track->attributes().source,
8288 .gain = 1, // capture tracks do not have volumes
Eric Laurent94579172020-11-20 18:41:04 +01008289 };
8290 trackMetadata.channel_mask = track->channelMask(),
8291 strncpy(trackMetadata.tags, track->attributes().tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
8292
8293 metadata.tracks.push_back(trackMetadata);
Kevin Rocard069c2712018-03-29 19:09:14 -07008294 }
8295 mInput->stream->updateSinkMetadata(metadata);
8296}
8297
Eric Laurent81784c32012-11-19 14:55:58 -08008298// destroyTrack_l() must be called with ThreadBase::mLock held
8299void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
8300{
Eric Laurentbfb1b832013-01-07 09:53:42 -08008301 track->terminate();
8302 track->mState = TrackBase::STOPPED;
Eric Laurentec376dc2021-04-08 20:41:22 +02008303
Eric Laurent81784c32012-11-19 14:55:58 -08008304 // active tracks are removed by threadLoop()
Glenn Kasten2b806402013-11-20 16:37:38 -08008305 if (mActiveTracks.indexOf(track) < 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08008306 removeTrack_l(track);
8307 }
8308}
8309
8310void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
8311{
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008312 String8 result;
8313 track->appendDump(result, false /* active */);
8314 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
8315
Eric Laurent81784c32012-11-19 14:55:58 -08008316 mTracks.remove(track);
8317 // need anything related to effects here?
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008318 if (track->isFastTrack()) {
8319 ALOG_ASSERT(!mFastTrackAvail);
8320 mFastTrackAvail = true;
8321 }
Eric Laurent81784c32012-11-19 14:55:58 -08008322}
8323
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07008324void AudioFlinger::RecordThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008325{
Mikhail Naganov913d06c2016-11-01 12:49:22 -07008326 AudioStreamIn *input = mInput;
8327 audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
8328 dprintf(fd, " AudioStreamIn: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08008329 input, flags, toString(flags).c_str());
Andy Hung6427e442018-08-09 12:51:02 -07008330 dprintf(fd, " Frames read: %lld\n", (long long)mFramesRead);
Eric Tan39ec8d62018-07-24 09:49:29 -07008331 if (mActiveTracks.isEmpty()) {
Elliott Hughes87cebad2014-05-22 10:14:43 -07008332 dprintf(fd, " No active record clients\n");
Eric Laurent81784c32012-11-19 14:55:58 -08008333 }
Andy Hungbfa64962017-06-12 14:43:19 -07008334
8335 if (input != nullptr) {
8336 dprintf(fd, " Hal stream dump:\n");
8337 (void)input->stream->dump(fd);
8338 }
8339
Glenn Kasten6e6704c2014-07-03 10:20:00 -07008340 dprintf(fd, " Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008341 dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
Glenn Kasten17c9c992015-03-02 15:53:01 -08008342
Glenn Kasten2f90c512015-12-02 11:40:09 -08008343 // Make a non-atomic copy of fast capture dump state so it won't change underneath us
8344 // while we are dumping it. It may be inconsistent, but it won't mutate!
8345 // This is a large object so we place it on the heap.
8346 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07008347 const std::unique_ptr<FastCaptureDumpState> copy =
8348 std::make_unique<FastCaptureDumpState>(mFastCaptureDumpState);
Glenn Kasten2f90c512015-12-02 11:40:09 -08008349 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08008350}
8351
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07008352void AudioFlinger::RecordThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008353{
Eric Laurent81784c32012-11-19 14:55:58 -08008354 String8 result;
Marco Nelissenb2208842014-02-07 14:00:50 -08008355 size_t numtracks = mTracks.size();
8356 size_t numactive = mActiveTracks.size();
8357 size_t numactiveseen = 0;
Glenn Kastenc42e9b42016-03-21 11:35:03 -07008358 dprintf(fd, " %zu Tracks", numtracks);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008359 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08008360 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07008361 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008362 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07008363 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08008364 for (size_t i = 0; i < numtracks ; ++i) {
8365 sp<RecordTrack> track = mTracks[i];
8366 if (track != 0) {
8367 bool active = mActiveTracks.indexOf(track) >= 0;
8368 if (active) {
8369 numactiveseen++;
8370 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008371 result.append(prefix);
8372 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08008373 }
Eric Laurent81784c32012-11-19 14:55:58 -08008374 }
Marco Nelissenb2208842014-02-07 14:00:50 -08008375 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -07008376 dprintf(fd, "\n");
Eric Laurent81784c32012-11-19 14:55:58 -08008377 }
8378
Marco Nelissenb2208842014-02-07 14:00:50 -08008379 if (numactiveseen != numactive) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008380 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08008381 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008382 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07008383 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08008384 for (size_t i = 0; i < numactive; ++i) {
Glenn Kasten2b806402013-11-20 16:37:38 -08008385 sp<RecordTrack> track = mActiveTracks[i];
Marco Nelissenb2208842014-02-07 14:00:50 -08008386 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008387 result.append(prefix);
8388 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08008389 }
Glenn Kasten2b806402013-11-20 16:37:38 -08008390 }
Eric Laurent81784c32012-11-19 14:55:58 -08008391
8392 }
8393 write(fd, result.string(), result.size());
8394}
8395
Eric Laurent5ada82e2019-08-29 17:53:54 -07008396void AudioFlinger::RecordThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008397{
8398 Mutex::Autolock _l(mLock);
8399 for (size_t i = 0; i < mTracks.size() ; i++) {
8400 sp<RecordTrack> track = mTracks[i];
Eric Laurent5ada82e2019-08-29 17:53:54 -07008401 if (track != 0 && track->portId() == portId) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008402 track->setSilenced(silenced);
8403 }
8404 }
8405}
Andy Hung73c02e42015-03-29 01:13:58 -07008406
8407void AudioFlinger::RecordThread::ResamplerBufferProvider::reset()
8408{
8409 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
8410 RecordThread *recordThread = (RecordThread *) threadBase.get();
Andy Hung73c02e42015-03-29 01:13:58 -07008411 mRsmpInUnrel = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02008412 const int32_t rear = recordThread->mRsmpInRear;
8413 ssize_t deltaFrames = 0;
Eric Laurent2407ce32021-04-26 14:56:03 +02008414 if (mRecordTrack->startFrames() >= 0) {
8415 int32_t startFrames = mRecordTrack->startFrames();
8416 // Accept a recent wraparound of mRsmpInRear
8417 if (startFrames <= rear) {
8418 deltaFrames = rear - startFrames;
8419 } else {
8420 deltaFrames = (int32_t)((int64_t)rear + UINT32_MAX + 1 - startFrames);
Eric Laurentec376dc2021-04-08 20:41:22 +02008421 }
Eric Laurentec376dc2021-04-08 20:41:22 +02008422 // start frame cannot be further in the past than start of resampling buffer
8423 if ((size_t) deltaFrames > recordThread->mRsmpInFrames) {
8424 deltaFrames = recordThread->mRsmpInFrames;
8425 }
8426 }
8427 mRsmpInFront = audio_utils::safe_sub_overflow(rear, static_cast<int32_t>(deltaFrames));
Andy Hung73c02e42015-03-29 01:13:58 -07008428}
8429
8430void AudioFlinger::RecordThread::ResamplerBufferProvider::sync(
8431 size_t *framesAvailable, bool *hasOverrun)
8432{
8433 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
8434 RecordThread *recordThread = (RecordThread *) threadBase.get();
8435 const int32_t rear = recordThread->mRsmpInRear;
8436 const int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07008437 const ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Andy Hung73c02e42015-03-29 01:13:58 -07008438
8439 size_t framesIn;
8440 bool overrun = false;
8441 if (filled < 0) {
8442 // should not happen, but treat like a massive overrun and re-sync
8443 framesIn = 0;
8444 mRsmpInFront = rear;
8445 overrun = true;
8446 } else if ((size_t) filled <= recordThread->mRsmpInFrames) {
8447 framesIn = (size_t) filled;
8448 } else {
8449 // client is not keeping up with server, but give it latest data
8450 framesIn = recordThread->mRsmpInFrames;
Hongwei Wang95e37682019-04-12 11:13:36 -07008451 mRsmpInFront = /* front = */ audio_utils::safe_sub_overflow(
8452 rear, static_cast<int32_t>(framesIn));
Andy Hung73c02e42015-03-29 01:13:58 -07008453 overrun = true;
8454 }
8455 if (framesAvailable != NULL) {
8456 *framesAvailable = framesIn;
8457 }
8458 if (hasOverrun != NULL) {
8459 *hasOverrun = overrun;
8460 }
8461}
8462
Eric Laurent81784c32012-11-19 14:55:58 -08008463// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008464status_t AudioFlinger::RecordThread::ResamplerBufferProvider::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08008465 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08008466{
Andy Hung73c02e42015-03-29 01:13:58 -07008467 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008468 if (threadBase == 0) {
8469 buffer->frameCount = 0;
Glenn Kasten607fa3e2014-02-21 14:24:58 -08008470 buffer->raw = NULL;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008471 return NOT_ENOUGH_DATA;
8472 }
8473 RecordThread *recordThread = (RecordThread *) threadBase.get();
8474 int32_t rear = recordThread->mRsmpInRear;
Andy Hung73c02e42015-03-29 01:13:58 -07008475 int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07008476 ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008477 // FIXME should not be P2 (don't want to increase latency)
8478 // FIXME if client not keeping up, discard
Glenn Kasten607fa3e2014-02-21 14:24:58 -08008479 LOG_ALWAYS_FATAL_IF(!(0 <= filled && (size_t) filled <= recordThread->mRsmpInFrames));
Glenn Kasten85948432013-08-19 12:09:05 -07008480 // 'filled' may be non-contiguous, so return only the first contiguous chunk
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008481
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008482 front &= recordThread->mRsmpInFramesP2 - 1;
8483 size_t part1 = recordThread->mRsmpInFramesP2 - front;
Glenn Kasten85948432013-08-19 12:09:05 -07008484 if (part1 > (size_t) filled) {
8485 part1 = filled;
8486 }
8487 size_t ask = buffer->frameCount;
8488 ALOG_ASSERT(ask > 0);
8489 if (part1 > ask) {
8490 part1 = ask;
8491 }
8492 if (part1 == 0) {
Andy Hung73c02e42015-03-29 01:13:58 -07008493 // out of data is fine since the resampler will return a short-count.
Glenn Kasten85948432013-08-19 12:09:05 -07008494 buffer->raw = NULL;
8495 buffer->frameCount = 0;
Andy Hung73c02e42015-03-29 01:13:58 -07008496 mRsmpInUnrel = 0;
Glenn Kasten85948432013-08-19 12:09:05 -07008497 return NOT_ENOUGH_DATA;
Eric Laurent81784c32012-11-19 14:55:58 -08008498 }
8499
Andy Hung57446612015-04-19 23:56:46 -07008500 buffer->raw = (uint8_t*)recordThread->mRsmpInBuffer + front * recordThread->mFrameSize;
Glenn Kasten85948432013-08-19 12:09:05 -07008501 buffer->frameCount = part1;
Andy Hung73c02e42015-03-29 01:13:58 -07008502 mRsmpInUnrel = part1;
Eric Laurent81784c32012-11-19 14:55:58 -08008503 return NO_ERROR;
8504}
8505
8506// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008507void AudioFlinger::RecordThread::ResamplerBufferProvider::releaseBuffer(
8508 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08008509{
Hongwei Wang95e37682019-04-12 11:13:36 -07008510 int32_t stepCount = static_cast<int32_t>(buffer->frameCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008511 if (stepCount == 0) {
8512 return;
8513 }
Andy Hung73c02e42015-03-29 01:13:58 -07008514 ALOG_ASSERT(stepCount <= mRsmpInUnrel);
8515 mRsmpInUnrel -= stepCount;
Hongwei Wang95e37682019-04-12 11:13:36 -07008516 mRsmpInFront = audio_utils::safe_add_overflow(mRsmpInFront, stepCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008517 buffer->raw = NULL;
Eric Laurent81784c32012-11-19 14:55:58 -08008518 buffer->frameCount = 0;
8519}
8520
Eric Laurentd8365c52017-07-16 15:27:05 -07008521void AudioFlinger::RecordThread::checkBtNrec()
8522{
8523 Mutex::Autolock _l(mLock);
8524 checkBtNrec_l();
8525}
8526
8527void AudioFlinger::RecordThread::checkBtNrec_l()
8528{
8529 // disable AEC and NS if the device is a BT SCO headset supporting those
8530 // pre processings
jiabinc52b1ff2019-10-31 17:20:42 -07008531 bool suspend = audio_is_bluetooth_sco_device(inDeviceType()) &&
Eric Laurentd8365c52017-07-16 15:27:05 -07008532 mAudioFlinger->btNrecIsOff();
8533 if (mBtNrecSuspended.exchange(suspend) != suspend) {
8534 for (size_t i = 0; i < mEffectChains.size(); i++) {
8535 setEffectSuspended_l(FX_IID_AEC, suspend, mEffectChains[i]->sessionId());
8536 setEffectSuspended_l(FX_IID_NS, suspend, mEffectChains[i]->sessionId());
8537 }
8538 }
8539}
8540
Andy Hung97a893e2015-03-29 01:03:07 -07008541
Eric Laurent10351942014-05-08 18:49:52 -07008542bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
8543 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08008544{
8545 bool reconfig = false;
8546
Eric Laurent10351942014-05-08 18:49:52 -07008547 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08008548
Eric Laurent10351942014-05-08 18:49:52 -07008549 audio_format_t reqFormat = mFormat;
8550 uint32_t samplingRate = mSampleRate;
Glenn Kastene1635ec2015-06-08 15:46:49 -07008551 // TODO this may change if we want to support capture from HDMI PCM multi channel (e.g on TVs).
Eric Laurent10351942014-05-08 18:49:52 -07008552 audio_channel_mask_t channelMask = audio_channel_in_mask_from_count(mChannelCount);
8553
8554 AudioParameter param = AudioParameter(keyValuePair);
8555 int value;
Haynes Mathew George9ce67b52015-09-30 11:40:47 -07008556
8557 // scope for AutoPark extends to end of method
8558 AutoPark<FastCapture> park(mFastCapture);
8559
Eric Laurent10351942014-05-08 18:49:52 -07008560 // TODO Investigate when this code runs. Check with audio policy when a sample rate and
8561 // channel count change can be requested. Do we mandate the first client defines the
8562 // HAL sampling rate and channel count or do we allow changes on the fly?
8563 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
8564 samplingRate = value;
8565 reconfig = true;
8566 }
8567 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung97a893e2015-03-29 01:03:07 -07008568 if (!audio_is_linear_pcm((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07008569 status = BAD_VALUE;
8570 } else {
8571 reqFormat = (audio_format_t) value;
Eric Laurent81784c32012-11-19 14:55:58 -08008572 reconfig = true;
8573 }
Eric Laurent10351942014-05-08 18:49:52 -07008574 }
8575 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
8576 audio_channel_mask_t mask = (audio_channel_mask_t) value;
Andy Hungd330ee42015-04-20 13:23:41 -07008577 if (!audio_is_input_channel(mask) ||
Andy Hung936845a2021-06-08 00:09:06 -07008578 audio_channel_count_from_in_mask(mask) > FCC_LIMIT) {
Eric Laurent10351942014-05-08 18:49:52 -07008579 status = BAD_VALUE;
8580 } else {
8581 channelMask = mask;
8582 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008583 }
Eric Laurent10351942014-05-08 18:49:52 -07008584 }
8585 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
8586 // do not accept frame count changes if tracks are open as the track buffer
8587 // size depends on frame count and correct behavior would not be guaranteed
8588 // if frame count is changed after track creation
8589 if (mActiveTracks.size() > 0) {
8590 status = INVALID_OPERATION;
8591 } else {
8592 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008593 }
Eric Laurent10351942014-05-08 18:49:52 -07008594 }
8595 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07008596 LOG_FATAL("Should not set routing device in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07008597 }
8598 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
8599 mAudioSource != (audio_source_t)value) {
jiabinc52b1ff2019-10-31 17:20:42 -07008600 LOG_FATAL("Should not set audio source in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07008601 }
Glenn Kastene198c362013-08-13 09:13:36 -07008602
Eric Laurent10351942014-05-08 18:49:52 -07008603 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008604 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008605 if (status == INVALID_OPERATION) {
8606 inputStandBy();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008607 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008608 }
8609 if (reconfig) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008610 if (status == BAD_VALUE) {
Mikhail Naganov560637e2021-03-31 22:40:13 +00008611 audio_config_base_t config = AUDIO_CONFIG_BASE_INITIALIZER;
8612 if (mInput->stream->getAudioProperties(&config) == OK &&
8613 audio_is_linear_pcm(config.format) && audio_is_linear_pcm(reqFormat) &&
8614 config.sample_rate <= (AUDIO_RESAMPLER_DOWN_RATIO_MAX * samplingRate) &&
Andy Hung936845a2021-06-08 00:09:06 -07008615 audio_channel_count_from_in_mask(config.channel_mask) <= FCC_LIMIT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008616 status = NO_ERROR;
8617 }
Eric Laurent81784c32012-11-19 14:55:58 -08008618 }
Eric Laurent10351942014-05-08 18:49:52 -07008619 if (status == NO_ERROR) {
8620 readInputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07008621 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
Eric Laurent81784c32012-11-19 14:55:58 -08008622 }
8623 }
Eric Laurent81784c32012-11-19 14:55:58 -08008624 }
Eric Laurent10351942014-05-08 18:49:52 -07008625
Eric Laurent81784c32012-11-19 14:55:58 -08008626 return reconfig;
8627}
8628
8629String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
8630{
Eric Laurent81784c32012-11-19 14:55:58 -08008631 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008632 if (initCheck() == NO_ERROR) {
8633 String8 out_s8;
8634 if (mInput->stream->getParameters(keys, &out_s8) == OK) {
8635 return out_s8;
8636 }
Eric Laurent81784c32012-11-19 14:55:58 -08008637 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008638 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08008639}
8640
Eric Laurent09f1ed22019-04-24 17:45:17 -07008641void AudioFlinger::RecordThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
8642 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008643 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
8644
8645 desc->mIoHandle = mId;
Eric Laurent81784c32012-11-19 14:55:58 -08008646
8647 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008648 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07008649 case AUDIO_INPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07008650 case AUDIO_INPUT_CONFIG_CHANGED:
Eric Laurent296fb132015-05-01 11:38:42 -07008651 desc->mPatch = mPatch;
Eric Laurent73e26b62015-04-27 16:55:58 -07008652 desc->mChannelMask = mChannelMask;
8653 desc->mSamplingRate = mSampleRate;
8654 desc->mFormat = mFormat;
8655 desc->mFrameCount = mFrameCount;
Glenn Kasten4a8308b2016-04-18 14:10:01 -07008656 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07008657 desc->mLatency = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008658 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07008659 case AUDIO_CLIENT_STARTED:
8660 desc->mPatch = mPatch;
8661 desc->mPortId = portId;
8662 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07008663 case AUDIO_INPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08008664 default:
8665 break;
8666 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07008667 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08008668}
8669
Glenn Kastendeca2ae2014-02-07 10:25:56 -08008670void AudioFlinger::RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08008671{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008672 status_t result = mInput->stream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
8673 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
Andy Hung463be252014-07-10 16:56:07 -07008674 mFormat = mHALFormat;
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008675 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
8676 if (audio_is_linear_pcm(mFormat)) {
Andy Hung936845a2021-06-08 00:09:06 -07008677 LOG_ALWAYS_FATAL_IF(mChannelCount > FCC_LIMIT, "HAL channel count %d > %d",
8678 mChannelCount, FCC_LIMIT);
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008679 } else {
Andy Hung936845a2021-06-08 00:09:06 -07008680 // Can have more that FCC_LIMIT channels in encoded streams.
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008681 ALOGI("HAL format %#x is not linear pcm", mFormat);
8682 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008683 result = mInput->stream->getFrameSize(&mFrameSize);
8684 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -07008685 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
8686 mFrameSize);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008687 result = mInput->stream->getBufferSize(&mBufferSize);
8688 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
Glenn Kasten548efc92012-11-29 08:48:51 -08008689 mFrameCount = mBufferSize / mFrameSize;
Hayden Gomes1a89ab32020-06-12 11:05:47 -07008690 ALOGV("%p RecordThread params: mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
8691 "mBufferSize=%zu, mFrameCount=%zu",
8692 this, mChannelCount, mFormat, mFrameSize, mBufferSize, mFrameCount);
Glenn Kasten49d00ad2014-07-21 11:22:03 -07008693
Eric Laurentec376dc2021-04-08 20:41:22 +02008694 // mRsmpInFrames must be 0 before calling resizeInputBuffer_l for the first time
8695 mRsmpInFrames = 0;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008696 resizeInputBuffer_l(0 /*maxSharedAudioHistoryMs*/);
Eric Laurent81784c32012-11-19 14:55:58 -08008697
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008698 // AudioRecord mSampleRate and mChannelCount are constant due to AudioRecord API constraints.
8699 // But if thread's mSampleRate or mChannelCount changes, how will that affect active tracks?
Andy Hungea840382020-05-05 21:50:17 -07008700
8701 audio_input_flags_t flags = mInput->flags;
8702 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
8703 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
8704 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
8705 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
8706 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
8707 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
8708 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
8709 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
8710 .record();
Eric Laurent81784c32012-11-19 14:55:58 -08008711}
8712
Glenn Kasten5f972c02014-01-13 09:59:31 -08008713uint32_t AudioFlinger::RecordThread::getInputFramesLost()
Eric Laurent81784c32012-11-19 14:55:58 -08008714{
8715 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008716 uint32_t result;
8717 if (initCheck() == NO_ERROR && mInput->stream->getInputFramesLost(&result) == OK) {
8718 return result;
Eric Laurent81784c32012-11-19 14:55:58 -08008719 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008720 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008721}
8722
Glenn Kastend848eb42016-03-08 13:42:11 -08008723KeyedVector<audio_session_t, bool> AudioFlinger::RecordThread::sessionIds() const
Eric Laurent81784c32012-11-19 14:55:58 -08008724{
Glenn Kastend848eb42016-03-08 13:42:11 -08008725 KeyedVector<audio_session_t, bool> ids;
Eric Laurent81784c32012-11-19 14:55:58 -08008726 Mutex::Autolock _l(mLock);
8727 for (size_t j = 0; j < mTracks.size(); ++j) {
8728 sp<RecordThread::RecordTrack> track = mTracks[j];
Glenn Kastend848eb42016-03-08 13:42:11 -08008729 audio_session_t sessionId = track->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08008730 if (ids.indexOfKey(sessionId) < 0) {
8731 ids.add(sessionId, true);
8732 }
8733 }
8734 return ids;
8735}
8736
8737AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
8738{
8739 Mutex::Autolock _l(mLock);
8740 AudioStreamIn *input = mInput;
8741 mInput = NULL;
8742 return input;
8743}
8744
8745// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008746sp<StreamHalInterface> AudioFlinger::RecordThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08008747{
8748 if (mInput == NULL) {
8749 return NULL;
8750 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008751 return mInput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08008752}
8753
8754status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
8755{
Eric Laurent81784c32012-11-19 14:55:58 -08008756 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
Eric Laurentaaa44472014-09-12 17:41:50 -07008757 chain->setThread(this);
Eric Laurent81784c32012-11-19 14:55:58 -08008758 chain->setInBuffer(NULL);
8759 chain->setOutBuffer(NULL);
8760
8761 checkSuspendOnAddEffectChain_l(chain);
8762
Eric Laurent1b928682014-10-02 19:41:47 -07008763 // make sure enabled pre processing effects state is communicated to the HAL as we
8764 // just moved them to a new input stream.
8765 chain->syncHalEffectsState();
8766
Eric Laurent81784c32012-11-19 14:55:58 -08008767 mEffectChains.add(chain);
8768
8769 return NO_ERROR;
8770}
8771
8772size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
8773{
8774 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008775
8776 for (size_t i = 0; i < mEffectChains.size(); i++) {
8777 if (chain == mEffectChains[i]) {
8778 mEffectChains.removeAt(i);
8779 break;
8780 }
Eric Laurent81784c32012-11-19 14:55:58 -08008781 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008782 return mEffectChains.size();
Eric Laurent81784c32012-11-19 14:55:58 -08008783}
8784
Eric Laurent1c333e22014-05-20 10:48:17 -07008785status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
8786 audio_patch_handle_t *handle)
8787{
8788 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008789
8790 // store new device and send to effects
jiabinc52b1ff2019-10-31 17:20:42 -07008791 mInDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
jiabin0a488932020-08-07 17:32:40 -07008792 mInDeviceTypeAddr.setAddress(patch->sources[0].ext.device.address);
François Gaffie0c280aa2018-07-25 10:02:15 +02008793 audio_port_handle_t deviceId = patch->sources[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07008794 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08008795 mEffectChains[i]->setInputDevice_l(inDeviceTypeAddr());
Eric Laurent054d9d32015-04-24 08:48:48 -07008796 }
8797
Eric Laurentd8365c52017-07-16 15:27:05 -07008798 checkBtNrec_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07008799
8800 // store new source and send to effects
8801 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
8802 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
Eric Laurent1c333e22014-05-20 10:48:17 -07008803 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurent054d9d32015-04-24 08:48:48 -07008804 mEffectChains[i]->setAudioSource_l(mAudioSource);
Eric Laurent1c333e22014-05-20 10:48:17 -07008805 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008806 }
Eric Laurent1c333e22014-05-20 10:48:17 -07008807
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008808 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008809 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8810 status = hwDevice->createAudioPatch(patch->num_sources,
8811 patch->sources,
8812 patch->num_sinks,
8813 patch->sinks,
8814 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008815 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008816 char *address;
8817 if (strcmp(patch->sources[0].ext.device.address, "") != 0) {
8818 address = audio_device_address_to_parameter(
8819 patch->sources[0].ext.device.type,
8820 patch->sources[0].ext.device.address);
8821 } else {
8822 address = (char *)calloc(1, 1);
8823 }
8824 AudioParameter param = AudioParameter(String8(address));
8825 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008826 param.addInt(String8(AudioParameter::keyRouting),
Eric Laurent054d9d32015-04-24 08:48:48 -07008827 (int)patch->sources[0].ext.device.type);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008828 param.addInt(String8(AudioParameter::keyInputSource),
Eric Laurent054d9d32015-04-24 08:48:48 -07008829 (int)patch->sinks[0].ext.mix.usecase.source);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008830 status = mInput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07008831 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07008832 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008833
jiabinc52b1ff2019-10-31 17:20:42 -07008834 if ((mPatch.num_sources == 0) || (mPatch.sources[0].id != deviceId)) {
Eric Laurente8726fe2015-06-26 09:39:24 -07008835 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
jiabinc52b1ff2019-10-31 17:20:42 -07008836 mPatch = *patch;
Eric Laurente8726fe2015-06-26 09:39:24 -07008837 }
Eric Laurent296fb132015-05-01 11:38:42 -07008838
Andy Hungc2b11cb2020-04-22 09:04:01 -07008839 const std::string pathSourcesAsString = patchSourcesToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07008840 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07008841 mThreadMetrics.logCreatePatch(pathSourcesAsString, /* outDevices */ {});
Andy Hungcf10d742020-04-28 15:38:24 -07008842 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07008843 // also dispatch to active AudioRecords
8844 for (const auto &track : mActiveTracks) {
8845 track->logEndInterval();
8846 track->logBeginInterval(pathSourcesAsString);
8847 }
Eric Laurent1c333e22014-05-20 10:48:17 -07008848 return status;
8849}
8850
8851status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
8852{
8853 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008854
jiabinc52b1ff2019-10-31 17:20:42 -07008855 mPatch = audio_patch{};
8856 mInDeviceTypeAddr.reset();
Eric Laurent054d9d32015-04-24 08:48:48 -07008857
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008858 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008859 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8860 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008861 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008862 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07008863 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008864 status = mInput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07008865 }
8866 return status;
8867}
8868
jiabinc52b1ff2019-10-31 17:20:42 -07008869void AudioFlinger::RecordThread::updateOutDevices(const DeviceDescriptorBaseVector& outDevices)
8870{
wendy lin56aa82b2020-12-02 15:19:55 +08008871 Mutex::Autolock _l(mLock);
jiabinc52b1ff2019-10-31 17:20:42 -07008872 mOutDevices = outDevices;
8873 mOutDeviceTypeAddrs = deviceTypeAddrsFromDescriptors(mOutDevices);
8874 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08008875 mEffectChains[i]->setDevices_l(outDeviceTypeAddrs());
jiabinc52b1ff2019-10-31 17:20:42 -07008876 }
8877}
8878
Eric Laurentec376dc2021-04-08 20:41:22 +02008879int32_t AudioFlinger::RecordThread::getOldestFront_l()
8880{
8881 if (mTracks.size() == 0) {
8882 return 0;
8883 }
Eric Laurent2407ce32021-04-26 14:56:03 +02008884 int32_t oldestFront = mRsmpInRear;
8885 int32_t maxFilled = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02008886 for (size_t i = 0; i < mTracks.size(); i++) {
Eric Laurent2407ce32021-04-26 14:56:03 +02008887 int32_t front = mTracks[i]->mResamplerBufferProvider->getFront();
8888 int32_t filled;
8889 if (front <= mRsmpInRear) {
8890 filled = mRsmpInRear - front;
8891 } else {
8892 filled = (int32_t)((int64_t)mRsmpInRear + UINT32_MAX + 1 - front);
8893 }
8894 if (filled > maxFilled) {
8895 oldestFront = front;
8896 maxFilled = filled;
8897 }
Eric Laurentec376dc2021-04-08 20:41:22 +02008898 }
Eric Laurent2407ce32021-04-26 14:56:03 +02008899 return oldestFront;
Eric Laurentec376dc2021-04-08 20:41:22 +02008900}
8901
8902void AudioFlinger::RecordThread::updateFronts_l(int32_t offset)
8903{
8904 if (offset == 0) {
8905 return;
8906 }
8907 for (size_t i = 0; i < mTracks.size(); i++) {
8908 int32_t front = mTracks[i]->mResamplerBufferProvider->getFront();
8909 front = audio_utils::safe_sub_overflow(front, offset);
8910 mTracks[i]->mResamplerBufferProvider->setFront(front);
8911 }
8912}
8913
8914void AudioFlinger::RecordThread::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs)
8915{
8916 // This is the formula for calculating the temporary buffer size.
8917 // With 7 HAL buffers, we can guarantee ability to down-sample the input by ratio of 6:1 to
8918 // 1 full output buffer, regardless of the alignment of the available input.
8919 // The value is somewhat arbitrary, and could probably be even larger.
8920 // A larger value should allow more old data to be read after a track calls start(),
8921 // without increasing latency.
8922 //
8923 // Note this is independent of the maximum downsampling ratio permitted for capture.
8924 size_t minRsmpInFrames = mFrameCount * 7;
8925
8926 // maxSharedAudioHistoryMs != 0 indicates a request to possibly make some part of the audio
8927 // capture history available to another client using the same session ID:
8928 // dimension the resampler input buffer accordingly.
8929
8930 // Get oldest client read position: getOldestFront_l() must be called before altering
8931 // mRsmpInRear, or mRsmpInFrames
8932 int32_t previousFront = getOldestFront_l();
8933 size_t previousRsmpInFramesP2 = mRsmpInFramesP2;
8934 int32_t previousRear = mRsmpInRear;
8935 mRsmpInRear = 0;
8936
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008937 ALOG_ASSERT(maxSharedAudioHistoryMs >= 0
8938 && maxSharedAudioHistoryMs <= AudioFlinger::kMaxSharedAudioHistoryMs,
8939 "resizeInputBuffer_l() called with invalid max shared history %d",
8940 maxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +02008941 if (maxSharedAudioHistoryMs != 0) {
8942 // resizeInputBuffer_l should never be called with a non zero shared history if the
8943 // buffer was not already allocated
8944 ALOG_ASSERT(mRsmpInBuffer != nullptr && mRsmpInFrames != 0,
8945 "resizeInputBuffer_l() called with shared history and unallocated buffer");
8946 size_t rsmpInFrames = (size_t)maxSharedAudioHistoryMs * mSampleRate / 1000;
8947 // never reduce resampler input buffer size
8948 if (rsmpInFrames < mRsmpInFrames) {
8949 return;
8950 }
8951 mRsmpInFrames = rsmpInFrames;
8952 }
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02008953 mMaxSharedAudioHistoryMs = maxSharedAudioHistoryMs;
Eric Laurentec376dc2021-04-08 20:41:22 +02008954 // Note: mRsmpInFrames is 0 when called with maxSharedAudioHistoryMs equals to 0 so it is always
8955 // initialized
8956 if (mRsmpInFrames < minRsmpInFrames) {
8957 mRsmpInFrames = minRsmpInFrames;
8958 }
8959 mRsmpInFramesP2 = roundup(mRsmpInFrames);
8960
8961 // TODO optimize audio capture buffer sizes ...
8962 // Here we calculate the size of the sliding buffer used as a source
8963 // for resampling. mRsmpInFramesP2 is currently roundup(mFrameCount * 7).
8964 // For current HAL frame counts, this is usually 2048 = 40 ms. It would
8965 // be better to have it derived from the pipe depth in the long term.
8966 // The current value is higher than necessary. However it should not add to latency.
8967
8968 // Over-allocate beyond mRsmpInFramesP2 to permit a HAL read past end of buffer
8969 mRsmpInFramesOA = mRsmpInFramesP2 + mFrameCount - 1;
8970
8971 void *rsmpInBuffer;
8972 (void)posix_memalign(&rsmpInBuffer, 32, mRsmpInFramesOA * mFrameSize);
8973 // if posix_memalign fails, will segv here.
8974 memset(rsmpInBuffer, 0, mRsmpInFramesOA * mFrameSize);
8975
8976 // Copy audio history if any from old buffer before freeing it
8977 if (previousRear != 0) {
8978 ALOG_ASSERT(mRsmpInBuffer != nullptr,
8979 "resizeInputBuffer_l() called with null buffer but frames already read from HAL");
8980
8981 ssize_t unread = audio_utils::safe_sub_overflow(previousRear, previousFront);
8982 previousFront &= previousRsmpInFramesP2 - 1;
8983 size_t part1 = previousRsmpInFramesP2 - previousFront;
8984 if (part1 > (size_t) unread) {
8985 part1 = unread;
8986 }
8987 if (part1 != 0) {
8988 memcpy(rsmpInBuffer, (const uint8_t*)mRsmpInBuffer + previousFront * mFrameSize,
8989 part1 * mFrameSize);
8990 mRsmpInRear = part1;
8991 part1 = unread - part1;
8992 if (part1 != 0) {
8993 memcpy((uint8_t*)rsmpInBuffer + mRsmpInRear * mFrameSize,
8994 (const uint8_t*)mRsmpInBuffer, part1 * mFrameSize);
8995 mRsmpInRear += part1;
8996 }
8997 }
8998 // Update front for all clients according to new rear
8999 updateFronts_l(audio_utils::safe_sub_overflow(previousRear, mRsmpInRear));
9000 } else {
9001 mRsmpInRear = 0;
9002 }
9003 free(mRsmpInBuffer);
9004 mRsmpInBuffer = rsmpInBuffer;
9005}
9006
Mikhail Naganov444ecc32018-05-01 17:40:05 -07009007void AudioFlinger::RecordThread::addPatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07009008{
9009 Mutex::Autolock _l(mLock);
9010 mTracks.add(record);
Mikhail Naganov2534b382019-09-25 13:05:02 -07009011 if (record->getSource()) {
9012 mSource = record->getSource();
9013 }
Eric Laurent83b88082014-06-20 18:31:16 -07009014}
9015
Mikhail Naganov444ecc32018-05-01 17:40:05 -07009016void AudioFlinger::RecordThread::deletePatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07009017{
9018 Mutex::Autolock _l(mLock);
Mikhail Naganov2534b382019-09-25 13:05:02 -07009019 if (mSource == record->getSource()) {
9020 mSource = mInput;
9021 }
Eric Laurent83b88082014-06-20 18:31:16 -07009022 destroyTrack_l(record);
9023}
9024
Mikhail Naganovdc769682018-05-04 15:34:08 -07009025void AudioFlinger::RecordThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07009026{
Mikhail Naganovdc769682018-05-04 15:34:08 -07009027 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07009028 config->role = AUDIO_PORT_ROLE_SINK;
9029 config->ext.mix.hw_module = mInput->audioHwDev->handle();
9030 config->ext.mix.usecase.source = mAudioSource;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009031 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
9032 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9033 config->flags.input = mInput->flags;
9034 }
Eric Laurent83b88082014-06-20 18:31:16 -07009035}
Eric Laurent1c333e22014-05-20 10:48:17 -07009036
Eric Laurent6acd1d42017-01-04 14:23:29 -08009037// ----------------------------------------------------------------------------
9038// Mmap
9039// ----------------------------------------------------------------------------
9040
9041AudioFlinger::MmapThreadHandle::MmapThreadHandle(const sp<MmapThread>& thread)
9042 : mThread(thread)
9043{
Phil Burk9fabbf82017-08-03 12:02:00 -07009044 assert(thread != 0); // thread must start non-null and stay non-null
Eric Laurent6acd1d42017-01-04 14:23:29 -08009045}
9046
9047AudioFlinger::MmapThreadHandle::~MmapThreadHandle()
9048{
Phil Burk9fabbf82017-08-03 12:02:00 -07009049 mThread->disconnect();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009050}
9051
9052status_t AudioFlinger::MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
9053 struct audio_mmap_buffer_info *info)
9054{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009055 return mThread->createMmapBuffer(minSizeFrames, info);
9056}
9057
9058status_t AudioFlinger::MmapThreadHandle::getMmapPosition(struct audio_mmap_position *position)
9059{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009060 return mThread->getMmapPosition(position);
9061}
9062
jiabinb7d8c5a2020-08-26 17:24:52 -07009063status_t AudioFlinger::MmapThreadHandle::getExternalPosition(uint64_t *position,
9064 int64_t *timeNanos) {
9065 return mThread->getExternalPosition(position, timeNanos);
9066}
9067
Eric Laurenta54f1282017-07-01 19:39:32 -07009068status_t AudioFlinger::MmapThreadHandle::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07009069 const audio_attributes_t *attr, audio_port_handle_t *handle)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009070
9071{
jiabind1f1cb62020-03-24 11:57:57 -07009072 return mThread->start(client, attr, handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009073}
9074
9075status_t AudioFlinger::MmapThreadHandle::stop(audio_port_handle_t handle)
9076{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009077 return mThread->stop(handle);
9078}
9079
Eric Laurent18b57012017-02-13 16:23:52 -08009080status_t AudioFlinger::MmapThreadHandle::standby()
9081{
Eric Laurent18b57012017-02-13 16:23:52 -08009082 return mThread->standby();
9083}
9084
Eric Laurent6acd1d42017-01-04 14:23:29 -08009085
9086AudioFlinger::MmapThread::MmapThread(
9087 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -07009088 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, bool systemReady, bool isOut)
Andy Hungea840382020-05-05 21:50:17 -07009089 : ThreadBase(audioFlinger, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009090 mSessionId(AUDIO_SESSION_NONE),
François Gaffie0c280aa2018-07-25 10:02:15 +02009091 mPortId(AUDIO_PORT_HANDLE_NONE),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009092 mHalStream(stream), mHalDevice(hwDev->hwDevice()), mAudioHwDev(hwDev),
Eric Laurent67f97292018-04-20 18:05:41 -07009093 mActiveTracks(&this->mLocalLog),
9094 mHalVolFloat(-1.0f), // Initialize to illegal value so it always gets set properly later.
9095 mNoCallbackWarningCount(0)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009096{
Eric Laurent18b57012017-02-13 16:23:52 -08009097 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009098 readHalParameters_l();
9099}
9100
9101AudioFlinger::MmapThread::~MmapThread()
9102{
9103}
9104
9105void AudioFlinger::MmapThread::onFirstRef()
9106{
9107 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
9108}
9109
9110void AudioFlinger::MmapThread::disconnect()
9111{
Eric Laurent331679c2018-04-16 17:03:16 -07009112 ActiveTracks<MmapTrack> activeTracks;
9113 {
9114 Mutex::Autolock _l(mLock);
9115 for (const sp<MmapTrack> &t : mActiveTracks) {
9116 activeTracks.add(t);
9117 }
9118 }
9119 for (const sp<MmapTrack> &t : activeTracks) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009120 stop(t->portId());
9121 }
Phil Burk9fabbf82017-08-03 12:02:00 -07009122 // This will decrement references and may cause the destruction of this thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08009123 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07009124 AudioSystem::releaseOutput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009125 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08009126 AudioSystem::releaseInput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009127 }
9128}
9129
9130
9131void AudioFlinger::MmapThread::configure(const audio_attributes_t *attr,
9132 audio_stream_type_t streamType __unused,
9133 audio_session_t sessionId,
9134 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009135 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009136 audio_port_handle_t portId)
9137{
9138 mAttr = *attr;
9139 mSessionId = sessionId;
9140 mCallback = callback;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009141 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009142 mPortId = portId;
9143}
9144
9145status_t AudioFlinger::MmapThread::createMmapBuffer(int32_t minSizeFrames,
9146 struct audio_mmap_buffer_info *info)
9147{
9148 if (mHalStream == 0) {
9149 return NO_INIT;
9150 }
Eric Laurent18b57012017-02-13 16:23:52 -08009151 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009152 return mHalStream->createMmapBuffer(minSizeFrames, info);
9153}
9154
9155status_t AudioFlinger::MmapThread::getMmapPosition(struct audio_mmap_position *position)
9156{
9157 if (mHalStream == 0) {
9158 return NO_INIT;
9159 }
9160 return mHalStream->getMmapPosition(position);
9161}
9162
Eric Laurent331679c2018-04-16 17:03:16 -07009163status_t AudioFlinger::MmapThread::exitStandby()
9164{
9165 status_t ret = mHalStream->start();
9166 if (ret != NO_ERROR) {
9167 ALOGE("%s: error mHalStream->start() = %d for first track", __FUNCTION__, ret);
9168 return ret;
9169 }
Andy Hungcf10d742020-04-28 15:38:24 -07009170 if (mStandby) {
9171 mThreadMetrics.logBeginInterval();
9172 mStandby = false;
9173 }
Eric Laurent331679c2018-04-16 17:03:16 -07009174 return NO_ERROR;
9175}
9176
Eric Laurenta54f1282017-07-01 19:39:32 -07009177status_t AudioFlinger::MmapThread::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07009178 const audio_attributes_t *attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009179 audio_port_handle_t *handle)
9180{
Eric Laurenta54f1282017-07-01 19:39:32 -07009181 ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
Svet Ganov33761132021-05-13 22:51:08 +00009182 client.attributionSource.uid, mStandby, mPortId, *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009183 if (mHalStream == 0) {
9184 return NO_INIT;
9185 }
9186
9187 status_t ret;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009188
Eric Laurenta54f1282017-07-01 19:39:32 -07009189 if (*handle == mPortId) {
Phil Burk98ab4082020-09-25 21:46:34 +00009190 // For the first track, reuse portId and session allocated when the stream was opened.
9191 ret = exitStandby();
9192 if (ret == NO_ERROR) {
9193 acquireWakeLock();
9194 }
9195 return ret;
Eric Laurenta54f1282017-07-01 19:39:32 -07009196 }
9197
9198 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
9199
9200 audio_io_handle_t io = mId;
9201 if (isOutput()) {
9202 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
9203 config.sample_rate = mSampleRate;
9204 config.channel_mask = mChannelMask;
9205 config.format = mFormat;
9206 audio_stream_type_t stream = streamType();
9207 audio_output_flags_t flags =
9208 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009209 audio_port_handle_t deviceId = mDeviceId;
Kevin Rocard153f92d2018-12-18 18:33:28 -08009210 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurenta54f1282017-07-01 19:39:32 -07009211 ret = AudioSystem::getOutputForAttr(&mAttr, &io,
9212 mSessionId,
9213 &stream,
Svet Ganov33761132021-05-13 22:51:08 +00009214 client.attributionSource,
Eric Laurenta54f1282017-07-01 19:39:32 -07009215 &config,
9216 flags,
9217 &deviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08009218 &portId,
9219 &secondaryOutputs);
9220 ALOGD_IF(!secondaryOutputs.empty(),
9221 "MmapThread::start does not support secondary outputs, ignoring them");
Eric Laurent6acd1d42017-01-04 14:23:29 -08009222 } else {
Eric Laurenta54f1282017-07-01 19:39:32 -07009223 audio_config_base_t config;
9224 config.sample_rate = mSampleRate;
9225 config.channel_mask = mChannelMask;
9226 config.format = mFormat;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009227 audio_port_handle_t deviceId = mDeviceId;
Eric Laurenta54f1282017-07-01 19:39:32 -07009228 ret = AudioSystem::getInputForAttr(&mAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -07009229 RECORD_RIID_INVALID,
Eric Laurenta54f1282017-07-01 19:39:32 -07009230 mSessionId,
Svet Ganov33761132021-05-13 22:51:08 +00009231 client.attributionSource,
Eric Laurenta54f1282017-07-01 19:39:32 -07009232 &config,
9233 AUDIO_INPUT_FLAG_MMAP_NOIRQ,
9234 &deviceId,
9235 &portId);
9236 }
9237 // APM should not chose a different input or output stream for the same set of attributes
9238 // and audo configuration
9239 if (ret != NO_ERROR || io != mId) {
9240 ALOGE("%s: error getting output or input from APM (error %d, io %d expected io %d)",
9241 __FUNCTION__, ret, io, mId);
9242 return BAD_VALUE;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009243 }
9244
9245 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07009246 ret = AudioSystem::startOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009247 } else {
Eric Laurent4eb58f12018-12-07 16:41:02 -08009248 ret = AudioSystem::startInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009249 }
9250
Eric Laurent331679c2018-04-16 17:03:16 -07009251 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009252 // abort if start is rejected by audio policy manager
9253 if (ret != NO_ERROR) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08009254 ALOGE("%s: error start rejected by AudioPolicyManager = %d", __FUNCTION__, ret);
Eric Tan39ec8d62018-07-24 09:49:29 -07009255 if (!mActiveTracks.isEmpty()) {
Eric Laurent331679c2018-04-16 17:03:16 -07009256 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009257 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07009258 AudioSystem::releaseOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009259 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08009260 AudioSystem::releaseInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009261 }
Eric Laurent331679c2018-04-16 17:03:16 -07009262 mLock.lock();
Eric Laurent18b57012017-02-13 16:23:52 -08009263 } else {
9264 mHalStream->stop();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009265 }
9266 return PERMISSION_DENIED;
9267 }
9268
Kevin Rocard1f564ac2018-03-29 13:53:10 -07009269 // Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
jiabind1f1cb62020-03-24 11:57:57 -07009270 sp<MmapTrack> track = new MmapTrack(this, attr == nullptr ? mAttr : *attr, mSampleRate, mFormat,
Svet Ganov33761132021-05-13 22:51:08 +00009271 mChannelMask, mSessionId, isOutput(),
9272 client.attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07009273 IPCThreadState::self()->getCallingPid(), portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009274
Eric Laurent4eb58f12018-12-07 16:41:02 -08009275 if (isOutput()) {
9276 // force volume update when a new track is added
9277 mHalVolFloat = -1.0f;
9278 } else if (!track->isSilenced_l()) {
9279 for (const sp<MmapTrack> &t : mActiveTracks) {
Svet Ganov33761132021-05-13 22:51:08 +00009280 if (t->isSilenced_l() && t->uid() != client.attributionSource.uid)
Eric Laurent4eb58f12018-12-07 16:41:02 -08009281 t->invalidate();
9282 }
9283 }
9284
9285
Eric Laurent6acd1d42017-01-04 14:23:29 -08009286 mActiveTracks.add(track);
Eric Laurenta54f1282017-07-01 19:39:32 -07009287 sp<EffectChain> chain = getEffectChain_l(mSessionId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009288 if (chain != 0) {
9289 chain->setStrategy(AudioSystem::getStrategyForStream(streamType()));
9290 chain->incTrackCnt();
9291 chain->incActiveTrackCnt();
9292 }
9293
Andy Hungc2b11cb2020-04-22 09:04:01 -07009294 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent6acd1d42017-01-04 14:23:29 -08009295 *handle = portId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009296 broadcast_l();
9297
Eric Laurenta54f1282017-07-01 19:39:32 -07009298 ALOGV("%s DONE handle %d stream %p", __FUNCTION__, *handle, mHalStream.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08009299
9300 return NO_ERROR;
9301}
9302
9303status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
9304{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009305 ALOGV("%s handle %d", __FUNCTION__, handle);
9306
9307 if (mHalStream == 0) {
9308 return NO_INIT;
9309 }
9310
Eric Laurenta54f1282017-07-01 19:39:32 -07009311 if (handle == mPortId) {
9312 mHalStream->stop();
Phil Burk98ab4082020-09-25 21:46:34 +00009313 releaseWakeLock();
Eric Laurenta54f1282017-07-01 19:39:32 -07009314 return NO_ERROR;
9315 }
9316
Eric Laurent331679c2018-04-16 17:03:16 -07009317 Mutex::Autolock _l(mLock);
9318
Eric Laurent6acd1d42017-01-04 14:23:29 -08009319 sp<MmapTrack> track;
9320 for (const sp<MmapTrack> &t : mActiveTracks) {
9321 if (handle == t->portId()) {
9322 track = t;
9323 break;
9324 }
9325 }
9326 if (track == 0) {
9327 return BAD_VALUE;
9328 }
9329
9330 mActiveTracks.remove(track);
9331
Eric Laurent331679c2018-04-16 17:03:16 -07009332 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009333 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07009334 AudioSystem::stopOutput(track->portId());
9335 AudioSystem::releaseOutput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08009336 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08009337 AudioSystem::stopInput(track->portId());
9338 AudioSystem::releaseInput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08009339 }
Eric Laurent331679c2018-04-16 17:03:16 -07009340 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009341
9342 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
9343 if (chain != 0) {
9344 chain->decActiveTrackCnt();
9345 chain->decTrackCnt();
9346 }
9347
9348 broadcast_l();
9349
Eric Laurent6acd1d42017-01-04 14:23:29 -08009350 return NO_ERROR;
9351}
9352
Eric Laurent18b57012017-02-13 16:23:52 -08009353status_t AudioFlinger::MmapThread::standby()
9354{
9355 ALOGV("%s", __FUNCTION__);
9356
9357 if (mHalStream == 0) {
9358 return NO_INIT;
9359 }
Eric Tan39ec8d62018-07-24 09:49:29 -07009360 if (!mActiveTracks.isEmpty()) {
Eric Laurent18b57012017-02-13 16:23:52 -08009361 return INVALID_OPERATION;
9362 }
9363 mHalStream->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07009364 if (!mStandby) {
9365 mThreadMetrics.logEndInterval();
9366 mStandby = true;
9367 }
Eric Laurent18b57012017-02-13 16:23:52 -08009368 releaseWakeLock();
9369 return NO_ERROR;
9370}
9371
Eric Laurent6acd1d42017-01-04 14:23:29 -08009372
9373void AudioFlinger::MmapThread::readHalParameters_l()
9374{
9375 status_t result = mHalStream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
9376 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
9377 mFormat = mHALFormat;
9378 LOG_ALWAYS_FATAL_IF(!audio_is_linear_pcm(mFormat), "HAL format %#x is not linear pcm", mFormat);
9379 result = mHalStream->getFrameSize(&mFrameSize);
9380 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -07009381 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
9382 mFrameSize);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009383 result = mHalStream->getBufferSize(&mBufferSize);
9384 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
9385 mFrameCount = mBufferSize / mFrameSize;
Andy Hungc2b11cb2020-04-22 09:04:01 -07009386
Andy Hungcf10d742020-04-28 15:38:24 -07009387 // TODO: make a readHalParameters call?
9388 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
Andy Hungc2b11cb2020-04-22 09:04:01 -07009389 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
9390 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
9391 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
9392 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
9393 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
9394 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
9395 /*
9396 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
9397 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
9398 (int32_t)mHapticChannelMask)
9399 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
9400 (int32_t)mHapticChannelCount)
9401 */
9402 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
9403 formatToString(mHALFormat).c_str())
9404 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
9405 (int32_t)mFrameCount) // sic - added HAL
9406 .record();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009407}
9408
9409bool AudioFlinger::MmapThread::threadLoop()
9410{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009411 checkSilentMode_l();
9412
9413 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
9414
9415 while (!exitPending())
9416 {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009417 Vector< sp<EffectChain> > effectChains;
9418
Andy Hung13850be2019-03-14 11:33:09 -07009419 { // under Thread lock
9420 Mutex::Autolock _l(mLock);
9421
Eric Laurent6acd1d42017-01-04 14:23:29 -08009422 if (mSignalPending) {
9423 // A signal was raised while we were unlocked
9424 mSignalPending = false;
9425 } else {
9426 if (mConfigEvents.isEmpty()) {
9427 // we're about to wait, flush the binder command buffer
9428 IPCThreadState::self()->flushCommands();
9429
9430 if (exitPending()) {
9431 break;
9432 }
9433
Eric Laurent6acd1d42017-01-04 14:23:29 -08009434 // wait until we have something to do...
9435 ALOGV("%s going to sleep", myName.string());
9436 mWaitWorkCV.wait(mLock);
9437 ALOGV("%s waking up", myName.string());
Eric Laurent6acd1d42017-01-04 14:23:29 -08009438
9439 checkSilentMode_l();
9440
9441 continue;
9442 }
9443 }
9444
9445 processConfigEvents_l();
9446
9447 processVolume_l();
9448
9449 checkInvalidTracks_l();
9450
9451 mActiveTracks.updatePowerState(this);
9452
Kevin Rocard069c2712018-03-29 19:09:14 -07009453 updateMetadata_l();
9454
Eric Laurent6acd1d42017-01-04 14:23:29 -08009455 lockEffectChains_l(effectChains);
Andy Hung13850be2019-03-14 11:33:09 -07009456 } // release Thread lock
9457
Eric Laurent6acd1d42017-01-04 14:23:29 -08009458 for (size_t i = 0; i < effectChains.size(); i ++) {
Andy Hung13850be2019-03-14 11:33:09 -07009459 effectChains[i]->process_l(); // Thread is not locked, but effect chain is locked
Eric Laurent6acd1d42017-01-04 14:23:29 -08009460 }
Andy Hung13850be2019-03-14 11:33:09 -07009461
9462 // enable changes in effect chain, including moving to another thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08009463 unlockEffectChains(effectChains);
9464 // Effect chains will be actually deleted here if they were removed from
9465 // mEffectChains list during mixing or effects processing
9466 }
9467
9468 threadLoop_exit();
9469
9470 if (!mStandby) {
9471 threadLoop_standby();
9472 mStandby = true;
9473 }
9474
Eric Laurent6acd1d42017-01-04 14:23:29 -08009475 ALOGV("Thread %p type %d exiting", this, mType);
9476 return false;
9477}
9478
9479// checkForNewParameter_l() must be called with ThreadBase::mLock held
9480bool AudioFlinger::MmapThread::checkForNewParameter_l(const String8& keyValuePair,
9481 status_t& status)
9482{
9483 AudioParameter param = AudioParameter(keyValuePair);
9484 int value;
Eric Laurente6e9a482017-07-25 19:26:02 -07009485 bool sendToHal = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009486 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabinc52b1ff2019-10-31 17:20:42 -07009487 LOG_FATAL("Should not happen set routing device in MmapThread");
Eric Laurent6acd1d42017-01-04 14:23:29 -08009488 }
Eric Laurente6e9a482017-07-25 19:26:02 -07009489 if (sendToHal) {
9490 status = mHalStream->setParameters(keyValuePair);
9491 } else {
9492 status = NO_ERROR;
9493 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009494
9495 return false;
9496}
9497
9498String8 AudioFlinger::MmapThread::getParameters(const String8& keys)
9499{
9500 Mutex::Autolock _l(mLock);
9501 String8 out_s8;
9502 if (initCheck() == NO_ERROR && mHalStream->getParameters(keys, &out_s8) == OK) {
9503 return out_s8;
9504 }
9505 return String8();
9506}
9507
Eric Laurent09f1ed22019-04-24 17:45:17 -07009508void AudioFlinger::MmapThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
9509 audio_port_handle_t portId __unused) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009510 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
9511
9512 desc->mIoHandle = mId;
9513
9514 switch (event) {
9515 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07009516 case AUDIO_INPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08009517 case AUDIO_INPUT_CONFIG_CHANGED:
9518 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07009519 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08009520 case AUDIO_OUTPUT_CONFIG_CHANGED:
9521 desc->mPatch = mPatch;
9522 desc->mChannelMask = mChannelMask;
9523 desc->mSamplingRate = mSampleRate;
9524 desc->mFormat = mFormat;
9525 desc->mFrameCount = mFrameCount;
9526 desc->mFrameCountHAL = mFrameCount;
9527 desc->mLatency = 0;
9528 break;
9529
9530 case AUDIO_INPUT_CLOSED:
9531 case AUDIO_OUTPUT_CLOSED:
9532 default:
9533 break;
9534 }
9535 mAudioFlinger->ioConfigChanged(event, desc, pid);
9536}
9537
9538status_t AudioFlinger::MmapThread::createAudioPatch_l(const struct audio_patch *patch,
9539 audio_patch_handle_t *handle)
9540{
9541 status_t status = NO_ERROR;
9542
9543 // store new device and send to effects
9544 audio_devices_t type = AUDIO_DEVICE_NONE;
9545 audio_port_handle_t deviceId;
jiabinc52b1ff2019-10-31 17:20:42 -07009546 AudioDeviceTypeAddrVector sinkDeviceTypeAddrs;
9547 AudioDeviceTypeAddr sourceDeviceTypeAddr;
9548 uint32_t numDevices = 0;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009549 if (isOutput()) {
9550 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabinc52b1ff2019-10-31 17:20:42 -07009551 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
9552 && !mAudioHwDev->supportsAudioPatches(),
9553 "Enumerated device type(%#x) must not be used "
9554 "as it does not support audio patches",
9555 patch->sinks[i].ext.device.type);
Mikhail Naganov55773032020-10-01 15:08:13 -07009556 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
jiabinc52b1ff2019-10-31 17:20:42 -07009557 sinkDeviceTypeAddrs.push_back(AudioDeviceTypeAddr(patch->sinks[i].ext.device.type,
9558 patch->sinks[i].ext.device.address));
Eric Laurent6acd1d42017-01-04 14:23:29 -08009559 }
9560 deviceId = patch->sinks[0].id;
jiabinc52b1ff2019-10-31 17:20:42 -07009561 numDevices = mPatch.num_sinks;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009562 } else {
9563 type = patch->sources[0].ext.device.type;
9564 deviceId = patch->sources[0].id;
jiabinc52b1ff2019-10-31 17:20:42 -07009565 numDevices = mPatch.num_sources;
9566 sourceDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
jiabin0a488932020-08-07 17:32:40 -07009567 sourceDeviceTypeAddr.setAddress(patch->sources[0].ext.device.address);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009568 }
9569
9570 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabin8f278ee2019-11-11 12:16:27 -08009571 if (isOutput()) {
9572 mEffectChains[i]->setDevices_l(sinkDeviceTypeAddrs);
9573 } else {
9574 mEffectChains[i]->setInputDevice_l(sourceDeviceTypeAddr);
9575 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009576 }
9577
jiabinc52b1ff2019-10-31 17:20:42 -07009578 if (!isOutput()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009579 // store new source and send to effects
9580 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
9581 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
9582 for (size_t i = 0; i < mEffectChains.size(); i++) {
9583 mEffectChains[i]->setAudioSource_l(mAudioSource);
9584 }
9585 }
9586 }
9587
9588 if (mAudioHwDev->supportsAudioPatches()) {
9589 status = mHalDevice->createAudioPatch(patch->num_sources,
9590 patch->sources,
9591 patch->num_sinks,
9592 patch->sinks,
9593 handle);
9594 } else {
9595 char *address;
9596 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
9597 //FIXME: we only support address on first sink with HAL version < 3.0
9598 address = audio_device_address_to_parameter(
9599 patch->sinks[0].ext.device.type,
9600 patch->sinks[0].ext.device.address);
9601 } else {
9602 address = (char *)calloc(1, 1);
9603 }
9604 AudioParameter param = AudioParameter(String8(address));
9605 free(address);
9606 param.addInt(String8(AudioParameter::keyRouting), (int)type);
9607 if (!isOutput()) {
9608 param.addInt(String8(AudioParameter::keyInputSource),
9609 (int)patch->sinks[0].ext.mix.usecase.source);
9610 }
9611 status = mHalStream->setParameters(param.toString());
9612 *handle = AUDIO_PATCH_HANDLE_NONE;
9613 }
9614
jiabinc52b1ff2019-10-31 17:20:42 -07009615 if (numDevices == 0 || mDeviceId != deviceId) {
9616 if (isOutput()) {
9617 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
9618 mOutDeviceTypeAddrs = sinkDeviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -07009619 checkSilentMode_l();
jiabinc52b1ff2019-10-31 17:20:42 -07009620 } else {
9621 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
9622 mInDeviceTypeAddr = sourceDeviceTypeAddr;
9623 }
Phil Burk7f6b40d2017-02-09 13:18:38 -08009624 sp<MmapStreamCallback> callback = mCallback.promote();
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009625 if (mDeviceId != deviceId && callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07009626 mLock.unlock();
Phil Burk7f6b40d2017-02-09 13:18:38 -08009627 callback->onRoutingChanged(deviceId);
Eric Laurent734046e2018-04-16 14:50:52 -07009628 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009629 }
jiabinc52b1ff2019-10-31 17:20:42 -07009630 mPatch = *patch;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009631 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009632 }
9633 return status;
9634}
9635
9636status_t AudioFlinger::MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
9637{
9638 status_t status = NO_ERROR;
9639
jiabinc52b1ff2019-10-31 17:20:42 -07009640 mPatch = audio_patch{};
9641 mOutDeviceTypeAddrs.clear();
9642 mInDeviceTypeAddr.reset();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009643
9644 bool supportsAudioPatches = mHalDevice->supportsAudioPatches(&supportsAudioPatches) == OK ?
9645 supportsAudioPatches : false;
9646
9647 if (supportsAudioPatches) {
9648 status = mHalDevice->releaseAudioPatch(handle);
9649 } else {
9650 AudioParameter param;
9651 param.addInt(String8(AudioParameter::keyRouting), 0);
9652 status = mHalStream->setParameters(param.toString());
9653 }
9654 return status;
9655}
9656
Mikhail Naganovdc769682018-05-04 15:34:08 -07009657void AudioFlinger::MmapThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009658{
Mikhail Naganovdc769682018-05-04 15:34:08 -07009659 ThreadBase::toAudioPortConfig(config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009660 if (isOutput()) {
9661 config->role = AUDIO_PORT_ROLE_SOURCE;
9662 config->ext.mix.hw_module = mAudioHwDev->handle();
9663 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
9664 } else {
9665 config->role = AUDIO_PORT_ROLE_SINK;
9666 config->ext.mix.hw_module = mAudioHwDev->handle();
9667 config->ext.mix.usecase.source = mAudioSource;
9668 }
9669}
9670
9671status_t AudioFlinger::MmapThread::addEffectChain_l(const sp<EffectChain>& chain)
9672{
9673 audio_session_t session = chain->sessionId();
9674
9675 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
9676 // Attach all tracks with same session ID to this chain.
9677 // indicate all active tracks in the chain
9678 for (const sp<MmapTrack> &track : mActiveTracks) {
9679 if (session == track->sessionId()) {
9680 chain->incTrackCnt();
9681 chain->incActiveTrackCnt();
9682 }
9683 }
9684
9685 chain->setThread(this);
9686 chain->setInBuffer(nullptr);
9687 chain->setOutBuffer(nullptr);
9688 chain->syncHalEffectsState();
9689
9690 mEffectChains.add(chain);
9691 checkSuspendOnAddEffectChain_l(chain);
9692 return NO_ERROR;
9693}
9694
9695size_t AudioFlinger::MmapThread::removeEffectChain_l(const sp<EffectChain>& chain)
9696{
9697 audio_session_t session = chain->sessionId();
9698
9699 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
9700
9701 for (size_t i = 0; i < mEffectChains.size(); i++) {
9702 if (chain == mEffectChains[i]) {
9703 mEffectChains.removeAt(i);
9704 // detach all active tracks from the chain
9705 // detach all tracks with same session ID from this chain
9706 for (const sp<MmapTrack> &track : mActiveTracks) {
9707 if (session == track->sessionId()) {
9708 chain->decActiveTrackCnt();
9709 chain->decTrackCnt();
9710 }
9711 }
9712 break;
9713 }
9714 }
9715 return mEffectChains.size();
9716}
9717
Eric Laurent6acd1d42017-01-04 14:23:29 -08009718void AudioFlinger::MmapThread::threadLoop_standby()
9719{
9720 mHalStream->standby();
9721}
9722
9723void AudioFlinger::MmapThread::threadLoop_exit()
9724{
Phil Burk7dce7282017-09-27 13:51:41 -07009725 // Do not call callback->onTearDown() because it is redundant for thread exit
9726 // and because it can cause a recursive mutex lock on stop().
Eric Laurent6acd1d42017-01-04 14:23:29 -08009727}
9728
9729status_t AudioFlinger::MmapThread::setSyncEvent(const sp<SyncEvent>& event __unused)
9730{
9731 return BAD_VALUE;
9732}
9733
9734bool AudioFlinger::MmapThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
9735{
9736 return false;
9737}
9738
9739status_t AudioFlinger::MmapThread::checkEffectCompatibility_l(
9740 const effect_descriptor_t *desc, audio_session_t sessionId)
9741{
9742 // No global effect sessions on mmap threads
Eric Laurent3f75a5b2019-11-12 15:55:51 -08009743 if (audio_is_global_session(sessionId)) {
9744 ALOGW("checkEffectCompatibility_l(): global effect %s on MMAP thread %s",
Eric Laurent6acd1d42017-01-04 14:23:29 -08009745 desc->name, mThreadName);
9746 return BAD_VALUE;
9747 }
9748
9749 if (!isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC)) {
9750 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on capture mmap thread",
9751 desc->name);
9752 return BAD_VALUE;
9753 }
9754 if (isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08009755 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback mmap "
9756 "thread", desc->name);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009757 return BAD_VALUE;
9758 }
9759
9760 // Only allow effects without processing load or latency
9761 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) != EFFECT_FLAG_NO_PROCESS) {
9762 return BAD_VALUE;
9763 }
9764
jiabineb3bda02020-06-30 14:07:03 -07009765 if (EffectModule::isHapticGenerator(&desc->type)) {
9766 ALOGE("%s(): HapticGenerator is not supported for MmapThread", __func__);
9767 return BAD_VALUE;
9768 }
9769
Eric Laurent6acd1d42017-01-04 14:23:29 -08009770 return NO_ERROR;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009771}
9772
9773void AudioFlinger::MmapThread::checkInvalidTracks_l()
9774{
9775 for (const sp<MmapTrack> &track : mActiveTracks) {
9776 if (track->isInvalid()) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08009777 sp<MmapStreamCallback> callback = mCallback.promote();
9778 if (callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07009779 mLock.unlock();
Eric Laurent331679c2018-04-16 17:03:16 -07009780 callback->onTearDown(track->portId());
Eric Laurent734046e2018-04-16 14:50:52 -07009781 mLock.lock();
Eric Laurent331679c2018-04-16 17:03:16 -07009782 } else if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9783 ALOGW("Could not notify MMAP stream tear down: no onTearDown callback!");
9784 mNoCallbackWarningCount++;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009785 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009786 }
9787 }
9788}
9789
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009790void AudioFlinger::MmapThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009791{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009792 dprintf(fd, " Attributes: content type %d usage %d source %d\n",
9793 mAttr.content_type, mAttr.usage, mAttr.source);
9794 dprintf(fd, " Session: %d port Id: %d\n", mSessionId, mPortId);
Eric Tan39ec8d62018-07-24 09:49:29 -07009795 if (mActiveTracks.isEmpty()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009796 dprintf(fd, " No active clients\n");
9797 }
9798}
9799
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009800void AudioFlinger::MmapThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009801{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009802 String8 result;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009803 size_t numtracks = mActiveTracks.size();
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009804 dprintf(fd, " %zu Tracks\n", numtracks);
9805 const char *prefix = " ";
Eric Laurent6acd1d42017-01-04 14:23:29 -08009806 if (numtracks) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009807 result.append(prefix);
Kevin Rocard5f2136e2018-05-11 22:03:00 -07009808 mActiveTracks[0]->appendDumpHeader(result);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009809 for (size_t i = 0; i < numtracks ; ++i) {
9810 sp<MmapTrack> track = mActiveTracks[i];
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009811 result.append(prefix);
9812 track->appendDump(result, true /* active */);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009813 }
9814 } else {
9815 dprintf(fd, "\n");
9816 }
9817 write(fd, result.string(), result.size());
9818}
9819
9820AudioFlinger::MmapPlaybackThread::MmapPlaybackThread(
9821 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07009822 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -07009823 : MmapThread(audioFlinger, id, hwDev, output->stream, systemReady, true /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -08009824 mStreamType(AUDIO_STREAM_MUSIC),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009825 mStreamVolume(1.0),
9826 mStreamMute(false),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009827 mOutput(output)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009828{
9829 snprintf(mThreadName, kThreadNameLength, "AudioMmapOut_%X", id);
9830 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
9831 mMasterVolume = audioFlinger->masterVolume_l();
9832 mMasterMute = audioFlinger->masterMute_l();
9833 if (mAudioHwDev) {
9834 if (mAudioHwDev->canSetMasterVolume()) {
9835 mMasterVolume = 1.0;
9836 }
9837
9838 if (mAudioHwDev->canSetMasterMute()) {
9839 mMasterMute = false;
9840 }
9841 }
9842}
9843
9844void AudioFlinger::MmapPlaybackThread::configure(const audio_attributes_t *attr,
9845 audio_stream_type_t streamType,
9846 audio_session_t sessionId,
9847 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009848 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009849 audio_port_handle_t portId)
9850{
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009851 MmapThread::configure(attr, streamType, sessionId, callback, deviceId, portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009852 mStreamType = streamType;
9853}
9854
9855AudioStreamOut* AudioFlinger::MmapPlaybackThread::clearOutput()
9856{
9857 Mutex::Autolock _l(mLock);
9858 AudioStreamOut *output = mOutput;
9859 mOutput = NULL;
9860 return output;
9861}
9862
9863void AudioFlinger::MmapPlaybackThread::setMasterVolume(float value)
9864{
9865 Mutex::Autolock _l(mLock);
9866 // Don't apply master volume in SW if our HAL can do it for us.
9867 if (mAudioHwDev &&
9868 mAudioHwDev->canSetMasterVolume()) {
9869 mMasterVolume = 1.0;
9870 } else {
9871 mMasterVolume = value;
9872 }
9873}
9874
9875void AudioFlinger::MmapPlaybackThread::setMasterMute(bool muted)
9876{
9877 Mutex::Autolock _l(mLock);
9878 // Don't apply master mute in SW if our HAL can do it for us.
9879 if (mAudioHwDev && mAudioHwDev->canSetMasterMute()) {
9880 mMasterMute = false;
9881 } else {
9882 mMasterMute = muted;
9883 }
9884}
9885
9886void AudioFlinger::MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
9887{
9888 Mutex::Autolock _l(mLock);
9889 if (stream == mStreamType) {
9890 mStreamVolume = value;
9891 broadcast_l();
9892 }
9893}
9894
9895float AudioFlinger::MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
9896{
9897 Mutex::Autolock _l(mLock);
9898 if (stream == mStreamType) {
9899 return mStreamVolume;
9900 }
9901 return 0.0f;
9902}
9903
9904void AudioFlinger::MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
9905{
9906 Mutex::Autolock _l(mLock);
9907 if (stream == mStreamType) {
9908 mStreamMute= muted;
9909 broadcast_l();
9910 }
9911}
9912
9913void AudioFlinger::MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
9914{
9915 Mutex::Autolock _l(mLock);
9916 if (streamType == mStreamType) {
9917 for (const sp<MmapTrack> &track : mActiveTracks) {
9918 track->invalidate();
9919 }
9920 broadcast_l();
9921 }
9922}
9923
9924void AudioFlinger::MmapPlaybackThread::processVolume_l()
9925{
9926 float volume;
9927
9928 if (mMasterMute || mStreamMute) {
9929 volume = 0;
9930 } else {
9931 volume = mMasterVolume * mStreamVolume;
9932 }
9933
9934 if (volume != mHalVolFloat) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009935
9936 // Convert volumes from float to 8.24
9937 uint32_t vol = (uint32_t)(volume * (1 << 24));
9938
9939 // Delegate volume control to effect in track effect chain if needed
9940 // only one effect chain can be present on DirectOutputThread, so if
9941 // there is one, the track is connected to it
9942 if (!mEffectChains.isEmpty()) {
9943 mEffectChains[0]->setVolume_l(&vol, &vol);
9944 volume = (float)vol / (1 << 24);
9945 }
Eric Laurentdff774a2017-04-21 15:29:38 -07009946 // Try to use HW volume control and fall back to SW control if not implemented
Phil Burk56ecf3e2018-03-12 15:38:17 -07009947 if (mOutput->stream->setVolume(volume, volume) == NO_ERROR) {
9948 mHalVolFloat = volume; // HW volume control worked, so update value.
9949 mNoCallbackWarningCount = 0;
9950 } else {
Eric Laurentdff774a2017-04-21 15:29:38 -07009951 sp<MmapStreamCallback> callback = mCallback.promote();
9952 if (callback != 0) {
9953 int channelCount;
9954 if (isOutput()) {
9955 channelCount = audio_channel_count_from_out_mask(mChannelMask);
9956 } else {
9957 channelCount = audio_channel_count_from_in_mask(mChannelMask);
9958 }
9959 Vector<float> values;
9960 for (int i = 0; i < channelCount; i++) {
9961 values.add(volume);
9962 }
Phil Burk56ecf3e2018-03-12 15:38:17 -07009963 mHalVolFloat = volume; // SW volume control worked, so update value.
9964 mNoCallbackWarningCount = 0;
Eric Laurent734046e2018-04-16 14:50:52 -07009965 mLock.unlock();
9966 callback->onVolumeChanged(mChannelMask, values);
9967 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009968 } else {
Phil Burk56ecf3e2018-03-12 15:38:17 -07009969 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9970 ALOGW("Could not set MMAP stream volume: no volume callback!");
9971 mNoCallbackWarningCount++;
9972 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009973 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009974 }
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009975 for (const sp<MmapTrack> &track : mActiveTracks) {
9976 track->setMetadataHasChanged();
9977 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009978 }
9979}
9980
Kevin Rocard069c2712018-03-29 19:09:14 -07009981void AudioFlinger::MmapPlaybackThread::updateMetadata_l()
9982{
Jasmine Chaeaa10e42021-05-11 10:11:14 +08009983 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
9984 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07009985 }
9986 StreamOutHalInterface::SourceMetadata metadata;
9987 for (const sp<MmapTrack> &track : mActiveTracks) {
9988 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent94579172020-11-20 18:41:04 +01009989 playback_track_metadata_v7_t trackMetadata;
9990 trackMetadata.base = {
Kevin Rocard069c2712018-03-29 19:09:14 -07009991 .usage = track->attributes().usage,
9992 .content_type = track->attributes().content_type,
9993 .gain = mHalVolFloat, // TODO: propagate from aaudio pre-mix volume
Eric Laurent94579172020-11-20 18:41:04 +01009994 };
9995 trackMetadata.channel_mask = track->channelMask(),
9996 strncpy(trackMetadata.tags, track->attributes().tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
9997 metadata.tracks.push_back(trackMetadata);
Kevin Rocard069c2712018-03-29 19:09:14 -07009998 }
9999 mOutput->stream->updateSourceMetadata(metadata);
10000}
10001
Eric Laurent6acd1d42017-01-04 14:23:29 -080010002void AudioFlinger::MmapPlaybackThread::checkSilentMode_l()
10003{
10004 if (!mMasterMute) {
10005 char value[PROPERTY_VALUE_MAX];
10006 if (property_get("ro.audio.silent", value, "0") > 0) {
10007 char *endptr;
10008 unsigned long ul = strtoul(value, &endptr, 0);
10009 if (*endptr == '\0' && ul != 0) {
10010 ALOGD("Silence is golden");
10011 // The setprop command will not allow a property to be changed after
10012 // the first time it is set, so we don't have to worry about un-muting.
10013 setMasterMute_l(true);
10014 }
10015 }
10016 }
10017}
10018
Mikhail Naganov32abc2b2018-05-24 12:57:11 -070010019void AudioFlinger::MmapPlaybackThread::toAudioPortConfig(struct audio_port_config *config)
10020{
10021 MmapThread::toAudioPortConfig(config);
10022 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
10023 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
10024 config->flags.output = mOutput->flags;
10025 }
10026}
10027
jiabinb7d8c5a2020-08-26 17:24:52 -070010028status_t AudioFlinger::MmapPlaybackThread::getExternalPosition(uint64_t *position,
10029 int64_t *timeNanos)
10030{
10031 if (mOutput == nullptr) {
10032 return NO_INIT;
10033 }
10034 struct timespec timestamp;
10035 status_t status = mOutput->getPresentationPosition(position, &timestamp);
10036 if (status == NO_ERROR) {
10037 *timeNanos = timestamp.tv_sec * NANOS_PER_SECOND + timestamp.tv_nsec;
10038 }
10039 return status;
10040}
10041
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010042void AudioFlinger::MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent6acd1d42017-01-04 14:23:29 -080010043{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -070010044 MmapThread::dumpInternals_l(fd, args);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010045
Glenn Kastend3bb6452016-12-05 18:14:37 -080010046 dprintf(fd, " Stream type: %d Stream volume: %f HAL volume: %f Stream mute %d\n",
10047 mStreamType, mStreamVolume, mHalVolFloat, mStreamMute);
Eric Laurent6acd1d42017-01-04 14:23:29 -080010048 dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
10049}
10050
10051AudioFlinger::MmapCaptureThread::MmapCaptureThread(
10052 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -070010053 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -070010054 : MmapThread(audioFlinger, id, hwDev, input->stream, systemReady, false /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -080010055 mInput(input)
10056{
10057 snprintf(mThreadName, kThreadNameLength, "AudioMmapIn_%X", id);
10058 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
10059}
10060
Eric Laurent331679c2018-04-16 17:03:16 -070010061status_t AudioFlinger::MmapCaptureThread::exitStandby()
10062{
Phil Burkf054fc32018-12-06 09:45:59 -080010063 {
10064 // mInput might have been cleared by clearInput()
10065 Mutex::Autolock _l(mLock);
10066 if (mInput != nullptr && mInput->stream != nullptr) {
10067 mInput->stream->setGain(1.0f);
10068 }
10069 }
Eric Laurent331679c2018-04-16 17:03:16 -070010070 return MmapThread::exitStandby();
10071}
10072
Eric Laurent6acd1d42017-01-04 14:23:29 -080010073AudioFlinger::AudioStreamIn* AudioFlinger::MmapCaptureThread::clearInput()
10074{
10075 Mutex::Autolock _l(mLock);
10076 AudioStreamIn *input = mInput;
10077 mInput = NULL;
10078 return input;
10079}
Kevin Rocard069c2712018-03-29 19:09:14 -070010080
Eric Laurent331679c2018-04-16 17:03:16 -070010081
10082void AudioFlinger::MmapCaptureThread::processVolume_l()
10083{
10084 bool changed = false;
10085 bool silenced = false;
10086
10087 sp<MmapStreamCallback> callback = mCallback.promote();
10088 if (callback == 0) {
10089 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
10090 ALOGW("Could not set MMAP stream silenced: no onStreamSilenced callback!");
10091 mNoCallbackWarningCount++;
10092 }
10093 }
10094
10095 // After a change occurred in track silenced state, mute capture in audio DSP if at least one
10096 // track is silenced and unmute otherwise
10097 for (size_t i = 0; i < mActiveTracks.size() && !silenced; i++) {
10098 if (!mActiveTracks[i]->getAndSetSilencedNotified_l()) {
10099 changed = true;
10100 silenced = mActiveTracks[i]->isSilenced_l();
10101 }
10102 }
10103
10104 if (changed) {
10105 mInput->stream->setGain(silenced ? 0.0f: 1.0f);
10106 }
10107}
10108
Kevin Rocard069c2712018-03-29 19:09:14 -070010109void AudioFlinger::MmapCaptureThread::updateMetadata_l()
10110{
Jasmine Chaeaa10e42021-05-11 10:11:14 +080010111 if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
10112 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -070010113 }
10114 StreamInHalInterface::SinkMetadata metadata;
10115 for (const sp<MmapTrack> &track : mActiveTracks) {
10116 // No track is invalid as this is called after prepareTrack_l in the same critical section
Eric Laurent94579172020-11-20 18:41:04 +010010117 record_track_metadata_v7_t trackMetadata;
10118 trackMetadata.base = {
Kevin Rocard069c2712018-03-29 19:09:14 -070010119 .source = track->attributes().source,
10120 .gain = 1, // capture tracks do not have volumes
Eric Laurent94579172020-11-20 18:41:04 +010010121 };
10122 trackMetadata.channel_mask = track->channelMask(),
10123 strncpy(trackMetadata.tags, track->attributes().tags, AUDIO_ATTRIBUTES_TAGS_MAX_SIZE);
10124 metadata.tracks.push_back(trackMetadata);
Kevin Rocard069c2712018-03-29 19:09:14 -070010125 }
10126 mInput->stream->updateSinkMetadata(metadata);
10127}
10128
Eric Laurent5ada82e2019-08-29 17:53:54 -070010129void AudioFlinger::MmapCaptureThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Eric Laurent331679c2018-04-16 17:03:16 -070010130{
10131 Mutex::Autolock _l(mLock);
10132 for (size_t i = 0; i < mActiveTracks.size() ; i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -070010133 if (mActiveTracks[i]->portId() == portId) {
Eric Laurent331679c2018-04-16 17:03:16 -070010134 mActiveTracks[i]->setSilenced_l(silenced);
10135 broadcast_l();
10136 }
10137 }
10138}
10139
Mikhail Naganov32abc2b2018-05-24 12:57:11 -070010140void AudioFlinger::MmapCaptureThread::toAudioPortConfig(struct audio_port_config *config)
10141{
10142 MmapThread::toAudioPortConfig(config);
10143 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
10144 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
10145 config->flags.input = mInput->flags;
10146 }
10147}
10148
jiabinb7d8c5a2020-08-26 17:24:52 -070010149status_t AudioFlinger::MmapCaptureThread::getExternalPosition(
10150 uint64_t *position, int64_t *timeNanos)
10151{
10152 if (mInput == nullptr) {
10153 return NO_INIT;
10154 }
10155 return mInput->getCapturePosition((int64_t*)position, timeNanos);
10156}
10157
Glenn Kasten63238ef2015-03-02 15:50:29 -080010158} // namespace android