blob: a555ebf605a8242b6ad46a7692a23964143558e5 [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>
jiabin10d86fd2019-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))
Andy Hung6770c6f2015-04-07 13:43:36 -0700111template <typename T>
112static inline T min(const T& a, const T& b)
113{
114 return a < b ? a : b;
115}
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700116
Eric Laurent81784c32012-11-19 14:55:58 -0800117namespace android {
118
119// retry counts for buffer fill timeout
120// 50 * ~20msecs = 1 second
121static const int8_t kMaxTrackRetries = 50;
122static const int8_t kMaxTrackStartupRetries = 50;
123// allow less retry attempts on direct output thread.
124// direct outputs can be a scarce resource in audio hardware and should
125// be released as quickly as possible.
126static const int8_t kMaxTrackRetriesDirect = 2;
Eric Laurente93cc032016-05-05 10:15:10 -0700127
Eric Laurent51716182016-02-29 18:00:56 -0800128
Eric Laurent81784c32012-11-19 14:55:58 -0800129
130// don't warn about blocked writes or record buffer overflows more often than this
131static const nsecs_t kWarningThrottleNs = seconds(5);
132
133// RecordThread loop sleep time upon application overrun or audio HAL read error
134static const int kRecordThreadSleepUs = 5000;
135
Eric Laurent10351942014-05-08 18:49:52 -0700136// maximum time to wait in sendConfigEvent_l() for a status to be received
137static const nsecs_t kConfigEventTimeoutNs = seconds(2);
Eric Laurent81784c32012-11-19 14:55:58 -0800138
139// minimum sleep time for the mixer thread loop when tracks are active but in underrun
140static const uint32_t kMinThreadSleepTimeUs = 5000;
141// maximum divider applied to the active sleep time in the mixer thread loop
142static const uint32_t kMaxThreadSleepTimeShift = 2;
143
Andy Hung09a50072014-02-27 14:30:47 -0800144// minimum normal sink buffer size, expressed in milliseconds rather than frames
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700145// FIXME This should be based on experimentally observed scheduling jitter
Andy Hung09a50072014-02-27 14:30:47 -0800146static const uint32_t kMinNormalSinkBufferSizeMs = 20;
147// maximum normal sink buffer size
148static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
Eric Laurent81784c32012-11-19 14:55:58 -0800149
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700150// minimum capture buffer size in milliseconds to _not_ need a fast capture thread
151// FIXME This should be based on experimentally observed scheduling jitter
152static const uint32_t kMinNormalCaptureBufferSizeMs = 12;
153
Eric Laurent972a1732013-09-04 09:42:59 -0700154// Offloaded output thread standby delay: allows track transition without going to standby
155static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
156
Eric Laurent51716182016-02-29 18:00:56 -0800157// Direct output thread minimum sleep time in idle or active(underrun) state
158static const nsecs_t kDirectMinSleepTimeUs = 10000;
159
Glenn Kasten1b291842016-07-18 14:55:21 -0700160// The universal constant for ubiquitous 20ms value. The value of 20ms seems to provide a good
161// balance between power consumption and latency, and allows threads to be scheduled reliably
162// by the CFS scheduler.
163// FIXME Express other hardcoded references to 20ms with references to this constant and move
164// it appropriately.
165#define FMS_20 20
Eric Laurent51716182016-02-29 18:00:56 -0800166
Eric Laurent81784c32012-11-19 14:55:58 -0800167// Whether to use fast mixer
168static const enum {
169 FastMixer_Never, // never initialize or use: for debugging only
170 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
171 // normal mixer multiplier is 1
172 FastMixer_Static, // initialize if needed, then use all the time if initialized,
173 // multiplier is calculated based on min & max normal mixer buffer size
174 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
175 // multiplier is calculated based on min & max normal mixer buffer size
176 // FIXME for FastMixer_Dynamic:
177 // Supporting this option will require fixing HALs that can't handle large writes.
178 // For example, one HAL implementation returns an error from a large write,
179 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
180 // We could either fix the HAL implementations, or provide a wrapper that breaks
181 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
182} kUseFastMixer = FastMixer_Static;
183
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700184// Whether to use fast capture
185static const enum {
186 FastCapture_Never, // never initialize or use: for debugging only
187 FastCapture_Always, // always initialize and use, even if not needed: for debugging only
188 FastCapture_Static, // initialize if needed, then use all the time if initialized
189} kUseFastCapture = FastCapture_Static;
190
Eric Laurent81784c32012-11-19 14:55:58 -0800191// Priorities for requestPriority
192static const int kPriorityAudioApp = 2;
193static const int kPriorityFastMixer = 3;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700194static const int kPriorityFastCapture = 3;
Eric Laurent81784c32012-11-19 14:55:58 -0800195
Glenn Kastenea38ee72016-04-18 11:08:01 -0700196// IAudioFlinger::createTrack() has an in/out parameter 'pFrameCount' for the total size of the
197// track buffer in shared memory. Zero on input means to use a default value. For fast tracks,
198// AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
Glenn Kasten03490092014-05-27 12:30:54 -0700199
200// This is the default value, if not specified by property.
Glenn Kastenb5fed682013-12-03 09:06:43 -0800201static const int kFastTrackMultiplier = 2;
Eric Laurent81784c32012-11-19 14:55:58 -0800202
Glenn Kasten03490092014-05-27 12:30:54 -0700203// The minimum and maximum allowed values
204static const int kFastTrackMultiplierMin = 1;
205static const int kFastTrackMultiplierMax = 2;
206
207// The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
208static int sFastTrackMultiplier = kFastTrackMultiplier;
209
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700210// See Thread::readOnlyHeap().
211// Initially this heap is used to allocate client buffers for "fast" AudioRecord.
212// Eventually it will be the single buffer that FastCapture writes into via HAL read(),
213// and that all "fast" AudioRecord clients read from. In either case, the size can be small.
Mikhail Naganov79a77822018-05-10 15:57:25 -0700214static const size_t kRecordThreadReadOnlyHeapSize = 0xD000;
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700215
Eric Laurent81784c32012-11-19 14:55:58 -0800216// ----------------------------------------------------------------------------
217
Andy Hungb68f5eb2019-12-03 16:49:17 -0800218// TODO: move all toString helpers to audio.h
219// under #ifdef __cplusplus #endif
220static std::string patchSinksToString(const struct audio_patch *patch)
221{
222 std::stringstream ss;
223 for (size_t i = 0; i < patch->num_sinks; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700224 if (i > 0) {
225 ss << "|";
226 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800227 ss << "(" << toString(patch->sinks[i].ext.device.type)
228 << ", " << patch->sinks[i].ext.device.address << ")";
229 }
230 return ss.str();
231}
232
233static std::string patchSourcesToString(const struct audio_patch *patch)
234{
235 std::stringstream ss;
236 for (size_t i = 0; i < patch->num_sources; ++i) {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700237 if (i > 0) {
238 ss << "|";
239 }
Andy Hungb68f5eb2019-12-03 16:49:17 -0800240 ss << "(" << toString(patch->sources[i].ext.device.type)
241 << ", " << patch->sources[i].ext.device.address << ")";
242 }
243 return ss.str();
244}
245
Glenn Kasten03490092014-05-27 12:30:54 -0700246static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
247
248static void sFastTrackMultiplierInit()
249{
250 char value[PROPERTY_VALUE_MAX];
251 if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
252 char *endptr;
253 unsigned long ul = strtoul(value, &endptr, 0);
254 if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
255 sFastTrackMultiplier = (int) ul;
256 }
257 }
258}
259
260// ----------------------------------------------------------------------------
261
Eric Laurent81784c32012-11-19 14:55:58 -0800262#ifdef ADD_BATTERY_DATA
263// To collect the amplifier usage
264static void addBatteryData(uint32_t params) {
265 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
266 if (service == NULL) {
267 // it already logged
268 return;
269 }
270
271 service->addBatteryData(params);
272}
273#endif
274
Andy Hung3f0c9022016-01-15 17:49:46 -0800275// Track the CLOCK_BOOTTIME versus CLOCK_MONOTONIC timebase offset
276struct {
277 // call when you acquire a partial wakelock
278 void acquire(const sp<IBinder> &wakeLockToken) {
279 pthread_mutex_lock(&mLock);
280 if (wakeLockToken.get() == nullptr) {
281 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
282 } else {
283 if (mCount == 0) {
284 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
285 }
286 ++mCount;
287 }
288 pthread_mutex_unlock(&mLock);
289 }
290
291 // call when you release a partial wakelock.
292 void release(const sp<IBinder> &wakeLockToken) {
293 if (wakeLockToken.get() == nullptr) {
294 return;
295 }
296 pthread_mutex_lock(&mLock);
297 if (--mCount < 0) {
298 ALOGE("negative wakelock count");
299 mCount = 0;
300 }
301 pthread_mutex_unlock(&mLock);
302 }
303
304 // retrieves the boottime timebase offset from monotonic.
305 int64_t getBoottimeOffset() {
306 pthread_mutex_lock(&mLock);
307 int64_t boottimeOffset = mBoottimeOffset;
308 pthread_mutex_unlock(&mLock);
309 return boottimeOffset;
310 }
311
312 // Adjusts the timebase offset between TIMEBASE_MONOTONIC
313 // and the selected timebase.
314 // Currently only TIMEBASE_BOOTTIME is allowed.
315 //
316 // This only needs to be called upon acquiring the first partial wakelock
317 // after all other partial wakelocks are released.
318 //
319 // We do an empirical measurement of the offset rather than parsing
320 // /proc/timer_list since the latter is not a formal kernel ABI.
321 static void adjustTimebaseOffset(int64_t *offset, ExtendedTimestamp::Timebase timebase) {
322 int clockbase;
323 switch (timebase) {
324 case ExtendedTimestamp::TIMEBASE_BOOTTIME:
325 clockbase = SYSTEM_TIME_BOOTTIME;
326 break;
327 default:
328 LOG_ALWAYS_FATAL("invalid timebase %d", timebase);
329 break;
330 }
331 // try three times to get the clock offset, choose the one
332 // with the minimum gap in measurements.
333 const int tries = 3;
334 nsecs_t bestGap, measured;
335 for (int i = 0; i < tries; ++i) {
336 const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
337 const nsecs_t tbase = systemTime(clockbase);
338 const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
339 const nsecs_t gap = tmono2 - tmono;
340 if (i == 0 || gap < bestGap) {
341 bestGap = gap;
342 measured = tbase - ((tmono + tmono2) >> 1);
343 }
344 }
345
346 // to avoid micro-adjusting, we don't change the timebase
347 // unless it is significantly different.
348 //
349 // Assumption: It probably takes more than toleranceNs to
350 // suspend and resume the device.
351 static int64_t toleranceNs = 10000; // 10 us
352 if (llabs(*offset - measured) > toleranceNs) {
353 ALOGV("Adjusting timebase offset old: %lld new: %lld",
354 (long long)*offset, (long long)measured);
355 *offset = measured;
356 }
357 }
358
359 pthread_mutex_t mLock;
360 int32_t mCount;
361 int64_t mBoottimeOffset;
362} gBoottime = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; // static, so use POD initialization
Eric Laurent81784c32012-11-19 14:55:58 -0800363
364// ----------------------------------------------------------------------------
365// CPU Stats
366// ----------------------------------------------------------------------------
367
368class CpuStats {
369public:
370 CpuStats();
371 void sample(const String8 &title);
372#ifdef DEBUG_CPU_USAGE
373private:
374 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
Andy Hung16698b82018-08-01 10:48:38 -0700375 audio_utils::Statistics<double> mWcStats; // statistics on thread CPU usage in wall clock ns
Eric Laurent81784c32012-11-19 14:55:58 -0800376
Andy Hung16698b82018-08-01 10:48:38 -0700377 audio_utils::Statistics<double> mHzStats; // statistics on thread CPU usage in cycles
Eric Laurent81784c32012-11-19 14:55:58 -0800378
379 int mCpuNum; // thread's current CPU number
380 int mCpukHz; // frequency of thread's current CPU in kHz
381#endif
382};
383
384CpuStats::CpuStats()
385#ifdef DEBUG_CPU_USAGE
386 : mCpuNum(-1), mCpukHz(-1)
387#endif
388{
389}
390
Glenn Kasten0f11b512014-01-31 16:18:54 -0800391void CpuStats::sample(const String8 &title
392#ifndef DEBUG_CPU_USAGE
393 __unused
394#endif
395 ) {
Eric Laurent81784c32012-11-19 14:55:58 -0800396#ifdef DEBUG_CPU_USAGE
397 // get current thread's delta CPU time in wall clock ns
398 double wcNs;
399 bool valid = mCpuUsage.sampleAndEnable(wcNs);
400
401 // record sample for wall clock statistics
402 if (valid) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700403 mWcStats.add(wcNs);
Eric Laurent81784c32012-11-19 14:55:58 -0800404 }
405
406 // get the current CPU number
407 int cpuNum = sched_getcpu();
408
409 // get the current CPU frequency in kHz
410 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
411
412 // check if either CPU number or frequency changed
413 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
414 mCpuNum = cpuNum;
415 mCpukHz = cpukHz;
416 // ignore sample for purposes of cycles
417 valid = false;
418 }
419
420 // if no change in CPU number or frequency, then record sample for cycle statistics
421 if (valid && mCpukHz > 0) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700422 const double cycles = wcNs * cpukHz * 0.000001;
423 mHzStats.add(cycles);
Eric Laurent81784c32012-11-19 14:55:58 -0800424 }
425
Eric Tan5b13ff82018-07-27 11:20:17 -0700426 const unsigned n = mWcStats.getN();
Eric Laurent81784c32012-11-19 14:55:58 -0800427 // mCpuUsage.elapsed() is expensive, so don't call it every loop
428 if ((n & 127) == 1) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700429 const long long elapsed = mCpuUsage.elapsed();
Eric Laurent81784c32012-11-19 14:55:58 -0800430 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700431 const double perLoop = elapsed / (double) n;
432 const double perLoop100 = perLoop * 0.01;
433 const double perLoop1k = perLoop * 0.001;
434 const double mean = mWcStats.getMean();
435 const double stddev = mWcStats.getStdDev();
436 const double minimum = mWcStats.getMin();
437 const double maximum = mWcStats.getMax();
438 const double meanCycles = mHzStats.getMean();
439 const double stddevCycles = mHzStats.getStdDev();
440 const double minCycles = mHzStats.getMin();
441 const double maxCycles = mHzStats.getMax();
Eric Laurent81784c32012-11-19 14:55:58 -0800442 mCpuUsage.resetElapsed();
443 mWcStats.reset();
444 mHzStats.reset();
445 ALOGD("CPU usage for %s over past %.1f secs\n"
446 " (%u mixer loops at %.1f mean ms per loop):\n"
447 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
448 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
449 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
450 title.string(),
451 elapsed * .000000001, n, perLoop * .000001,
452 mean * .001,
453 stddev * .001,
454 minimum * .001,
455 maximum * .001,
456 mean / perLoop100,
457 stddev / perLoop100,
458 minimum / perLoop100,
459 maximum / perLoop100,
460 meanCycles / perLoop1k,
461 stddevCycles / perLoop1k,
462 minCycles / perLoop1k,
463 maxCycles / perLoop1k);
464
465 }
466 }
467#endif
468};
469
470// ----------------------------------------------------------------------------
471// ThreadBase
472// ----------------------------------------------------------------------------
473
Glenn Kasten97b7b752014-09-28 13:04:24 -0700474// static
475const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
476{
477 switch (type) {
478 case MIXER:
479 return "MIXER";
480 case DIRECT:
481 return "DIRECT";
482 case DUPLICATING:
483 return "DUPLICATING";
484 case RECORD:
485 return "RECORD";
486 case OFFLOAD:
487 return "OFFLOAD";
Andy Hungea840382020-05-05 21:50:17 -0700488 case MMAP_PLAYBACK:
489 return "MMAP_PLAYBACK";
490 case MMAP_CAPTURE:
491 return "MMAP_CAPTURE";
Glenn Kasten97b7b752014-09-28 13:04:24 -0700492 default:
493 return "unknown";
494 }
495}
496
Eric Laurent81784c32012-11-19 14:55:58 -0800497AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -0700498 type_t type, bool systemReady, bool isOut)
Eric Laurent81784c32012-11-19 14:55:58 -0800499 : Thread(false /*canCallJava*/),
500 mType(type),
Glenn Kasten9b58f632013-07-16 11:37:48 -0700501 mAudioFlinger(audioFlinger),
Andy Hungcf10d742020-04-28 15:38:24 -0700502 mThreadMetrics(std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_THREAD) + std::to_string(id),
503 isOut),
504 mIsOut(isOut),
Glenn Kasten70949c42013-08-06 07:40:12 -0700505 // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800506 // are set by PlaybackThread::readOutputParameters_l() or
507 // RecordThread::readInputParameters_l()
Eric Laurentfd477972013-10-25 18:10:40 -0700508 //FIXME: mStandby should be true here. Is this some kind of hack?
jiabin10d86fd2019-10-31 17:20:42 -0700509 mStandby(false),
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700510 mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
Eric Laurent81784c32012-11-19 14:55:58 -0800511 // mName will be set by concrete (non-virtual) subclass
Eric Laurent72e3f392015-05-20 14:43:50 -0700512 mDeathRecipient(new PMDeathRecipient(this)),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800513 mSystemReady(systemReady),
514 mSignalPending(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800515{
Andy Hungcf10d742020-04-28 15:38:24 -0700516 mThreadMetrics.logConstructor(getpid(), threadTypeToString(type), id);
Eric Laurent296fb132015-05-01 11:38:42 -0700517 memset(&mPatch, 0, sizeof(struct audio_patch));
Eric Laurent81784c32012-11-19 14:55:58 -0800518}
519
520AudioFlinger::ThreadBase::~ThreadBase()
521{
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700522 // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700523 mConfigEvents.clear();
524
Eric Laurent81784c32012-11-19 14:55:58 -0800525 // do not lock the mutex in destructor
526 releaseWakeLock_l();
527 if (mPowerManager != 0) {
Marco Nelissen06b46062014-11-14 07:58:25 -0800528 sp<IBinder> binder = IInterface::asBinder(mPowerManager);
Eric Laurent81784c32012-11-19 14:55:58 -0800529 binder->unlinkToDeath(mDeathRecipient);
530 }
Andy Hungd0979812019-02-21 15:51:44 -0800531
532 sendStatistics(true /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -0800533}
534
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700535status_t AudioFlinger::ThreadBase::readyToRun()
536{
537 status_t status = initCheck();
538 if (status == NO_ERROR) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800539 ALOGI("AudioFlinger's thread %p tid=%d ready to run", this, getTid());
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700540 } else {
541 ALOGE("No working audio driver found.");
542 }
543 return status;
544}
545
Eric Laurent81784c32012-11-19 14:55:58 -0800546void AudioFlinger::ThreadBase::exit()
547{
548 ALOGV("ThreadBase::exit");
549 // do any cleanup required for exit to succeed
550 preExit();
551 {
552 // This lock prevents the following race in thread (uniprocessor for illustration):
553 // if (!exitPending()) {
554 // // context switch from here to exit()
555 // // exit() calls requestExit(), what exitPending() observes
556 // // exit() calls signal(), which is dropped since no waiters
557 // // context switch back from exit() to here
558 // mWaitWorkCV.wait(...);
559 // // now thread is hung
560 // }
561 AutoMutex lock(mLock);
562 requestExit();
563 mWaitWorkCV.broadcast();
564 }
565 // When Thread::requestExitAndWait is made virtual and this method is renamed to
566 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
567 requestExitAndWait();
568}
569
570status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
571{
Eric Laurent81784c32012-11-19 14:55:58 -0800572 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
573 Mutex::Autolock _l(mLock);
574
Eric Laurent10351942014-05-08 18:49:52 -0700575 return sendSetParameterConfigEvent_l(keyValuePairs);
576}
577
578// sendConfigEvent_l() must be called with ThreadBase::mLock held
579// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
580status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
581{
582 status_t status = NO_ERROR;
583
Eric Laurent72e3f392015-05-20 14:43:50 -0700584 if (event->mRequiresSystemReady && !mSystemReady) {
585 event->mWaitStatus = false;
586 mPendingConfigEvents.add(event);
587 return status;
588 }
Eric Laurent10351942014-05-08 18:49:52 -0700589 mConfigEvents.add(event);
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700590 ALOGV("sendConfigEvent_l() num events %zu event %d", mConfigEvents.size(), event->mType);
Eric Laurent81784c32012-11-19 14:55:58 -0800591 mWaitWorkCV.signal();
Eric Laurent10351942014-05-08 18:49:52 -0700592 mLock.unlock();
593 {
594 Mutex::Autolock _l(event->mLock);
595 while (event->mWaitStatus) {
596 if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
597 event->mStatus = TIMED_OUT;
598 event->mWaitStatus = false;
599 }
600 }
601 status = event->mStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800602 }
Eric Laurent10351942014-05-08 18:49:52 -0700603 mLock.lock();
Eric Laurent81784c32012-11-19 14:55:58 -0800604 return status;
605}
606
Eric Laurent09f1ed22019-04-24 17:45:17 -0700607void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event event, pid_t pid,
608 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800609{
610 Mutex::Autolock _l(mLock);
Eric Laurent09f1ed22019-04-24 17:45:17 -0700611 sendIoConfigEvent_l(event, pid, portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800612}
613
614// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
Eric Laurent09f1ed22019-04-24 17:45:17 -0700615void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event event, pid_t pid,
616 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800617{
Andy Hungd0979812019-02-21 15:51:44 -0800618 // The audio statistics history is exponentially weighted to forget events
619 // about five or more seconds in the past. In order to have
620 // crisper statistics for mediametrics, we reset the statistics on
621 // an IoConfigEvent, to reflect different properties for a new device.
622 mIoJitterMs.reset();
623 mLatencyMs.reset();
624 mProcessTimeMs.reset();
625 mTimestampVerifier.discontinuity();
626
Eric Laurent09f1ed22019-04-24 17:45:17 -0700627 sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700628 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800629}
630
Mikhail Naganov83f04272017-02-07 10:45:09 -0800631void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent72e3f392015-05-20 14:43:50 -0700632{
633 Mutex::Autolock _l(mLock);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800634 sendPrioConfigEvent_l(pid, tid, prio, forApp);
Eric Laurent72e3f392015-05-20 14:43:50 -0700635}
636
Eric Laurent81784c32012-11-19 14:55:58 -0800637// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
Mikhail Naganov83f04272017-02-07 10:45:09 -0800638void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(
639 pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent81784c32012-11-19 14:55:58 -0800640{
Mikhail Naganov83f04272017-02-07 10:45:09 -0800641 sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700642 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800643}
644
Eric Laurent10351942014-05-08 18:49:52 -0700645// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
646status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
Eric Laurent81784c32012-11-19 14:55:58 -0800647{
Andy Hung2ddee192015-12-18 17:34:44 -0800648 sp<ConfigEvent> configEvent;
649 AudioParameter param(keyValuePair);
650 int value;
Mikhail Naganov00260b52016-10-13 12:54:24 -0700651 if (param.getInt(String8(AudioParameter::keyMonoOutput), value) == NO_ERROR) {
Andy Hung2ddee192015-12-18 17:34:44 -0800652 setMasterMono_l(value != 0);
653 if (param.size() == 1) {
654 return NO_ERROR; // should be a solo parameter - we don't pass down
655 }
Mikhail Naganov00260b52016-10-13 12:54:24 -0700656 param.remove(String8(AudioParameter::keyMonoOutput));
Andy Hung2ddee192015-12-18 17:34:44 -0800657 configEvent = new SetParameterConfigEvent(param.toString());
658 } else {
659 configEvent = new SetParameterConfigEvent(keyValuePair);
660 }
Eric Laurent10351942014-05-08 18:49:52 -0700661 return sendConfigEvent_l(configEvent);
Glenn Kastenf7773312013-08-13 16:00:42 -0700662}
663
Eric Laurent1c333e22014-05-20 10:48:17 -0700664status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
665 const struct audio_patch *patch,
666 audio_patch_handle_t *handle)
667{
668 Mutex::Autolock _l(mLock);
669 sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
670 status_t status = sendConfigEvent_l(configEvent);
671 if (status == NO_ERROR) {
672 CreateAudioPatchConfigEventData *data =
673 (CreateAudioPatchConfigEventData *)configEvent->mData.get();
674 *handle = data->mHandle;
675 }
676 return status;
677}
678
679status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
680 const audio_patch_handle_t handle)
681{
682 Mutex::Autolock _l(mLock);
683 sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
684 return sendConfigEvent_l(configEvent);
685}
686
jiabin10d86fd2019-10-31 17:20:42 -0700687status_t AudioFlinger::ThreadBase::sendUpdateOutDeviceConfigEvent(
688 const DeviceDescriptorBaseVector& outDevices)
689{
690 if (type() != RECORD) {
691 // The update out device operation is only for record thread.
692 return INVALID_OPERATION;
693 }
694 Mutex::Autolock _l(mLock);
695 sp<ConfigEvent> configEvent = (ConfigEvent *)new UpdateOutDevicesConfigEvent(outDevices);
696 return sendConfigEvent_l(configEvent);
697}
698
Eric Laurent1c333e22014-05-20 10:48:17 -0700699
Glenn Kasten2cfbf882013-08-14 13:12:11 -0700700// post condition: mConfigEvents.isEmpty()
Eric Laurent021cf962014-05-13 10:18:14 -0700701void AudioFlinger::ThreadBase::processConfigEvents_l()
Glenn Kastenf7773312013-08-13 16:00:42 -0700702{
Eric Laurent10351942014-05-08 18:49:52 -0700703 bool configChanged = false;
704
Eric Laurent81784c32012-11-19 14:55:58 -0800705 while (!mConfigEvents.isEmpty()) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700706 ALOGV("processConfigEvents_l() remaining events %zu", mConfigEvents.size());
Eric Laurent10351942014-05-08 18:49:52 -0700707 sp<ConfigEvent> event = mConfigEvents[0];
Eric Laurent81784c32012-11-19 14:55:58 -0800708 mConfigEvents.removeAt(0);
Eric Laurent10351942014-05-08 18:49:52 -0700709 switch (event->mType) {
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700710 case CFG_EVENT_PRIO: {
Eric Laurent10351942014-05-08 18:49:52 -0700711 PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
712 // FIXME Need to understand why this has to be done asynchronously
Mikhail Naganov83f04272017-02-07 10:45:09 -0800713 int err = requestPriority(data->mPid, data->mTid, data->mPrio, data->mForApp,
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700714 true /*asynchronous*/);
715 if (err != 0) {
716 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
Eric Laurent10351942014-05-08 18:49:52 -0700717 data->mPrio, data->mPid, data->mTid, err);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700718 }
719 } break;
720 case CFG_EVENT_IO: {
Eric Laurent10351942014-05-08 18:49:52 -0700721 IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
Eric Laurent09f1ed22019-04-24 17:45:17 -0700722 ioConfigChanged(data->mEvent, data->mPid, data->mPortId);
Eric Laurent10351942014-05-08 18:49:52 -0700723 } break;
724 case CFG_EVENT_SET_PARAMETER: {
725 SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
726 if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
727 configChanged = true;
Andy Hung293558a2017-03-21 12:19:20 -0700728 mLocalLog.log("CFG_EVENT_SET_PARAMETER: (%s) configuration changed",
729 data->mKeyValuePairs.string());
Glenn Kastend5418eb2013-08-14 13:11:06 -0700730 }
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700731 } break;
Eric Laurent1c333e22014-05-20 10:48:17 -0700732 case CFG_EVENT_CREATE_AUDIO_PATCH: {
jiabin10d86fd2019-10-31 17:20:42 -0700733 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700734 CreateAudioPatchConfigEventData *data =
735 (CreateAudioPatchConfigEventData *)event->mData.get();
736 event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
jiabin10d86fd2019-10-31 17:20:42 -0700737 const DeviceTypeSet newDevices = getDeviceTypes();
738 mLocalLog.log("CFG_EVENT_CREATE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
739 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
740 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -0700741 } break;
742 case CFG_EVENT_RELEASE_AUDIO_PATCH: {
jiabin10d86fd2019-10-31 17:20:42 -0700743 const DeviceTypeSet oldDevices = getDeviceTypes();
Eric Laurent1c333e22014-05-20 10:48:17 -0700744 ReleaseAudioPatchConfigEventData *data =
745 (ReleaseAudioPatchConfigEventData *)event->mData.get();
746 event->mStatus = releaseAudioPatch_l(data->mHandle);
jiabin10d86fd2019-10-31 17:20:42 -0700747 const DeviceTypeSet newDevices = getDeviceTypes();
748 mLocalLog.log("CFG_EVENT_RELEASE_AUDIO_PATCH: old device %s (%s) new device %s (%s)",
749 dumpDeviceTypes(oldDevices).c_str(), toString(oldDevices).c_str(),
750 dumpDeviceTypes(newDevices).c_str(), toString(newDevices).c_str());
751 } break;
752 case CFG_EVENT_UPDATE_OUT_DEVICE: {
753 UpdateOutDevicesConfigEventData *data =
754 (UpdateOutDevicesConfigEventData *)event->mData.get();
755 updateOutDevices(data->mOutDevices);
Eric Laurent1c333e22014-05-20 10:48:17 -0700756 } break;
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700757 default:
Eric Laurent10351942014-05-08 18:49:52 -0700758 ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700759 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800760 }
Eric Laurent10351942014-05-08 18:49:52 -0700761 {
762 Mutex::Autolock _l(event->mLock);
763 if (event->mWaitStatus) {
764 event->mWaitStatus = false;
765 event->mCond.signal();
766 }
767 }
768 ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
769 }
770
771 if (configChanged) {
772 cacheParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800773 }
Eric Laurent81784c32012-11-19 14:55:58 -0800774}
775
Marco Nelissenb2208842014-02-07 14:00:50 -0800776String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
777 String8 s;
Glenn Kastene1635ec2015-06-08 15:46:49 -0700778 const audio_channel_representation_t representation =
779 audio_channel_mask_get_representation(mask);
Andy Hungf98ec8d2015-05-19 12:53:24 -0700780
781 switch (representation) {
jiabin245cdd92018-12-07 17:55:15 -0800782 // Travel all single bit channel mask to convert channel mask to string.
Andy Hungf98ec8d2015-05-19 12:53:24 -0700783 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
784 if (output) {
785 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
786 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
787 if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
788 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low freq, ");
789 if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
790 if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
791 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
792 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
793 if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
794 if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
795 if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
796 if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
797 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
798 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
799 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
800 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
801 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, " );
802 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, " );
Mikhail Naganovc9948492018-05-10 17:25:28 -0700803 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT) s.append("top-side-left, " );
804 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT) s.append("top-side-right, " );
jiabin245cdd92018-12-07 17:55:15 -0800805 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_B) s.append("haptic-B, " );
806 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_A) s.append("haptic-A, " );
Andy Hungf98ec8d2015-05-19 12:53:24 -0700807 if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown, ");
808 } else {
809 if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
810 if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
811 if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
812 if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
813 if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
814 if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
815 if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
816 if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
817 if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
818 if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
819 if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
820 if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
Mikhail Naganovc9948492018-05-10 17:25:28 -0700821 if (mask & AUDIO_CHANNEL_IN_BACK_LEFT) s.append("back-left, ");
822 if (mask & AUDIO_CHANNEL_IN_BACK_RIGHT) s.append("back-right, ");
823 if (mask & AUDIO_CHANNEL_IN_CENTER) s.append("center, ");
824 if (mask & AUDIO_CHANNEL_IN_LOW_FREQUENCY) s.append("low freq, ");
825 if (mask & AUDIO_CHANNEL_IN_TOP_LEFT) s.append("top-left, " );
826 if (mask & AUDIO_CHANNEL_IN_TOP_RIGHT) s.append("top-right, " );
Andy Hungf98ec8d2015-05-19 12:53:24 -0700827 if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
828 if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
829 if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown, ");
830 }
831 const int len = s.length();
832 if (len > 2) {
Glenn Kasten57c4e6f2016-03-18 14:54:07 -0700833 (void) s.lockBuffer(len); // needed?
Andy Hungf98ec8d2015-05-19 12:53:24 -0700834 s.unlockBuffer(len - 2); // remove trailing ", "
835 }
836 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800837 }
Andy Hungf98ec8d2015-05-19 12:53:24 -0700838 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
839 s.appendFormat("index mask, bits:%#x", audio_channel_mask_get_bits(mask));
840 return s;
841 default:
842 s.appendFormat("unknown mask, representation:%d bits:%#x",
843 representation, audio_channel_mask_get_bits(mask));
844 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800845 }
Marco Nelissenb2208842014-02-07 14:00:50 -0800846}
847
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700848void AudioFlinger::ThreadBase::dump(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800849{
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800850 dprintf(fd, "\n%s thread %p, name %s, tid %d, type %d (%s):\n", isOutput() ? "Output" : "Input",
851 this, mThreadName, getTid(), type(), threadTypeToString(type()));
852
Eric Laurent81784c32012-11-19 14:55:58 -0800853 bool locked = AudioFlinger::dumpTryLock(mLock);
854 if (!locked) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800855 dprintf(fd, " Thread may be deadlocked\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800856 }
857
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700858 dumpBase_l(fd, args);
859 dumpInternals_l(fd, args);
860 dumpTracks_l(fd, args);
861 dumpEffectChains_l(fd, args);
862
863 if (locked) {
864 mLock.unlock();
865 }
866
867 dprintf(fd, " Local log:\n");
868 mLocalLog.dump(fd, " " /* prefix */, 40 /* lines */);
869}
870
871void AudioFlinger::ThreadBase::dumpBase_l(int fd, const Vector<String16>& args __unused)
872{
Elliott Hughes87cebad2014-05-22 10:14:43 -0700873 dprintf(fd, " I/O handle: %d\n", mId);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700874 dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
Glenn Kasten97b7b752014-09-28 13:04:24 -0700875 dprintf(fd, " Sample rate: %u Hz\n", mSampleRate);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700876 dprintf(fd, " HAL frame count: %zu\n", mFrameCount);
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700877 dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat).c_str());
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700878 dprintf(fd, " HAL buffer size: %zu bytes\n", mBufferSize);
Glenn Kasten97b7b752014-09-28 13:04:24 -0700879 dprintf(fd, " Channel count: %u\n", mChannelCount);
880 dprintf(fd, " Channel mask: 0x%08x (%s)\n", mChannelMask,
Marco Nelissenb2208842014-02-07 14:00:50 -0800881 channelMaskToString(mChannelMask, mType != RECORD).string());
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700882 dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat).c_str());
Glenn Kastenf87c2f52015-08-21 08:03:57 -0700883 dprintf(fd, " Processing frame size: %zu bytes\n", mFrameSize);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700884 dprintf(fd, " Pending config events:");
Marco Nelissenb2208842014-02-07 14:00:50 -0800885 size_t numConfig = mConfigEvents.size();
886 if (numConfig) {
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700887 const size_t SIZE = 256;
888 char buffer[SIZE];
Marco Nelissenb2208842014-02-07 14:00:50 -0800889 for (size_t i = 0; i < numConfig; i++) {
890 mConfigEvents[i]->dump(buffer, SIZE);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700891 dprintf(fd, "\n %s", buffer);
Marco Nelissenb2208842014-02-07 14:00:50 -0800892 }
Elliott Hughes87cebad2014-05-22 10:14:43 -0700893 dprintf(fd, "\n");
Marco Nelissenb2208842014-02-07 14:00:50 -0800894 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -0700895 dprintf(fd, " none\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800896 }
Andy Hung293558a2017-03-21 12:19:20 -0700897 // Note: output device may be used by capture threads for effects such as AEC.
jiabin10d86fd2019-10-31 17:20:42 -0700898 dprintf(fd, " Output devices: %s (%s)\n",
899 dumpDeviceTypes(outDeviceTypes()).c_str(), toString(outDeviceTypes()).c_str());
900 dprintf(fd, " Input device: %#x (%s)\n",
901 inDeviceType(), toString(inDeviceType()).c_str());
Andy Hung9b181952019-02-25 14:53:36 -0800902 dprintf(fd, " Audio source: %d (%s)\n", mAudioSource, toString(mAudioSource).c_str());
Eric Laurent81784c32012-11-19 14:55:58 -0800903
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700904 // Dump timestamp statistics for the Thread types that support it.
905 if (mType == RECORD
906 || mType == MIXER
907 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -0700908 || mType == DIRECT
909 || mType == OFFLOAD) {
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700910 dprintf(fd, " Timestamp stats: %s\n", mTimestampVerifier.toString().c_str());
Andy Hungc8fddf32018-08-08 18:32:37 -0700911 dprintf(fd, " Timestamp corrected: %s\n", isTimestampCorrectionEnabled() ? "yes" : "no");
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700912 }
913
Andy Hung446f4df2019-02-21 12:26:41 -0800914 if (mLastIoBeginNs > 0) { // MMAP may not set this
915 dprintf(fd, " Last %s occurred (msecs): %lld\n",
916 isOutput() ? "write" : "read",
917 (long long) (systemTime() - mLastIoBeginNs) / NANOS_PER_MILLISECOND);
918 }
919
920 if (mProcessTimeMs.getN() > 0) {
921 dprintf(fd, " Process time ms stats: %s\n", mProcessTimeMs.toString().c_str());
922 }
923
924 if (mIoJitterMs.getN() > 0) {
925 dprintf(fd, " Hal %s jitter ms stats: %s\n",
926 isOutput() ? "write" : "read",
927 mIoJitterMs.toString().c_str());
928 }
929
Andy Hunge6c37112019-02-26 17:38:10 -0800930 if (mLatencyMs.getN() > 0) {
931 dprintf(fd, " Threadloop %s latency stats: %s\n",
932 isOutput() ? "write" : "read",
933 mLatencyMs.toString().c_str());
934 }
Eric Laurent81784c32012-11-19 14:55:58 -0800935}
936
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700937void AudioFlinger::ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800938{
939 const size_t SIZE = 256;
940 char buffer[SIZE];
Eric Laurent81784c32012-11-19 14:55:58 -0800941
Marco Nelissenb2208842014-02-07 14:00:50 -0800942 size_t numEffectChains = mEffectChains.size();
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +0000943 snprintf(buffer, SIZE, " %zu Effect Chains\n", numEffectChains);
Eric Laurent81784c32012-11-19 14:55:58 -0800944 write(fd, buffer, strlen(buffer));
945
Marco Nelissenb2208842014-02-07 14:00:50 -0800946 for (size_t i = 0; i < numEffectChains; ++i) {
Eric Laurent81784c32012-11-19 14:55:58 -0800947 sp<EffectChain> chain = mEffectChains[i];
948 if (chain != 0) {
949 chain->dump(fd, args);
950 }
951 }
952}
953
Andy Hungdae27702016-10-31 14:01:16 -0700954void AudioFlinger::ThreadBase::acquireWakeLock()
Eric Laurent81784c32012-11-19 14:55:58 -0800955{
956 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -0700957 acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800958}
959
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100960String16 AudioFlinger::ThreadBase::getWakeLockTag()
961{
962 switch (mType) {
Glenn Kastenbcb14862015-03-05 17:11:21 -0800963 case MIXER:
964 return String16("AudioMix");
965 case DIRECT:
966 return String16("AudioDirectOut");
967 case DUPLICATING:
968 return String16("AudioDup");
969 case RECORD:
970 return String16("AudioIn");
971 case OFFLOAD:
972 return String16("AudioOffload");
Andy Hungea840382020-05-05 21:50:17 -0700973 case MMAP_PLAYBACK:
974 return String16("MmapPlayback");
975 case MMAP_CAPTURE:
976 return String16("MmapCapture");
Glenn Kastenbcb14862015-03-05 17:11:21 -0800977 default:
978 ALOG_ASSERT(false);
979 return String16("AudioUnknown");
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100980 }
981}
982
Andy Hungdae27702016-10-31 14:01:16 -0700983void AudioFlinger::ThreadBase::acquireWakeLock_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800984{
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800985 getPowerManager_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800986 if (mPowerManager != 0) {
987 sp<IBinder> binder = new BBinder();
Andy Hungdae27702016-10-31 14:01:16 -0700988 // Uses AID_AUDIOSERVER for wakelock. updateWakeLockUids_l() updates with client uids.
989 status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
Marco Nelissene14a5d62013-10-03 08:51:24 -0700990 binder,
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100991 getWakeLockTag(),
Marco Nelissendcb346b2015-09-09 10:47:29 -0700992 String16("audioserver"),
Glenn Kasten3abc2de2014-09-05 16:45:52 -0700993 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent81784c32012-11-19 14:55:58 -0800994 if (status == NO_ERROR) {
995 mWakeLockToken = binder;
996 }
Glenn Kastend7dca052015-03-05 16:05:54 -0800997 ALOGV("acquireWakeLock_l() %s status %d", mThreadName, status);
Eric Laurent81784c32012-11-19 14:55:58 -0800998 }
Wei Jia3f273d12015-11-24 09:06:49 -0800999
Andy Hung3f0c9022016-01-15 17:49:46 -08001000 gBoottime.acquire(mWakeLockToken);
Andy Hung818e7a32016-02-16 18:08:07 -08001001 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
1002 gBoottime.getBoottimeOffset();
Eric Laurent81784c32012-11-19 14:55:58 -08001003}
1004
1005void AudioFlinger::ThreadBase::releaseWakeLock()
1006{
1007 Mutex::Autolock _l(mLock);
1008 releaseWakeLock_l();
1009}
1010
1011void AudioFlinger::ThreadBase::releaseWakeLock_l()
1012{
Andy Hung3f0c9022016-01-15 17:49:46 -08001013 gBoottime.release(mWakeLockToken);
Eric Laurent81784c32012-11-19 14:55:58 -08001014 if (mWakeLockToken != 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001015 ALOGV("releaseWakeLock_l() %s", mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001016 if (mPowerManager != 0) {
Glenn Kasten3abc2de2014-09-05 16:45:52 -07001017 mPowerManager->releaseWakeLock(mWakeLockToken, 0,
1018 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent81784c32012-11-19 14:55:58 -08001019 }
1020 mWakeLockToken.clear();
1021 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001022}
1023
1024void AudioFlinger::ThreadBase::getPowerManager_l() {
Eric Laurent72e3f392015-05-20 14:43:50 -07001025 if (mSystemReady && mPowerManager == 0) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001026 // use checkService() to avoid blocking if power service is not up yet
1027 sp<IBinder> binder =
1028 defaultServiceManager()->checkService(String16("power"));
1029 if (binder == 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -08001030 ALOGW("Thread %s cannot connect to the power manager service", mThreadName);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001031 } else {
1032 mPowerManager = interface_cast<IPowerManager>(binder);
1033 binder->linkToDeath(mDeathRecipient);
1034 }
1035 }
1036}
1037
Andy Hungd01b0f12016-11-07 16:10:30 -08001038void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t> &uids) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001039 getPowerManager_l();
Andy Hungdae27702016-10-31 14:01:16 -07001040
1041#if !LOG_NDEBUG
1042 std::stringstream s;
Andy Hungd01b0f12016-11-07 16:10:30 -08001043 for (uid_t uid : uids) {
Andy Hungdae27702016-10-31 14:01:16 -07001044 s << uid << " ";
1045 }
1046 ALOGD("updateWakeLockUids_l %s uids:%s", mThreadName, s.str().c_str());
1047#endif
1048
Andy Hung438e7572015-12-14 15:51:17 -08001049 if (mWakeLockToken == NULL) { // token may be NULL if AudioFlinger::systemReady() not called.
1050 if (mSystemReady) {
1051 ALOGE("no wake lock to update, but system ready!");
1052 } else {
1053 ALOGW("no wake lock to update, system not ready yet");
1054 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001055 return;
1056 }
1057 if (mPowerManager != 0) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08001058 std::vector<int> uidsAsInt(uids.begin(), uids.end()); // powermanager expects uids as ints
1059 status_t status = mPowerManager->updateWakeLockUids(
1060 mWakeLockToken, uidsAsInt.size(), uidsAsInt.data(),
1061 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001062 ALOGV("updateWakeLockUids_l() %s status %d", mThreadName, status);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001063 }
1064}
1065
Eric Laurent81784c32012-11-19 14:55:58 -08001066void AudioFlinger::ThreadBase::clearPowerManager()
1067{
1068 Mutex::Autolock _l(mLock);
1069 releaseWakeLock_l();
1070 mPowerManager.clear();
1071}
1072
jiabin10d86fd2019-10-31 17:20:42 -07001073void AudioFlinger::ThreadBase::updateOutDevices(
1074 const DeviceDescriptorBaseVector& outDevices __unused)
1075{
1076 ALOGE("%s should only be called in RecordThread", __func__);
1077}
1078
Glenn Kasten0f11b512014-01-31 16:18:54 -08001079void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001080{
1081 sp<ThreadBase> thread = mThread.promote();
1082 if (thread != 0) {
1083 thread->clearPowerManager();
1084 }
1085 ALOGW("power manager service died !!!");
1086}
1087
Eric Laurent81784c32012-11-19 14:55:58 -08001088void AudioFlinger::ThreadBase::setEffectSuspended_l(
Glenn Kastend848eb42016-03-08 13:42:11 -08001089 const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001090{
1091 sp<EffectChain> chain = getEffectChain_l(sessionId);
1092 if (chain != 0) {
1093 if (type != NULL) {
1094 chain->setEffectSuspended_l(type, suspend);
1095 } else {
1096 chain->setEffectSuspendedAll_l(suspend);
1097 }
1098 }
1099
1100 updateSuspendedSessions_l(type, suspend, sessionId);
1101}
1102
1103void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1104{
1105 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
1106 if (index < 0) {
1107 return;
1108 }
1109
1110 const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
1111 mSuspendedSessions.valueAt(index);
1112
1113 for (size_t i = 0; i < sessionEffects.size(); i++) {
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001114 const sp<SuspendedSessionDesc>& desc = sessionEffects.valueAt(i);
Eric Laurent81784c32012-11-19 14:55:58 -08001115 for (int j = 0; j < desc->mRefCount; j++) {
1116 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1117 chain->setEffectSuspendedAll_l(true);
1118 } else {
1119 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1120 desc->mType.timeLow);
1121 chain->setEffectSuspended_l(&desc->mType, true);
1122 }
1123 }
1124 }
1125}
1126
1127void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1128 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -08001129 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001130{
1131 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
1132
1133 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1134
1135 if (suspend) {
1136 if (index >= 0) {
1137 sessionEffects = mSuspendedSessions.valueAt(index);
1138 } else {
1139 mSuspendedSessions.add(sessionId, sessionEffects);
1140 }
1141 } else {
1142 if (index < 0) {
1143 return;
1144 }
1145 sessionEffects = mSuspendedSessions.valueAt(index);
1146 }
1147
1148
1149 int key = EffectChain::kKeyForSuspendAll;
1150 if (type != NULL) {
1151 key = type->timeLow;
1152 }
1153 index = sessionEffects.indexOfKey(key);
1154
1155 sp<SuspendedSessionDesc> desc;
1156 if (suspend) {
1157 if (index >= 0) {
1158 desc = sessionEffects.valueAt(index);
1159 } else {
1160 desc = new SuspendedSessionDesc();
1161 if (type != NULL) {
1162 desc->mType = *type;
1163 }
1164 sessionEffects.add(key, desc);
1165 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1166 }
1167 desc->mRefCount++;
1168 } else {
1169 if (index < 0) {
1170 return;
1171 }
1172 desc = sessionEffects.valueAt(index);
1173 if (--desc->mRefCount == 0) {
1174 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1175 sessionEffects.removeItemsAt(index);
1176 if (sessionEffects.isEmpty()) {
1177 ALOGV("updateSuspendedSessions_l() restore removing session %d",
1178 sessionId);
1179 mSuspendedSessions.removeItem(sessionId);
1180 }
1181 }
1182 }
1183 if (!sessionEffects.isEmpty()) {
1184 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1185 }
1186}
1187
Eric Laurent5d885392019-12-13 10:56:31 -08001188void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
1189 audio_session_t sessionId,
1190 bool threadLocked) {
1191 if (!threadLocked) {
1192 mLock.lock();
1193 }
Eric Laurent81784c32012-11-19 14:55:58 -08001194
Eric Laurent81784c32012-11-19 14:55:58 -08001195 if (mType != RECORD) {
1196 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1197 // another session. This gives the priority to well behaved effect control panels
1198 // and applications not using global effects.
1199 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1200 // global effects
Eric Laurenta20c4e92019-11-12 15:55:51 -08001201 if (!audio_is_global_session(sessionId)) {
Eric Laurent81784c32012-11-19 14:55:58 -08001202 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1203 }
1204 }
1205
Eric Laurent5d885392019-12-13 10:56:31 -08001206 if (!threadLocked) {
1207 mLock.unlock();
Eric Laurent81784c32012-11-19 14:55:58 -08001208 }
1209}
1210
Eric Laurent4c415062016-06-17 16:14:16 -07001211// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1212status_t AudioFlinger::RecordThread::checkEffectCompatibility_l(
1213 const effect_descriptor_t *desc, audio_session_t sessionId)
1214{
Eric Laurenta20c4e92019-11-12 15:55:51 -08001215 // No global output effect sessions on record threads
1216 if (sessionId == AUDIO_SESSION_OUTPUT_MIX
1217 || sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Eric Laurent4c415062016-06-17 16:14:16 -07001218 ALOGW("checkEffectCompatibility_l(): global effect %s on record thread %s",
1219 desc->name, mThreadName);
1220 return BAD_VALUE;
1221 }
1222 // only pre processing effects on record thread
1223 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) {
1224 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on record thread %s",
1225 desc->name, mThreadName);
1226 return BAD_VALUE;
1227 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001228
1229 // always allow effects without processing load or latency
1230 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1231 return NO_ERROR;
1232 }
1233
Eric Laurent4c415062016-06-17 16:14:16 -07001234 audio_input_flags_t flags = mInput->flags;
1235 if (hasFastCapture() || (flags & AUDIO_INPUT_FLAG_FAST)) {
1236 if (flags & AUDIO_INPUT_FLAG_RAW) {
1237 ALOGW("checkEffectCompatibility_l(): effect %s on record thread %s in raw mode",
1238 desc->name, mThreadName);
1239 return BAD_VALUE;
1240 }
1241 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1242 ALOGW("checkEffectCompatibility_l(): non HW effect %s on record thread %s in fast mode",
1243 desc->name, mThreadName);
1244 return BAD_VALUE;
1245 }
1246 }
1247 return NO_ERROR;
1248}
1249
1250// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1251status_t AudioFlinger::PlaybackThread::checkEffectCompatibility_l(
1252 const effect_descriptor_t *desc, audio_session_t sessionId)
1253{
1254 // no preprocessing on playback threads
1255 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) {
1256 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback"
1257 " thread %s", desc->name, mThreadName);
1258 return BAD_VALUE;
1259 }
1260
Eric Laurent3e4de772017-07-16 16:55:08 -07001261 // always allow effects without processing load or latency
1262 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1263 return NO_ERROR;
1264 }
1265
Eric Laurent4c415062016-06-17 16:14:16 -07001266 switch (mType) {
1267 case MIXER: {
Andy Hung9aad48c2017-11-29 10:29:19 -08001268#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001269 // Reject any effect on mixer multichannel sinks.
1270 // TODO: fix both format and multichannel issues with effects.
1271 if (mChannelCount != FCC_2) {
1272 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d) on MIXER"
1273 " thread %s", desc->name, mChannelCount, mThreadName);
1274 return BAD_VALUE;
1275 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001276#endif
Eric Laurent4c415062016-06-17 16:14:16 -07001277 audio_output_flags_t flags = mOutput->flags;
1278 if (hasFastMixer() || (flags & AUDIO_OUTPUT_FLAG_FAST)) {
1279 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1280 // global effects are applied only to non fast tracks if they are SW
1281 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1282 break;
1283 }
1284 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1285 // only post processing on output stage session
1286 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1287 ALOGW("checkEffectCompatibility_l(): non post processing effect %s not allowed"
1288 " on output stage session", desc->name);
1289 return BAD_VALUE;
1290 }
Eric Laurenta20c4e92019-11-12 15:55:51 -08001291 } else if (sessionId == AUDIO_SESSION_DEVICE) {
1292 // only post processing on output stage session
1293 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1294 ALOGW("checkEffectCompatibility_l(): non post processing effect %s not allowed"
1295 " on device session", desc->name);
1296 return BAD_VALUE;
1297 }
Eric Laurent4c415062016-06-17 16:14:16 -07001298 } else {
1299 // no restriction on effects applied on non fast tracks
1300 if ((hasAudioSession_l(sessionId) & ThreadBase::FAST_SESSION) == 0) {
1301 break;
1302 }
1303 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001304
Eric Laurent4c415062016-06-17 16:14:16 -07001305 if (flags & AUDIO_OUTPUT_FLAG_RAW) {
1306 ALOGW("checkEffectCompatibility_l(): effect %s on playback thread in raw mode",
1307 desc->name);
1308 return BAD_VALUE;
1309 }
1310 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1311 ALOGW("checkEffectCompatibility_l(): non HW effect %s on playback thread"
1312 " in fast mode", desc->name);
1313 return BAD_VALUE;
1314 }
1315 }
1316 } break;
1317 case OFFLOAD:
Jean-Michel Trivi773ee952016-07-11 16:53:18 -07001318 // nothing actionable on offload threads, if the effect:
1319 // - is offloadable: the effect can be created
1320 // - is NOT offloadable: the effect should still be created, but EffectHandle::enable()
1321 // will take care of invalidating the tracks of the thread
Eric Laurent4c415062016-06-17 16:14:16 -07001322 break;
1323 case DIRECT:
1324 // Reject any effect on Direct output threads for now, since the format of
1325 // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
1326 ALOGW("checkEffectCompatibility_l(): effect %s on DIRECT output thread %s",
1327 desc->name, mThreadName);
1328 return BAD_VALUE;
1329 case DUPLICATING:
Andy Hung9aad48c2017-11-29 10:29:19 -08001330#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001331 // Reject any effect on mixer multichannel sinks.
1332 // TODO: fix both format and multichannel issues with effects.
1333 if (mChannelCount != FCC_2) {
1334 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d)"
1335 " on DUPLICATING thread %s", desc->name, mChannelCount, mThreadName);
1336 return BAD_VALUE;
1337 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001338#endif
Eric Laurenta20c4e92019-11-12 15:55:51 -08001339 if (audio_is_global_session(sessionId)) {
Eric Laurent4c415062016-06-17 16:14:16 -07001340 ALOGW("checkEffectCompatibility_l(): global effect %s on DUPLICATING"
1341 " thread %s", desc->name, mThreadName);
1342 return BAD_VALUE;
1343 }
1344 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
1345 ALOGW("checkEffectCompatibility_l(): post processing effect %s on"
1346 " DUPLICATING thread %s", desc->name, mThreadName);
1347 return BAD_VALUE;
1348 }
1349 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) != 0) {
1350 ALOGW("checkEffectCompatibility_l(): HW tunneled effect %s on"
1351 " DUPLICATING thread %s", desc->name, mThreadName);
1352 return BAD_VALUE;
1353 }
1354 break;
1355 default:
1356 LOG_ALWAYS_FATAL("checkEffectCompatibility_l(): wrong thread type %d", mType);
1357 }
1358
1359 return NO_ERROR;
1360}
1361
Eric Laurent81784c32012-11-19 14:55:58 -08001362// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
1363sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
1364 const sp<AudioFlinger::Client>& client,
1365 const sp<IEffectClient>& effectClient,
1366 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -08001367 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -08001368 effect_descriptor_t *desc,
1369 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001370 status_t *status,
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001371 bool pinned,
1372 bool probe)
Eric Laurent81784c32012-11-19 14:55:58 -08001373{
1374 sp<EffectModule> effect;
1375 sp<EffectHandle> handle;
1376 status_t lStatus;
1377 sp<EffectChain> chain;
1378 bool chainCreated = false;
1379 bool effectCreated = false;
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001380 audio_unique_id_t effectId = AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
Eric Laurent81784c32012-11-19 14:55:58 -08001381
1382 lStatus = initCheck();
1383 if (lStatus != NO_ERROR) {
1384 ALOGW("createEffect_l() Audio driver not initialized.");
1385 goto Exit;
1386 }
1387
Eric Laurent81784c32012-11-19 14:55:58 -08001388 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
1389
1390 { // scope for mLock
1391 Mutex::Autolock _l(mLock);
1392
Eric Laurent4c415062016-06-17 16:14:16 -07001393 lStatus = checkEffectCompatibility_l(desc, sessionId);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001394 if (probe || lStatus != NO_ERROR) {
Eric Laurent4c415062016-06-17 16:14:16 -07001395 goto Exit;
1396 }
1397
Eric Laurent81784c32012-11-19 14:55:58 -08001398 // check for existing effect chain with the requested audio session
1399 chain = getEffectChain_l(sessionId);
1400 if (chain == 0) {
1401 // create a new chain for this session
1402 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
1403 chain = new EffectChain(this, sessionId);
1404 addEffectChain_l(chain);
1405 chain->setStrategy(getStrategyForSession_l(sessionId));
1406 chainCreated = true;
1407 } else {
1408 effect = chain->getEffectFromDesc_l(desc);
1409 }
1410
1411 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
1412
1413 if (effect == 0) {
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001414 effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
Eric Laurent81784c32012-11-19 14:55:58 -08001415 // create a new effect module if none present in the chain
Eric Laurent5d885392019-12-13 10:56:31 -08001416 lStatus = chain->createEffect_l(effect, desc, effectId, sessionId, pinned);
Eric Laurent81784c32012-11-19 14:55:58 -08001417 if (lStatus != NO_ERROR) {
1418 goto Exit;
1419 }
1420 effectCreated = true;
1421
jiabin10d86fd2019-10-31 17:20:42 -07001422 // FIXME: use vector of device and address when effect interface is ready.
jiabinb8269fd2019-11-11 12:16:27 -08001423 effect->setDevices(outDeviceTypeAddrs());
1424 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001425 effect->setMode(mAudioFlinger->getMode());
1426 effect->setAudioSource(mAudioSource);
1427 }
1428 // create effect handle and connect it to effect module
1429 handle = new EffectHandle(effect, client, effectClient, priority);
Glenn Kastene75da402013-11-20 13:54:52 -08001430 lStatus = handle->initCheck();
1431 if (lStatus == OK) {
1432 lStatus = effect->addHandle(handle.get());
1433 }
Eric Laurent81784c32012-11-19 14:55:58 -08001434 if (enabled != NULL) {
1435 *enabled = (int)effect->isEnabled();
1436 }
1437 }
1438
1439Exit:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07001440 if (!probe && lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurent81784c32012-11-19 14:55:58 -08001441 Mutex::Autolock _l(mLock);
1442 if (effectCreated) {
1443 chain->removeEffect_l(effect);
1444 }
Eric Laurent81784c32012-11-19 14:55:58 -08001445 if (chainCreated) {
1446 removeEffectChain_l(chain);
1447 }
haobo101735295ff7b0d2017-03-17 17:44:03 +08001448 // handle must be cleared by caller to avoid deadlock.
Eric Laurent81784c32012-11-19 14:55:58 -08001449 }
1450
Glenn Kasten9156ef32013-08-06 15:39:08 -07001451 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08001452 return handle;
1453}
1454
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001455void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
1456 bool unpinIfLast)
1457{
1458 bool remove = false;
1459 sp<EffectModule> effect;
1460 {
1461 Mutex::Autolock _l(mLock);
Eric Laurente0b9a362019-12-16 19:34:05 -08001462 sp<EffectBase> effectBase = handle->effect().promote();
1463 if (effectBase == nullptr) {
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001464 return;
1465 }
Eric Laurent9b2064c2019-11-22 17:25:04 -08001466 effect = effectBase->asEffectModule();
1467 if (effect == nullptr) {
1468 return;
1469 }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001470 // restore suspended effects if the disconnected handle was enabled and the last one.
1471 remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
1472 if (remove) {
1473 removeEffect_l(effect, true);
1474 }
1475 }
1476 if (remove) {
1477 mAudioFlinger->updateOrphanEffectChains(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001478 if (handle->enabled()) {
Eric Laurent5d885392019-12-13 10:56:31 -08001479 effect->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001480 }
1481 }
1482}
1483
Eric Laurent5d885392019-12-13 10:56:31 -08001484void AudioFlinger::ThreadBase::onEffectEnable(const sp<EffectModule>& effect) {
Andy Hungea840382020-05-05 21:50:17 -07001485 if (isOffloadOrMmap()) {
Eric Laurent5d885392019-12-13 10:56:31 -08001486 Mutex::Autolock _l(mLock);
1487 broadcast_l();
1488 }
1489 if (!effect->isOffloadable()) {
1490 if (mType == ThreadBase::OFFLOAD) {
1491 PlaybackThread *t = (PlaybackThread *)this;
1492 t->invalidateTracks(AUDIO_STREAM_MUSIC);
1493 }
1494 if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
1495 mAudioFlinger->onNonOffloadableGlobalEffectEnable();
1496 }
1497 }
1498}
1499
1500void AudioFlinger::ThreadBase::onEffectDisable() {
Andy Hungea840382020-05-05 21:50:17 -07001501 if (isOffloadOrMmap()) {
Eric Laurent5d885392019-12-13 10:56:31 -08001502 Mutex::Autolock _l(mLock);
1503 broadcast_l();
1504 }
1505}
1506
Glenn Kastend848eb42016-03-08 13:42:11 -08001507sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
1508 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001509{
1510 Mutex::Autolock _l(mLock);
1511 return getEffect_l(sessionId, effectId);
1512}
1513
Glenn Kastend848eb42016-03-08 13:42:11 -08001514sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
1515 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001516{
1517 sp<EffectChain> chain = getEffectChain_l(sessionId);
1518 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
1519}
1520
Eric Laurent6c796322019-04-09 14:13:17 -07001521std::vector<int> AudioFlinger::ThreadBase::getEffectIds_l(audio_session_t sessionId)
1522{
1523 sp<EffectChain> chain = getEffectChain_l(sessionId);
1524 return chain != nullptr ? chain->getEffectIds() : std::vector<int>{};
1525}
1526
Eric Laurent81784c32012-11-19 14:55:58 -08001527// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
1528// PlaybackThread::mLock held
1529status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
1530{
1531 // check for existing effect chain with the requested audio session
Glenn Kastend848eb42016-03-08 13:42:11 -08001532 audio_session_t sessionId = effect->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08001533 sp<EffectChain> chain = getEffectChain_l(sessionId);
1534 bool chainCreated = false;
1535
Eric Laurent5baf2af2013-09-12 17:37:00 -07001536 ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001537 "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %#x",
Eric Laurent5baf2af2013-09-12 17:37:00 -07001538 this, effect->desc().name, effect->desc().flags);
1539
Eric Laurent81784c32012-11-19 14:55:58 -08001540 if (chain == 0) {
1541 // create a new chain for this session
1542 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
1543 chain = new EffectChain(this, sessionId);
1544 addEffectChain_l(chain);
1545 chain->setStrategy(getStrategyForSession_l(sessionId));
1546 chainCreated = true;
1547 }
1548 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
1549
1550 if (chain->getEffectFromId_l(effect->id()) != 0) {
1551 ALOGW("addEffect_l() %p effect %s already present in chain %p",
1552 this, effect->desc().name, chain.get());
1553 return BAD_VALUE;
1554 }
1555
Eric Laurent5baf2af2013-09-12 17:37:00 -07001556 effect->setOffloaded(mType == OFFLOAD, mId);
1557
Eric Laurent81784c32012-11-19 14:55:58 -08001558 status_t status = chain->addEffect_l(effect);
1559 if (status != NO_ERROR) {
1560 if (chainCreated) {
1561 removeEffectChain_l(chain);
1562 }
1563 return status;
1564 }
1565
jiabinb8269fd2019-11-11 12:16:27 -08001566 effect->setDevices(outDeviceTypeAddrs());
1567 effect->setInputDevice(inDeviceTypeAddr());
Eric Laurent81784c32012-11-19 14:55:58 -08001568 effect->setMode(mAudioFlinger->getMode());
1569 effect->setAudioSource(mAudioSource);
Eric Laurentd8365c52017-07-16 15:27:05 -07001570
Eric Laurent81784c32012-11-19 14:55:58 -08001571 return NO_ERROR;
1572}
1573
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001574void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect, bool release) {
Eric Laurent81784c32012-11-19 14:55:58 -08001575
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001576 ALOGV("%s %p effect %p", __FUNCTION__, this, effect.get());
Eric Laurent81784c32012-11-19 14:55:58 -08001577 effect_descriptor_t desc = effect->desc();
1578 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1579 detachAuxEffect_l(effect->id());
1580 }
1581
Eric Laurent5d885392019-12-13 10:56:31 -08001582 sp<EffectChain> chain = effect->callback()->chain().promote();
Eric Laurent81784c32012-11-19 14:55:58 -08001583 if (chain != 0) {
1584 // remove effect chain if removing last effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001585 if (chain->removeEffect_l(effect, release) == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001586 removeEffectChain_l(chain);
1587 }
1588 } else {
1589 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
1590 }
1591}
1592
1593void AudioFlinger::ThreadBase::lockEffectChains_l(
1594 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1595{
1596 effectChains = mEffectChains;
1597 for (size_t i = 0; i < mEffectChains.size(); i++) {
1598 mEffectChains[i]->lock();
1599 }
1600}
1601
1602void AudioFlinger::ThreadBase::unlockEffectChains(
1603 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1604{
1605 for (size_t i = 0; i < effectChains.size(); i++) {
1606 effectChains[i]->unlock();
1607 }
1608}
1609
Glenn Kastend848eb42016-03-08 13:42:11 -08001610sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001611{
1612 Mutex::Autolock _l(mLock);
1613 return getEffectChain_l(sessionId);
1614}
1615
Glenn Kastend848eb42016-03-08 13:42:11 -08001616sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
1617 const
Eric Laurent81784c32012-11-19 14:55:58 -08001618{
1619 size_t size = mEffectChains.size();
1620 for (size_t i = 0; i < size; i++) {
1621 if (mEffectChains[i]->sessionId() == sessionId) {
1622 return mEffectChains[i];
1623 }
1624 }
1625 return 0;
1626}
1627
1628void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
1629{
1630 Mutex::Autolock _l(mLock);
1631 size_t size = mEffectChains.size();
1632 for (size_t i = 0; i < size; i++) {
1633 mEffectChains[i]->setMode_l(mode);
1634 }
1635}
1636
Mikhail Naganovdc769682018-05-04 15:34:08 -07001637void AudioFlinger::ThreadBase::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07001638{
1639 config->type = AUDIO_PORT_TYPE_MIX;
1640 config->ext.mix.handle = mId;
1641 config->sample_rate = mSampleRate;
1642 config->format = mFormat;
1643 config->channel_mask = mChannelMask;
1644 config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
1645 AUDIO_PORT_CONFIG_FORMAT;
1646}
1647
Eric Laurent72e3f392015-05-20 14:43:50 -07001648void AudioFlinger::ThreadBase::systemReady()
1649{
1650 Mutex::Autolock _l(mLock);
1651 if (mSystemReady) {
1652 return;
1653 }
1654 mSystemReady = true;
1655
1656 for (size_t i = 0; i < mPendingConfigEvents.size(); i++) {
1657 sendConfigEvent_l(mPendingConfigEvents.editItemAt(i));
1658 }
1659 mPendingConfigEvents.clear();
1660}
1661
Andy Hungdae27702016-10-31 14:01:16 -07001662template <typename T>
1663ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::add(const sp<T> &track) {
1664 ssize_t index = mActiveTracks.indexOf(track);
1665 if (index >= 0) {
1666 ALOGW("ActiveTracks<T>::add track %p already there", track.get());
1667 return index;
1668 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001669 logTrack("add", track);
Andy Hungdae27702016-10-31 14:01:16 -07001670 mActiveTracksGeneration++;
1671 mLatestActiveTrack = track;
1672 ++mBatteryCounter[track->uid()].second;
Kevin Rocard069c2712018-03-29 19:09:14 -07001673 mHasChanged = true;
Andy Hungdae27702016-10-31 14:01:16 -07001674 return mActiveTracks.add(track);
1675}
1676
1677template <typename T>
1678ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::remove(const sp<T> &track) {
1679 ssize_t index = mActiveTracks.remove(track);
1680 if (index < 0) {
1681 ALOGW("ActiveTracks<T>::remove nonexistent track %p", track.get());
1682 return index;
1683 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001684 logTrack("remove", track);
Andy Hungdae27702016-10-31 14:01:16 -07001685 mActiveTracksGeneration++;
1686 --mBatteryCounter[track->uid()].second;
1687 // mLatestActiveTrack is not cleared even if is the same as track.
Kevin Rocard069c2712018-03-29 19:09:14 -07001688 mHasChanged = true;
Andy Hung8946a282018-04-19 20:04:56 -07001689#ifdef TEE_SINK
1690 track->dumpTee(-1 /* fd */, "_REMOVE");
1691#endif
Andy Hungc2b11cb2020-04-22 09:04:01 -07001692 track->logEndInterval(); // log to MediaMetrics
Andy Hungdae27702016-10-31 14:01:16 -07001693 return index;
1694}
1695
1696template <typename T>
1697void AudioFlinger::ThreadBase::ActiveTracks<T>::clear() {
1698 for (const sp<T> &track : mActiveTracks) {
1699 BatteryNotifier::getInstance().noteStopAudio(track->uid());
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001700 logTrack("clear", track);
Andy Hungdae27702016-10-31 14:01:16 -07001701 }
1702 mLastActiveTracksGeneration = mActiveTracksGeneration;
Kevin Rocard069c2712018-03-29 19:09:14 -07001703 if (!mActiveTracks.empty()) { mHasChanged = true; }
Andy Hungdae27702016-10-31 14:01:16 -07001704 mActiveTracks.clear();
1705 mLatestActiveTrack.clear();
1706 mBatteryCounter.clear();
1707}
1708
1709template <typename T>
1710void AudioFlinger::ThreadBase::ActiveTracks<T>::updatePowerState(
1711 sp<ThreadBase> thread, bool force) {
1712 // Updates ActiveTracks client uids to the thread wakelock.
1713 if (mActiveTracksGeneration != mLastActiveTracksGeneration || force) {
1714 thread->updateWakeLockUids_l(getWakeLockUids());
1715 mLastActiveTracksGeneration = mActiveTracksGeneration;
1716 }
1717
1718 // Updates BatteryNotifier uids
1719 for (auto it = mBatteryCounter.begin(); it != mBatteryCounter.end();) {
1720 const uid_t uid = it->first;
1721 ssize_t &previous = it->second.first;
1722 ssize_t &current = it->second.second;
1723 if (current > 0) {
1724 if (previous == 0) {
1725 BatteryNotifier::getInstance().noteStartAudio(uid);
1726 }
1727 previous = current;
1728 ++it;
1729 } else if (current == 0) {
1730 if (previous > 0) {
1731 BatteryNotifier::getInstance().noteStopAudio(uid);
1732 }
1733 it = mBatteryCounter.erase(it); // std::map<> is stable on iterator erase.
1734 } else /* (current < 0) */ {
1735 LOG_ALWAYS_FATAL("negative battery count %zd", current);
1736 }
1737 }
1738}
Eric Laurent83b88082014-06-20 18:31:16 -07001739
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001740template <typename T>
Kevin Rocard069c2712018-03-29 19:09:14 -07001741bool AudioFlinger::ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
1742 const bool hasChanged = mHasChanged;
1743 mHasChanged = false;
1744 return hasChanged;
1745}
1746
1747template <typename T>
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001748void AudioFlinger::ThreadBase::ActiveTracks<T>::logTrack(
1749 const char *funcName, const sp<T> &track) const {
1750 if (mLocalLog != nullptr) {
1751 String8 result;
1752 track->appendDump(result, false /* active */);
1753 mLocalLog->log("AT::%-10s(%p) %s", funcName, track.get(), result.string());
1754 }
1755}
1756
Eric Laurent6acd1d42017-01-04 14:23:29 -08001757void AudioFlinger::ThreadBase::broadcast_l()
1758{
1759 // Thread could be blocked waiting for async
1760 // so signal it to handle state changes immediately
1761 // If threadLoop is currently unlocked a signal of mWaitWorkCV will
1762 // be lost so we also flag to prevent it blocking on mWaitWorkCV
1763 mSignalPending = true;
1764 mWaitWorkCV.broadcast();
1765}
1766
Andy Hungd0979812019-02-21 15:51:44 -08001767// Call only from threadLoop() or when it is idle.
1768// Do not call from high performance code as this may do binder rpc to the MediaMetrics service.
1769void AudioFlinger::ThreadBase::sendStatistics(bool force)
1770{
1771 // Do not log if we have no stats.
1772 // We choose the timestamp verifier because it is the most likely item to be present.
1773 const int64_t nstats = mTimestampVerifier.getN() - mLastRecordedTimestampVerifierN;
1774 if (nstats == 0) {
1775 return;
1776 }
1777
1778 // Don't log more frequently than once per 12 hours.
1779 // We use BOOTTIME to include suspend time.
1780 const int64_t timeNs = systemTime(SYSTEM_TIME_BOOTTIME);
1781 const int64_t sinceNs = timeNs - mLastRecordedTimeNs; // ok if mLastRecordedTimeNs = 0
1782 if (!force && sinceNs <= 12 * NANOS_PER_HOUR) {
1783 return;
1784 }
1785
1786 mLastRecordedTimestampVerifierN = mTimestampVerifier.getN();
1787 mLastRecordedTimeNs = timeNs;
1788
Ray Essickf27e9872019-12-07 06:28:46 -08001789 std::unique_ptr<mediametrics::Item> item(mediametrics::Item::create("audiothread"));
Andy Hungd0979812019-02-21 15:51:44 -08001790
1791#define MM_PREFIX "android.media.audiothread." // avoid cut-n-paste errors.
1792
1793 // thread configuration
1794 item->setInt32(MM_PREFIX "id", (int32_t)mId); // IO handle
1795 // item->setInt32(MM_PREFIX "portId", (int32_t)mPortId);
1796 item->setCString(MM_PREFIX "type", threadTypeToString(mType));
1797 item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
1798 item->setInt64(MM_PREFIX "channelMask", (int64_t)mChannelMask);
1799 item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
1800 item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
jiabin10d86fd2019-10-31 17:20:42 -07001801 item->setCString(MM_PREFIX "outDevice", toString(outDeviceTypes()).c_str());
1802 item->setCString(MM_PREFIX "inDevice", toString(inDeviceType()).c_str());
Andy Hungd0979812019-02-21 15:51:44 -08001803
1804 // thread statistics
1805 if (mIoJitterMs.getN() > 0) {
1806 item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
1807 item->setDouble(MM_PREFIX "ioJitterMs.std", mIoJitterMs.getStdDev());
1808 }
1809 if (mProcessTimeMs.getN() > 0) {
1810 item->setDouble(MM_PREFIX "processTimeMs.mean", mProcessTimeMs.getMean());
1811 item->setDouble(MM_PREFIX "processTimeMs.std", mProcessTimeMs.getStdDev());
1812 }
1813 const auto tsjitter = mTimestampVerifier.getJitterMs();
1814 if (tsjitter.getN() > 0) {
1815 item->setDouble(MM_PREFIX "timestampJitterMs.mean", tsjitter.getMean());
1816 item->setDouble(MM_PREFIX "timestampJitterMs.std", tsjitter.getStdDev());
1817 }
1818 if (mLatencyMs.getN() > 0) {
1819 item->setDouble(MM_PREFIX "latencyMs.mean", mLatencyMs.getMean());
1820 item->setDouble(MM_PREFIX "latencyMs.std", mLatencyMs.getStdDev());
1821 }
1822
1823 item->selfrecord();
1824}
1825
Eric Laurent81784c32012-11-19 14:55:58 -08001826// ----------------------------------------------------------------------------
1827// Playback
1828// ----------------------------------------------------------------------------
1829
1830AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1831 AudioStreamOut* output,
1832 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001833 type_t type,
Eric Laurente93cc032016-05-05 10:15:10 -07001834 bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -07001835 : ThreadBase(audioFlinger, id, type, systemReady, true /* isOut */),
Andy Hung2098f272014-02-27 14:00:06 -08001836 mNormalFrameCount(0), mSinkBuffer(NULL),
Andy Hung6146c082014-03-18 11:56:15 -07001837 mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung69aed5f2014-02-25 17:24:40 -08001838 mMixerBuffer(NULL),
1839 mMixerBufferSize(0),
1840 mMixerBufferFormat(AUDIO_FORMAT_INVALID),
1841 mMixerBufferValid(false),
Andy Hung6146c082014-03-18 11:56:15 -07001842 mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung98ef9782014-03-04 14:46:50 -08001843 mEffectBuffer(NULL),
1844 mEffectBufferSize(0),
1845 mEffectBufferFormat(AUDIO_FORMAT_INVALID),
1846 mEffectBufferValid(false),
Glenn Kastenc1fac192013-08-06 07:41:36 -07001847 mSuspended(0), mBytesWritten(0),
Andy Hungc54b1ff2016-02-23 14:07:07 -08001848 mFramesWritten(0),
Andy Hung238fa3d2016-07-28 10:53:22 -07001849 mSuspendedFrames(0),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001850 mActiveTracks(&this->mLocalLog),
Eric Laurent81784c32012-11-19 14:55:58 -08001851 // mStreamTypes[] initialized in constructor body
Andy Hung1bc088a2018-02-09 15:57:31 -08001852 mTracks(type == MIXER),
Eric Laurent81784c32012-11-19 14:55:58 -08001853 mOutput(output),
Andy Hung446f4df2019-02-21 12:26:41 -08001854 mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
Eric Laurent81784c32012-11-19 14:55:58 -08001855 mMixerStatus(MIXER_IDLE),
1856 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001857 mStandbyDelayNs(AudioFlinger::mStandbyTimeInNsecs),
Eric Laurentbfb1b832013-01-07 09:53:42 -08001858 mBytesRemaining(0),
1859 mCurrentWriteLength(0),
1860 mUseAsyncWrite(false),
Eric Laurent3b4529e2013-09-05 18:09:19 -07001861 mWriteAckSequence(0),
1862 mDrainSequence(0),
Eric Laurent81784c32012-11-19 14:55:58 -08001863 mScreenState(AudioFlinger::mScreenState),
1864 // index 0 is reserved for normal mixer's submix
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001865 mFastTrackAvailMask(((1 << FastMixerState::sMaxFastTracks) - 1) & ~1),
Eric Laurent7c29ec92017-09-20 17:54:22 -07001866 mHwSupportsPause(false), mHwPaused(false), mFlushPending(false),
1867 mLeftVolFloat(-1.0), mRightVolFloat(-1.0)
Eric Laurent81784c32012-11-19 14:55:58 -08001868{
Glenn Kastend7dca052015-03-05 16:05:54 -08001869 snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
1870 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001871
1872 // Assumes constructor is called by AudioFlinger with it's mLock held, but
1873 // it would be safer to explicitly pass initial masterVolume/masterMute as
1874 // parameter.
1875 //
1876 // If the HAL we are using has support for master volume or master mute,
1877 // then do not attenuate or mute during mixing (just leave the volume at 1.0
1878 // and the mute set to false).
1879 mMasterVolume = audioFlinger->masterVolume_l();
1880 mMasterMute = audioFlinger->masterMute_l();
George Burgess IV5e4d86f2020-02-18 12:55:36 -08001881 if (mOutput->audioHwDev) {
Eric Laurent81784c32012-11-19 14:55:58 -08001882 if (mOutput->audioHwDev->canSetMasterVolume()) {
1883 mMasterVolume = 1.0;
1884 }
1885
1886 if (mOutput->audioHwDev->canSetMasterMute()) {
1887 mMasterMute = false;
1888 }
Andy Hungc8fddf32018-08-08 18:32:37 -07001889 mIsMsdDevice = strcmp(
1890 mOutput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001891 }
1892
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001893 readOutputParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001894
Andy Hungc8fddf32018-08-08 18:32:37 -07001895 // TODO: We may also match on address as well as device type for
1896 // AUDIO_DEVICE_OUT_BUS, AUDIO_DEVICE_OUT_ALL_A2DP, AUDIO_DEVICE_OUT_REMOTE_SUBMIX
Dean Wheatleyf8726f02019-12-02 14:12:01 +11001897 if (type == MIXER || type == DIRECT || type == OFFLOAD) {
jiabin10d86fd2019-10-31 17:20:42 -07001898 // TODO: This property should be ensure that only contains one single device type.
1899 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
1900 "audio.timestamp.corrected_output_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07001901 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_OUT_BUS // turn on by default for MSD
1902 : AUDIO_DEVICE_NONE));
1903 }
1904
Mikhail Naganovdc6be0d2020-09-25 23:03:05 +00001905 for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
1906 const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
Eric Laurent98e38192018-02-15 18:31:53 -08001907 mStreamTypes[stream].volume = 0.0f;
Eric Laurent81784c32012-11-19 14:55:58 -08001908 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
1909 }
Eric Laurent35f8c7c2020-02-08 11:42:35 -08001910 // Audio patch and call assistant volume are always max
Eric Laurent98e38192018-02-15 18:31:53 -08001911 mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
1912 mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
Eric Laurent35f8c7c2020-02-08 11:42:35 -08001913 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].volume = 1.0f;
1914 mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001915}
1916
1917AudioFlinger::PlaybackThread::~PlaybackThread()
1918{
Glenn Kasten9e58b552013-01-18 15:09:48 -08001919 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung010a1a12014-03-13 13:57:33 -07001920 free(mSinkBuffer);
Andy Hung69aed5f2014-02-25 17:24:40 -08001921 free(mMixerBuffer);
Andy Hung98ef9782014-03-04 14:46:50 -08001922 free(mEffectBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001923}
1924
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001925// Thread virtuals
1926
1927void AudioFlinger::PlaybackThread::onFirstRef()
Eric Laurent81784c32012-11-19 14:55:58 -08001928{
jiabinf6eb4c32020-02-25 14:06:25 -08001929 if (mOutput == nullptr || mOutput->stream == nullptr) {
1930 ALOGE("The stream is not open yet"); // This should not happen.
1931 } else {
1932 // setEventCallback will need a strong pointer as a parameter. Calling it
1933 // here instead of constructor of PlaybackThread so that the onFirstRef
1934 // callback would not be made on an incompletely constructed object.
1935 if (mOutput->stream->setEventCallback(this) != OK) {
1936 ALOGE("Failed to add event callback");
1937 }
1938 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001939 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08001940}
1941
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001942// ThreadBase virtuals
1943void AudioFlinger::PlaybackThread::preExit()
1944{
1945 ALOGV(" preExit()");
1946 // FIXME this is using hard-coded strings but in the future, this functionality will be
1947 // converted to use audio HAL extensions required to support tunneling
1948 status_t result = mOutput->stream->setParameters(String8("exiting=1"));
1949 ALOGE_IF(result != OK, "Error when setting parameters on exit: %d", result);
1950}
1951
1952void AudioFlinger::PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001953{
Eric Laurent81784c32012-11-19 14:55:58 -08001954 String8 result;
1955
Marco Nelissenb2208842014-02-07 14:00:50 -08001956 result.appendFormat(" Stream volumes in dB: ");
Eric Laurent81784c32012-11-19 14:55:58 -08001957 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
1958 const stream_type_t *st = &mStreamTypes[i];
1959 if (i > 0) {
1960 result.appendFormat(", ");
1961 }
1962 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
1963 if (st->mute) {
1964 result.append("M");
1965 }
1966 }
1967 result.append("\n");
1968 write(fd, result.string(), result.length());
1969 result.clear();
1970
Eric Laurent81784c32012-11-19 14:55:58 -08001971 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
1972 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
Elliott Hughes87cebad2014-05-22 10:14:43 -07001973 dprintf(fd, " Normal mixer raw underrun counters: partial=%u empty=%u\n",
Eric Laurent81784c32012-11-19 14:55:58 -08001974 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
Marco Nelissenb2208842014-02-07 14:00:50 -08001975
1976 size_t numtracks = mTracks.size();
1977 size_t numactive = mActiveTracks.size();
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001978 dprintf(fd, " %zu Tracks", numtracks);
Marco Nelissenb2208842014-02-07 14:00:50 -08001979 size_t numactiveseen = 0;
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001980 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08001981 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001982 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001983 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07001984 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08001985 for (size_t i = 0; i < numtracks; ++i) {
1986 sp<Track> track = mTracks[i];
1987 if (track != 0) {
1988 bool active = mActiveTracks.indexOf(track) >= 0;
1989 if (active) {
1990 numactiveseen++;
1991 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001992 result.append(prefix);
1993 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08001994 }
1995 }
1996 } else {
1997 result.append("\n");
1998 }
1999 if (numactiveseen != numactive) {
2000 // some tracks in the active list were not in the tracks list
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002001 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08002002 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002003 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07002004 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08002005 for (size_t i = 0; i < numactive; ++i) {
Andy Hungdae27702016-10-31 14:01:16 -07002006 sp<Track> track = mActiveTracks[i];
2007 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002008 result.append(prefix);
2009 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08002010 }
2011 }
2012 }
2013
2014 write(fd, result.string(), result.size());
Eric Laurent81784c32012-11-19 14:55:58 -08002015}
2016
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002017void AudioFlinger::PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08002018{
Andy Hung04cb8f72020-03-20 13:44:33 -07002019 dprintf(fd, " Master volume: %f\n", mMasterVolume);
Mikhail Naganovdfb411f2018-09-11 13:39:56 -07002020 dprintf(fd, " Master mute: %s\n", mMasterMute ? "on" : "off");
jiabin245cdd92018-12-07 17:55:15 -08002021 if (mHapticChannelMask != AUDIO_CHANNEL_NONE) {
2022 dprintf(fd, " Haptic channel mask: %#x (%s)\n", mHapticChannelMask,
2023 channelMaskToString(mHapticChannelMask, true /* output */).c_str());
2024 }
Elliott Hughes87cebad2014-05-22 10:14:43 -07002025 dprintf(fd, " Normal frame count: %zu\n", mNormalFrameCount);
Elliott Hughes87cebad2014-05-22 10:14:43 -07002026 dprintf(fd, " Total writes: %d\n", mNumWrites);
2027 dprintf(fd, " Delayed writes: %d\n", mNumDelayedWrites);
2028 dprintf(fd, " Blocked in write: %s\n", mInWrite ? "yes" : "no");
2029 dprintf(fd, " Suspend count: %d\n", mSuspended);
2030 dprintf(fd, " Sink buffer : %p\n", mSinkBuffer);
2031 dprintf(fd, " Mixer buffer: %p\n", mMixerBuffer);
2032 dprintf(fd, " Effect buffer: %p\n", mEffectBuffer);
2033 dprintf(fd, " Fast track availMask=%#x\n", mFastTrackAvailMask);
Eric Laurent42537be2016-01-08 17:16:42 -08002034 dprintf(fd, " Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
Glenn Kasten97b7b752014-09-28 13:04:24 -07002035 AudioStreamOut *output = mOutput;
2036 audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
Mikhail Naganov913d06c2016-11-01 12:49:22 -07002037 dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08002038 output, flags, toString(flags).c_str());
Andy Hungb54c8542016-09-21 12:55:15 -07002039 dprintf(fd, " Frames written: %lld\n", (long long)mFramesWritten);
2040 dprintf(fd, " Suspended frames: %lld\n", (long long)mSuspendedFrames);
2041 if (mPipeSink.get() != nullptr) {
2042 dprintf(fd, " PipeSink frames written: %lld\n", (long long)mPipeSink->framesWritten());
2043 }
2044 if (output != nullptr) {
2045 dprintf(fd, " Hal stream dump:\n");
2046 (void)output->stream->dump(fd);
2047 }
Eric Laurent81784c32012-11-19 14:55:58 -08002048}
2049
Eric Laurent81784c32012-11-19 14:55:58 -08002050// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
2051sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
2052 const sp<AudioFlinger::Client>& client,
2053 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002054 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -08002055 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08002056 audio_format_t format,
2057 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08002058 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -08002059 size_t *pNotificationFrameCount,
2060 uint32_t notificationsPerBuffer,
2061 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -08002062 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -08002063 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -07002064 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002065 pid_t creatorPid,
Eric Laurent81784c32012-11-19 14:55:58 -08002066 pid_t tid,
Andy Hung1f12a8a2016-11-07 16:10:30 -08002067 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002068 status_t *status,
jiabinf6eb4c32020-02-25 14:06:25 -08002069 audio_port_handle_t portId,
2070 const sp<media::IAudioTrackCallback>& callback)
Eric Laurent81784c32012-11-19 14:55:58 -08002071{
Glenn Kasten74935e42013-12-19 08:56:45 -08002072 size_t frameCount = *pFrameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002073 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002074 sp<Track> track;
2075 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07002076 audio_output_flags_t outputFlags = mOutput->flags;
Eric Laurent21da6472017-11-09 16:29:26 -08002077 audio_output_flags_t requestedFlags = *flags;
Eric Laurent9b11c022018-06-06 19:19:22 -07002078 uint32_t sampleRate;
2079
2080 if (sharedBuffer != 0 && checkIMemory(sharedBuffer) != NO_ERROR) {
2081 lStatus = BAD_VALUE;
2082 goto Exit;
2083 }
Eric Laurent21da6472017-11-09 16:29:26 -08002084
2085 if (*pSampleRate == 0) {
2086 *pSampleRate = mSampleRate;
2087 }
Eric Laurent9b11c022018-06-06 19:19:22 -07002088 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07002089
2090 // special case for FAST flag considered OK if fast mixer is present
2091 if (hasFastMixer()) {
2092 outputFlags = (audio_output_flags_t)(outputFlags | AUDIO_OUTPUT_FLAG_FAST);
2093 }
2094
2095 // Check if requested flags are compatible with output stream flags
2096 if ((*flags & outputFlags) != *flags) {
2097 ALOGW("createTrack_l(): mismatch between requested flags (%08x) and output flags (%08x)",
2098 *flags, outputFlags);
2099 *flags = (audio_output_flags_t)(*flags & outputFlags);
2100 }
Eric Laurent81784c32012-11-19 14:55:58 -08002101
Eric Laurent81784c32012-11-19 14:55:58 -08002102 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07002103 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent81784c32012-11-19 14:55:58 -08002104 if (
Eric Laurent81784c32012-11-19 14:55:58 -08002105 // PCM data
2106 audio_is_linear_pcm(format) &&
Andy Hung1f439e12015-05-19 12:57:41 -07002107 // TODO: extract as a data library function that checks that a computationally
2108 // expensive downmixer is not required: isFastOutputChannelConversion()
jiabin245cdd92018-12-07 17:55:15 -08002109 (channelMask == (mChannelMask | mHapticChannelMask) ||
Andy Hung1f439e12015-05-19 12:57:41 -07002110 mChannelMask != AUDIO_CHANNEL_OUT_STEREO ||
2111 (channelMask == AUDIO_CHANNEL_OUT_MONO
2112 /* && mChannelMask == AUDIO_CHANNEL_OUT_STEREO */)) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002113 // hardware sample rate
2114 (sampleRate == mSampleRate) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002115 // normal mixer has an associated fast mixer
2116 hasFastMixer() &&
2117 // there are sufficient fast track slots available
2118 (mFastTrackAvailMask != 0)
2119 // FIXME test that MixerThread for this fast track has a capable output HAL
2120 // FIXME add a permission test also?
2121 ) {
Andy Hunge0a269a2016-03-23 15:13:42 -07002122 // static tracks can have any nonzero framecount, streaming tracks check against minimum.
2123 if (sharedBuffer == 0) {
Glenn Kasten03490092014-05-27 12:30:54 -07002124 // read the fast track multiplier property the first time it is needed
2125 int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
2126 if (ok != 0) {
2127 ALOGE("%s pthread_once failed: %d", __func__, ok);
2128 }
Andy Hunge0a269a2016-03-23 15:13:42 -07002129 frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
Eric Laurent81784c32012-11-19 14:55:58 -08002130 }
Eric Laurent4c415062016-06-17 16:14:16 -07002131
2132 // check compatibility with audio effects.
2133 { // scope for mLock
2134 Mutex::Autolock _l(mLock);
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002135 for (audio_session_t session : {
Eric Laurenta20c4e92019-11-12 15:55:51 -08002136 AUDIO_SESSION_DEVICE,
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002137 AUDIO_SESSION_OUTPUT_STAGE,
2138 AUDIO_SESSION_OUTPUT_MIX,
2139 sessionId,
2140 }) {
2141 sp<EffectChain> chain = getEffectChain_l(session);
2142 if (chain.get() != nullptr) {
2143 audio_output_flags_t old = *flags;
2144 chain->checkOutputFlagCompatibility(flags);
2145 if (old != *flags) {
2146 ALOGV("AUDIO_OUTPUT_FLAGS denied by effect, session=%d old=%#x new=%#x",
2147 (int)session, (int)old, (int)*flags);
2148 }
Eric Laurent4c415062016-06-17 16:14:16 -07002149 }
2150 }
2151 }
Eric Laurent122f7e72016-06-29 11:53:29 -07002152 ALOGV_IF((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0,
Eric Laurent4c415062016-06-17 16:14:16 -07002153 "AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
2154 frameCount, mFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08002155 } else {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002156 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: sharedBuffer=%p frameCount=%zu "
2157 "mFrameCount=%zu format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
Andy Hung6146c082014-03-18 11:56:15 -07002158 "sampleRate=%u mSampleRate=%u "
Eric Laurent81784c32012-11-19 14:55:58 -08002159 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
Glenn Kastend79072e2016-01-06 08:41:20 -08002160 sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08002161 audio_is_linear_pcm(format),
2162 channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
Eric Laurent4c415062016-06-17 16:14:16 -07002163 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
Andy Hung0e48d252015-01-26 11:43:15 -08002164 }
2165 }
Eric Laurent21da6472017-11-09 16:29:26 -08002166
2167 if (!audio_has_proportional_frames(format)) {
2168 if (sharedBuffer != 0) {
2169 // Same comment as below about ignoring frameCount parameter for set()
2170 frameCount = sharedBuffer->size();
2171 } else if (frameCount == 0) {
2172 frameCount = mNormalFrameCount;
2173 }
2174 if (notificationFrameCount != frameCount) {
2175 notificationFrameCount = frameCount;
2176 }
2177 } else if (sharedBuffer != 0) {
2178 // FIXME: Ensure client side memory buffers need
2179 // not have additional alignment beyond sample
2180 // (e.g. 16 bit stereo accessed as 32 bit frame).
2181 size_t alignment = audio_bytes_per_sample(format);
2182 if (alignment & 1) {
2183 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
2184 alignment = 1;
2185 }
2186 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
2187 size_t frameSize = channelCount * audio_bytes_per_sample(format);
2188 if (channelCount > 1) {
2189 // More than 2 channels does not require stronger alignment than stereo
2190 alignment <<= 1;
2191 }
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002192 if (((uintptr_t)sharedBuffer->unsecurePointer() & (alignment - 1)) != 0) {
Eric Laurent21da6472017-11-09 16:29:26 -08002193 ALOGE("Invalid buffer alignment: address %p, channel count %u",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07002194 sharedBuffer->unsecurePointer(), channelCount);
Eric Laurent21da6472017-11-09 16:29:26 -08002195 lStatus = BAD_VALUE;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002196 goto Exit;
2197 }
Eric Laurent21da6472017-11-09 16:29:26 -08002198
2199 // When initializing a shared buffer AudioTrack via constructors,
2200 // there's no frameCount parameter.
2201 // But when initializing a shared buffer AudioTrack via set(),
2202 // there _is_ a frameCount parameter. We silently ignore it.
2203 frameCount = sharedBuffer->size() / frameSize;
2204 } else {
2205 size_t minFrameCount = 0;
2206 // For fast tracks we try to respect the application's request for notifications per buffer.
2207 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2208 if (notificationsPerBuffer > 0) {
2209 // Avoid possible arithmetic overflow during multiplication.
2210 if (notificationsPerBuffer > SIZE_MAX / mFrameCount) {
2211 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
2212 notificationsPerBuffer, mFrameCount);
2213 } else {
2214 minFrameCount = mFrameCount * notificationsPerBuffer;
2215 }
2216 }
2217 } else {
2218 // For normal PCM streaming tracks, update minimum frame count.
2219 // Buffer depth is forced to be at least 2 x the normal mixer frame count and
2220 // cover audio hardware latency.
2221 // This is probably too conservative, but legacy application code may depend on it.
2222 // If you change this calculation, also review the start threshold which is related.
2223 uint32_t latencyMs = latency_l();
2224 if (latencyMs == 0) {
2225 ALOGE("Error when retrieving output stream latency");
2226 lStatus = UNKNOWN_ERROR;
2227 goto Exit;
2228 }
2229
2230 minFrameCount = AudioSystem::calculateMinFrameCount(latencyMs, mNormalFrameCount,
2231 mSampleRate, sampleRate, speed /*, 0 mNotificationsPerBufferReq*/);
2232
Eric Laurent81784c32012-11-19 14:55:58 -08002233 }
Eric Laurent21da6472017-11-09 16:29:26 -08002234 if (frameCount < minFrameCount) {
Eric Laurent81784c32012-11-19 14:55:58 -08002235 frameCount = minFrameCount;
2236 }
Eric Laurent81784c32012-11-19 14:55:58 -08002237 }
Eric Laurent21da6472017-11-09 16:29:26 -08002238
2239 // Make sure that application is notified with sufficient margin before underrun.
2240 // The client can divide the AudioTrack buffer into sub-buffers,
2241 // and expresses its desire to server as the notification frame count.
2242 if (sharedBuffer == 0 && audio_is_linear_pcm(format)) {
2243 size_t maxNotificationFrames;
2244 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2245 // notify every HAL buffer, regardless of the size of the track buffer
2246 maxNotificationFrames = mFrameCount;
2247 } else {
Andy Hungfa117802019-04-12 13:50:39 -07002248 // Triple buffer the notification period for a triple buffered mixer period;
2249 // otherwise, double buffering for the notification period is fine.
2250 //
2251 // TODO: This should be moved to AudioTrack to modify the notification period
2252 // on AudioTrack::setBufferSizeInFrames() changes.
2253 const int nBuffering =
2254 (uint64_t{frameCount} * mSampleRate)
2255 / (uint64_t{mNormalFrameCount} * sampleRate) == 3 ? 3 : 2;
2256
Eric Laurent21da6472017-11-09 16:29:26 -08002257 maxNotificationFrames = frameCount / nBuffering;
2258 // If client requested a fast track but this was denied, then use the smaller maximum.
2259 if (requestedFlags & AUDIO_OUTPUT_FLAG_FAST) {
2260 size_t maxNotificationFramesFastDenied = FMS_20 * sampleRate / 1000;
2261 if (maxNotificationFrames > maxNotificationFramesFastDenied) {
2262 maxNotificationFrames = maxNotificationFramesFastDenied;
2263 }
2264 }
2265 }
2266 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
2267 if (notificationFrameCount == 0) {
2268 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
2269 maxNotificationFrames, frameCount);
2270 } else {
2271 ALOGW("Client adjusted notificationFrames from %zu to %zu for frameCount %zu",
2272 notificationFrameCount, maxNotificationFrames, frameCount);
2273 }
2274 notificationFrameCount = maxNotificationFrames;
2275 }
2276 }
2277
Glenn Kasten74935e42013-12-19 08:56:45 -08002278 *pFrameCount = frameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002279 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002280
Glenn Kastenc3df8382014-03-13 15:05:25 -07002281 switch (mType) {
2282
2283 case DIRECT:
Phil Burkfdb3c072016-02-09 10:47:02 -08002284 if (audio_is_linear_pcm(format)) { // TODO maybe use audio_has_proportional_frames()?
Eric Laurent81784c32012-11-19 14:55:58 -08002285 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002286 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
2287 "for output %p with format %#x",
Eric Laurent81784c32012-11-19 14:55:58 -08002288 sampleRate, format, channelMask, mOutput, mFormat);
2289 lStatus = BAD_VALUE;
2290 goto Exit;
2291 }
2292 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002293 break;
2294
2295 case OFFLOAD:
Eric Laurentbfb1b832013-01-07 09:53:42 -08002296 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002297 ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
2298 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002299 sampleRate, format, channelMask, mOutput, mFormat);
2300 lStatus = BAD_VALUE;
2301 goto Exit;
2302 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002303 break;
2304
2305 default:
Glenn Kasten993fa062014-05-02 11:14:34 -07002306 if (!audio_is_linear_pcm(format)) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002307 ALOGE("createTrack_l() Bad parameter: format %#x \""
2308 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002309 format, mOutput, mFormat);
2310 lStatus = BAD_VALUE;
2311 goto Exit;
2312 }
Andy Hungcd044842014-08-07 11:04:34 -07002313 if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Eric Laurent81784c32012-11-19 14:55:58 -08002314 ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
2315 lStatus = BAD_VALUE;
2316 goto Exit;
2317 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002318 break;
2319
Eric Laurent81784c32012-11-19 14:55:58 -08002320 }
2321
2322 lStatus = initCheck();
2323 if (lStatus != NO_ERROR) {
Glenn Kasten15e57982013-09-24 11:52:37 -07002324 ALOGE("createTrack_l() audio driver not initialized");
Eric Laurent81784c32012-11-19 14:55:58 -08002325 goto Exit;
2326 }
2327
2328 { // scope for mLock
2329 Mutex::Autolock _l(mLock);
2330
2331 // all tracks in same audio session must share the same routing strategy otherwise
2332 // conflicts will happen when tracks are moved from one output to another by audio policy
2333 // manager
2334 uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
2335 for (size_t i = 0; i < mTracks.size(); ++i) {
2336 sp<Track> t = mTracks[i];
Eric Laurent83b88082014-06-20 18:31:16 -07002337 if (t != 0 && t->isExternalTrack()) {
Eric Laurent81784c32012-11-19 14:55:58 -08002338 uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
2339 if (sessionId == t->sessionId() && strategy != actual) {
2340 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
2341 strategy, actual);
2342 lStatus = BAD_VALUE;
2343 goto Exit;
2344 }
2345 }
2346 }
2347
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002348 track = new Track(this, client, streamType, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002349 channelMask, frameCount,
2350 nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002351 sessionId, creatorPid, uid, *flags, TrackBase::TYPE_DEFAULT, portId);
Glenn Kasten03003332013-08-06 15:40:54 -07002352
Glenn Kasten03003332013-08-06 15:40:54 -07002353 lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
2354 if (lStatus != NO_ERROR) {
Glenn Kasten0cde0762014-01-16 15:06:36 -08002355 ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002356 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08002357 goto Exit;
2358 }
2359 mTracks.add(track);
jiabinf6eb4c32020-02-25 14:06:25 -08002360 {
2361 Mutex::Autolock _atCbL(mAudioTrackCbLock);
2362 if (callback.get() != nullptr) {
2363 mAudioTrackCallbacks.emplace(callback);
2364 }
2365 }
Eric Laurent81784c32012-11-19 14:55:58 -08002366
2367 sp<EffectChain> chain = getEffectChain_l(sessionId);
2368 if (chain != 0) {
2369 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
2370 track->setMainBuffer(chain->inBuffer());
2371 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
2372 chain->incTrackCnt();
2373 }
2374
Eric Laurent05067782016-06-01 18:27:28 -07002375 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) && (tid != -1)) {
Eric Laurent81784c32012-11-19 14:55:58 -08002376 pid_t callingPid = IPCThreadState::self()->getCallingPid();
2377 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
2378 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07002379 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08002380 }
2381 }
2382
2383 lStatus = NO_ERROR;
2384
2385Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07002386 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08002387 return track;
2388}
2389
Andy Hung1bc088a2018-02-09 15:57:31 -08002390template<typename T>
Andy Hung1bc088a2018-02-09 15:57:31 -08002391ssize_t AudioFlinger::PlaybackThread::Tracks<T>::remove(const sp<T> &track)
2392{
Andy Hungc0691382018-09-12 18:01:57 -07002393 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08002394 const ssize_t index = mTracks.remove(track);
2395 if (index >= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07002396 if (mSaveDeletedTrackIds) {
Andy Hung1bc088a2018-02-09 15:57:31 -08002397 // We can't directly access mAudioMixer since the caller may be outside of threadLoop.
Andy Hungc0691382018-09-12 18:01:57 -07002398 // Instead, we add to mDeletedTrackIds which is solely used for mAudioMixer update,
Andy Hung1bc088a2018-02-09 15:57:31 -08002399 // to be handled when MixerThread::prepareTracks_l() next changes mAudioMixer.
Andy Hungc0691382018-09-12 18:01:57 -07002400 mDeletedTrackIds.emplace(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08002401 }
Andy Hung1bc088a2018-02-09 15:57:31 -08002402 }
2403 return index;
2404}
2405
Eric Laurent81784c32012-11-19 14:55:58 -08002406uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
2407{
2408 return latency;
2409}
2410
2411uint32_t AudioFlinger::PlaybackThread::latency() const
2412{
2413 Mutex::Autolock _l(mLock);
2414 return latency_l();
2415}
2416uint32_t AudioFlinger::PlaybackThread::latency_l() const
2417{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002418 uint32_t latency;
2419 if (initCheck() == NO_ERROR && mOutput->stream->getLatency(&latency) == OK) {
2420 return correctLatency_l(latency);
Eric Laurent81784c32012-11-19 14:55:58 -08002421 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002422 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002423}
2424
2425void AudioFlinger::PlaybackThread::setMasterVolume(float value)
2426{
2427 Mutex::Autolock _l(mLock);
2428 // Don't apply master volume in SW if our HAL can do it for us.
2429 if (mOutput && mOutput->audioHwDev &&
2430 mOutput->audioHwDev->canSetMasterVolume()) {
2431 mMasterVolume = 1.0;
2432 } else {
2433 mMasterVolume = value;
2434 }
2435}
2436
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002437void AudioFlinger::PlaybackThread::setMasterBalance(float balance)
2438{
2439 mMasterBalance.store(balance);
2440}
2441
Eric Laurent81784c32012-11-19 14:55:58 -08002442void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
2443{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002444 if (isDuplicating()) {
2445 return;
2446 }
Eric Laurent81784c32012-11-19 14:55:58 -08002447 Mutex::Autolock _l(mLock);
2448 // Don't apply master mute in SW if our HAL can do it for us.
2449 if (mOutput && mOutput->audioHwDev &&
2450 mOutput->audioHwDev->canSetMasterMute()) {
2451 mMasterMute = false;
2452 } else {
2453 mMasterMute = muted;
2454 }
2455}
2456
2457void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
2458{
2459 Mutex::Autolock _l(mLock);
2460 mStreamTypes[stream].volume = value;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002461 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002462}
2463
2464void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
2465{
2466 Mutex::Autolock _l(mLock);
2467 mStreamTypes[stream].mute = muted;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002468 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002469}
2470
2471float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
2472{
2473 Mutex::Autolock _l(mLock);
2474 return mStreamTypes[stream].volume;
2475}
2476
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09002477void AudioFlinger::PlaybackThread::setVolumeForOutput_l(float left, float right) const
2478{
2479 mOutput->stream->setVolume(left, right);
2480}
2481
Eric Laurent81784c32012-11-19 14:55:58 -08002482// addTrack_l() must be called with ThreadBase::mLock held
2483status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
2484{
2485 status_t status = ALREADY_EXISTS;
2486
Eric Laurent81784c32012-11-19 14:55:58 -08002487 if (mActiveTracks.indexOf(track) < 0) {
2488 // the track is newly added, make sure it fills up all its
2489 // buffers before playing. This is to ensure the client will
2490 // effectively get the latency it requested.
Eric Laurent83b88082014-06-20 18:31:16 -07002491 if (track->isExternalTrack()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002492 TrackBase::track_state state = track->mState;
2493 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002494 status = AudioSystem::startOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002495 mLock.lock();
2496 // abort track was stopped/paused while we released the lock
2497 if (state != track->mState) {
2498 if (status == NO_ERROR) {
2499 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002500 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002501 mLock.lock();
2502 }
2503 return INVALID_OPERATION;
2504 }
2505 // abort if start is rejected by audio policy manager
2506 if (status != NO_ERROR) {
2507 return PERMISSION_DENIED;
2508 }
2509#ifdef ADD_BATTERY_DATA
2510 // to track the speaker usage
2511 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
2512#endif
Eric Laurent09f1ed22019-04-24 17:45:17 -07002513 sendIoConfigEvent_l(AUDIO_CLIENT_STARTED, track->creatorPid(), track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002514 }
2515
Eric Laurent51716182016-02-29 18:00:56 -08002516 // set retry count for buffer fill
2517 if (track->isOffloaded()) {
Eric Laurente93cc032016-05-05 10:15:10 -07002518 if (track->isStopping_1()) {
2519 track->mRetryCount = kMaxTrackStopRetriesOffload;
2520 } else {
2521 track->mRetryCount = kMaxTrackStartupRetriesOffload;
2522 }
2523 track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
Eric Laurent51716182016-02-29 18:00:56 -08002524 } else {
2525 track->mRetryCount = kMaxTrackStartupRetries;
Eric Laurente93cc032016-05-05 10:15:10 -07002526 track->mFillingUpStatus =
2527 track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
Eric Laurent51716182016-02-29 18:00:56 -08002528 }
2529
jiabin245cdd92018-12-07 17:55:15 -08002530 if ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
2531 && mHapticChannelMask != AUDIO_CHANNEL_NONE) {
jiabin57303cc2018-12-18 15:45:57 -08002532 // Unlock due to VibratorService will lock for this call and will
2533 // call Tracks.mute/unmute which also require thread's lock.
2534 mLock.unlock();
2535 const int intensity = AudioFlinger::onExternalVibrationStart(
2536 track->getExternalVibration());
2537 mLock.lock();
jiabinbf6b0ec2019-02-12 12:30:12 -08002538 track->setHapticIntensity(static_cast<AudioMixer::haptic_intensity_t>(intensity));
jiabin57303cc2018-12-18 15:45:57 -08002539 // Haptic playback should be enabled by vibrator service.
2540 if (track->getHapticPlaybackEnabled()) {
2541 // Disable haptic playback of all active track to ensure only
2542 // one track playing haptic if current track should play haptic.
2543 for (const auto &t : mActiveTracks) {
2544 t->setHapticPlaybackEnabled(false);
2545 }
jiabin245cdd92018-12-07 17:55:15 -08002546 }
jiabin245cdd92018-12-07 17:55:15 -08002547 }
2548
Eric Laurent81784c32012-11-19 14:55:58 -08002549 track->mResetDone = false;
2550 track->mPresentationCompleteFrames = 0;
2551 mActiveTracks.add(track);
Eric Laurentd0107bc2013-06-11 14:38:48 -07002552 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2553 if (chain != 0) {
2554 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2555 track->sessionId());
2556 chain->incActiveTrackCnt();
Eric Laurent81784c32012-11-19 14:55:58 -08002557 }
2558
Andy Hungc2b11cb2020-04-22 09:04:01 -07002559 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent81784c32012-11-19 14:55:58 -08002560 status = NO_ERROR;
2561 }
2562
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08002563 onAddNewTrack_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002564 return status;
2565}
2566
Eric Laurentbfb1b832013-01-07 09:53:42 -08002567bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
Eric Laurent81784c32012-11-19 14:55:58 -08002568{
Eric Laurentbfb1b832013-01-07 09:53:42 -08002569 track->terminate();
Eric Laurent81784c32012-11-19 14:55:58 -08002570 // active tracks are removed by threadLoop()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002571 bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2572 track->mState = TrackBase::STOPPED;
2573 if (!trackActive) {
Eric Laurent81784c32012-11-19 14:55:58 -08002574 removeTrack_l(track);
Eric Laurentab5cdba2014-06-09 17:22:27 -07002575 } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002576 track->mState = TrackBase::STOPPING_1;
Eric Laurent81784c32012-11-19 14:55:58 -08002577 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002578
2579 return trackActive;
Eric Laurent81784c32012-11-19 14:55:58 -08002580}
2581
2582void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2583{
2584 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Andy Hung2148bf02016-11-28 19:01:02 -08002585
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002586 String8 result;
2587 track->appendDump(result, false /* active */);
2588 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
Andy Hung2148bf02016-11-28 19:01:02 -08002589
Eric Laurent81784c32012-11-19 14:55:58 -08002590 mTracks.remove(track);
Eric Laurent81784c32012-11-19 14:55:58 -08002591 if (track->isFastTrack()) {
2592 int index = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07002593 ALOG_ASSERT(0 < index && index < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08002594 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
2595 mFastTrackAvailMask |= 1 << index;
2596 // redundant as track is about to be destroyed, for dumpsys only
2597 track->mFastIndex = -1;
2598 }
2599 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2600 if (chain != 0) {
2601 chain->decTrackCnt();
2602 }
2603}
2604
2605String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
2606{
Eric Laurent81784c32012-11-19 14:55:58 -08002607 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002608 String8 out_s8;
2609 if (initCheck() == NO_ERROR && mOutput->stream->getParameters(keys, &out_s8) == OK) {
2610 return out_s8;
Eric Laurent81784c32012-11-19 14:55:58 -08002611 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002612 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08002613}
2614
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002615status_t AudioFlinger::DirectOutputThread::selectPresentation(int presentationId, int programId) {
2616 Mutex::Autolock _l(mLock);
2617 if (mOutput == nullptr || mOutput->stream == nullptr) {
2618 return NO_INIT;
2619 }
2620 return mOutput->stream->selectPresentation(presentationId, programId);
2621}
2622
Eric Laurent09f1ed22019-04-24 17:45:17 -07002623void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
2624 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002625 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
2626 ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
Eric Laurent81784c32012-11-19 14:55:58 -08002627
Eric Laurent73e26b62015-04-27 16:55:58 -07002628 desc->mIoHandle = mId;
Eric Laurent81784c32012-11-19 14:55:58 -08002629
2630 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002631 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002632 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07002633 case AUDIO_OUTPUT_CONFIG_CHANGED:
Eric Laurent296fb132015-05-01 11:38:42 -07002634 desc->mPatch = mPatch;
Eric Laurent73e26b62015-04-27 16:55:58 -07002635 desc->mChannelMask = mChannelMask;
2636 desc->mSamplingRate = mSampleRate;
2637 desc->mFormat = mFormat;
2638 desc->mFrameCount = mNormalFrameCount; // FIXME see
Eric Laurent81784c32012-11-19 14:55:58 -08002639 // AudioFlinger::frameCount(audio_io_handle_t)
Glenn Kasten4a8308b2016-04-18 14:10:01 -07002640 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07002641 desc->mLatency = latency_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002642 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07002643 case AUDIO_CLIENT_STARTED:
2644 desc->mPatch = mPatch;
2645 desc->mPortId = portId;
2646 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07002647 case AUDIO_OUTPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08002648 default:
2649 break;
2650 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002651 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08002652}
2653
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002654void AudioFlinger::PlaybackThread::onWriteReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002655{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002656 mCallbackThread->resetWriteBlocked();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002657}
2658
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002659void AudioFlinger::PlaybackThread::onDrainReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002660{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002661 mCallbackThread->resetDraining();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002662}
2663
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002664void AudioFlinger::PlaybackThread::onError()
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002665{
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002666 mCallbackThread->setAsyncError();
2667}
2668
jiabinf6eb4c32020-02-25 14:06:25 -08002669void AudioFlinger::PlaybackThread::onCodecFormatChanged(
2670 const std::basic_string<uint8_t>& metadataBs)
2671{
2672 std::thread([this, metadataBs]() {
2673 audio_utils::metadata::Data metadata =
2674 audio_utils::metadata::dataFromByteString(metadataBs);
2675 if (metadata.empty()) {
2676 ALOGW("Can not transform the buffer to audio metadata, %s, %d",
2677 reinterpret_cast<char*>(const_cast<uint8_t*>(metadataBs.data())),
2678 (int)metadataBs.size());
2679 return;
2680 }
2681
2682 audio_utils::metadata::ByteString metaDataStr =
2683 audio_utils::metadata::byteStringFromData(metadata);
2684 std::vector metadataVec(metaDataStr.begin(), metaDataStr.end());
2685 Mutex::Autolock _l(mAudioTrackCbLock);
2686 for (const auto& callback : mAudioTrackCallbacks) {
2687 callback->onCodecFormatChanged(metadataVec);
2688 }
2689 }).detach();
2690}
2691
Eric Laurent3b4529e2013-09-05 18:09:19 -07002692void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002693{
2694 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002695 // reject out of sequence requests
2696 if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
2697 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002698 mWaitWorkCV.signal();
2699 }
2700}
2701
Eric Laurent3b4529e2013-09-05 18:09:19 -07002702void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002703{
2704 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002705 // reject out of sequence requests
2706 if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
Andy Hungf3234512018-07-03 14:51:47 -07002707 // Register discontinuity when HW drain is completed because that can cause
2708 // the timestamp frame position to reset to 0 for direct and offload threads.
2709 // (Out of sequence requests are ignored, since the discontinuity would be handled
2710 // elsewhere, e.g. in flush).
2711 mTimestampVerifier.discontinuity();
Eric Laurent3b4529e2013-09-05 18:09:19 -07002712 mDrainSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002713 mWaitWorkCV.signal();
2714 }
2715}
2716
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002717void AudioFlinger::PlaybackThread::readOutputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08002718{
Glenn Kastenadad3d72014-02-21 14:51:43 -08002719 // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
Phil Burkca5e6142015-07-14 09:42:29 -07002720 mSampleRate = mOutput->getSampleRate();
2721 mChannelMask = mOutput->getChannelMask();
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002722 if (!audio_is_output_channel(mChannelMask)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002723 LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002724 }
Andy Hung9a592762014-07-21 21:56:01 -07002725 if ((mType == MIXER || mType == DUPLICATING)
2726 && !isValidPcmSinkChannelMask(mChannelMask)) {
2727 LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
2728 mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002729 }
Andy Hunge5412692014-05-16 11:25:07 -07002730 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002731 mBalance.setChannelMask(mChannelMask);
Phil Burkca5e6142015-07-14 09:42:29 -07002732
2733 // Get actual HAL format.
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002734 status_t result = mOutput->stream->getFormat(&mHALFormat);
2735 LOG_ALWAYS_FATAL_IF(result != OK, "Error when retrieving output stream format: %d", result);
Phil Burkca5e6142015-07-14 09:42:29 -07002736 // Get format from the shim, which will be different than the HAL format
2737 // if playing compressed audio over HDMI passthrough.
2738 mFormat = mOutput->getFormat();
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002739 if (!audio_is_valid_format(mFormat)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002740 LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002741 }
Andy Hung6146c082014-03-18 11:56:15 -07002742 if ((mType == MIXER || mType == DUPLICATING)
2743 && !isValidPcmSinkFormat(mFormat)) {
2744 LOG_FATAL("HAL format %#x not supported for mixed output",
2745 mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002746 }
Phil Burk062e67a2015-02-11 13:40:50 -08002747 mFrameSize = mOutput->getFrameSize();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002748 result = mOutput->stream->getBufferSize(&mBufferSize);
2749 LOG_ALWAYS_FATAL_IF(result != OK,
2750 "Error when retrieving output stream buffer size: %d", result);
Glenn Kasten70949c42013-08-06 07:40:12 -07002751 mFrameCount = mBufferSize / mFrameSize;
Dean Wheatley77cbebd2019-04-23 14:18:44 +10002752 if ((mType == MIXER || mType == DUPLICATING) && (mFrameCount & 15)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002753 ALOGW("HAL output buffer size is %zu frames but AudioMixer requires multiples of 16 frames",
Eric Laurent81784c32012-11-19 14:55:58 -08002754 mFrameCount);
2755 }
2756
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002757 if (mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) {
2758 if (mOutput->stream->setCallback(this) == OK) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002759 mUseAsyncWrite = true;
Eric Laurent4de95592013-09-26 15:28:21 -07002760 mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002761 }
2762 }
2763
Eric Laurentd1f69b02014-12-15 14:33:13 -08002764 mHwSupportsPause = false;
2765 if (mOutput->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002766 bool supportsPause = false, supportsResume = false;
2767 if (mOutput->stream->supportsPauseAndResume(&supportsPause, &supportsResume) == OK) {
2768 if (supportsPause && supportsResume) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002769 mHwSupportsPause = true;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002770 } else if (supportsPause) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002771 ALOGW("direct output implements pause but not resume");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002772 } else if (supportsResume) {
2773 ALOGW("direct output implements resume but not pause");
Eric Laurentd1f69b02014-12-15 14:33:13 -08002774 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002775 }
2776 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07002777 if (!mHwSupportsPause && mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
2778 LOG_ALWAYS_FATAL("HW_AV_SYNC requested but HAL does not implement pause and resume");
2779 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002780
Andy Hungfbfc3952015-01-15 13:33:51 -08002781 if (mType == DUPLICATING && mMixerBufferEnabled && mEffectBufferEnabled) {
2782 // For best precision, we use float instead of the associated output
2783 // device format (typically PCM 16 bit).
2784
2785 mFormat = AUDIO_FORMAT_PCM_FLOAT;
2786 mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
2787 mBufferSize = mFrameSize * mFrameCount;
2788
2789 // TODO: We currently use the associated output device channel mask and sample rate.
2790 // (1) Perhaps use the ORed channel mask of all downstream MixerThreads
2791 // (if a valid mask) to avoid premature downmix.
2792 // (2) Perhaps use the maximum sample rate of all downstream MixerThreads
2793 // instead of the output device sample rate to avoid loss of high frequency information.
2794 // This may need to be updated as MixerThread/OutputTracks are added and not here.
2795 }
2796
Andy Hung09a50072014-02-27 14:30:47 -08002797 // Calculate size of normal sink buffer relative to the HAL output buffer size
Eric Laurent81784c32012-11-19 14:55:58 -08002798 double multiplier = 1.0;
2799 if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
2800 kUseFastMixer == FastMixer_Dynamic)) {
Andy Hung09a50072014-02-27 14:30:47 -08002801 size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
2802 size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002803
Eric Laurent81784c32012-11-19 14:55:58 -08002804 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
2805 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
2806 maxNormalFrameCount = maxNormalFrameCount & ~15;
2807 if (maxNormalFrameCount < minNormalFrameCount) {
2808 maxNormalFrameCount = minNormalFrameCount;
2809 }
2810 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
2811 if (multiplier <= 1.0) {
2812 multiplier = 1.0;
2813 } else if (multiplier <= 2.0) {
2814 if (2 * mFrameCount <= maxNormalFrameCount) {
2815 multiplier = 2.0;
2816 } else {
2817 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
2818 }
2819 } else {
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002820 multiplier = floor(multiplier);
Eric Laurent81784c32012-11-19 14:55:58 -08002821 }
2822 }
2823 mNormalFrameCount = multiplier * mFrameCount;
2824 // round up to nearest 16 frames to satisfy AudioMixer
Eric Laurentab5cdba2014-06-09 17:22:27 -07002825 if (mType == MIXER || mType == DUPLICATING) {
2826 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
2827 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002828 ALOGI("HAL output buffer size %zu frames, normal sink buffer size %zu frames", mFrameCount,
Eric Laurent81784c32012-11-19 14:55:58 -08002829 mNormalFrameCount);
2830
Andy Hung08fb1742015-05-31 23:22:10 -07002831 // Check if we want to throttle the processing to no more than 2x normal rate
2832 mThreadThrottle = property_get_bool("af.thread.throttle", true /* default_value */);
Andy Hung40eb1a12015-06-18 13:42:02 -07002833 mThreadThrottleTimeMs = 0;
2834 mThreadThrottleEndMs = 0;
Andy Hung08fb1742015-05-31 23:22:10 -07002835 mHalfBufferMs = mNormalFrameCount * 1000 / (2 * mSampleRate);
2836
Andy Hung010a1a12014-03-13 13:57:33 -07002837 // mSinkBuffer is the sink buffer. Size is always multiple-of-16 frames.
2838 // Originally this was int16_t[] array, need to remove legacy implications.
2839 free(mSinkBuffer);
2840 mSinkBuffer = NULL;
Andy Hung5b10a202014-03-13 13:59:29 -07002841 // For sink buffer size, we use the frame size from the downstream sink to avoid problems
2842 // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
2843 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
Andy Hung010a1a12014-03-13 13:57:33 -07002844 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002845
Andy Hung69aed5f2014-02-25 17:24:40 -08002846 // We resize the mMixerBuffer according to the requirements of the sink buffer which
2847 // drives the output.
2848 free(mMixerBuffer);
2849 mMixerBuffer = NULL;
2850 if (mMixerBufferEnabled) {
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002851 mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // no longer valid: AUDIO_FORMAT_PCM_16_BIT.
Andy Hung69aed5f2014-02-25 17:24:40 -08002852 mMixerBufferSize = mNormalFrameCount * mChannelCount
2853 * audio_bytes_per_sample(mMixerBufferFormat);
2854 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
2855 }
Andy Hung98ef9782014-03-04 14:46:50 -08002856 free(mEffectBuffer);
2857 mEffectBuffer = NULL;
2858 if (mEffectBufferEnabled) {
rago94a1ee82017-07-21 15:11:02 -07002859 mEffectBufferFormat = EFFECT_BUFFER_FORMAT;
Andy Hung98ef9782014-03-04 14:46:50 -08002860 mEffectBufferSize = mNormalFrameCount * mChannelCount
2861 * audio_bytes_per_sample(mEffectBufferFormat);
2862 (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
2863 }
Andy Hung69aed5f2014-02-25 17:24:40 -08002864
Mikhail Naganove3b59ac2020-10-01 15:08:13 -07002865 mHapticChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & AUDIO_CHANNEL_HAPTIC_ALL);
2866 mChannelMask = static_cast<audio_channel_mask_t>(mChannelMask & ~mHapticChannelMask);
jiabin245cdd92018-12-07 17:55:15 -08002867 mHapticChannelCount = audio_channel_count_from_out_mask(mHapticChannelMask);
2868 mChannelCount -= mHapticChannelCount;
2869
Eric Laurent81784c32012-11-19 14:55:58 -08002870 // force reconfiguration of effect chains and engines to take new buffer size and audio
2871 // parameters into account
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002872 // Note that mLock is not held when readOutputParameters_l() is called from the constructor
Eric Laurent81784c32012-11-19 14:55:58 -08002873 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
2874 // matter.
2875 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
2876 Vector< sp<EffectChain> > effectChains = mEffectChains;
2877 for (size_t i = 0; i < effectChains.size(); i ++) {
Eric Laurent6c796322019-04-09 14:13:17 -07002878 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(),
2879 this/* srcThread */, this/* dstThread */);
Eric Laurent81784c32012-11-19 14:55:58 -08002880 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08002881
George Burgess IV5e4d86f2020-02-18 12:55:36 -08002882 audio_output_flags_t flags = mOutput->flags;
Andy Hungcf10d742020-04-28 15:38:24 -07002883 mediametrics::LogItem item(mThreadMetrics.getMetricsId()); // TODO: method in ThreadMetrics?
Andy Hungb68f5eb2019-12-03 16:49:17 -08002884 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
2885 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
2886 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
2887 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
2888 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
2889 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mNormalFrameCount)
2890 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
2891 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
2892 (int32_t)mHapticChannelMask)
2893 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
2894 (int32_t)mHapticChannelCount)
2895 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
2896 formatToString(mHALFormat).c_str())
2897 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
2898 (int32_t)mFrameCount) // sic - added HAL
2899 ;
2900 uint32_t latencyMs;
2901 if (mOutput->stream->getLatency(&latencyMs) == NO_ERROR) {
2902 item.set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_LATENCYMS, (double)latencyMs);
2903 }
2904 item.record();
Eric Laurent81784c32012-11-19 14:55:58 -08002905}
2906
Kevin Rocard069c2712018-03-29 19:09:14 -07002907void AudioFlinger::PlaybackThread::updateMetadata_l()
2908{
Kevin Rocard12381092018-04-11 09:19:59 -07002909 if (mOutput == nullptr || mOutput->stream == nullptr ) {
2910 return; // That should not happen
2911 }
2912 bool hasChanged = mActiveTracks.readAndClearHasChanged();
2913 for (const sp<Track> &track : mActiveTracks) {
2914 // Do not short-circuit as all hasChanged states must be reset
2915 // as all the metadata are going to be sent
2916 hasChanged |= track->readAndClearHasChanged();
2917 }
2918 if (!hasChanged) {
2919 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07002920 }
2921 StreamOutHalInterface::SourceMetadata metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07002922 auto backInserter = std::back_inserter(metadata.tracks);
Kevin Rocard069c2712018-03-29 19:09:14 -07002923 for (const sp<Track> &track : mActiveTracks) {
2924 // No track is invalid as this is called after prepareTrack_l in the same critical section
Kevin Rocard12381092018-04-11 09:19:59 -07002925 track->copyMetadataTo(backInserter);
Kevin Rocard069c2712018-03-29 19:09:14 -07002926 }
Kevin Rocard12381092018-04-11 09:19:59 -07002927 sendMetadataToBackend_l(metadata);
Kevin Rocard80ee2722018-04-11 15:53:48 +00002928}
Kevin Rocardc86a7f72018-04-03 09:00:09 -07002929
Kevin Rocard12381092018-04-11 09:19:59 -07002930void AudioFlinger::PlaybackThread::sendMetadataToBackend_l(
2931 const StreamOutHalInterface::SourceMetadata& metadata)
2932{
2933 mOutput->stream->updateSourceMetadata(metadata);
2934};
2935
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002936status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002937{
2938 if (halFrames == NULL || dspFrames == NULL) {
2939 return BAD_VALUE;
2940 }
2941 Mutex::Autolock _l(mLock);
2942 if (initCheck() != NO_ERROR) {
2943 return INVALID_OPERATION;
2944 }
Andy Hung818e7a32016-02-16 18:08:07 -08002945 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002946 *halFrames = framesWritten;
2947
2948 if (isSuspended()) {
2949 // return an estimation of rendered frames when the output is suspended
2950 size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08002951 *dspFrames = (uint32_t)
2952 (framesWritten >= (int64_t)latencyFrames ? framesWritten - latencyFrames : 0);
Eric Laurent81784c32012-11-19 14:55:58 -08002953 return NO_ERROR;
2954 } else {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002955 status_t status;
2956 uint32_t frames;
Phil Burk062e67a2015-02-11 13:40:50 -08002957 status = mOutput->getRenderPosition(&frames);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002958 *dspFrames = (size_t)frames;
2959 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002960 }
2961}
2962
Glenn Kastend848eb42016-03-08 13:42:11 -08002963uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08002964{
2965 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
2966 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
2967 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
2968 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2969 }
2970 for (size_t i = 0; i < mTracks.size(); i++) {
2971 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08002972 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurent81784c32012-11-19 14:55:58 -08002973 return AudioSystem::getStrategyForStream(track->streamType());
2974 }
2975 }
2976 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2977}
2978
2979
Phil Burk062e67a2015-02-11 13:40:50 -08002980AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
Eric Laurent81784c32012-11-19 14:55:58 -08002981{
2982 Mutex::Autolock _l(mLock);
2983 return mOutput;
2984}
2985
Phil Burk062e67a2015-02-11 13:40:50 -08002986AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
Eric Laurent81784c32012-11-19 14:55:58 -08002987{
2988 Mutex::Autolock _l(mLock);
2989 AudioStreamOut *output = mOutput;
2990 mOutput = NULL;
2991 // FIXME FastMixer might also have a raw ptr to mOutputSink;
2992 // must push a NULL and wait for ack
2993 mOutputSink.clear();
2994 mPipeSink.clear();
2995 mNormalSink.clear();
2996 return output;
2997}
2998
2999// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003000sp<StreamHalInterface> AudioFlinger::PlaybackThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08003001{
3002 if (mOutput == NULL) {
3003 return NULL;
3004 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003005 return mOutput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08003006}
3007
3008uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
3009{
3010 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
3011}
3012
3013status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
3014{
3015 if (!isValidSyncEvent(event)) {
3016 return BAD_VALUE;
3017 }
3018
3019 Mutex::Autolock _l(mLock);
3020
3021 for (size_t i = 0; i < mTracks.size(); ++i) {
3022 sp<Track> track = mTracks[i];
3023 if (event->triggerSession() == track->sessionId()) {
3024 (void) track->setSyncEvent(event);
3025 return NO_ERROR;
3026 }
3027 }
3028
3029 return NAME_NOT_FOUND;
3030}
3031
3032bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
3033{
3034 return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
3035}
3036
3037void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
3038 const Vector< sp<Track> >& tracksToRemove)
3039{
Andy Hungfe726a62018-09-27 15:17:25 -07003040 // Miscellaneous track cleanup when removed from the active list,
3041 // called without Thread lock but synchronized with threadLoop processing.
Eric Laurentbfb1b832013-01-07 09:53:42 -08003042#ifdef ADD_BATTERY_DATA
Andy Hungfe726a62018-09-27 15:17:25 -07003043 for (const auto& track : tracksToRemove) {
3044 if (track->isExternalTrack()) {
3045 // to track the speaker usage
3046 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Eric Laurent81784c32012-11-19 14:55:58 -08003047 }
3048 }
Andy Hungfe726a62018-09-27 15:17:25 -07003049#else
3050 (void)tracksToRemove; // suppress unused warning
3051#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003052}
3053
3054void AudioFlinger::PlaybackThread::checkSilentMode_l()
3055{
3056 if (!mMasterMute) {
3057 char value[PROPERTY_VALUE_MAX];
jiabin0a957d32020-04-29 10:56:20 -07003058 if (mOutDeviceTypeAddrs.empty()) {
3059 ALOGD("ro.audio.silent is ignored since no output device is set");
3060 return;
3061 }
jiabin10d86fd2019-10-31 17:20:42 -07003062 if (isSingleDeviceType(outDeviceTypes(), AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) {
Jean-Michel Trivi32f37c22016-03-31 16:00:32 -07003063 ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
3064 return;
3065 }
Eric Laurent81784c32012-11-19 14:55:58 -08003066 if (property_get("ro.audio.silent", value, "0") > 0) {
3067 char *endptr;
3068 unsigned long ul = strtoul(value, &endptr, 0);
3069 if (*endptr == '\0' && ul != 0) {
3070 ALOGD("Silence is golden");
3071 // The setprop command will not allow a property to be changed after
3072 // the first time it is set, so we don't have to worry about un-muting.
3073 setMasterMute_l(true);
3074 }
3075 }
3076 }
3077}
3078
3079// shared by MIXER and DIRECT, overridden by DUPLICATING
Eric Laurentbfb1b832013-01-07 09:53:42 -08003080ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08003081{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003082 LOG_HIST_TS();
Eric Laurent81784c32012-11-19 14:55:58 -08003083 mInWrite = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003084 ssize_t bytesWritten;
Andy Hung010a1a12014-03-13 13:57:33 -07003085 const size_t offset = mCurrentWriteLength - mBytesRemaining;
Eric Laurent81784c32012-11-19 14:55:58 -08003086
3087 // If an NBAIO sink is present, use it to write the normal mixer's submix
3088 if (mNormalSink != 0) {
Glenn Kasten4c053ea2014-09-28 14:41:07 -07003089
Andy Hung010a1a12014-03-13 13:57:33 -07003090 const size_t count = mBytesRemaining / mFrameSize;
3091
Simon Wilson2d590962012-11-29 15:18:50 -08003092 ATRACE_BEGIN("write");
Eric Laurent81784c32012-11-19 14:55:58 -08003093 // update the setpoint when AudioFlinger::mScreenState changes
3094 uint32_t screenState = AudioFlinger::mScreenState;
3095 if (screenState != mScreenState) {
3096 mScreenState = screenState;
3097 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
3098 if (pipe != NULL) {
3099 pipe->setAvgFrames((mScreenState & 1) ?
3100 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
3101 }
3102 }
Andy Hung010a1a12014-03-13 13:57:33 -07003103 ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
Simon Wilson2d590962012-11-29 15:18:50 -08003104 ATRACE_END();
Eric Laurent81784c32012-11-19 14:55:58 -08003105 if (framesWritten > 0) {
Andy Hung010a1a12014-03-13 13:57:33 -07003106 bytesWritten = framesWritten * mFrameSize;
Andy Hung8946a282018-04-19 20:04:56 -07003107#ifdef TEE_SINK
3108 mTee.write((char *)mSinkBuffer + offset, framesWritten);
3109#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003110 } else {
3111 bytesWritten = framesWritten;
3112 }
3113 // otherwise use the HAL / AudioStreamOut directly
3114 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003115 // Direct output and offload threads
Andy Hung010a1a12014-03-13 13:57:33 -07003116
Eric Laurentbfb1b832013-01-07 09:53:42 -08003117 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003118 ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
3119 mWriteAckSequence += 2;
3120 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003121 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003122 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003123 }
Mikhail Naganov76e89c32019-08-15 20:18:47 -07003124 ATRACE_BEGIN("write");
Glenn Kasten767094d2013-08-23 13:51:43 -07003125 // FIXME We should have an implementation of timestamps for direct output threads.
3126 // They are used e.g for multichannel PCM playback over HDMI.
Phil Burk062e67a2015-02-11 13:40:50 -08003127 bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
Mikhail Naganov76e89c32019-08-15 20:18:47 -07003128 ATRACE_END();
Eric Laurent51716182016-02-29 18:00:56 -08003129
Eric Laurentbfb1b832013-01-07 09:53:42 -08003130 if (mUseAsyncWrite &&
3131 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
3132 // do not wait for async callback in case of error of full write
Eric Laurent3b4529e2013-09-05 18:09:19 -07003133 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003134 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003135 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003136 }
Eric Laurent81784c32012-11-19 14:55:58 -08003137 }
3138
Eric Laurent81784c32012-11-19 14:55:58 -08003139 mNumWrites++;
3140 mInWrite = false;
Andy Hungcf10d742020-04-28 15:38:24 -07003141 if (mStandby) {
3142 mThreadMetrics.logBeginInterval();
3143 mStandby = false;
3144 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003145 return bytesWritten;
3146}
3147
3148void AudioFlinger::PlaybackThread::threadLoop_drain()
3149{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003150 bool supportsDrain = false;
3151 if (mOutput->stream->supportsDrain(&supportsDrain) == OK && supportsDrain) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003152 ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
3153 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07003154 ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
3155 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003156 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07003157 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003158 }
Mikhail Naganovcbc8f612016-10-11 18:05:13 -07003159 status_t result = mOutput->stream->drain(mMixerStatus == MIXER_DRAIN_TRACK);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003160 ALOGE_IF(result != OK, "Error when draining stream: %d", result);
Eric Laurentbfb1b832013-01-07 09:53:42 -08003161 }
3162}
3163
3164void AudioFlinger::PlaybackThread::threadLoop_exit()
3165{
Eric Laurent275e8e92014-11-30 15:14:47 -08003166 {
3167 Mutex::Autolock _l(mLock);
3168 for (size_t i = 0; i < mTracks.size(); i++) {
3169 sp<Track> track = mTracks[i];
3170 track->invalidate();
3171 }
Andy Hungdae27702016-10-31 14:01:16 -07003172 // Clear ActiveTracks to update BatteryNotifier in case active tracks remain.
3173 // After we exit there are no more track changes sent to BatteryNotifier
3174 // because that requires an active threadLoop.
3175 // TODO: should we decActiveTrackCnt() of the cleared track effect chain?
3176 mActiveTracks.clear();
Eric Laurent275e8e92014-11-30 15:14:47 -08003177 }
Eric Laurent81784c32012-11-19 14:55:58 -08003178}
3179
3180/*
3181The derived values that are cached:
Andy Hung25c2dac2014-02-27 14:56:00 -08003182 - mSinkBufferSize from frame count * frame size
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003183 - mActiveSleepTimeUs from activeSleepTimeUs()
3184 - mIdleSleepTimeUs from idleSleepTimeUs()
Eric Laurent42537be2016-01-08 17:16:42 -08003185 - mStandbyDelayNs from mActiveSleepTimeUs (DIRECT only) or forced to at least
3186 kDefaultStandbyTimeInNsecs when connected to an A2DP device.
Eric Laurent81784c32012-11-19 14:55:58 -08003187 - maxPeriod from frame count and sample rate (MIXER only)
3188
3189The parameters that affect these derived values are:
3190 - frame count
3191 - frame size
3192 - sample rate
3193 - device type: A2DP or not
3194 - device latency
3195 - format: PCM or not
3196 - active sleep time
3197 - idle sleep time
3198*/
3199
3200void AudioFlinger::PlaybackThread::cacheParameters_l()
3201{
Andy Hung25c2dac2014-02-27 14:56:00 -08003202 mSinkBufferSize = mNormalFrameCount * mFrameSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003203 mActiveSleepTimeUs = activeSleepTimeUs();
3204 mIdleSleepTimeUs = idleSleepTimeUs();
Eric Laurent42537be2016-01-08 17:16:42 -08003205
3206 // make sure standby delay is not too short when connected to an A2DP sink to avoid
3207 // truncating audio when going to standby.
3208 mStandbyDelayNs = AudioFlinger::mStandbyTimeInNsecs;
jiabin10d86fd2019-10-31 17:20:42 -07003209 if (!Intersection(outDeviceTypes(), getAudioDeviceOutAllA2dpSet()).empty()) {
Eric Laurent42537be2016-01-08 17:16:42 -08003210 if (mStandbyDelayNs < kDefaultStandbyTimeInNsecs) {
3211 mStandbyDelayNs = kDefaultStandbyTimeInNsecs;
3212 }
3213 }
Eric Laurent81784c32012-11-19 14:55:58 -08003214}
3215
Eric Laurent13084622016-05-17 10:51:49 -07003216bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
Eric Laurent81784c32012-11-19 14:55:58 -08003217{
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003218 ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
Eric Laurent81784c32012-11-19 14:55:58 -08003219 this, streamType, mTracks.size());
Eric Laurent13084622016-05-17 10:51:49 -07003220 bool trackMatch = false;
Eric Laurent81784c32012-11-19 14:55:58 -08003221 size_t size = mTracks.size();
3222 for (size_t i = 0; i < size; i++) {
3223 sp<Track> t = mTracks[i];
Eric Laurentd60560a2015-04-10 11:31:20 -07003224 if (t->streamType() == streamType && t->isExternalTrack()) {
Glenn Kasten5736c352012-12-04 12:12:34 -08003225 t->invalidate();
Eric Laurent13084622016-05-17 10:51:49 -07003226 trackMatch = true;
Eric Laurent81784c32012-11-19 14:55:58 -08003227 }
3228 }
Eric Laurent13084622016-05-17 10:51:49 -07003229 return trackMatch;
Eric Laurent81784c32012-11-19 14:55:58 -08003230}
3231
Haynes Mathew George05317d22016-05-03 16:34:26 -07003232void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
3233{
3234 Mutex::Autolock _l(mLock);
3235 invalidateTracks_l(streamType);
3236}
3237
Eric Laurent81784c32012-11-19 14:55:58 -08003238status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
3239{
Glenn Kastend848eb42016-03-08 13:42:11 -08003240 audio_session_t session = chain->sessionId();
Mikhail Naganov022b9952017-01-04 16:36:51 -08003241 sp<EffectBufferHalInterface> halInBuffer, halOutBuffer;
Kevin Rocard7588ff42018-01-08 11:11:30 -08003242 status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
Mikhail Naganov022b9952017-01-04 16:36:51 -08003243 mEffectBufferEnabled ? mEffectBuffer : mSinkBuffer,
3244 mEffectBufferEnabled ? mEffectBufferSize : mSinkBufferSize,
3245 &halInBuffer);
3246 if (result != OK) return result;
3247 halOutBuffer = halInBuffer;
rago94a1ee82017-07-21 15:11:02 -07003248 effect_buffer_t *buffer = reinterpret_cast<effect_buffer_t*>(halInBuffer->externalData());
Eric Laurent81784c32012-11-19 14:55:58 -08003249 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
Eric Laurenta20c4e92019-11-12 15:55:51 -08003250 if (!audio_is_global_session(session)) {
Eric Laurent81784c32012-11-19 14:55:58 -08003251 // Only one effect chain can be present in direct output thread and it uses
Andy Hung2098f272014-02-27 14:00:06 -08003252 // the sink buffer as input
Eric Laurent81784c32012-11-19 14:55:58 -08003253 if (mType != DIRECT) {
jiabin245cdd92018-12-07 17:55:15 -08003254 size_t numSamples = mNormalFrameCount * (mChannelCount + mHapticChannelCount);
Kevin Rocard7588ff42018-01-08 11:11:30 -08003255 status_t result = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
rago94a1ee82017-07-21 15:11:02 -07003256 numSamples * sizeof(effect_buffer_t),
Mikhail Naganov022b9952017-01-04 16:36:51 -08003257 &halInBuffer);
3258 if (result != OK) return result;
rago94a1ee82017-07-21 15:11:02 -07003259#ifdef FLOAT_EFFECT_CHAIN
3260 buffer = halInBuffer->audioBuffer()->f32;
3261#else
Mikhail Naganov022b9952017-01-04 16:36:51 -08003262 buffer = halInBuffer->audioBuffer()->s16;
rago94a1ee82017-07-21 15:11:02 -07003263#endif
Mikhail Naganov022b9952017-01-04 16:36:51 -08003264 ALOGV("addEffectChain_l() creating new input buffer %p session %d",
3265 buffer, session);
Eric Laurent81784c32012-11-19 14:55:58 -08003266 }
3267
3268 // Attach all tracks with same session ID to this chain.
3269 for (size_t i = 0; i < mTracks.size(); ++i) {
3270 sp<Track> track = mTracks[i];
3271 if (session == track->sessionId()) {
3272 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
3273 buffer);
3274 track->setMainBuffer(buffer);
3275 chain->incTrackCnt();
3276 }
3277 }
3278
3279 // indicate all active tracks in the chain
Andy Hungdae27702016-10-31 14:01:16 -07003280 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003281 if (session == track->sessionId()) {
3282 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
3283 chain->incActiveTrackCnt();
3284 }
3285 }
3286 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003287 chain->setThread(this);
Mikhail Naganov022b9952017-01-04 16:36:51 -08003288 chain->setInBuffer(halInBuffer);
3289 chain->setOutBuffer(halOutBuffer);
Eric Laurenta20c4e92019-11-12 15:55:51 -08003290 // Effect chain for session AUDIO_SESSION_DEVICE is inserted at end of effect
3291 // chains list in order to be processed last as it contains output device effects.
3292 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted just before to apply post
3293 // processing effects specific to an output stream before effects applied to all streams
3294 // routed to a given device.
Eric Laurent81784c32012-11-19 14:55:58 -08003295 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
3296 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
Glenn Kastend848eb42016-03-08 13:42:11 -08003297 // after track specific effects and before output stage.
Eric Laurent81784c32012-11-19 14:55:58 -08003298 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
Glenn Kastend848eb42016-03-08 13:42:11 -08003299 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX.
Eric Laurent81784c32012-11-19 14:55:58 -08003300 // Effect chain for other sessions are inserted at beginning of effect
3301 // chains list to be processed before output mix effects. Relative order between other
Glenn Kastend848eb42016-03-08 13:42:11 -08003302 // sessions is not important.
3303 static_assert(AUDIO_SESSION_OUTPUT_MIX == 0 &&
Eric Laurenta20c4e92019-11-12 15:55:51 -08003304 AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX &&
3305 AUDIO_SESSION_DEVICE < AUDIO_SESSION_OUTPUT_STAGE,
Glenn Kastend848eb42016-03-08 13:42:11 -08003306 "audio_session_t constants misdefined");
Eric Laurent81784c32012-11-19 14:55:58 -08003307 size_t size = mEffectChains.size();
3308 size_t i = 0;
3309 for (i = 0; i < size; i++) {
3310 if (mEffectChains[i]->sessionId() < session) {
3311 break;
3312 }
3313 }
3314 mEffectChains.insertAt(chain, i);
3315 checkSuspendOnAddEffectChain_l(chain);
3316
3317 return NO_ERROR;
3318}
3319
3320size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
3321{
Glenn Kastend848eb42016-03-08 13:42:11 -08003322 audio_session_t session = chain->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08003323
3324 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
3325
3326 for (size_t i = 0; i < mEffectChains.size(); i++) {
3327 if (chain == mEffectChains[i]) {
3328 mEffectChains.removeAt(i);
3329 // detach all active tracks from the chain
Andy Hungdae27702016-10-31 14:01:16 -07003330 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003331 if (session == track->sessionId()) {
3332 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
3333 chain.get(), session);
3334 chain->decActiveTrackCnt();
3335 }
3336 }
3337
3338 // detach all tracks with same session ID from this chain
3339 for (size_t i = 0; i < mTracks.size(); ++i) {
3340 sp<Track> track = mTracks[i];
3341 if (session == track->sessionId()) {
rago94a1ee82017-07-21 15:11:02 -07003342 track->setMainBuffer(reinterpret_cast<effect_buffer_t*>(mSinkBuffer));
Eric Laurent81784c32012-11-19 14:55:58 -08003343 chain->decTrackCnt();
3344 }
3345 }
3346 break;
3347 }
3348 }
3349 return mEffectChains.size();
3350}
3351
3352status_t AudioFlinger::PlaybackThread::attachAuxEffect(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003353 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003354{
3355 Mutex::Autolock _l(mLock);
3356 return attachAuxEffect_l(track, EffectId);
3357}
3358
3359status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003360 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003361{
3362 status_t status = NO_ERROR;
3363
3364 if (EffectId == 0) {
3365 track->setAuxBuffer(0, NULL);
3366 } else {
3367 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
3368 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
3369 if (effect != 0) {
3370 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
3371 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
3372 } else {
3373 status = INVALID_OPERATION;
3374 }
3375 } else {
3376 status = BAD_VALUE;
3377 }
3378 }
3379 return status;
3380}
3381
3382void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
3383{
3384 for (size_t i = 0; i < mTracks.size(); ++i) {
3385 sp<Track> track = mTracks[i];
3386 if (track->auxEffectId() == effectId) {
3387 attachAuxEffect_l(track, 0);
3388 }
3389 }
3390}
3391
3392bool AudioFlinger::PlaybackThread::threadLoop()
3393{
Glenn Kasten388d5712017-04-07 14:38:41 -07003394 tlNBLogWriter = mNBLogWriter.get();
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003395
Eric Laurent81784c32012-11-19 14:55:58 -08003396 Vector< sp<Track> > tracksToRemove;
3397
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003398 mStandbyTimeNs = systemTime();
Andy Hung446f4df2019-02-21 12:26:41 -08003399 int64_t lastLoopCountWritten = -2; // never matches "previous" loop, when loopCount = 0.
3400 int64_t lastFramesWritten = -1; // track changes in timestamp server frames written
Eric Laurent81784c32012-11-19 14:55:58 -08003401
3402 // MIXER
3403 nsecs_t lastWarning = 0;
3404
3405 // DUPLICATING
3406 // FIXME could this be made local to while loop?
3407 writeFrames = 0;
3408
3409 cacheParameters_l();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003410 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003411
3412 if (mType == MIXER) {
3413 sleepTimeShift = 0;
3414 }
3415
3416 CpuStats cpuStats;
3417 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
3418
3419 acquireWakeLock();
3420
Glenn Kasteneef598c2017-04-03 14:41:13 -07003421 // mNBLogWriter logging APIs can only be called by a single thread, typically the
3422 // thread associated with this PlaybackThread.
3423 // If you want to share the mNBLogWriter with other threads (for example, binder threads)
3424 // then all such threads must agree to hold a common mutex before logging.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003425 // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
3426 // and then that string will be logged at the next convenient opportunity.
Glenn Kasteneef598c2017-04-03 14:41:13 -07003427 // See reference to logString below.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003428 const char *logString = NULL;
3429
rago1bb90822017-05-02 18:31:48 -07003430 // Estimated time for next buffer to be written to hal. This is used only on
3431 // suspended mode (for now) to help schedule the wait time until next iteration.
3432 nsecs_t timeLoopNextNs = 0;
3433
Eric Laurent664539d2013-09-23 18:24:31 -07003434 checkSilentMode_l();
Glenn Kasteneef598c2017-04-03 14:41:13 -07003435
Andy Hungf3234512018-07-03 14:51:47 -07003436 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
3437 // TODO: add confirmation checks:
3438 // 1) DIRECT threads and linear PCM format really resets to 0?
3439 // 2) Is frame count really valid if not linear pcm?
3440 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
3441 if (mType == OFFLOAD || mType == DIRECT) {
3442 mTimestampVerifier.setDiscontinuityMode(mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
3443 }
Andy Hung2dbffc22018-08-08 18:50:41 -07003444 audio_patch_handle_t lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Andy Hungf3234512018-07-03 14:51:47 -07003445
Andy Hung446f4df2019-02-21 12:26:41 -08003446 // loopCount is used for statistics and diagnostics.
3447 for (int64_t loopCount = 0; !exitPending(); ++loopCount)
Eric Laurent81784c32012-11-19 14:55:58 -08003448 {
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08003449 // Log merge requests are performed during AudioFlinger binder transactions, but
3450 // that does not cover audio playback. It's requested here for that reason.
3451 mAudioFlinger->requestLogMerge();
3452
Eric Laurent81784c32012-11-19 14:55:58 -08003453 cpuStats.sample(myName);
3454
3455 Vector< sp<EffectChain> > effectChains;
Andy Hung6e6a2e62019-04-30 16:38:41 -07003456 audio_session_t activeHapticSessionId = AUDIO_SESSION_NONE;
Andy Hungc1646382019-04-30 16:12:10 -07003457 std::vector<sp<Track>> activeTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08003458
Andy Hung2dbffc22018-08-08 18:50:41 -07003459 // If the device is AUDIO_DEVICE_OUT_BUS, check for downstream latency.
3460 //
jiabin10d86fd2019-10-31 17:20:42 -07003461 // Note: we access outDeviceTypes() outside of mLock.
3462 if (isMsdDevice() && outDeviceTypes().count(AUDIO_DEVICE_OUT_BUS) != 0) {
Andy Hung2dbffc22018-08-08 18:50:41 -07003463 // Here, we try for the AF lock, but do not block on it as the latency
3464 // is more informational.
3465 if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
3466 std::vector<PatchPanel::SoftwarePatch> swPatches;
3467 double latencyMs;
3468 status_t status = INVALID_OPERATION;
3469 audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3470 if (mAudioFlinger->mPatchPanel.getDownstreamSoftwarePatches(id(), &swPatches) == OK
3471 && swPatches.size() > 0) {
3472 status = swPatches[0].getLatencyMs_l(&latencyMs);
3473 downstreamPatchHandle = swPatches[0].getPatchHandle();
3474 }
3475 if (downstreamPatchHandle != lastDownstreamPatchHandle) {
Dean Wheatley30d28422018-11-06 10:27:40 +11003476 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003477 lastDownstreamPatchHandle = downstreamPatchHandle;
3478 }
3479 if (status == OK) {
3480 // verify downstream latency (we assume a max reasonable
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003481 // latency of 5 seconds).
3482 const double minLatency = 0., maxLatency = 5000.;
3483 if (latencyMs >= minLatency && latencyMs <= maxLatency) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10003484 ALOGVV("new downstream latency %lf ms", latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003485 } else {
3486 ALOGD("out of range downstream latency %lf ms", latencyMs);
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003487 if (latencyMs < minLatency) latencyMs = minLatency;
3488 else if (latencyMs > maxLatency) latencyMs = maxLatency;
Andy Hung2dbffc22018-08-08 18:50:41 -07003489 }
Dean Wheatley30d28422018-11-06 10:27:40 +11003490 mDownstreamLatencyStatMs.add(latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003491 }
3492 mAudioFlinger->mLock.unlock();
3493 }
3494 } else {
3495 if (lastDownstreamPatchHandle != AUDIO_PATCH_HANDLE_NONE) {
3496 // our device is no longer AUDIO_DEVICE_OUT_BUS, reset patch handle and stats.
Dean Wheatley30d28422018-11-06 10:27:40 +11003497 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003498 lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3499 }
3500 }
3501
Eric Laurent81784c32012-11-19 14:55:58 -08003502 { // scope for mLock
3503
3504 Mutex::Autolock _l(mLock);
3505
Eric Laurent021cf962014-05-13 10:18:14 -07003506 processConfigEvents_l();
Eric Laurent10351942014-05-08 18:49:52 -07003507
Glenn Kasteneef598c2017-04-03 14:41:13 -07003508 // See comment at declaration of logString for why this is done under mLock
Glenn Kasten9e58b552013-01-18 15:09:48 -08003509 if (logString != NULL) {
3510 mNBLogWriter->logTimestamp();
3511 mNBLogWriter->log(logString);
3512 logString = NULL;
3513 }
3514
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003515 // Collect timestamp statistics for the Playback Thread types that support it.
3516 if (mType == MIXER
3517 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -07003518 || mType == DIRECT
3519 || mType == OFFLOAD) { // no indentation
Glenn Kasten4c053ea2014-09-28 14:41:07 -07003520 // Gather the framesReleased counters for all active tracks,
Andy Hunge10393e2015-06-12 13:59:33 -07003521 // and associate with the sink frames written out. We need
3522 // this to convert the sink timestamp to the track timestamp.
Andy Hung69488c42016-05-16 18:43:33 -07003523 bool kernelLocationUpdate = false;
Andy Hung1c86ebe2018-05-29 20:29:08 -07003524 ExtendedTimestamp timestamp; // use private copy to fetch
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003525 if (mStandby) {
3526 mTimestampVerifier.discontinuity();
3527 } else if (threadloop_getHalTimestamp_l(&timestamp) == OK) {
3528 mTimestampVerifier.add(timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
3529 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3530 mSampleRate);
Andy Hungc8fddf32018-08-08 18:32:37 -07003531
3532 if (isTimestampCorrectionEnabled()) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10003533 ALOGVV("TS_BEFORE: %d %lld %lld", id(),
Andy Hungc8fddf32018-08-08 18:32:37 -07003534 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3535 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
3536 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
3537 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3538 = correctedTimestamp.mFrames;
3539 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
3540 = correctedTimestamp.mTimeNs;
Dean Wheatley56a583e2020-05-08 15:12:17 +10003541 ALOGVV("TS_AFTER: %d %lld %lld", id(),
Andy Hungc8fddf32018-08-08 18:32:37 -07003542 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3543 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
Andy Hung2dbffc22018-08-08 18:50:41 -07003544
3545 // Note: Downstream latency only added if timestamp correction enabled.
Dean Wheatley30d28422018-11-06 10:27:40 +11003546 if (mDownstreamLatencyStatMs.getN() > 0) { // we have latency info.
Andy Hung2dbffc22018-08-08 18:50:41 -07003547 const int64_t newPosition =
3548 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
Dean Wheatley30d28422018-11-06 10:27:40 +11003549 - int64_t(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
Andy Hung2dbffc22018-08-08 18:50:41 -07003550 // prevent retrograde
3551 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = max(
3552 newPosition,
3553 (mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3554 - mSuspendedFrames));
3555 }
Andy Hungc8fddf32018-08-08 18:32:37 -07003556 }
3557
Andy Hung818e7a32016-02-16 18:08:07 -08003558 // We always fetch the timestamp here because often the downstream
Andy Hung69488c42016-05-16 18:43:33 -07003559 // sink will block while writing.
Andy Hung6d7b1192016-05-07 22:59:48 -07003560
3561 // We keep track of the last valid kernel position in case we are in underrun
3562 // and the normal mixer period is the same as the fast mixer period, or there
3563 // is some error from the HAL.
3564 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
3565 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
3566 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
3567 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
3568 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
3569
3570 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
3571 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER];
3572 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
3573 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER];
Andy Hung69488c42016-05-16 18:43:33 -07003574 }
3575
3576 if (timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
3577 kernelLocationUpdate = true;
Andy Hung6d7b1192016-05-07 22:59:48 -07003578 } else {
Eric Laurent122f7e72016-06-29 11:53:29 -07003579 ALOGVV("getTimestamp error - no valid kernel position");
Andy Hung6d7b1192016-05-07 22:59:48 -07003580 }
3581
Andy Hung818e7a32016-02-16 18:08:07 -08003582 // copy over kernel info
3583 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
Andy Hung238fa3d2016-07-28 10:53:22 -07003584 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3585 + mSuspendedFrames; // add frames discarded when suspended
Andy Hung818e7a32016-02-16 18:08:07 -08003586 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
3587 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003588 } else {
3589 mTimestampVerifier.error();
Andy Hungc54b1ff2016-02-23 14:07:07 -08003590 }
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003591
Andy Hungc54b1ff2016-02-23 14:07:07 -08003592 // mFramesWritten for non-offloaded tracks are contiguous
3593 // even after standby() is called. This is useful for the track frame
3594 // to sink frame mapping.
Andy Hung69488c42016-05-16 18:43:33 -07003595 bool serverLocationUpdate = false;
3596 if (mFramesWritten != lastFramesWritten) {
3597 serverLocationUpdate = true;
3598 lastFramesWritten = mFramesWritten;
3599 }
3600 // Only update timestamps if there is a meaningful change.
3601 // Either the kernel timestamp must be valid or we have written something.
3602 if (kernelLocationUpdate || serverLocationUpdate) {
3603 if (serverLocationUpdate) {
3604 // use the time before we called the HAL write - it is a bit more accurate
3605 // to when the server last read data than the current time here.
3606 //
Andy Hung446f4df2019-02-21 12:26:41 -08003607 // If we haven't written anything, mLastIoBeginNs will be -1
Andy Hung69488c42016-05-16 18:43:33 -07003608 // and we use systemTime().
3609 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = mFramesWritten;
Andy Hung446f4df2019-02-21 12:26:41 -08003610 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = mLastIoBeginNs == -1
3611 ? systemTime() : mLastIoBeginNs;
Andy Hung69488c42016-05-16 18:43:33 -07003612 }
Andy Hungdae27702016-10-31 14:01:16 -07003613
3614 for (const sp<Track> &t : mActiveTracks) {
3615 if (!t->isFastTrack()) {
Andy Hung69488c42016-05-16 18:43:33 -07003616 t->updateTrackFrameInfo(
3617 t->mAudioTrackServerProxy->framesReleased(),
3618 mFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07003619 mSampleRate,
Andy Hung69488c42016-05-16 18:43:33 -07003620 mTimestamp);
3621 }
Andy Hunge10393e2015-06-12 13:59:33 -07003622 }
Glenn Kastenbd096fd2013-08-23 13:53:56 -07003623 }
Andy Hunge6c37112019-02-26 17:38:10 -08003624
3625 if (audio_has_proportional_frames(mFormat)) {
3626 const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
3627 if (latencyMs != 0.) { // note 0. means timestamp is empty.
3628 mLatencyMs.add(latencyMs);
3629 }
3630 }
3631
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003632 } // if (mType ... ) { // no indentation
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003633#if 0
3634 // logFormat example
Nicolas Rouletc20cb502017-02-01 12:35:24 -08003635 if (z % 100 == 0) {
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003636 timespec ts;
3637 clock_gettime(CLOCK_MONOTONIC, &ts);
Nicolas Roulet4da78202017-02-03 12:53:39 -08003638 LOGT("This is an integer %d, this is a float %f, this is my "
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003639 "pid %p %% %s %t", 42, 3.14, "and this is a timestamp", ts);
Nicolas Roulet4da78202017-02-03 12:53:39 -08003640 LOGT("A deceptive null-terminated string %\0");
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003641 }
3642 ++z;
3643#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003644 saveOutputTracks();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003645 if (mSignalPending) {
3646 // A signal was raised while we were unlocked
3647 mSignalPending = false;
3648 } else if (waitingAsyncCallback_l()) {
3649 if (exitPending()) {
3650 break;
3651 }
Marco Nelissen078538c2015-05-12 09:17:57 -07003652 bool released = false;
Eric Laurent64667972016-03-30 18:19:46 -07003653 if (!keepWakeLock()) {
Marco Nelissen078538c2015-05-12 09:17:57 -07003654 releaseWakeLock_l();
3655 released = true;
3656 }
Andy Hung10cbff12017-02-21 17:30:14 -08003657
3658 const int64_t waitNs = computeWaitTimeNs_l();
3659 ALOGV("wait async completion (wait time: %lld)", (long long)waitNs);
3660 status_t status = mWaitWorkCV.waitRelative(mLock, waitNs);
3661 if (status == TIMED_OUT) {
3662 mSignalPending = true; // if timeout recheck everything
3663 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003664 ALOGV("async completion/wake");
Marco Nelissen078538c2015-05-12 09:17:57 -07003665 if (released) {
3666 acquireWakeLock_l();
3667 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003668 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3669 mSleepTimeUs = 0;
Eric Laurentede6c3b2013-09-19 14:37:46 -07003670
3671 continue;
3672 }
Eric Tan39ec8d62018-07-24 09:49:29 -07003673 if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
Eric Laurentbfb1b832013-01-07 09:53:42 -08003674 isSuspended()) {
3675 // put audio hardware into standby after short delay
3676 if (shouldStandby_l()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003677
3678 threadLoop_standby();
3679
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003680 // This is where we go into standby
3681 if (!mStandby) {
3682 LOG_AUDIO_STATE();
Andy Hungcf10d742020-04-28 15:38:24 -07003683 mThreadMetrics.logEndInterval();
3684 mStandby = true;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003685 }
Andy Hungd0979812019-02-21 15:51:44 -08003686 sendStatistics(false /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -08003687 }
3688
Eric Tan39ec8d62018-07-24 09:49:29 -07003689 if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003690 // we're about to wait, flush the binder command buffer
3691 IPCThreadState::self()->flushCommands();
3692
3693 clearOutputTracks();
3694
3695 if (exitPending()) {
3696 break;
3697 }
3698
3699 releaseWakeLock_l();
3700 // wait until we have something to do...
3701 ALOGV("%s going to sleep", myName.string());
3702 mWaitWorkCV.wait(mLock);
3703 ALOGV("%s waking up", myName.string());
3704 acquireWakeLock_l();
3705
3706 mMixerStatus = MIXER_IDLE;
3707 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
3708 mBytesWritten = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003709 mBytesRemaining = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08003710 checkSilentMode_l();
3711
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003712 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3713 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003714 if (mType == MIXER) {
3715 sleepTimeShift = 0;
3716 }
3717
3718 continue;
3719 }
3720 }
Eric Laurent81784c32012-11-19 14:55:58 -08003721 // mMixerStatusIgnoringFastTracks is also updated internally
3722 mMixerStatus = prepareTracks_l(&tracksToRemove);
3723
Andy Hungdae27702016-10-31 14:01:16 -07003724 mActiveTracks.updatePowerState(this);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003725
Kevin Rocard069c2712018-03-29 19:09:14 -07003726 updateMetadata_l();
3727
Eric Laurent81784c32012-11-19 14:55:58 -08003728 // prevent any changes in effect chain list and in each effect chain
3729 // during mixing and effect process as the audio buffers could be deleted
3730 // or modified if an effect is created or deleted
3731 lockEffectChains_l(effectChains);
Andy Hung6e6a2e62019-04-30 16:38:41 -07003732
3733 // Determine which session to pick up haptic data.
3734 // This must be done under the same lock as prepareTracks_l().
3735 // TODO: Write haptic data directly to sink buffer when mixing.
3736 if (mHapticChannelCount > 0 && effectChains.size() > 0) {
3737 for (const auto& track : mActiveTracks) {
3738 if (track->getHapticPlaybackEnabled()) {
3739 activeHapticSessionId = track->sessionId();
3740 break;
3741 }
3742 }
3743 }
3744
Andy Hungc1646382019-04-30 16:12:10 -07003745 // Acquire a local copy of active tracks with lock (release w/o lock).
3746 //
3747 // Control methods on the track acquire the ThreadBase lock (e.g. start()
3748 // stop(), pause(), etc.), but the threadLoop is entitled to call audio
3749 // data / buffer methods on tracks from activeTracks without the ThreadBase lock.
3750 activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003751 } // mLock scope ends
Eric Laurent81784c32012-11-19 14:55:58 -08003752
Eric Laurentbfb1b832013-01-07 09:53:42 -08003753 if (mBytesRemaining == 0) {
3754 mCurrentWriteLength = 0;
3755 if (mMixerStatus == MIXER_TRACKS_READY) {
3756 // threadLoop_mix() sets mCurrentWriteLength
3757 threadLoop_mix();
3758 } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
3759 && (mMixerStatus != MIXER_DRAIN_ALL)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003760 // threadLoop_sleepTime sets mSleepTimeUs to 0 if data
Eric Laurentbfb1b832013-01-07 09:53:42 -08003761 // must be written to HAL
3762 threadLoop_sleepTime();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003763 if (mSleepTimeUs == 0) {
Andy Hung25c2dac2014-02-27 14:56:00 -08003764 mCurrentWriteLength = mSinkBufferSize;
Andy Hungc1646382019-04-30 16:12:10 -07003765
3766 // Tally underrun frames as we are inserting 0s here.
3767 for (const auto& track : activeTracks) {
Andy Hunge2e830f2019-12-03 12:54:46 -08003768 if (track->mFillingUpStatus == Track::FS_ACTIVE
3769 && !track->isStopped()
3770 && !track->isPaused()
3771 && !track->isTerminated()) {
3772 ALOGV("%s: track(%d) %s underrun due to thread sleep of %zu frames",
3773 __func__, track->id(), track->getTrackStateAsString(),
3774 mNormalFrameCount);
Andy Hungc1646382019-04-30 16:12:10 -07003775 track->mAudioTrackServerProxy->tallyUnderrunFrames(mNormalFrameCount);
3776 }
3777 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003778 }
3779 }
Andy Hung98ef9782014-03-04 14:46:50 -08003780 // Either threadLoop_mix() or threadLoop_sleepTime() should have set
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003781 // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
Andy Hung98ef9782014-03-04 14:46:50 -08003782 // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
3783 // or mSinkBuffer (if there are no effects).
3784 //
3785 // This is done pre-effects computation; if effects change to
3786 // support higher precision, this needs to move.
3787 //
3788 // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003789 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003790 if (mMixerBufferValid) {
3791 void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
3792 audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
3793
Andy Hung2ddee192015-12-18 17:34:44 -08003794 // mono blend occurs for mixer threads only (not direct or offloaded)
3795 // and is handled here if we're going directly to the sink.
3796 if (requireMonoBlend() && !mEffectBufferValid) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003797 mono_blend(mMixerBuffer, mMixerBufferFormat, mChannelCount, mNormalFrameCount,
3798 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003799 }
3800
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003801 if (!hasFastMixer()) {
3802 // Balance must take effect after mono conversion.
3803 // We do it here if there is no FastMixer.
3804 // mBalance detects zero balance within the class for speed (not needed here).
3805 mBalance.setBalance(mMasterBalance.load());
3806 mBalance.process((float *)mMixerBuffer, mNormalFrameCount);
3807 }
3808
Andy Hung98ef9782014-03-04 14:46:50 -08003809 memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003810 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3811
3812 // If we're going directly to the sink and there are haptic channels,
3813 // we should adjust channels as the sample data is partially interleaved
3814 // in this case.
3815 if (!mEffectBufferValid && mHapticChannelCount > 0) {
3816 adjust_channels_non_destructive(buffer, mChannelCount, buffer,
3817 mChannelCount + mHapticChannelCount,
3818 audio_bytes_per_sample(format),
3819 audio_bytes_per_frame(mChannelCount, format) * mNormalFrameCount);
3820 }
Andy Hung98ef9782014-03-04 14:46:50 -08003821 }
3822
Eric Laurentbfb1b832013-01-07 09:53:42 -08003823 mBytesRemaining = mCurrentWriteLength;
3824 if (isSuspended()) {
Andy Hung238fa3d2016-07-28 10:53:22 -07003825 // Simulate write to HAL when suspended (e.g. BT SCO phone call).
3826 mSleepTimeUs = suspendSleepTimeUs(); // assumes full buffer.
3827 const size_t framesRemaining = mBytesRemaining / mFrameSize;
3828 mBytesWritten += mBytesRemaining;
3829 mFramesWritten += framesRemaining;
3830 mSuspendedFrames += framesRemaining; // to adjust kernel HAL position
Eric Laurentbfb1b832013-01-07 09:53:42 -08003831 mBytesRemaining = 0;
3832 }
Eric Laurent81784c32012-11-19 14:55:58 -08003833
Eric Laurentbfb1b832013-01-07 09:53:42 -08003834 // only process effects if we're going to write
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003835 if (mSleepTimeUs == 0 && mType != OFFLOAD) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003836 for (size_t i = 0; i < effectChains.size(); i ++) {
3837 effectChains[i]->process_l();
jiabin47affe52019-04-04 18:02:07 -07003838 // TODO: Write haptic data directly to sink buffer when mixing.
Andy Hung6e6a2e62019-04-30 16:38:41 -07003839 if (activeHapticSessionId != AUDIO_SESSION_NONE
3840 && activeHapticSessionId == effectChains[i]->sessionId()) {
jiabin47affe52019-04-04 18:02:07 -07003841 // Haptic data is active in this case, copy it directly from
3842 // in buffer to out buffer.
3843 const size_t audioBufferSize = mNormalFrameCount
3844 * audio_bytes_per_frame(mChannelCount, EFFECT_BUFFER_FORMAT);
3845 memcpy_by_audio_format(
3846 (uint8_t*)effectChains[i]->outBuffer() + audioBufferSize,
3847 EFFECT_BUFFER_FORMAT,
3848 (const uint8_t*)effectChains[i]->inBuffer() + audioBufferSize,
3849 EFFECT_BUFFER_FORMAT, mNormalFrameCount * mHapticChannelCount);
3850 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003851 }
Eric Laurent81784c32012-11-19 14:55:58 -08003852 }
3853 }
Eric Laurent59fe0102013-09-27 18:48:26 -07003854 // Process effect chains for offloaded thread even if no audio
3855 // was read from audio track: process only updates effect state
3856 // and thus does have to be synchronized with audio writes but may have
3857 // to be called while waiting for async write callback
3858 if (mType == OFFLOAD) {
3859 for (size_t i = 0; i < effectChains.size(); i ++) {
3860 effectChains[i]->process_l();
3861 }
3862 }
Eric Laurent81784c32012-11-19 14:55:58 -08003863
Andy Hung98ef9782014-03-04 14:46:50 -08003864 // Only if the Effects buffer is enabled and there is data in the
3865 // Effects buffer (buffer valid), we need to
3866 // copy into the sink buffer.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003867 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003868 if (mEffectBufferValid) {
3869 //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
Andy Hung2ddee192015-12-18 17:34:44 -08003870
3871 if (requireMonoBlend()) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003872 mono_blend(mEffectBuffer, mEffectBufferFormat, mChannelCount, mNormalFrameCount,
3873 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003874 }
3875
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003876 if (!hasFastMixer()) {
3877 // Balance must take effect after mono conversion.
3878 // We do it here if there is no FastMixer.
3879 // mBalance detects zero balance within the class for speed (not needed here).
3880 mBalance.setBalance(mMasterBalance.load());
3881 mBalance.process((float *)mEffectBuffer, mNormalFrameCount);
3882 }
3883
Andy Hung98ef9782014-03-04 14:46:50 -08003884 memcpy_by_audio_format(mSinkBuffer, mFormat, mEffectBuffer, mEffectBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003885 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3886 // The sample data is partially interleaved when haptic channels exist,
3887 // we need to adjust channels here.
3888 if (mHapticChannelCount > 0) {
3889 adjust_channels_non_destructive(mSinkBuffer, mChannelCount, mSinkBuffer,
3890 mChannelCount + mHapticChannelCount,
3891 audio_bytes_per_sample(mFormat),
3892 audio_bytes_per_frame(mChannelCount, mFormat) * mNormalFrameCount);
3893 }
Andy Hung98ef9782014-03-04 14:46:50 -08003894 }
3895
Eric Laurent81784c32012-11-19 14:55:58 -08003896 // enable changes in effect chain
3897 unlockEffectChains(effectChains);
3898
Eric Laurentbfb1b832013-01-07 09:53:42 -08003899 if (!waitingAsyncCallback()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003900 // mSleepTimeUs == 0 means we must write to audio hardware
3901 if (mSleepTimeUs == 0) {
Andy Hung08fb1742015-05-31 23:22:10 -07003902 ssize_t ret = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003903 // writePeriodNs is updated >= 0 when ret > 0.
3904 int64_t writePeriodNs = -1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003905 if (mBytesRemaining) {
Andy Hung69488c42016-05-16 18:43:33 -07003906 // FIXME rewrite to reduce number of system calls
Andy Hung446f4df2019-02-21 12:26:41 -08003907 const int64_t lastIoBeginNs = systemTime();
Andy Hung08fb1742015-05-31 23:22:10 -07003908 ret = threadLoop_write();
Andy Hung446f4df2019-02-21 12:26:41 -08003909 const int64_t lastIoEndNs = systemTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003910 if (ret < 0) {
3911 mBytesRemaining = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003912 } else if (ret > 0) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003913 mBytesWritten += ret;
3914 mBytesRemaining -= ret;
Andy Hung446f4df2019-02-21 12:26:41 -08003915 const int64_t frames = ret / mFrameSize;
3916 mFramesWritten += frames;
3917
3918 writePeriodNs = lastIoEndNs - mLastIoEndNs;
3919 // process information relating to write time.
3920 if (audio_has_proportional_frames(mFormat)) {
3921 // we are in a continuous mixing cycle
3922 if (mMixerStatus == MIXER_TRACKS_READY &&
3923 loopCount == lastLoopCountWritten + 1) {
3924
3925 const double jitterMs =
3926 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
3927 {frames, writePeriodNs},
3928 {0, 0} /* lastTimestamp */, mSampleRate);
3929 const double processMs =
3930 (lastIoBeginNs - mLastIoEndNs) * 1e-6;
3931
3932 Mutex::Autolock _l(mLock);
3933 mIoJitterMs.add(jitterMs);
3934 mProcessTimeMs.add(processMs);
3935 }
3936
3937 // write blocked detection
3938 const int64_t deltaWriteNs = lastIoEndNs - lastIoBeginNs;
3939 if (mType == MIXER && deltaWriteNs > maxPeriod) {
3940 mNumDelayedWrites++;
3941 if ((lastIoEndNs - lastWarning) > kWarningThrottleNs) {
3942 ATRACE_NAME("underrun");
3943 ALOGW("write blocked for %lld msecs, "
3944 "%d delayed writes, thread %d",
3945 (long long)deltaWriteNs / NANOS_PER_MILLISECOND,
3946 mNumDelayedWrites, mId);
3947 lastWarning = lastIoEndNs;
3948 }
3949 }
3950 }
3951 // update timing info.
3952 mLastIoBeginNs = lastIoBeginNs;
3953 mLastIoEndNs = lastIoEndNs;
3954 lastLoopCountWritten = loopCount;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003955 }
3956 } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
3957 (mMixerStatus == MIXER_DRAIN_ALL)) {
3958 threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -08003959 }
Andy Hung08fb1742015-05-31 23:22:10 -07003960 if (mType == MIXER && !mStandby) {
Andy Hung08fb1742015-05-31 23:22:10 -07003961
3962 if (mThreadThrottle
3963 && mMixerStatus == MIXER_TRACKS_READY // we are mixing (active tracks)
Andy Hung446f4df2019-02-21 12:26:41 -08003964 && writePeriodNs > 0) { // we have write period info
Andy Hung08fb1742015-05-31 23:22:10 -07003965 // Limit MixerThread data processing to no more than twice the
3966 // expected processing rate.
3967 //
3968 // This helps prevent underruns with NuPlayer and other applications
3969 // which may set up buffers that are close to the minimum size, or use
3970 // deep buffers, and rely on a double-buffering sleep strategy to fill.
3971 //
3972 // The throttle smooths out sudden large data drains from the device,
3973 // e.g. when it comes out of standby, which often causes problems with
3974 // (1) mixer threads without a fast mixer (which has its own warm-up)
3975 // (2) minimum buffer sized tracks (even if the track is full,
3976 // the app won't fill fast enough to handle the sudden draw).
Haynes Mathew Georgef92b2172016-05-09 11:34:15 -07003977 //
3978 // Total time spent in last processing cycle equals time spent in
3979 // 1. threadLoop_write, as well as time spent in
3980 // 2. threadLoop_mix (significant for heavy mixing, especially
3981 // on low tier processors)
Andy Hung08fb1742015-05-31 23:22:10 -07003982
Andy Hung446f4df2019-02-21 12:26:41 -08003983 // it's OK if deltaMs is an overestimate.
3984
3985 const int32_t deltaMs = writePeriodNs / NANOS_PER_MILLISECOND;
Ivan Lozanoe02bc542017-10-26 09:51:54 -07003986
Ivan Lozanoea04d392017-11-07 14:37:07 -08003987 const int32_t throttleMs = (int32_t)mHalfBufferMs - deltaMs;
Andy Hung08fb1742015-05-31 23:22:10 -07003988 if ((signed)mHalfBufferMs >= throttleMs && throttleMs > 0) {
Andy Hungcf10d742020-04-28 15:38:24 -07003989 mThreadMetrics.logThrottleMs((double)throttleMs);
Andy Hungb68f5eb2019-12-03 16:49:17 -08003990
Andy Hung08fb1742015-05-31 23:22:10 -07003991 usleep(throttleMs * 1000);
Andy Hung40eb1a12015-06-18 13:42:02 -07003992 // notify of throttle start on verbose log
3993 ALOGV_IF(mThreadThrottleEndMs == mThreadThrottleTimeMs,
3994 "mixer(%p) throttle begin:"
3995 " ret(%zd) deltaMs(%d) requires sleep %d ms",
Andy Hung08fb1742015-05-31 23:22:10 -07003996 this, ret, deltaMs, throttleMs);
Andy Hung40eb1a12015-06-18 13:42:02 -07003997 mThreadThrottleTimeMs += throttleMs;
Andy Hung0a31ddd2016-07-06 19:10:29 -07003998 // Throttle must be attributed to the previous mixer loop's write time
3999 // to allow back-to-back throttling.
Andy Hung446f4df2019-02-21 12:26:41 -08004000 // This also ensures proper timing statistics.
4001 mLastIoEndNs = systemTime(); // we fetch the write end time again.
Andy Hung40eb1a12015-06-18 13:42:02 -07004002 } else {
4003 uint32_t diff = mThreadThrottleTimeMs - mThreadThrottleEndMs;
4004 if (diff > 0) {
4005 // notify of throttle end on debug log
Andy Hung3ea004d2016-05-05 16:48:37 -07004006 // but prevent spamming for bluetooth
jiabin10d86fd2019-10-31 17:20:42 -07004007 ALOGD_IF(!isSingleDeviceType(
4008 outDeviceTypes(), audio_is_a2dp_out_device) &&
4009 !isSingleDeviceType(
4010 outDeviceTypes(), audio_is_hearing_aid_out_device),
Andy Hung3ea004d2016-05-05 16:48:37 -07004011 "mixer(%p) throttle end: throttle time(%u)", this, diff);
Andy Hung40eb1a12015-06-18 13:42:02 -07004012 mThreadThrottleEndMs = mThreadThrottleTimeMs;
4013 }
Andy Hung08fb1742015-05-31 23:22:10 -07004014 }
4015 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004016 }
Eric Laurent81784c32012-11-19 14:55:58 -08004017
Eric Laurentbfb1b832013-01-07 09:53:42 -08004018 } else {
Glenn Kastene7754022014-10-31 12:11:26 -07004019 ATRACE_BEGIN("sleep");
Eric Laurente93cc032016-05-05 10:15:10 -07004020 Mutex::Autolock _l(mLock);
rago1bb90822017-05-02 18:31:48 -07004021 // suspended requires accurate metering of sleep time.
4022 if (isSuspended()) {
4023 // advance by expected sleepTime
4024 timeLoopNextNs += microseconds((nsecs_t)mSleepTimeUs);
4025 const nsecs_t nowNs = systemTime();
4026
4027 // compute expected next time vs current time.
4028 // (negative deltas are treated as delays).
4029 nsecs_t deltaNs = timeLoopNextNs - nowNs;
4030 if (deltaNs < -kMaxNextBufferDelayNs) {
4031 // Delays longer than the max allowed trigger a reset.
4032 ALOGV("DelayNs: %lld, resetting timeLoopNextNs", (long long) deltaNs);
4033 deltaNs = microseconds((nsecs_t)mSleepTimeUs);
4034 timeLoopNextNs = nowNs + deltaNs;
4035 } else if (deltaNs < 0) {
4036 // Delays within the max delay allowed: zero the delta/sleepTime
4037 // to help the system catch up in the next iteration(s)
4038 ALOGV("DelayNs: %lld, catching-up", (long long) deltaNs);
4039 deltaNs = 0;
4040 }
4041 // update sleep time (which is >= 0)
4042 mSleepTimeUs = deltaNs / 1000;
4043 }
Eric Laurente93cc032016-05-05 10:15:10 -07004044 if (!mSignalPending && mConfigEvents.isEmpty() && !exitPending()) {
4045 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)mSleepTimeUs));
Eric Laurent51716182016-02-29 18:00:56 -08004046 }
Glenn Kastene7754022014-10-31 12:11:26 -07004047 ATRACE_END();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004048 }
Eric Laurent81784c32012-11-19 14:55:58 -08004049 }
4050
4051 // Finally let go of removed track(s), without the lock held
4052 // since we can't guarantee the destructors won't acquire that
4053 // same lock. This will also mutate and push a new fast mixer state.
4054 threadLoop_removeTracks(tracksToRemove);
4055 tracksToRemove.clear();
4056
4057 // FIXME I don't understand the need for this here;
4058 // it was in the original code but maybe the
4059 // assignment in saveOutputTracks() makes this unnecessary?
4060 clearOutputTracks();
4061
4062 // Effect chains will be actually deleted here if they were removed from
4063 // mEffectChains list during mixing or effects processing
4064 effectChains.clear();
4065
4066 // FIXME Note that the above .clear() is no longer necessary since effectChains
4067 // is now local to this block, but will keep it for now (at least until merge done).
4068 }
4069
Eric Laurentbfb1b832013-01-07 09:53:42 -08004070 threadLoop_exit();
4071
Eric Laurentcf817a22014-08-04 20:36:31 -07004072 if (!mStandby) {
4073 threadLoop_standby();
4074 mStandby = true;
Eric Laurent81784c32012-11-19 14:55:58 -08004075 }
4076
4077 releaseWakeLock();
4078
4079 ALOGV("Thread %p type %d exiting", this, mType);
4080 return false;
4081}
4082
Eric Laurentbfb1b832013-01-07 09:53:42 -08004083// removeTracks_l() must be called with ThreadBase::mLock held
4084void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
4085{
Andy Hungfe726a62018-09-27 15:17:25 -07004086 for (const auto& track : tracksToRemove) {
4087 mActiveTracks.remove(track);
4088 ALOGV("%s(%d): removing track on session %d", __func__, track->id(), track->sessionId());
4089 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
4090 if (chain != 0) {
4091 ALOGV("%s(%d): stopping track on chain %p for session Id: %d",
4092 __func__, track->id(), chain.get(), track->sessionId());
4093 chain->decActiveTrackCnt();
4094 }
4095 // If an external client track, inform APM we're no longer active, and remove if needed.
4096 // We do this under lock so that the state is consistent if the Track is destroyed.
4097 if (track->isExternalTrack()) {
4098 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004099 if (track->isTerminated()) {
Andy Hungfe726a62018-09-27 15:17:25 -07004100 AudioSystem::releaseOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08004101 }
4102 }
Andy Hungfe726a62018-09-27 15:17:25 -07004103 if (track->isTerminated()) {
4104 // remove from our tracks vector
4105 removeTrack_l(track);
4106 }
jiabin57303cc2018-12-18 15:45:57 -08004107 if ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
4108 && mHapticChannelCount > 0) {
4109 mLock.unlock();
4110 // Unlock due to VibratorService will lock for this call and will
4111 // call Tracks.mute/unmute which also require thread's lock.
4112 AudioFlinger::onExternalVibrationStop(track->getExternalVibration());
4113 mLock.lock();
jiabin245cdd92018-12-07 17:55:15 -08004114 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004115 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004116}
Eric Laurent81784c32012-11-19 14:55:58 -08004117
Eric Laurentaccc1472013-09-20 09:36:34 -07004118status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
4119{
4120 if (mNormalSink != 0) {
Andy Hung818e7a32016-02-16 18:08:07 -08004121 ExtendedTimestamp ets;
4122 status_t status = mNormalSink->getTimestamp(ets);
4123 if (status == NO_ERROR) {
4124 status = ets.getBestTimestamp(&timestamp);
4125 }
4126 return status;
Eric Laurentaccc1472013-09-20 09:36:34 -07004127 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004128 if ((mType == OFFLOAD || mType == DIRECT) && mOutput != NULL) {
Eric Laurentaccc1472013-09-20 09:36:34 -07004129 uint64_t position64;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004130 if (mOutput->getPresentationPosition(&position64, &timestamp.mTime) == OK) {
Eric Laurentaccc1472013-09-20 09:36:34 -07004131 timestamp.mPosition = (uint32_t)position64;
Dean Wheatley30d28422018-11-06 10:27:40 +11004132 if (mDownstreamLatencyStatMs.getN() > 0) {
4133 const uint32_t positionOffset =
4134 (uint32_t)(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
4135 if (positionOffset > timestamp.mPosition) {
4136 timestamp.mPosition = 0;
4137 } else {
4138 timestamp.mPosition -= positionOffset;
4139 }
4140 }
Eric Laurentaccc1472013-09-20 09:36:34 -07004141 return NO_ERROR;
4142 }
4143 }
4144 return INVALID_OPERATION;
4145}
Eric Laurent1c333e22014-05-20 10:48:17 -07004146
Eric Laurenteab90452019-06-24 15:17:46 -07004147// For dedicated VoIP outputs, let the HAL apply the stream volume. Track volume is
4148// still applied by the mixer.
4149// All tracks attached to a mixer with flag VOIP_RX are tied to the same
4150// stream type STREAM_VOICE_CALL so this will only change the HAL volume once even
4151// if more than one track are active
4152status_t AudioFlinger::PlaybackThread::handleVoipVolume_l(float *volume)
4153{
4154 status_t result = NO_ERROR;
4155 if ((mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
4156 if (*volume != mLeftVolFloat) {
4157 result = mOutput->stream->setVolume(*volume, *volume);
4158 ALOGE_IF(result != OK,
4159 "Error when setting output stream volume: %d", result);
4160 if (result == NO_ERROR) {
4161 mLeftVolFloat = *volume;
4162 }
4163 }
4164 // if stream volume was successfully sent to the HAL, mLeftVolFloat == v here and we
4165 // remove stream volume contribution from software volume.
4166 if (mLeftVolFloat == *volume) {
4167 *volume = 1.0f;
4168 }
4169 }
4170 return result;
4171}
4172
Eric Laurent054d9d32015-04-24 08:48:48 -07004173status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
4174 audio_patch_handle_t *handle)
4175{
Andy Hungf60abce2016-08-26 11:37:54 -07004176 status_t status;
4177 if (property_get_bool("af.patch_park", false /* default_value */)) {
4178 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4179 // or if HAL does not properly lock against access.
4180 AutoPark<FastMixer> park(mFastMixer);
4181 status = PlaybackThread::createAudioPatch_l(patch, handle);
4182 } else {
4183 status = PlaybackThread::createAudioPatch_l(patch, handle);
4184 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004185 return status;
4186}
4187
Eric Laurent1c333e22014-05-20 10:48:17 -07004188status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
4189 audio_patch_handle_t *handle)
4190{
4191 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004192
4193 // store new device and send to effects
4194 audio_devices_t type = AUDIO_DEVICE_NONE;
jiabin10d86fd2019-10-31 17:20:42 -07004195 AudioDeviceTypeAddrVector deviceTypeAddrs;
Eric Laurent054d9d32015-04-24 08:48:48 -07004196 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabin10d86fd2019-10-31 17:20:42 -07004197 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
4198 && !mOutput->audioHwDev->supportsAudioPatches(),
4199 "Enumerated device type(%#x) must not be used "
4200 "as it does not support audio patches",
4201 patch->sinks[i].ext.device.type);
Mikhail Naganove3b59ac2020-10-01 15:08:13 -07004202 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
jiabin10d86fd2019-10-31 17:20:42 -07004203 deviceTypeAddrs.push_back(AudioDeviceTypeAddr(patch->sinks[i].ext.device.type,
4204 patch->sinks[i].ext.device.address));
Eric Laurent054d9d32015-04-24 08:48:48 -07004205 }
4206
François Gaffie0c280aa2018-07-25 10:02:15 +02004207 audio_port_handle_t sinkPortId = patch->sinks[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07004208#ifdef ADD_BATTERY_DATA
4209 // when changing the audio output device, call addBatteryData to notify
4210 // the change
jiabin10d86fd2019-10-31 17:20:42 -07004211 if (outDeviceTypes() != deviceTypes) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004212 uint32_t params = 0;
4213 // check whether speaker is on
jiabin10d86fd2019-10-31 17:20:42 -07004214 if (deviceTypes.count(AUDIO_DEVICE_OUT_SPEAKER) > 0) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004215 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
Eric Laurent1c333e22014-05-20 10:48:17 -07004216 }
4217
Eric Laurent054d9d32015-04-24 08:48:48 -07004218 // check if any other device (except speaker) is on
jiabin10d86fd2019-10-31 17:20:42 -07004219 if (!isSingleDeviceType(deviceTypes, AUDIO_DEVICE_OUT_SPEAKER)) {
Eric Laurent054d9d32015-04-24 08:48:48 -07004220 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
4221 }
4222
4223 if (params != 0) {
4224 addBatteryData(params);
4225 }
4226 }
4227#endif
4228
4229 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabinb8269fd2019-11-11 12:16:27 -08004230 mEffectChains[i]->setDevices_l(deviceTypeAddrs);
Eric Laurent054d9d32015-04-24 08:48:48 -07004231 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07004232
jiabin10d86fd2019-10-31 17:20:42 -07004233 // mPatch.num_sinks is not set when the thread is created so that
4234 // the first patch creation triggers an ioConfigChanged callback
4235 bool configChanged = (mPatch.num_sinks == 0) ||
4236 (mPatch.sinks[0].id != sinkPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07004237 mPatch = *patch;
jiabin10d86fd2019-10-31 17:20:42 -07004238 mOutDeviceTypeAddrs = deviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -07004239 checkSilentMode_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07004240
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004241 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004242 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4243 status = hwDevice->createAudioPatch(patch->num_sources,
4244 patch->sources,
4245 patch->num_sinks,
4246 patch->sinks,
4247 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004248 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004249 char *address;
4250 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
4251 //FIXME: we only support address on first sink with HAL version < 3.0
4252 address = audio_device_address_to_parameter(
4253 patch->sinks[0].ext.device.type,
4254 patch->sinks[0].ext.device.address);
4255 } else {
4256 address = (char *)calloc(1, 1);
4257 }
4258 AudioParameter param = AudioParameter(String8(address));
4259 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07004260 param.addInt(String8(AudioParameter::keyRouting), (int)type);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004261 status = mOutput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07004262 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07004263 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07004264 const std::string patchSinksAsString = patchSinksToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07004265
4266 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07004267 mThreadMetrics.logCreatePatch(/* inDevices */ {}, patchSinksAsString);
Andy Hungcf10d742020-04-28 15:38:24 -07004268 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07004269 // also dispatch to active AudioTracks for MediaMetrics
4270 for (const auto &track : mActiveTracks) {
4271 track->logEndInterval();
4272 track->logBeginInterval(patchSinksAsString);
4273 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08004274
Eric Laurente8726fe2015-06-26 09:39:24 -07004275 if (configChanged) {
4276 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
4277 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004278 return status;
4279}
4280
Eric Laurent054d9d32015-04-24 08:48:48 -07004281status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4282{
Andy Hungf60abce2016-08-26 11:37:54 -07004283 status_t status;
4284 if (property_get_bool("af.patch_park", false /* default_value */)) {
4285 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4286 // or if HAL does not properly lock against access.
4287 AutoPark<FastMixer> park(mFastMixer);
4288 status = PlaybackThread::releaseAudioPatch_l(handle);
4289 } else {
4290 status = PlaybackThread::releaseAudioPatch_l(handle);
4291 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004292 return status;
4293}
4294
Eric Laurent1c333e22014-05-20 10:48:17 -07004295status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4296{
4297 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004298
jiabin10d86fd2019-10-31 17:20:42 -07004299 mPatch = audio_patch{};
4300 mOutDeviceTypeAddrs.clear();
Eric Laurent054d9d32015-04-24 08:48:48 -07004301
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004302 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004303 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4304 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004305 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004306 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07004307 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004308 status = mOutput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07004309 }
4310 return status;
4311}
4312
Eric Laurent83b88082014-06-20 18:31:16 -07004313void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
4314{
4315 Mutex::Autolock _l(mLock);
4316 mTracks.add(track);
4317}
4318
4319void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
4320{
4321 Mutex::Autolock _l(mLock);
4322 destroyTrack_l(track);
4323}
4324
Mikhail Naganovdc769682018-05-04 15:34:08 -07004325void AudioFlinger::PlaybackThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07004326{
Mikhail Naganovdc769682018-05-04 15:34:08 -07004327 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07004328 config->role = AUDIO_PORT_ROLE_SOURCE;
4329 config->ext.mix.hw_module = mOutput->audioHwDev->handle();
4330 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07004331 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
4332 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
4333 config->flags.output = mOutput->flags;
4334 }
Eric Laurent83b88082014-06-20 18:31:16 -07004335}
4336
Eric Laurent81784c32012-11-19 14:55:58 -08004337// ----------------------------------------------------------------------------
4338
4339AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
jiabin10d86fd2019-10-31 17:20:42 -07004340 audio_io_handle_t id, bool systemReady, type_t type)
4341 : PlaybackThread(audioFlinger, output, id, type, systemReady),
Eric Laurent81784c32012-11-19 14:55:58 -08004342 // mAudioMixer below
4343 // mFastMixer below
Andy Hung2ddee192015-12-18 17:34:44 -08004344 mFastMixerFutex(0),
4345 mMasterMono(false)
Eric Laurent81784c32012-11-19 14:55:58 -08004346 // mOutputSink below
4347 // mPipeSink below
4348 // mNormalSink below
4349{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004350 setMasterBalance(audioFlinger->getMasterBalance_l());
jiabin10d86fd2019-10-31 17:20:42 -07004351 ALOGV("MixerThread() id=%d type=%d", id, type);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004352 ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004353 "mFrameCount=%zu, mNormalFrameCount=%zu",
Eric Laurent81784c32012-11-19 14:55:58 -08004354 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
4355 mNormalFrameCount);
4356 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
4357
Andy Hungfbfc3952015-01-15 13:33:51 -08004358 if (type == DUPLICATING) {
4359 // The Duplicating thread uses the AudioMixer and delivers data to OutputTracks
4360 // (downstream MixerThreads) in DuplicatingThread::threadLoop_write().
4361 // Do not create or use mFastMixer, mOutputSink, mPipeSink, or mNormalSink.
4362 return;
4363 }
Eric Laurent81784c32012-11-19 14:55:58 -08004364 // create an NBAIO sink for the HAL output stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07004365 mOutputSink = new AudioStreamOutSink(output->stream);
Eric Laurent81784c32012-11-19 14:55:58 -08004366 size_t numCounterOffers = 0;
jiabin245cdd92018-12-07 17:55:15 -08004367 const NBAIO_Format offers[1] = {Format_from_SR_C(
4368 mSampleRate, mChannelCount + mHapticChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004369#if !LOG_NDEBUG
4370 ssize_t index =
4371#else
4372 (void)
4373#endif
4374 mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004375 ALOG_ASSERT(index == 0);
4376
4377 // initialize fast mixer depending on configuration
4378 bool initFastMixer;
4379 switch (kUseFastMixer) {
4380 case FastMixer_Never:
4381 initFastMixer = false;
4382 break;
4383 case FastMixer_Always:
4384 initFastMixer = true;
4385 break;
4386 case FastMixer_Static:
4387 case FastMixer_Dynamic:
Andy Hungfda69402017-02-15 14:33:12 -08004388 // FastMixer was designed to operate with a HAL that pulls at a regular rate,
4389 // where the period is less than an experimentally determined threshold that can be
4390 // scheduled reliably with CFS. However, the BT A2DP HAL is
4391 // bursty (does not pull at a regular rate) and so cannot operate with FastMixer.
4392 initFastMixer = mFrameCount < mNormalFrameCount
jiabin10d86fd2019-10-31 17:20:42 -07004393 && Intersection(outDeviceTypes(), getAudioDeviceOutAllA2dpSet()).empty();
Eric Laurent81784c32012-11-19 14:55:58 -08004394 break;
4395 }
Andy Hungfda69402017-02-15 14:33:12 -08004396 ALOGW_IF(initFastMixer == false && mFrameCount < mNormalFrameCount,
4397 "FastMixer is preferred for this sink as frameCount %zu is less than threshold %zu",
4398 mFrameCount, mNormalFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08004399 if (initFastMixer) {
Andy Hung1258c1a2014-05-23 21:22:17 -07004400 audio_format_t fastMixerFormat;
4401 if (mMixerBufferEnabled && mEffectBufferEnabled) {
4402 fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
4403 } else {
4404 fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
4405 }
4406 if (mFormat != fastMixerFormat) {
4407 // change our Sink format to accept our intermediate precision
4408 mFormat = fastMixerFormat;
4409 free(mSinkBuffer);
jiabin245cdd92018-12-07 17:55:15 -08004410 mFrameSize = audio_bytes_per_frame(mChannelCount + mHapticChannelCount, mFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004411 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
4412 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
4413 }
Eric Laurent81784c32012-11-19 14:55:58 -08004414
4415 // create a MonoPipe to connect our submix to FastMixer
4416 NBAIO_Format format = mOutputSink->format();
Andy Hung8946a282018-04-19 20:04:56 -07004417
Andy Hung1258c1a2014-05-23 21:22:17 -07004418 // adjust format to match that of the Fast Mixer
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004419 ALOGV("format changed from %#x to %#x", format.mFormat, fastMixerFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004420 format.mFormat = fastMixerFormat;
4421 format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
4422
Eric Laurent81784c32012-11-19 14:55:58 -08004423 // This pipe depth compensates for scheduling latency of the normal mixer thread.
4424 // When it wakes up after a maximum latency, it runs a few cycles quickly before
4425 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
4426 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
4427 const NBAIO_Format offers[1] = {format};
4428 size_t numCounterOffers = 0;
Andy Hung8946a282018-04-19 20:04:56 -07004429#if !LOG_NDEBUG
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004430 ssize_t index =
4431#else
4432 (void)
4433#endif
4434 monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004435 ALOG_ASSERT(index == 0);
4436 monoPipe->setAvgFrames((mScreenState & 1) ?
4437 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
4438 mPipeSink = monoPipe;
4439
Eric Laurent81784c32012-11-19 14:55:58 -08004440 // create fast mixer and configure it initially with just one fast track for our submix
Andy Hung8946a282018-04-19 20:04:56 -07004441 mFastMixer = new FastMixer(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08004442 FastMixerStateQueue *sq = mFastMixer->sq();
4443#ifdef STATE_QUEUE_DUMP
4444 sq->setObserverDump(&mStateQueueObserverDump);
4445 sq->setMutatorDump(&mStateQueueMutatorDump);
4446#endif
4447 FastMixerState *state = sq->begin();
4448 FastTrack *fastTrack = &state->mFastTracks[0];
4449 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
4450 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
4451 fastTrack->mVolumeProvider = NULL;
Mikhail Naganove3b59ac2020-10-01 15:08:13 -07004452 fastTrack->mChannelMask = static_cast<audio_channel_mask_t>(
4453 mChannelMask | mHapticChannelMask); // mPipeSink channel mask for
4454 // audio to FastMixer
Andy Hunge8a1ced2014-05-09 15:02:21 -07004455 fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer
jiabin245cdd92018-12-07 17:55:15 -08004456 fastTrack->mHapticPlaybackEnabled = mHapticChannelMask != AUDIO_CHANNEL_NONE;
jiabin84114c32019-04-10 16:38:07 -07004457 fastTrack->mHapticIntensity = AudioMixer::HAPTIC_SCALE_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08004458 fastTrack->mGeneration++;
4459 state->mFastTracksGen++;
4460 state->mTrackMask = 1;
4461 // fast mixer will use the HAL output sink
4462 state->mOutputSink = mOutputSink.get();
4463 state->mOutputSinkGen++;
4464 state->mFrameCount = mFrameCount;
jiabin245cdd92018-12-07 17:55:15 -08004465 // specify sink channel mask when haptic channel mask present as it can not
4466 // be calculated directly from channel count
4467 state->mSinkChannelMask = mHapticChannelMask == AUDIO_CHANNEL_NONE
Mikhail Naganove3b59ac2020-10-01 15:08:13 -07004468 ? AUDIO_CHANNEL_NONE
4469 : static_cast<audio_channel_mask_t>(mChannelMask | mHapticChannelMask);
Eric Laurent81784c32012-11-19 14:55:58 -08004470 state->mCommand = FastMixerState::COLD_IDLE;
4471 // already done in constructor initialization list
4472 //mFastMixerFutex = 0;
4473 state->mColdFutexAddr = &mFastMixerFutex;
4474 state->mColdGen++;
4475 state->mDumpState = &mFastMixerDumpState;
Glenn Kasten9e58b552013-01-18 15:09:48 -08004476 mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
4477 state->mNBLogWriter = mFastMixerNBLogWriter.get();
Eric Laurent81784c32012-11-19 14:55:58 -08004478 sq->end();
4479 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4480
Eric Tan0513b5d2018-09-17 10:32:48 -07004481 NBLog::thread_info_t info;
4482 info.id = mId;
4483 info.type = NBLog::FASTMIXER;
4484 mFastMixerNBLogWriter->log<NBLog::EVENT_THREAD_INFO>(info);
4485
Eric Laurent81784c32012-11-19 14:55:58 -08004486 // start the fast mixer
4487 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
4488 pid_t tid = mFastMixer->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004489 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08004490 stream()->setHalThreadPriority(kPriorityFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08004491
4492#ifdef AUDIO_WATCHDOG
4493 // create and start the watchdog
4494 mAudioWatchdog = new AudioWatchdog();
4495 mAudioWatchdog->setDump(&mAudioWatchdogDump);
4496 mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
4497 tid = mAudioWatchdog->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004498 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08004499#endif
Andy Hung8946a282018-04-19 20:04:56 -07004500 } else {
4501#ifdef TEE_SINK
4502 // Only use the MixerThread tee if there is no FastMixer.
4503 mTee.set(mOutputSink->format(), NBAIO_Tee::TEE_FLAG_OUTPUT_THREAD);
4504 mTee.setId(std::string("_") + std::to_string(mId) + "_M");
4505#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004506 }
4507
4508 switch (kUseFastMixer) {
4509 case FastMixer_Never:
4510 case FastMixer_Dynamic:
4511 mNormalSink = mOutputSink;
4512 break;
4513 case FastMixer_Always:
4514 mNormalSink = mPipeSink;
4515 break;
4516 case FastMixer_Static:
4517 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
4518 break;
4519 }
4520}
4521
4522AudioFlinger::MixerThread::~MixerThread()
4523{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004524 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004525 FastMixerStateQueue *sq = mFastMixer->sq();
4526 FastMixerState *state = sq->begin();
4527 if (state->mCommand == FastMixerState::COLD_IDLE) {
4528 int32_t old = android_atomic_inc(&mFastMixerFutex);
4529 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004530 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004531 }
4532 }
4533 state->mCommand = FastMixerState::EXIT;
4534 sq->end();
4535 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4536 mFastMixer->join();
4537 // Though the fast mixer thread has exited, it's state queue is still valid.
4538 // We'll use that extract the final state which contains one remaining fast track
4539 // corresponding to our sub-mix.
4540 state = sq->begin();
4541 ALOG_ASSERT(state->mTrackMask == 1);
4542 FastTrack *fastTrack = &state->mFastTracks[0];
4543 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
4544 delete fastTrack->mBufferProvider;
4545 sq->end(false /*didModify*/);
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004546 mFastMixer.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08004547#ifdef AUDIO_WATCHDOG
4548 if (mAudioWatchdog != 0) {
4549 mAudioWatchdog->requestExit();
4550 mAudioWatchdog->requestExitAndWait();
4551 mAudioWatchdog.clear();
4552 }
4553#endif
4554 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08004555 mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -08004556 delete mAudioMixer;
4557}
4558
4559
4560uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
4561{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004562 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004563 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
4564 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
4565 }
4566 return latency;
4567}
4568
Eric Laurentbfb1b832013-01-07 09:53:42 -08004569ssize_t AudioFlinger::MixerThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08004570{
4571 // FIXME we should only do one push per cycle; confirm this is true
4572 // Start the fast mixer if it's not already running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004573 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004574 FastMixerStateQueue *sq = mFastMixer->sq();
4575 FastMixerState *state = sq->begin();
4576 if (state->mCommand != FastMixerState::MIX_WRITE &&
4577 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
4578 if (state->mCommand == FastMixerState::COLD_IDLE) {
Eric Laurenta2ab4502015-09-09 12:25:51 -07004579
4580 // FIXME workaround for first HAL write being CPU bound on some devices
4581 ATRACE_BEGIN("write");
4582 mOutput->write((char *)mSinkBuffer, 0);
4583 ATRACE_END();
4584
Eric Laurent81784c32012-11-19 14:55:58 -08004585 int32_t old = android_atomic_inc(&mFastMixerFutex);
4586 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004587 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004588 }
4589#ifdef AUDIO_WATCHDOG
4590 if (mAudioWatchdog != 0) {
4591 mAudioWatchdog->resume();
4592 }
4593#endif
4594 }
4595 state->mCommand = FastMixerState::MIX_WRITE;
Glenn Kastend797a9d2015-03-02 14:19:25 -08004596#ifdef FAST_THREAD_STATISTICS
Glenn Kasten4182c4e2013-07-15 14:45:07 -07004597 mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08004598 FastThreadDumpState::kSamplingNforLowRamDevice : FastThreadDumpState::kSamplingN);
Glenn Kastend797a9d2015-03-02 14:19:25 -08004599#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004600 sq->end();
4601 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4602 if (kUseFastMixer == FastMixer_Dynamic) {
4603 mNormalSink = mPipeSink;
4604 }
4605 } else {
4606 sq->end(false /*didModify*/);
4607 }
4608 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004609 return PlaybackThread::threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08004610}
4611
4612void AudioFlinger::MixerThread::threadLoop_standby()
4613{
4614 // Idle the fast mixer if it's currently running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004615 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004616 FastMixerStateQueue *sq = mFastMixer->sq();
4617 FastMixerState *state = sq->begin();
4618 if (!(state->mCommand & FastMixerState::IDLE)) {
Andy Hung2148bf02016-11-28 19:01:02 -08004619 // Report any frames trapped in the Monopipe
4620 MonoPipe *monoPipe = (MonoPipe *)mPipeSink.get();
4621 const long long pipeFrames = monoPipe->maxFrames() - monoPipe->availableToWrite();
4622 mLocalLog.log("threadLoop_standby: framesWritten:%lld suspendedFrames:%lld "
4623 "monoPipeWritten:%lld monoPipeLeft:%lld",
4624 (long long)mFramesWritten, (long long)mSuspendedFrames,
4625 (long long)mPipeSink->framesWritten(), pipeFrames);
4626 mLocalLog.log("threadLoop_standby: %s", mTimestamp.toString().c_str());
4627
Eric Laurent81784c32012-11-19 14:55:58 -08004628 state->mCommand = FastMixerState::COLD_IDLE;
4629 state->mColdFutexAddr = &mFastMixerFutex;
4630 state->mColdGen++;
4631 mFastMixerFutex = 0;
4632 sq->end();
4633 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
4634 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
4635 if (kUseFastMixer == FastMixer_Dynamic) {
4636 mNormalSink = mOutputSink;
4637 }
4638#ifdef AUDIO_WATCHDOG
4639 if (mAudioWatchdog != 0) {
4640 mAudioWatchdog->pause();
4641 }
4642#endif
4643 } else {
4644 sq->end(false /*didModify*/);
4645 }
4646 }
4647 PlaybackThread::threadLoop_standby();
4648}
4649
Eric Laurentbfb1b832013-01-07 09:53:42 -08004650bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
4651{
4652 return false;
4653}
4654
4655bool AudioFlinger::PlaybackThread::shouldStandby_l()
4656{
4657 return !mStandby;
4658}
4659
4660bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
4661{
4662 Mutex::Autolock _l(mLock);
4663 return waitingAsyncCallback_l();
4664}
4665
Eric Laurent81784c32012-11-19 14:55:58 -08004666// shared by MIXER and DIRECT, overridden by DUPLICATING
4667void AudioFlinger::PlaybackThread::threadLoop_standby()
4668{
4669 ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
Phil Burk062e67a2015-02-11 13:40:50 -08004670 mOutput->standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004671 if (mUseAsyncWrite != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07004672 // discard any pending drain or write ack by incrementing sequence
4673 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
4674 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004675 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07004676 mCallbackThread->setWriteBlocked(mWriteAckSequence);
4677 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08004678 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08004679 mHwPaused = false;
Eric Laurent81784c32012-11-19 14:55:58 -08004680}
4681
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08004682void AudioFlinger::PlaybackThread::onAddNewTrack_l()
4683{
4684 ALOGV("signal playback thread");
4685 broadcast_l();
4686}
4687
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07004688void AudioFlinger::PlaybackThread::onAsyncError()
4689{
4690 for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
4691 invalidateTracks((audio_stream_type_t)i);
4692 }
4693}
4694
Eric Laurent81784c32012-11-19 14:55:58 -08004695void AudioFlinger::MixerThread::threadLoop_mix()
4696{
Eric Laurent81784c32012-11-19 14:55:58 -08004697 // mix buffers...
Glenn Kastend79072e2016-01-06 08:41:20 -08004698 mAudioMixer->process();
Andy Hung25c2dac2014-02-27 14:56:00 -08004699 mCurrentWriteLength = mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08004700 // increase sleep time progressively when application underrun condition clears.
4701 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
4702 // that a steady state of alternating ready/not ready conditions keeps the sleep time
4703 // such that we would underrun the audio HAL.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004704 if ((mSleepTimeUs == 0) && (sleepTimeShift > 0)) {
Eric Laurent81784c32012-11-19 14:55:58 -08004705 sleepTimeShift--;
4706 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004707 mSleepTimeUs = 0;
4708 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08004709 //TODO: delay standby when effects have a tail
Glenn Kasten4c053ea2014-09-28 14:41:07 -07004710
Eric Laurent81784c32012-11-19 14:55:58 -08004711}
4712
4713void AudioFlinger::MixerThread::threadLoop_sleepTime()
4714{
4715 // If no tracks are ready, sleep once for the duration of an output
4716 // buffer size, then write 0s to the output
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004717 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004718 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Andy Hung06d13222018-05-03 20:13:31 -07004719 if (mPipeSink.get() != nullptr && mPipeSink == mNormalSink) {
4720 // Using the Monopipe availableToWrite, we estimate the
4721 // sleep time to retry for more data (before we underrun).
4722 MonoPipe *monoPipe = static_cast<MonoPipe *>(mPipeSink.get());
4723 const ssize_t availableToWrite = mPipeSink->availableToWrite();
4724 const size_t pipeFrames = monoPipe->maxFrames();
4725 const size_t framesLeft = pipeFrames - max(availableToWrite, 0);
4726 // HAL_framecount <= framesDelay ~ framesLeft / 2 <= Normal_Mixer_framecount
4727 const size_t framesDelay = std::min(
4728 mNormalFrameCount, max(framesLeft / 2, mFrameCount));
4729 ALOGV("pipeFrames:%zu framesLeft:%zu framesDelay:%zu",
4730 pipeFrames, framesLeft, framesDelay);
4731 mSleepTimeUs = framesDelay * MICROS_PER_SECOND / mSampleRate;
4732 } else {
4733 mSleepTimeUs = mActiveSleepTimeUs >> sleepTimeShift;
4734 if (mSleepTimeUs < kMinThreadSleepTimeUs) {
4735 mSleepTimeUs = kMinThreadSleepTimeUs;
4736 }
4737 // reduce sleep time in case of consecutive application underruns to avoid
4738 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
4739 // duration we would end up writing less data than needed by the audio HAL if
4740 // the condition persists.
4741 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
4742 sleepTimeShift++;
4743 }
Eric Laurent81784c32012-11-19 14:55:58 -08004744 }
4745 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004746 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08004747 }
4748 } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
Andy Hung98ef9782014-03-04 14:46:50 -08004749 // clear out mMixerBuffer or mSinkBuffer, to ensure buffers are cleared
4750 // before effects processing or output.
4751 if (mMixerBufferValid) {
4752 memset(mMixerBuffer, 0, mMixerBufferSize);
4753 } else {
4754 memset(mSinkBuffer, 0, mSinkBufferSize);
4755 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004756 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08004757 ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
4758 "anticipated start");
4759 }
4760 // TODO add standby time extension fct of effect tail
4761}
4762
4763// prepareTracks_l() must be called with ThreadBase::mLock held
4764AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
4765 Vector< sp<Track> > *tracksToRemove)
4766{
Andy Hungc0691382018-09-12 18:01:57 -07004767 // clean up deleted track ids in AudioMixer before allocating new tracks
4768 (void)mTracks.processDeletedTrackIds([this](int trackId) {
4769 // for each trackId, destroy it in the AudioMixer
4770 if (mAudioMixer->exists(trackId)) {
4771 mAudioMixer->destroy(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08004772 }
4773 });
Andy Hungc0691382018-09-12 18:01:57 -07004774 mTracks.clearDeletedTrackIds();
Eric Laurent81784c32012-11-19 14:55:58 -08004775
4776 mixer_state mixerStatus = MIXER_IDLE;
4777 // find out which tracks need to be processed
4778 size_t count = mActiveTracks.size();
4779 size_t mixedTracks = 0;
4780 size_t tracksWithEffect = 0;
4781 // counts only _active_ fast tracks
4782 size_t fastTracks = 0;
4783 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
4784
4785 float masterVolume = mMasterVolume;
4786 bool masterMute = mMasterMute;
4787
4788 if (masterMute) {
4789 masterVolume = 0;
4790 }
4791 // Delegate master volume control to effect in output mix effect chain if needed
4792 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4793 if (chain != 0) {
4794 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
4795 chain->setVolume_l(&v, &v);
4796 masterVolume = (float)((v + (1 << 23)) >> 24);
4797 chain.clear();
4798 }
4799
4800 // prepare a new state to push
4801 FastMixerStateQueue *sq = NULL;
4802 FastMixerState *state = NULL;
4803 bool didModify = false;
4804 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
Andy Hungf2285312017-02-14 18:31:59 -08004805 bool coldIdle = false;
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004806 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004807 sq = mFastMixer->sq();
4808 state = sq->begin();
Andy Hungf2285312017-02-14 18:31:59 -08004809 coldIdle = state->mCommand == FastMixerState::COLD_IDLE;
Eric Laurent81784c32012-11-19 14:55:58 -08004810 }
4811
Andy Hung69aed5f2014-02-25 17:24:40 -08004812 mMixerBufferValid = false; // mMixerBuffer has no valid data until appropriate tracks found.
Andy Hung98ef9782014-03-04 14:46:50 -08004813 mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found.
Andy Hung69aed5f2014-02-25 17:24:40 -08004814
Andy Hungbd3b2b02018-05-21 10:53:11 -07004815 // DeferredOperations handles statistics after setting mixerStatus.
4816 class DeferredOperations {
4817 public:
Andy Hungea840382020-05-05 21:50:17 -07004818 DeferredOperations(mixer_state *mixerStatus, ThreadMetrics *threadMetrics)
4819 : mMixerStatus(mixerStatus)
4820 , mThreadMetrics(threadMetrics) {}
Andy Hungbd3b2b02018-05-21 10:53:11 -07004821
4822 // when leaving scope, tally frames properly.
4823 ~DeferredOperations() {
4824 // Tally underrun frames only if we are actually mixing (MIXER_TRACKS_READY)
4825 // because that is when the underrun occurs.
4826 // We do not distinguish between FastTracks and NormalTracks here.
Andy Hungea840382020-05-05 21:50:17 -07004827 size_t maxUnderrunFrames = 0;
Andy Hungb68f5eb2019-12-03 16:49:17 -08004828 if (*mMixerStatus == MIXER_TRACKS_READY && mUnderrunFrames.size() > 0) {
Andy Hungbd3b2b02018-05-21 10:53:11 -07004829 for (const auto &underrun : mUnderrunFrames) {
Andy Hungc2b11cb2020-04-22 09:04:01 -07004830 underrun.first->tallyUnderrunFrames(underrun.second);
Andy Hungea840382020-05-05 21:50:17 -07004831 maxUnderrunFrames = max(underrun.second, maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07004832 }
4833 }
Andy Hungea840382020-05-05 21:50:17 -07004834 // send the max underrun frames for this mixer period
4835 mThreadMetrics->logUnderrunFrames(maxUnderrunFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07004836 }
4837
4838 // tallyUnderrunFrames() is called to update the track counters
4839 // with the number of underrun frames for a particular mixer period.
4840 // We defer tallying until we know the final mixer status.
4841 void tallyUnderrunFrames(sp<Track> track, size_t underrunFrames) {
4842 mUnderrunFrames.emplace_back(track, underrunFrames);
4843 }
4844
4845 private:
4846 const mixer_state * const mMixerStatus;
Andy Hungea840382020-05-05 21:50:17 -07004847 ThreadMetrics * const mThreadMetrics;
Andy Hungbd3b2b02018-05-21 10:53:11 -07004848 std::vector<std::pair<sp<Track>, size_t>> mUnderrunFrames;
Andy Hungea840382020-05-05 21:50:17 -07004849 } deferredOperations(&mixerStatus, &mThreadMetrics);
Andy Hungb68f5eb2019-12-03 16:49:17 -08004850 // implicit nested scope for variable capture
Andy Hungbd3b2b02018-05-21 10:53:11 -07004851
jiabin245cdd92018-12-07 17:55:15 -08004852 bool noFastHapticTrack = true;
Eric Laurent81784c32012-11-19 14:55:58 -08004853 for (size_t i=0 ; i<count ; i++) {
Andy Hungdae27702016-10-31 14:01:16 -07004854 const sp<Track> t = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08004855
4856 // this const just means the local variable doesn't change
4857 Track* const track = t.get();
4858
4859 // process fast tracks
4860 if (track->isFastTrack()) {
Andy Hungae22b482019-05-09 15:38:55 -07004861 LOG_ALWAYS_FATAL_IF(mFastMixer.get() == nullptr,
4862 "%s(%d): FastTrack(%d) present without FastMixer",
4863 __func__, id(), track->id());
4864
jiabin245cdd92018-12-07 17:55:15 -08004865 if (track->getHapticPlaybackEnabled()) {
4866 noFastHapticTrack = false;
4867 }
Eric Laurent81784c32012-11-19 14:55:58 -08004868
4869 // It's theoretically possible (though unlikely) for a fast track to be created
4870 // and then removed within the same normal mix cycle. This is not a problem, as
4871 // the track never becomes active so it's fast mixer slot is never touched.
4872 // The converse, of removing an (active) track and then creating a new track
4873 // at the identical fast mixer slot within the same normal mix cycle,
4874 // is impossible because the slot isn't marked available until the end of each cycle.
4875 int j = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07004876 ALOG_ASSERT(0 < j && j < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08004877 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
4878 FastTrack *fastTrack = &state->mFastTracks[j];
4879
4880 // Determine whether the track is currently in underrun condition,
4881 // and whether it had a recent underrun.
4882 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
4883 FastTrackUnderruns underruns = ftDump->mUnderruns;
4884 uint32_t recentFull = (underruns.mBitFields.mFull -
4885 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
4886 uint32_t recentPartial = (underruns.mBitFields.mPartial -
4887 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
4888 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
4889 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
4890 uint32_t recentUnderruns = recentPartial + recentEmpty;
4891 track->mObservedUnderruns = underruns;
4892 // don't count underruns that occur while stopping or pausing
4893 // or stopped which can occur when flush() is called while active
Andy Hungbd3b2b02018-05-21 10:53:11 -07004894 size_t underrunFrames = 0;
Glenn Kasten82aaf942013-07-17 16:05:07 -07004895 if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
4896 recentUnderruns > 0) {
4897 // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun
Andy Hungbd3b2b02018-05-21 10:53:11 -07004898 underrunFrames = recentUnderruns * mFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08004899 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07004900 // Immediately account for FastTrack underruns.
4901 track->mAudioTrackServerProxy->tallyUnderrunFrames(underrunFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08004902
4903 // This is similar to the state machine for normal tracks,
4904 // with a few modifications for fast tracks.
4905 bool isActive = true;
4906 switch (track->mState) {
4907 case TrackBase::STOPPING_1:
4908 // track stays active in STOPPING_1 state until first underrun
Eric Laurentbfb1b832013-01-07 09:53:42 -08004909 if (recentUnderruns > 0 || track->isTerminated()) {
Eric Laurent81784c32012-11-19 14:55:58 -08004910 track->mState = TrackBase::STOPPING_2;
4911 }
4912 break;
4913 case TrackBase::PAUSING:
4914 // ramp down is not yet implemented
4915 track->setPaused();
4916 break;
4917 case TrackBase::RESUMING:
4918 // ramp up is not yet implemented
4919 track->mState = TrackBase::ACTIVE;
4920 break;
4921 case TrackBase::ACTIVE:
4922 if (recentFull > 0 || recentPartial > 0) {
4923 // track has provided at least some frames recently: reset retry count
4924 track->mRetryCount = kMaxTrackRetries;
4925 }
4926 if (recentUnderruns == 0) {
4927 // no recent underruns: stay active
4928 break;
4929 }
4930 // there has recently been an underrun of some kind
4931 if (track->sharedBuffer() == 0) {
4932 // were any of the recent underruns "empty" (no frames available)?
4933 if (recentEmpty == 0) {
4934 // no, then ignore the partial underruns as they are allowed indefinitely
4935 break;
4936 }
4937 // there has recently been an "empty" underrun: decrement the retry counter
4938 if (--(track->mRetryCount) > 0) {
4939 break;
4940 }
4941 // indicate to client process that the track was disabled because of underrun;
4942 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08004943 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08004944 // remove from active list, but state remains ACTIVE [confusing but true]
4945 isActive = false;
4946 break;
4947 }
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07004948 FALLTHROUGH_INTENDED;
Eric Laurent81784c32012-11-19 14:55:58 -08004949 case TrackBase::STOPPING_2:
4950 case TrackBase::PAUSED:
Eric Laurent81784c32012-11-19 14:55:58 -08004951 case TrackBase::STOPPED:
4952 case TrackBase::FLUSHED: // flush() while active
4953 // Check for presentation complete if track is inactive
4954 // We have consumed all the buffers of this track.
4955 // This would be incomplete if we auto-paused on underrun
4956 {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004957 uint32_t latency = 0;
4958 status_t result = mOutput->stream->getLatency(&latency);
4959 ALOGE_IF(result != OK,
4960 "Error when retrieving output stream latency: %d", result);
4961 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08004962 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08004963 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
4964 // track stays in active list until presentation is complete
4965 break;
4966 }
4967 }
4968 if (track->isStopping_2()) {
4969 track->mState = TrackBase::STOPPED;
4970 }
4971 if (track->isStopped()) {
4972 // Can't reset directly, as fast mixer is still polling this track
4973 // track->reset();
4974 // So instead mark this track as needing to be reset after push with ack
4975 resetMask |= 1 << i;
4976 }
4977 isActive = false;
4978 break;
4979 case TrackBase::IDLE:
4980 default:
Glenn Kastenadad3d72014-02-21 14:51:43 -08004981 LOG_ALWAYS_FATAL("unexpected track state %d", track->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08004982 }
4983
4984 if (isActive) {
4985 // was it previously inactive?
4986 if (!(state->mTrackMask & (1 << j))) {
4987 ExtendedAudioBufferProvider *eabp = track;
4988 VolumeProvider *vp = track;
4989 fastTrack->mBufferProvider = eabp;
4990 fastTrack->mVolumeProvider = vp;
Eric Laurent81784c32012-11-19 14:55:58 -08004991 fastTrack->mChannelMask = track->mChannelMask;
Andy Hunge8a1ced2014-05-09 15:02:21 -07004992 fastTrack->mFormat = track->mFormat;
jiabin245cdd92018-12-07 17:55:15 -08004993 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
jiabin77270b82018-12-18 15:41:29 -08004994 fastTrack->mHapticIntensity = track->getHapticIntensity();
Eric Laurent81784c32012-11-19 14:55:58 -08004995 fastTrack->mGeneration++;
4996 state->mTrackMask |= 1 << j;
4997 didModify = true;
4998 // no acknowledgement required for newly active tracks
4999 }
Kevin Rocard12381092018-04-11 09:19:59 -07005000 sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
Eric Laurenteab90452019-06-24 15:17:46 -07005001 float volume;
5002 if (track->isPlaybackRestricted() || mStreamTypes[track->streamType()].mute) {
5003 volume = 0.f;
5004 } else {
5005 volume = masterVolume * mStreamTypes[track->streamType()].volume;
5006 }
5007
5008 handleVoipVolume_l(&volume);
5009
Eric Laurent81784c32012-11-19 14:55:58 -08005010 // cache the combined master volume and stream type volume for fast mixer; this
5011 // lacks any synchronization or barrier so VolumeProvider may read a stale value
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005012 const float vh = track->getVolumeHandler()->getVolume(
Eric Laurenteab90452019-06-24 15:17:46 -07005013 proxy->framesReleased()).first;
5014 volume *= vh;
Kevin Rocardb0eeaf122018-04-11 08:30:16 -07005015 track->mCachedVolume = volume;
Kevin Rocard12381092018-04-11 09:19:59 -07005016 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
5017 float vlf = volume * float_from_gain(gain_minifloat_unpack_left(vlr));
5018 float vrf = volume * float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurenteab90452019-06-24 15:17:46 -07005019
Kevin Rocard12381092018-04-11 09:19:59 -07005020 track->setFinalVolume((vlf + vrf) / 2.f);
Eric Laurent81784c32012-11-19 14:55:58 -08005021 ++fastTracks;
5022 } else {
5023 // was it previously active?
5024 if (state->mTrackMask & (1 << j)) {
5025 fastTrack->mBufferProvider = NULL;
5026 fastTrack->mGeneration++;
5027 state->mTrackMask &= ~(1 << j);
5028 didModify = true;
5029 // If any fast tracks were removed, we must wait for acknowledgement
5030 // because we're about to decrement the last sp<> on those tracks.
5031 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5032 } else {
Glenn Kastenbf848af2017-12-22 11:55:01 -08005033 // ALOGW rather than LOG_ALWAYS_FATAL because it seems there are cases where an
5034 // AudioTrack may start (which may not be with a start() but with a write()
5035 // after underrun) and immediately paused or released. In that case the
5036 // FastTrack state hasn't had time to update.
5037 // TODO Remove the ALOGW when this theory is confirmed.
5038 ALOGW("fast track %d should have been active; "
Glenn Kastenf7d65ee2015-12-02 13:45:01 -08005039 "mState=%d, mTrackMask=%#x, recentUnderruns=%u, isShared=%d",
5040 j, track->mState, state->mTrackMask, recentUnderruns,
5041 track->sharedBuffer() != 0);
Glenn Kastenbf848af2017-12-22 11:55:01 -08005042 // Since the FastMixer state already has the track inactive, do nothing here.
Eric Laurent81784c32012-11-19 14:55:58 -08005043 }
5044 tracksToRemove->add(track);
5045 // Avoids a misleading display in dumpsys
5046 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
5047 }
jiabin245cdd92018-12-07 17:55:15 -08005048 if (fastTrack->mHapticPlaybackEnabled != track->getHapticPlaybackEnabled()) {
5049 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
5050 didModify = true;
5051 }
Eric Laurent81784c32012-11-19 14:55:58 -08005052 continue;
5053 }
5054
5055 { // local variable scope to avoid goto warning
5056
5057 audio_track_cblk_t* cblk = track->cblk();
5058
5059 // The first time a track is added we wait
5060 // for all its buffers to be filled before processing it
Andy Hungc0691382018-09-12 18:01:57 -07005061 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005062
5063 // if an active track doesn't exist in the AudioMixer, create it.
Andy Hungc0691382018-09-12 18:01:57 -07005064 // use the trackId as the AudioMixer name.
5065 if (!mAudioMixer->exists(trackId)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005066 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005067 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005068 track->mChannelMask,
5069 track->mFormat,
5070 track->mSessionId);
5071 if (status != OK) {
Andy Hungc0691382018-09-12 18:01:57 -07005072 ALOGW("%s(): AudioMixer cannot create track(%d)"
5073 " mask %#x, format %#x, sessionId %d",
5074 __func__, trackId,
5075 track->mChannelMask, track->mFormat, track->mSessionId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005076 tracksToRemove->add(track);
5077 track->invalidate(); // consider it dead.
5078 continue;
5079 }
5080 }
5081
Eric Laurent81784c32012-11-19 14:55:58 -08005082 // make sure that we have enough frames to mix one full buffer.
5083 // enforce this condition only once to enable draining the buffer in case the client
5084 // app does not call stop() and relies on underrun to stop:
5085 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
5086 // during last round
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005087 size_t desiredFrames;
Andy Hung8edb8dc2015-03-26 19:13:55 -07005088 const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate();
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005089 AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005090
5091 desiredFrames = sourceFramesNeededWithTimestretch(
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005092 sampleRate, mNormalFrameCount, mSampleRate, playbackRate.mSpeed);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005093 // TODO: ONLY USED FOR LEGACY RESAMPLERS, remove when they are removed.
5094 // add frames already consumed but not yet released by the resampler
5095 // because mAudioTrackServerProxy->framesReady() will include these frames
Andy Hungc0691382018-09-12 18:01:57 -07005096 desiredFrames += mAudioMixer->getUnreleasedFrames(trackId);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005097
Eric Laurent81784c32012-11-19 14:55:58 -08005098 uint32_t minFrames = 1;
5099 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
5100 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005101 minFrames = desiredFrames;
Eric Laurent81784c32012-11-19 14:55:58 -08005102 }
Eric Laurent13e4c962013-12-20 17:36:01 -08005103
5104 size_t framesReady = track->framesReady();
Glenn Kastene7754022014-10-31 12:11:26 -07005105 if (ATRACE_ENABLED()) {
5106 // I wish we had formatted trace names
Andy Hung1bc088a2018-02-09 15:57:31 -08005107 std::string traceName("nRdy");
Andy Hungc0691382018-09-12 18:01:57 -07005108 traceName += std::to_string(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08005109 ATRACE_INT(traceName.c_str(), framesReady);
Glenn Kastene7754022014-10-31 12:11:26 -07005110 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005111 if ((framesReady >= minFrames) && track->isReady() &&
Eric Laurent81784c32012-11-19 14:55:58 -08005112 !track->isPaused() && !track->isTerminated())
5113 {
Andy Hungc0691382018-09-12 18:01:57 -07005114 ALOGVV("track(%d) s=%08x [OK] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005115
5116 mixedTracks++;
5117
Andy Hung69aed5f2014-02-25 17:24:40 -08005118 // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
5119 // there is an effect chain connected to the track
Eric Laurent81784c32012-11-19 14:55:58 -08005120 chain.clear();
Andy Hung69aed5f2014-02-25 17:24:40 -08005121 if (track->mainBuffer() != mSinkBuffer &&
5122 track->mainBuffer() != mMixerBuffer) {
Andy Hung98ef9782014-03-04 14:46:50 -08005123 if (mEffectBufferEnabled) {
5124 mEffectBufferValid = true; // Later can set directly.
5125 }
Eric Laurent81784c32012-11-19 14:55:58 -08005126 chain = getEffectChain_l(track->sessionId());
5127 // Delegate volume control to effect in track effect chain if needed
5128 if (chain != 0) {
5129 tracksWithEffect++;
5130 } else {
Andy Hungc0691382018-09-12 18:01:57 -07005131 ALOGW("prepareTracks_l(): track(%d) attached to effect but no chain found on "
Eric Laurent81784c32012-11-19 14:55:58 -08005132 "session %d",
Andy Hungc0691382018-09-12 18:01:57 -07005133 trackId, track->sessionId());
Eric Laurent81784c32012-11-19 14:55:58 -08005134 }
5135 }
5136
5137
5138 int param = AudioMixer::VOLUME;
5139 if (track->mFillingUpStatus == Track::FS_FILLED) {
5140 // no ramp for the first volume setting
5141 track->mFillingUpStatus = Track::FS_ACTIVE;
5142 if (track->mState == TrackBase::RESUMING) {
5143 track->mState = TrackBase::ACTIVE;
Revathi Uddaraju453bcb52017-08-14 14:19:40 +08005144 // If a new track is paused immediately after start, do not ramp on resume.
5145 if (cblk->mServer != 0) {
5146 param = AudioMixer::RAMP_VOLUME;
5147 }
Eric Laurent81784c32012-11-19 14:55:58 -08005148 }
Andy Hungc0691382018-09-12 18:01:57 -07005149 mAudioMixer->setParameter(trackId, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
Eric Laurent7c29ec92017-09-20 17:54:22 -07005150 mLeftVolFloat = -1.0;
Glenn Kastenf20e1d82013-07-12 09:45:18 -07005151 // FIXME should not make a decision based on mServer
5152 } else if (cblk->mServer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005153 // If the track is stopped before the first frame was mixed,
5154 // do not apply ramp
5155 param = AudioMixer::RAMP_VOLUME;
5156 }
5157
5158 // compute volume for this track
Andy Hung6be49402014-05-30 10:42:03 -07005159 uint32_t vl, vr; // in U8.24 integer format
5160 float vlf, vrf, vaf; // in [0.0, 1.0] float format
Eric Laurent7c29ec92017-09-20 17:54:22 -07005161 // read original volumes with volume control
Eric Laurenteab90452019-06-24 15:17:46 -07005162 float v = masterVolume * mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005163 // Always fetch volumeshaper volume to ensure state is updated.
5164 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5165 const float vh = track->getVolumeHandler()->getVolume(
5166 track->mAudioTrackServerProxy->framesReleased()).first;
Eric Laurent7c29ec92017-09-20 17:54:22 -07005167
Eric Laurenteab90452019-06-24 15:17:46 -07005168 if (mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
5169 v = 0;
5170 }
5171
5172 handleVoipVolume_l(&v);
5173
5174 if (track->isPausing()) {
Andy Hung6be49402014-05-30 10:42:03 -07005175 vl = vr = 0;
5176 vlf = vrf = vaf = 0.;
Eric Laurenteab90452019-06-24 15:17:46 -07005177 track->setPaused();
Eric Laurent81784c32012-11-19 14:55:58 -08005178 } else {
Glenn Kastenc56f3422014-03-21 17:53:17 -07005179 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
Andy Hung6be49402014-05-30 10:42:03 -07005180 vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
5181 vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08005182 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07005183 if (vlf > GAIN_FLOAT_UNITY) {
5184 ALOGV("Track left volume out of range: %.3g", vlf);
5185 vlf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005186 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07005187 if (vrf > GAIN_FLOAT_UNITY) {
5188 ALOGV("Track right volume out of range: %.3g", vrf);
5189 vrf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08005190 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005191 // now apply the master volume and stream type volume and shaper volume
5192 vlf *= v * vh;
5193 vrf *= v * vh;
Eric Laurent81784c32012-11-19 14:55:58 -08005194 // assuming master volume and stream type volume each go up to 1.0,
Andy Hung6be49402014-05-30 10:42:03 -07005195 // then derive vl and vr as U8.24 versions for the effect chain
5196 const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT;
5197 vl = (uint32_t) (scaleto8_24 * vlf);
5198 vr = (uint32_t) (scaleto8_24 * vrf);
5199 // vl and vr are now in U8.24 format
Glenn Kastene3aa6592012-12-04 12:22:46 -08005200 uint16_t sendLevel = proxy->getSendLevel_U4_12();
Eric Laurent81784c32012-11-19 14:55:58 -08005201 // send level comes from shared memory and so may be corrupt
5202 if (sendLevel > MAX_GAIN_INT) {
5203 ALOGV("Track send level out of range: %04X", sendLevel);
5204 sendLevel = MAX_GAIN_INT;
5205 }
Andy Hung6be49402014-05-30 10:42:03 -07005206 // vaf is represented as [0.0, 1.0] float by rescaling sendLevel
5207 vaf = v * sendLevel * (1. / MAX_GAIN_INT);
Eric Laurent81784c32012-11-19 14:55:58 -08005208 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005209
Kevin Rocard12381092018-04-11 09:19:59 -07005210 track->setFinalVolume((vrf + vlf) / 2.f);
5211
Eric Laurent81784c32012-11-19 14:55:58 -08005212 // Delegate volume control to effect in track effect chain if needed
5213 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
5214 // Do not ramp volume if volume is controlled by effect
5215 param = AudioMixer::VOLUME;
Bryant Liub6be7f22014-06-12 22:02:41 +08005216 // Update remaining floating point volume levels
5217 vlf = (float)vl / (1 << 24);
5218 vrf = (float)vr / (1 << 24);
Eric Laurent81784c32012-11-19 14:55:58 -08005219 track->mHasVolumeController = true;
5220 } else {
5221 // force no volume ramp when volume controller was just disabled or removed
5222 // from effect chain to avoid volume spike
5223 if (track->mHasVolumeController) {
5224 param = AudioMixer::VOLUME;
5225 }
5226 track->mHasVolumeController = false;
5227 }
5228
Eric Laurent81784c32012-11-19 14:55:58 -08005229 // XXX: these things DON'T need to be done each time
Andy Hungc0691382018-09-12 18:01:57 -07005230 mAudioMixer->setBufferProvider(trackId, track);
5231 mAudioMixer->enable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005232
Andy Hungc0691382018-09-12 18:01:57 -07005233 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME0, &vlf);
5234 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME1, &vrf);
5235 mAudioMixer->setParameter(trackId, param, AudioMixer::AUXLEVEL, &vaf);
Eric Laurent81784c32012-11-19 14:55:58 -08005236 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005237 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005238 AudioMixer::TRACK,
5239 AudioMixer::FORMAT, (void *)track->format());
5240 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005241 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005242 AudioMixer::TRACK,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005243 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
Andy Hung9a592762014-07-21 21:56:01 -07005244 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005245 trackId,
Andy Hung9a592762014-07-21 21:56:01 -07005246 AudioMixer::TRACK,
jiabin245cdd92018-12-07 17:55:15 -08005247 AudioMixer::MIXER_CHANNEL_MASK,
5248 (void *)(uintptr_t)(mChannelMask | mHapticChannelMask));
Glenn Kastene3aa6592012-12-04 12:22:46 -08005249 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
Andy Hungcd044842014-08-07 11:04:34 -07005250 uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX;
Andy Hung333ab962019-05-28 20:23:35 -07005251 uint32_t reqSampleRate = proxy->getSampleRate();
Glenn Kastene3aa6592012-12-04 12:22:46 -08005252 if (reqSampleRate == 0) {
5253 reqSampleRate = mSampleRate;
5254 } else if (reqSampleRate > maxSampleRate) {
5255 reqSampleRate = maxSampleRate;
5256 }
Eric Laurent81784c32012-11-19 14:55:58 -08005257 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005258 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005259 AudioMixer::RESAMPLE,
5260 AudioMixer::SAMPLE_RATE,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005261 (void *)(uintptr_t)reqSampleRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005262
Andy Hung333ab962019-05-28 20:23:35 -07005263 AudioPlaybackRate playbackRate = proxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005264 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005265 trackId,
Andy Hung8edb8dc2015-03-26 19:13:55 -07005266 AudioMixer::TIMESTRETCH,
5267 AudioMixer::PLAYBACK_RATE,
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005268 &playbackRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005269
Andy Hung69aed5f2014-02-25 17:24:40 -08005270 /*
5271 * Select the appropriate output buffer for the track.
5272 *
Andy Hung98ef9782014-03-04 14:46:50 -08005273 * Tracks with effects go into their own effects chain buffer
5274 * and from there into either mEffectBuffer or mSinkBuffer.
Andy Hung69aed5f2014-02-25 17:24:40 -08005275 *
5276 * Other tracks can use mMixerBuffer for higher precision
5277 * channel accumulation. If this buffer is enabled
5278 * (mMixerBufferEnabled true), then selected tracks will accumulate
5279 * into it.
5280 *
5281 */
5282 if (mMixerBufferEnabled
5283 && (track->mainBuffer() == mSinkBuffer
5284 || track->mainBuffer() == mMixerBuffer)) {
5285 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005286 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005287 AudioMixer::TRACK,
Andy Hung78820702014-02-28 16:23:02 -08005288 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
Andy Hung69aed5f2014-02-25 17:24:40 -08005289 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005290 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005291 AudioMixer::TRACK,
5292 AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer);
5293 // TODO: override track->mainBuffer()?
5294 mMixerBufferValid = true;
5295 } else {
5296 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005297 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005298 AudioMixer::TRACK,
rago94a1ee82017-07-21 15:11:02 -07005299 AudioMixer::MIXER_FORMAT, (void *)EFFECT_BUFFER_FORMAT);
Andy Hung69aed5f2014-02-25 17:24:40 -08005300 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005301 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005302 AudioMixer::TRACK,
5303 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
5304 }
Eric Laurent81784c32012-11-19 14:55:58 -08005305 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005306 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005307 AudioMixer::TRACK,
5308 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
jiabin245cdd92018-12-07 17:55:15 -08005309 mAudioMixer->setParameter(
5310 trackId,
5311 AudioMixer::TRACK,
5312 AudioMixer::HAPTIC_ENABLED, (void *)(uintptr_t)track->getHapticPlaybackEnabled());
jiabin77270b82018-12-18 15:41:29 -08005313 mAudioMixer->setParameter(
5314 trackId,
5315 AudioMixer::TRACK,
5316 AudioMixer::HAPTIC_INTENSITY, (void *)(uintptr_t)track->getHapticIntensity());
Eric Laurent81784c32012-11-19 14:55:58 -08005317
5318 // reset retry count
5319 track->mRetryCount = kMaxTrackRetries;
5320
5321 // If one track is ready, set the mixer ready if:
5322 // - the mixer was not ready during previous round OR
5323 // - no other track is not ready
5324 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
5325 mixerStatus != MIXER_TRACKS_ENABLED) {
5326 mixerStatus = MIXER_TRACKS_READY;
5327 }
Andy Hungb68f5eb2019-12-03 16:49:17 -08005328
5329 // Enable the next few lines to instrument a test for underrun log handling.
5330 // TODO: Remove when we have a better way of testing the underrun log.
5331#if 0
5332 static int i;
5333 if ((++i & 0xf) == 0) {
5334 deferredOperations.tallyUnderrunFrames(track, 10 /* underrunFrames */);
5335 }
5336#endif
Eric Laurent81784c32012-11-19 14:55:58 -08005337 } else {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005338 size_t underrunFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005339 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
Andy Hungb68f5eb2019-12-03 16:49:17 -08005340 ALOGV("track(%d) underrun, track state %s framesReady(%zu) < framesDesired(%zd)",
5341 trackId, track->getTrackStateAsString(), framesReady, desiredFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005342 underrunFrames = desiredFrames;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005343 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005344 deferredOperations.tallyUnderrunFrames(track, underrunFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08005345
Eric Laurent81784c32012-11-19 14:55:58 -08005346 // clear effect chain input buffer if an active track underruns to avoid sending
5347 // previous audio buffer again to effects
5348 chain = getEffectChain_l(track->sessionId());
5349 if (chain != 0) {
5350 chain->clearInputBuffer();
5351 }
5352
Andy Hungc0691382018-09-12 18:01:57 -07005353 ALOGVV("track(%d) s=%08x [NOT READY] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005354 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
5355 track->isStopped() || track->isPaused()) {
5356 // We have consumed all the buffers of this track.
5357 // Remove it from the list of active tracks.
5358 // TODO: use actual buffer filling status instead of latency when available from
5359 // audio HAL
5360 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005361 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005362 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
5363 if (track->isStopped()) {
5364 track->reset();
5365 }
5366 tracksToRemove->add(track);
5367 }
5368 } else {
Eric Laurent81784c32012-11-19 14:55:58 -08005369 // No buffers for this track. Give it a few chances to
5370 // fill a buffer, then remove it from active list.
5371 if (--(track->mRetryCount) <= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07005372 ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p",
5373 trackId, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005374 tracksToRemove->add(track);
5375 // indicate to client process that the track was disabled because of underrun;
5376 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005377 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08005378 // If one track is not ready, mark the mixer also not ready if:
5379 // - the mixer was ready during previous round OR
5380 // - no other track is ready
5381 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
5382 mixerStatus != MIXER_TRACKS_READY) {
5383 mixerStatus = MIXER_TRACKS_ENABLED;
5384 }
5385 }
Andy Hungc0691382018-09-12 18:01:57 -07005386 mAudioMixer->disable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005387 }
5388
5389 } // local variable scope to avoid goto warning
Eric Laurent81784c32012-11-19 14:55:58 -08005390
5391 }
5392
jiabin245cdd92018-12-07 17:55:15 -08005393 if (mHapticChannelMask != AUDIO_CHANNEL_NONE && sq != NULL) {
5394 // When there is no fast track playing haptic and FastMixer exists,
5395 // enabling the first FastTrack, which provides mixed data from normal
5396 // tracks, to play haptic data.
5397 FastTrack *fastTrack = &state->mFastTracks[0];
5398 if (fastTrack->mHapticPlaybackEnabled != noFastHapticTrack) {
5399 fastTrack->mHapticPlaybackEnabled = noFastHapticTrack;
5400 didModify = true;
5401 }
5402 }
5403
Eric Laurent81784c32012-11-19 14:55:58 -08005404 // Push the new FastMixer state if necessary
5405 bool pauseAudioWatchdog = false;
5406 if (didModify) {
5407 state->mFastTracksGen++;
5408 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
5409 if (kUseFastMixer == FastMixer_Dynamic &&
5410 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
5411 state->mCommand = FastMixerState::COLD_IDLE;
5412 state->mColdFutexAddr = &mFastMixerFutex;
5413 state->mColdGen++;
5414 mFastMixerFutex = 0;
5415 if (kUseFastMixer == FastMixer_Dynamic) {
5416 mNormalSink = mOutputSink;
5417 }
5418 // If we go into cold idle, need to wait for acknowledgement
5419 // so that fast mixer stops doing I/O.
5420 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5421 pauseAudioWatchdog = true;
5422 }
Eric Laurent81784c32012-11-19 14:55:58 -08005423 }
5424 if (sq != NULL) {
5425 sq->end(didModify);
Andy Hungf2285312017-02-14 18:31:59 -08005426 // No need to block if the FastMixer is in COLD_IDLE as the FastThread
5427 // is not active. (We BLOCK_UNTIL_ACKED when entering COLD_IDLE
5428 // when bringing the output sink into standby.)
5429 //
5430 // We will get the latest FastMixer state when we come out of COLD_IDLE.
5431 //
5432 // This occurs with BT suspend when we idle the FastMixer with
5433 // active tracks, which may be added or removed.
5434 sq->push(coldIdle ? FastMixerStateQueue::BLOCK_NEVER : block);
Eric Laurent81784c32012-11-19 14:55:58 -08005435 }
5436#ifdef AUDIO_WATCHDOG
5437 if (pauseAudioWatchdog && mAudioWatchdog != 0) {
5438 mAudioWatchdog->pause();
5439 }
5440#endif
5441
5442 // Now perform the deferred reset on fast tracks that have stopped
5443 while (resetMask != 0) {
5444 size_t i = __builtin_ctz(resetMask);
5445 ALOG_ASSERT(i < count);
5446 resetMask &= ~(1 << i);
Andy Hungdae27702016-10-31 14:01:16 -07005447 sp<Track> track = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08005448 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
5449 track->reset();
5450 }
5451
Andy Hung80d03d22018-04-10 10:32:11 -07005452 // Track destruction may occur outside of threadLoop once it is removed from active tracks.
5453 // Ensure the AudioMixer doesn't have a raw "buffer provider" pointer to the track if
5454 // it ceases to be active, to allow safe removal from the AudioMixer at the start
5455 // of prepareTracks_l(); this releases any outstanding buffer back to the track.
5456 // See also the implementation of destroyTrack_l().
5457 for (const auto &track : *tracksToRemove) {
Andy Hungc0691382018-09-12 18:01:57 -07005458 const int trackId = track->id();
5459 if (mAudioMixer->exists(trackId)) { // Normal tracks here, fast tracks in FastMixer.
5460 mAudioMixer->setBufferProvider(trackId, nullptr /* bufferProvider */);
Andy Hung80d03d22018-04-10 10:32:11 -07005461 }
5462 }
5463
Eric Laurent81784c32012-11-19 14:55:58 -08005464 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08005465 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08005466
Eric Laurent97d547d2014-09-02 14:45:53 -07005467 if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0) {
5468 mEffectBufferValid = true;
Marco Nelissenac302142014-10-20 13:15:38 -07005469 }
5470
5471 if (mEffectBufferValid) {
Marco Nelissen57088b52014-10-17 16:39:39 -07005472 // as long as there are effects we should clear the effects buffer, to avoid
5473 // passing a non-clean buffer to the effect chain
5474 memset(mEffectBuffer, 0, mEffectBufferSize);
Eric Laurent97d547d2014-09-02 14:45:53 -07005475 }
Andy Hung69aed5f2014-02-25 17:24:40 -08005476 // sink or mix buffer must be cleared if all tracks are connected to an
5477 // effect chain as in this case the mixer will not write to the sink or mix buffer
5478 // and track effects will accumulate into it
Eric Laurentbfb1b832013-01-07 09:53:42 -08005479 if ((mBytesRemaining == 0) && ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5480 (mixedTracks == 0 && fastTracks > 0))) {
Eric Laurent81784c32012-11-19 14:55:58 -08005481 // FIXME as a performance optimization, should remember previous zero status
Andy Hung69aed5f2014-02-25 17:24:40 -08005482 if (mMixerBufferValid) {
5483 memset(mMixerBuffer, 0, mMixerBufferSize);
5484 // TODO: In testing, mSinkBuffer below need not be cleared because
5485 // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer
5486 // after mixing.
5487 //
5488 // To enforce this guarantee:
5489 // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5490 // (mixedTracks == 0 && fastTracks > 0))
5491 // must imply MIXER_TRACKS_READY.
5492 // Later, we may clear buffers regardless, and skip much of this logic.
5493 }
Andy Hung98ef9782014-03-04 14:46:50 -08005494 // FIXME as a performance optimization, should remember previous zero status
Andy Hung5567aaf2014-07-17 14:00:07 -07005495 memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08005496 }
5497
5498 // if any fast tracks, then status is ready
5499 mMixerStatusIgnoringFastTracks = mixerStatus;
5500 if (fastTracks > 0) {
5501 mixerStatus = MIXER_TRACKS_READY;
5502 }
5503 return mixerStatus;
5504}
5505
Eric Laurentad7dd962016-09-22 12:38:37 -07005506// trackCountForUid_l() must be called with ThreadBase::mLock held
Andy Hung1bc088a2018-02-09 15:57:31 -08005507uint32_t AudioFlinger::PlaybackThread::trackCountForUid_l(uid_t uid) const
Eric Laurentad7dd962016-09-22 12:38:37 -07005508{
5509 uint32_t trackCount = 0;
5510 for (size_t i = 0; i < mTracks.size() ; i++) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08005511 if (mTracks[i]->uid() == uid) {
Eric Laurentad7dd962016-09-22 12:38:37 -07005512 trackCount++;
5513 }
5514 }
5515 return trackCount;
5516}
5517
Andy Hung1bc088a2018-02-09 15:57:31 -08005518// isTrackAllowed_l() must be called with ThreadBase::mLock held
5519bool AudioFlinger::MixerThread::isTrackAllowed_l(
5520 audio_channel_mask_t channelMask, audio_format_t format,
5521 audio_session_t sessionId, uid_t uid) const
Eric Laurent81784c32012-11-19 14:55:58 -08005522{
Andy Hung1bc088a2018-02-09 15:57:31 -08005523 if (!PlaybackThread::isTrackAllowed_l(channelMask, format, sessionId, uid)) {
5524 return false;
Eric Laurentad7dd962016-09-22 12:38:37 -07005525 }
Andy Hung1bc088a2018-02-09 15:57:31 -08005526 // Check validity as we don't call AudioMixer::create() here.
Mikhail Naganov32f0d162019-07-30 14:42:32 -07005527 if (!mAudioMixer->isValidFormat(format)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005528 ALOGW("%s: invalid format: %#x", __func__, format);
5529 return false;
5530 }
Mikhail Naganov32f0d162019-07-30 14:42:32 -07005531 if (!mAudioMixer->isValidChannelMask(channelMask)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08005532 ALOGW("%s: invalid channelMask: %#x", __func__, channelMask);
5533 return false;
5534 }
5535 return true;
Eric Laurent81784c32012-11-19 14:55:58 -08005536}
5537
Eric Laurent10351942014-05-08 18:49:52 -07005538// checkForNewParameter_l() must be called with ThreadBase::mLock held
5539bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
5540 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08005541{
Eric Laurent81784c32012-11-19 14:55:58 -08005542 bool reconfig = false;
Eric Laurent42537be2016-01-08 17:16:42 -08005543 bool a2dpDeviceChanged = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005544
Eric Laurent10351942014-05-08 18:49:52 -07005545 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08005546
Glenn Kastenc05b8d72016-03-24 09:48:17 -07005547 AutoPark<FastMixer> park(mFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08005548
Eric Laurent10351942014-05-08 18:49:52 -07005549 AudioParameter param = AudioParameter(keyValuePair);
5550 int value;
5551 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
5552 reconfig = true;
5553 }
5554 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005555 if (!isValidPcmSinkFormat((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005556 status = BAD_VALUE;
5557 } else {
5558 // no need to save value, since it's constant
Eric Laurent81784c32012-11-19 14:55:58 -08005559 reconfig = true;
5560 }
Eric Laurent10351942014-05-08 18:49:52 -07005561 }
5562 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005563 if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005564 status = BAD_VALUE;
5565 } else {
5566 // no need to save value, since it's constant
5567 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005568 }
Eric Laurent10351942014-05-08 18:49:52 -07005569 }
5570 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
5571 // do not accept frame count changes if tracks are open as the track buffer
5572 // size depends on frame count and correct behavior would not be guaranteed
5573 // if frame count is changed after track creation
5574 if (!mTracks.isEmpty()) {
5575 status = INVALID_OPERATION;
5576 } else {
5577 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005578 }
Eric Laurent10351942014-05-08 18:49:52 -07005579 }
5580 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabin10d86fd2019-10-31 17:20:42 -07005581 LOG_FATAL("Should not set routing device in MixerThread");
Eric Laurent10351942014-05-08 18:49:52 -07005582 }
Eric Laurent81784c32012-11-19 14:55:58 -08005583
Eric Laurent10351942014-05-08 18:49:52 -07005584 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005585 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07005586 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08005587 mOutput->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07005588 if (!mStandby) {
5589 mThreadMetrics.logEndInterval();
5590 mStandby = true;
5591 }
Eric Laurent10351942014-05-08 18:49:52 -07005592 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005593 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent81784c32012-11-19 14:55:58 -08005594 }
Eric Laurent10351942014-05-08 18:49:52 -07005595 if (status == NO_ERROR && reconfig) {
5596 readOutputParameters_l();
5597 delete mAudioMixer;
5598 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
Andy Hung1bc088a2018-02-09 15:57:31 -08005599 for (const auto &track : mTracks) {
Andy Hungc0691382018-09-12 18:01:57 -07005600 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005601 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005602 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005603 track->mChannelMask,
5604 track->mFormat,
5605 track->mSessionId);
5606 ALOGW_IF(status != NO_ERROR,
Andy Hungc0691382018-09-12 18:01:57 -07005607 "%s(): AudioMixer cannot create track(%d)"
5608 " mask %#x, format %#x, sessionId %d",
Andy Hung1bc088a2018-02-09 15:57:31 -08005609 __func__,
Andy Hungc0691382018-09-12 18:01:57 -07005610 trackId, track->mChannelMask, track->mFormat, track->mSessionId);
Eric Laurent10351942014-05-08 18:49:52 -07005611 }
Eric Laurent73e26b62015-04-27 16:55:58 -07005612 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07005613 }
Eric Laurent81784c32012-11-19 14:55:58 -08005614 }
5615
Eric Laurent42537be2016-01-08 17:16:42 -08005616 return reconfig || a2dpDeviceChanged;
Eric Laurent81784c32012-11-19 14:55:58 -08005617}
5618
5619
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005620void AudioFlinger::MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08005621{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005622 PlaybackThread::dumpInternals_l(fd, args);
Andy Hung40eb1a12015-06-18 13:42:02 -07005623 dprintf(fd, " Thread throttle time (msecs): %u\n", mThreadThrottleTimeMs);
Andy Hung8ed196a2018-01-05 13:21:11 -08005624 dprintf(fd, " AudioMixer tracks: %s\n", mAudioMixer->trackNames().c_str());
Andy Hung2ddee192015-12-18 17:34:44 -08005625 dprintf(fd, " Master mono: %s\n", mMasterMono ? "on" : "off");
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005626 dprintf(fd, " Master balance: %f (%s)\n", mMasterBalance.load(),
5627 (hasFastMixer() ? std::to_string(mFastMixer->getMasterBalance())
5628 : mBalance.toString()).c_str());
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005629 if (hasFastMixer()) {
5630 dprintf(fd, " FastMixer thread %p tid=%d", mFastMixer.get(), mFastMixer->getTid());
5631
5632 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
5633 // while we are dumping it. It may be inconsistent, but it won't mutate!
5634 // This is a large object so we place it on the heap.
5635 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07005636 const std::unique_ptr<FastMixerDumpState> copy =
5637 std::make_unique<FastMixerDumpState>(mFastMixerDumpState);
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005638 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005639
5640#ifdef STATE_QUEUE_DUMP
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005641 // Similar for state queue
5642 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
5643 observerCopy.dump(fd);
5644 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
5645 mutatorCopy.dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005646#endif
5647
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005648#ifdef AUDIO_WATCHDOG
5649 if (mAudioWatchdog != 0) {
5650 // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
5651 AudioWatchdogDump wdCopy = mAudioWatchdogDump;
5652 wdCopy.dump(fd);
5653 }
5654#endif
5655
5656 } else {
5657 dprintf(fd, " No FastMixer\n");
5658 }
Eric Laurent81784c32012-11-19 14:55:58 -08005659}
5660
5661uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
5662{
5663 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
5664}
5665
5666uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
5667{
5668 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
5669}
5670
5671void AudioFlinger::MixerThread::cacheParameters_l()
5672{
5673 PlaybackThread::cacheParameters_l();
5674
5675 // FIXME: Relaxed timing because of a certain device that can't meet latency
5676 // Should be reduced to 2x after the vendor fixes the driver issue
5677 // increase threshold again due to low power audio mode. The way this warning
5678 // threshold is calculated and its usefulness should be reconsidered anyway.
5679 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
5680}
5681
5682// ----------------------------------------------------------------------------
5683
5684AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
jiabin10d86fd2019-10-31 17:20:42 -07005685 AudioStreamOut* output, audio_io_handle_t id, ThreadBase::type_t type, bool systemReady)
5686 : PlaybackThread(audioFlinger, output, id, type, systemReady)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005687{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005688 setMasterBalance(audioFlinger->getMasterBalance_l());
Eric Laurentbfb1b832013-01-07 09:53:42 -08005689}
5690
Eric Laurent81784c32012-11-19 14:55:58 -08005691AudioFlinger::DirectOutputThread::~DirectOutputThread()
5692{
5693}
5694
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005695void AudioFlinger::DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005696{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005697 PlaybackThread::dumpInternals_l(fd, args);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005698 dprintf(fd, " Master balance: %f Left: %f Right: %f\n",
5699 mMasterBalance.load(), mMasterBalanceLeft, mMasterBalanceRight);
5700}
5701
5702void AudioFlinger::DirectOutputThread::setMasterBalance(float balance)
5703{
5704 Mutex::Autolock _l(mLock);
5705 if (mMasterBalance != balance) {
5706 mMasterBalance.store(balance);
5707 mBalance.computeStereoBalance(balance, &mMasterBalanceLeft, &mMasterBalanceRight);
5708 broadcast_l();
5709 }
5710}
5711
Eric Laurent5850c4c2016-11-10 13:04:31 -08005712void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005713{
Eric Laurentbfb1b832013-01-07 09:53:42 -08005714 float left, right;
5715
Andy Hung333ab962019-05-28 20:23:35 -07005716 // Ensure volumeshaper state always advances even when muted.
5717 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5718 const auto [shaperVolume, shaperActive] = track->getVolumeHandler()->getVolume(
5719 proxy->framesReleased());
5720 mVolumeShaperActive = shaperActive;
5721
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08005722 if (mMasterMute || mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08005723 left = right = 0;
5724 } else {
5725 float typeVolume = mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005726 const float v = mMasterVolume * typeVolume * shaperVolume;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005727
Glenn Kastenc56f3422014-03-21 17:53:17 -07005728 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
5729 left = float_from_gain(gain_minifloat_unpack_left(vlr));
5730 if (left > GAIN_FLOAT_UNITY) {
5731 left = GAIN_FLOAT_UNITY;
5732 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005733 left *= v * mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
Glenn Kastenc56f3422014-03-21 17:53:17 -07005734 right = float_from_gain(gain_minifloat_unpack_right(vlr));
5735 if (right > GAIN_FLOAT_UNITY) {
5736 right = GAIN_FLOAT_UNITY;
5737 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005738 right *= v * mMasterBalanceRight;
Eric Laurentbfb1b832013-01-07 09:53:42 -08005739 }
5740
5741 if (lastTrack) {
Kevin Rocard12381092018-04-11 09:19:59 -07005742 track->setFinalVolume((left + right) / 2.f);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005743 if (left != mLeftVolFloat || right != mRightVolFloat) {
5744 mLeftVolFloat = left;
5745 mRightVolFloat = right;
5746
Eric Laurentbfb1b832013-01-07 09:53:42 -08005747 // Delegate volume control to effect in track effect chain if needed
5748 // only one effect chain can be present on DirectOutputThread, so if
5749 // there is one, the track is connected to it
5750 if (!mEffectChains.isEmpty()) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09005751 // if effect chain exists, volume is handled by it.
5752 // Convert volumes from float to 8.24
5753 uint32_t vl = (uint32_t)(left * (1 << 24));
5754 uint32_t vr = (uint32_t)(right * (1 << 24));
5755 // Direct/Offload effect chains set output volume in setVolume_l().
5756 (void)mEffectChains[0]->setVolume_l(&vl, &vr);
5757 } else {
5758 // otherwise we directly set the volume.
5759 setVolumeForOutput_l(left, right);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005760 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005761 }
5762 }
5763}
5764
Phil Burk43b4dcc2015-06-09 16:53:44 -07005765void AudioFlinger::DirectOutputThread::onAddNewTrack_l()
5766{
5767 sp<Track> previousTrack = mPreviousTrack.promote();
Andy Hungdae27702016-10-31 14:01:16 -07005768 sp<Track> latestTrack = mActiveTracks.getLatest();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005769
Eric Laurent0f0631e2015-07-06 18:01:25 -07005770 if (previousTrack != 0 && latestTrack != 0) {
5771 if (mType == DIRECT) {
5772 if (previousTrack.get() != latestTrack.get()) {
5773 mFlushPending = true;
5774 }
5775 } else /* mType == OFFLOAD */ {
5776 if (previousTrack->sessionId() != latestTrack->sessionId()) {
5777 mFlushPending = true;
5778 }
5779 }
Revathi Uddaraju20413a92016-10-13 17:16:14 +08005780 } else if (previousTrack == 0) {
5781 // there could be an old track added back during track transition for direct
5782 // output, so always issues flush to flush data of the previous track if it
5783 // was already destroyed with HAL paused, then flush can resume the playback
5784 mFlushPending = true;
Phil Burk43b4dcc2015-06-09 16:53:44 -07005785 }
5786 PlaybackThread::onAddNewTrack_l();
5787}
Eric Laurentbfb1b832013-01-07 09:53:42 -08005788
Eric Laurent81784c32012-11-19 14:55:58 -08005789AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
5790 Vector< sp<Track> > *tracksToRemove
5791)
5792{
Eric Laurentd595b7c2013-04-03 17:27:56 -07005793 size_t count = mActiveTracks.size();
Eric Laurent81784c32012-11-19 14:55:58 -08005794 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005795 bool doHwPause = false;
5796 bool doHwResume = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005797
5798 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07005799 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08005800 if (t->isInvalid()) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005801 ALOGW("An invalidated track shouldn't be in active list");
Eric Laurent5850c4c2016-11-10 13:04:31 -08005802 tracksToRemove->add(t);
Phil Burk43b4dcc2015-06-09 16:53:44 -07005803 continue;
5804 }
5805
Eric Laurent5850c4c2016-11-10 13:04:31 -08005806 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005807#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurent81784c32012-11-19 14:55:58 -08005808 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005809#endif
Eric Laurentfd477972013-10-25 18:10:40 -07005810 // Only consider last track started for volume and mixer state control.
5811 // In theory an older track could underrun and restart after the new one starts
5812 // but as we only care about the transition phase between two tracks on a
5813 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07005814 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08005815 bool last = l.get() == track;
Eric Laurent81784c32012-11-19 14:55:58 -08005816
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005817 if (track->isPausing()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005818 track->setPaused();
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005819 if (mHwSupportsPause && last && !mHwPaused) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005820 doHwPause = true;
5821 mHwPaused = true;
5822 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005823 } else if (track->isFlushPending()) {
5824 track->flushAck();
5825 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005826 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005827 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005828 } else if (track->isResumePending()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005829 track->resumeAck();
Eric Laurent3df841a2016-07-15 15:15:40 -07005830 if (last) {
5831 mLeftVolFloat = mRightVolFloat = -1.0;
5832 if (mHwPaused) {
5833 doHwResume = true;
5834 mHwPaused = false;
5835 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005836 }
5837 }
5838
Eric Laurent81784c32012-11-19 14:55:58 -08005839 // The first time a track is added we wait
Phil Burk99adee32014-12-10 16:46:30 -08005840 // for all its buffers to be filled before processing it.
5841 // Allow draining the buffer in case the client
5842 // app does not call stop() and relies on underrun to stop:
5843 // hence the test on (track->mRetryCount > 1).
5844 // If retryCount<=1 then track is about to underrun and be removed.
Phil Burkca5e6142015-07-14 09:42:29 -07005845 // Do not use a high threshold for compressed audio.
Eric Laurent81784c32012-11-19 14:55:58 -08005846 uint32_t minFrames;
Phil Burk99adee32014-12-10 16:46:30 -08005847 if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
Phil Burkfdb3c072016-02-09 10:47:02 -08005848 && (track->mRetryCount > 1) && audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005849 minFrames = mNormalFrameCount;
5850 } else {
5851 minFrames = 1;
5852 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005853
Mikhail Naganov76e89c32019-08-15 20:18:47 -07005854 const size_t framesReady = track->framesReady();
5855 const int trackId = track->id();
5856 if (ATRACE_ENABLED()) {
5857 std::string traceName("nRdy");
5858 traceName += std::to_string(trackId);
5859 ATRACE_INT(traceName.c_str(), framesReady);
5860 }
5861 if ((framesReady >= minFrames) && track->isReady() && !track->isPaused() &&
Eric Laurentab5cdba2014-06-09 17:22:27 -07005862 !track->isStopping_2() && !track->isStopped())
Eric Laurent81784c32012-11-19 14:55:58 -08005863 {
Mikhail Naganov76e89c32019-08-15 20:18:47 -07005864 ALOGVV("track(%d) s=%08x [OK]", trackId, cblk->mServer);
Eric Laurent81784c32012-11-19 14:55:58 -08005865
5866 if (track->mFillingUpStatus == Track::FS_FILLED) {
5867 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07005868 if (last) {
5869 // make sure processVolume_l() will apply new volume even if 0
5870 mLeftVolFloat = mRightVolFloat = -1.0;
5871 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005872 if (!mHwSupportsPause) {
5873 track->resumeAck();
Eric Laurent81784c32012-11-19 14:55:58 -08005874 }
5875 }
5876
5877 // compute volume for this track
Eric Laurentbfb1b832013-01-07 09:53:42 -08005878 processVolume_l(track, last);
5879 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005880 sp<Track> previousTrack = mPreviousTrack.promote();
5881 if (previousTrack != 0) {
5882 if (track != previousTrack.get()) {
5883 // Flush any data still being written from last track
5884 mBytesRemaining = 0;
Eric Laurent0f0631e2015-07-06 18:01:25 -07005885 // Invalidate previous track to force a seek when resuming.
5886 previousTrack->invalidate();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005887 }
5888 }
5889 mPreviousTrack = track;
5890
Eric Laurentd595b7c2013-04-03 17:27:56 -07005891 // reset retry count
5892 track->mRetryCount = kMaxTrackRetriesDirect;
Eric Laurent5850c4c2016-11-10 13:04:31 -08005893 mActiveTrack = t;
Eric Laurentd595b7c2013-04-03 17:27:56 -07005894 mixerStatus = MIXER_TRACKS_READY;
Eric Laurent5cff4032015-05-26 13:49:58 -07005895 if (mHwPaused) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08005896 doHwResume = true;
5897 mHwPaused = false;
5898 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07005899 }
Eric Laurent81784c32012-11-19 14:55:58 -08005900 } else {
Eric Laurentd595b7c2013-04-03 17:27:56 -07005901 // clear effect chain input buffer if the last active track started underruns
5902 // to avoid sending previous audio buffer again to effects
Eric Laurentfd477972013-10-25 18:10:40 -07005903 if (!mEffectChains.isEmpty() && last) {
Eric Laurent81784c32012-11-19 14:55:58 -08005904 mEffectChains[0]->clearInputBuffer();
5905 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07005906 if (track->isStopping_1()) {
5907 track->mState = TrackBase::STOPPING_2;
Eric Laurentb369caf2015-03-30 20:51:47 -07005908 if (last && mHwPaused) {
5909 doHwResume = true;
5910 mHwPaused = false;
5911 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07005912 }
5913 if ((track->sharedBuffer() != 0) || track->isStopped() ||
5914 track->isStopping_2() || track->isPaused()) {
Eric Laurent81784c32012-11-19 14:55:58 -08005915 // We have consumed all the buffers of this track.
5916 // Remove it from the list of active tracks.
Eric Laurentab5cdba2014-06-09 17:22:27 -07005917 size_t audioHALFrames;
Phil Burkfdb3c072016-02-09 10:47:02 -08005918 if (audio_has_proportional_frames(mFormat)) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07005919 audioHALFrames = (latency_l() * mSampleRate) / 1000;
5920 } else {
5921 audioHALFrames = 0;
5922 }
5923
Andy Hung818e7a32016-02-16 18:08:07 -08005924 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurentfd477972013-10-25 18:10:40 -07005925 if (mStandby || !last ||
Aniket Kumar Lata179a0742019-01-30 14:16:16 -08005926 track->presentationComplete(framesWritten, audioHALFrames) ||
Jindong32dc26e2019-11-11 18:10:01 +08005927 track->isPaused() || mHwPaused) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07005928 if (track->isStopping_2()) {
5929 track->mState = TrackBase::STOPPED;
5930 }
Eric Laurent81784c32012-11-19 14:55:58 -08005931 if (track->isStopped()) {
5932 track->reset();
5933 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07005934 tracksToRemove->add(track);
Eric Laurent81784c32012-11-19 14:55:58 -08005935 }
5936 } else {
5937 // No buffers for this track. Give it a few chances to
5938 // fill a buffer, then remove it from active list.
Eric Laurentd595b7c2013-04-03 17:27:56 -07005939 // Only consider last track started for mixer state control
Eric Laurent81784c32012-11-19 14:55:58 -08005940 if (--(track->mRetryCount) <= 0) {
Mikhail Naganov76e89c32019-08-15 20:18:47 -07005941 ALOGV("BUFFER TIMEOUT: remove track(%d) from active list", trackId);
Eric Laurentd595b7c2013-04-03 17:27:56 -07005942 tracksToRemove->add(track);
Eric Laurenta23f17a2013-11-05 18:22:08 -08005943 // indicate to client process that the track was disabled because of underrun;
5944 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005945 track->disable();
Eric Laurentbfb1b832013-01-07 09:53:42 -08005946 } else if (last) {
Phil Burkca5e6142015-07-14 09:42:29 -07005947 ALOGW("pause because of UNDERRUN, framesReady = %zu,"
5948 "minFrames = %u, mFormat = %#x",
Mikhail Naganov76e89c32019-08-15 20:18:47 -07005949 framesReady, minFrames, mFormat);
Eric Laurent81784c32012-11-19 14:55:58 -08005950 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurent5cff4032015-05-26 13:49:58 -07005951 if (mHwSupportsPause && !mHwPaused && !mStandby) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08005952 doHwPause = true;
5953 mHwPaused = true;
5954 }
Eric Laurent81784c32012-11-19 14:55:58 -08005955 }
5956 }
5957 }
5958 }
5959
Eric Laurentd1f69b02014-12-15 14:33:13 -08005960 // if an active track did not command a flush, check for pending flush on stopped tracks
Phil Burk43b4dcc2015-06-09 16:53:44 -07005961 if (!mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005962 for (size_t i = 0; i < mTracks.size(); i++) {
5963 if (mTracks[i]->isFlushPending()) {
5964 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005965 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005966 }
5967 }
5968 }
5969
5970 // make sure the pause/flush/resume sequence is executed in the right order.
5971 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
5972 // before flush and then resume HW. This can happen in case of pause/flush/resume
5973 // if resume is received before pause is executed.
5974 if (mHwSupportsPause && !mStandby &&
Phil Burk43b4dcc2015-06-09 16:53:44 -07005975 (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005976 status_t result = mOutput->stream->pause();
5977 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08005978 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07005979 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005980 flushHw_l();
5981 }
5982 if (mHwSupportsPause && !mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005983 status_t result = mOutput->stream->resume();
5984 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08005985 }
Eric Laurent81784c32012-11-19 14:55:58 -08005986 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08005987 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08005988
5989 return mixerStatus;
5990}
5991
5992void AudioFlinger::DirectOutputThread::threadLoop_mix()
5993{
Eric Laurent81784c32012-11-19 14:55:58 -08005994 size_t frameCount = mFrameCount;
Andy Hung2098f272014-02-27 14:00:06 -08005995 int8_t *curBuf = (int8_t *)mSinkBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08005996 // output audio to hardware
5997 while (frameCount) {
Glenn Kasten34542ac2013-06-26 11:29:02 -07005998 AudioBufferProvider::Buffer buffer;
Eric Laurent81784c32012-11-19 14:55:58 -08005999 buffer.frameCount = frameCount;
Phil Burk062e67a2015-02-11 13:40:50 -08006000 status_t status = mActiveTrack->getNextBuffer(&buffer);
6001 if (status != NO_ERROR || buffer.raw == NULL) {
Eric Laurent51716182016-02-29 18:00:56 -08006002 // no need to pad with 0 for compressed audio
6003 if (audio_has_proportional_frames(mFormat)) {
6004 memset(curBuf, 0, frameCount * mFrameSize);
6005 }
Eric Laurent81784c32012-11-19 14:55:58 -08006006 break;
6007 }
6008 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
6009 frameCount -= buffer.frameCount;
6010 curBuf += buffer.frameCount * mFrameSize;
6011 mActiveTrack->releaseBuffer(&buffer);
6012 }
Andy Hung2098f272014-02-27 14:00:06 -08006013 mCurrentWriteLength = curBuf - (int8_t *)mSinkBuffer;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006014 mSleepTimeUs = 0;
6015 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006016 mActiveTrack.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08006017}
6018
6019void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
6020{
Eric Laurentd1f69b02014-12-15 14:33:13 -08006021 // do not write to HAL when paused
Eric Laurent0f7b5f22014-12-19 10:43:21 -08006022 if (mHwPaused || (usesHwAvSync() && mStandby)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006023 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006024 return;
6025 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006026 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08006027 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurente93cc032016-05-05 10:15:10 -07006028 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006029 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006030 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006031 }
Phil Burkfdb3c072016-02-09 10:47:02 -08006032 } else if (mBytesWritten != 0 && audio_has_proportional_frames(mFormat)) {
Andy Hung2098f272014-02-27 14:00:06 -08006033 memset(mSinkBuffer, 0, mFrameCount * mFrameSize);
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006034 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006035 }
6036}
6037
Eric Laurentd1f69b02014-12-15 14:33:13 -08006038void AudioFlinger::DirectOutputThread::threadLoop_exit()
6039{
6040 {
6041 Mutex::Autolock _l(mLock);
Eric Laurentd1f69b02014-12-15 14:33:13 -08006042 for (size_t i = 0; i < mTracks.size(); i++) {
6043 if (mTracks[i]->isFlushPending()) {
6044 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07006045 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006046 }
6047 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07006048 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08006049 flushHw_l();
6050 }
6051 }
6052 PlaybackThread::threadLoop_exit();
6053}
6054
6055// must be called with thread mutex locked
6056bool AudioFlinger::DirectOutputThread::shouldStandby_l()
6057{
6058 bool trackPaused = false;
Eric Laurentb369caf2015-03-30 20:51:47 -07006059 bool trackStopped = false;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006060
6061 // do not put the HAL in standby when paused. AwesomePlayer clear the offloaded AudioTrack
6062 // after a timeout and we will enter standby then.
6063 if (mTracks.size() > 0) {
6064 trackPaused = mTracks[mTracks.size() - 1]->isPaused();
Eric Laurentb369caf2015-03-30 20:51:47 -07006065 trackStopped = mTracks[mTracks.size() - 1]->isStopped() ||
6066 mTracks[mTracks.size() - 1]->mState == TrackBase::IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08006067 }
6068
Eric Laurent5cff4032015-05-26 13:49:58 -07006069 return !mStandby && !(trackPaused || (mHwPaused && !trackStopped));
Eric Laurentd1f69b02014-12-15 14:33:13 -08006070}
6071
Eric Laurent10351942014-05-08 18:49:52 -07006072// checkForNewParameter_l() must be called with ThreadBase::mLock held
6073bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
6074 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08006075{
6076 bool reconfig = false;
Eric Laurent42537be2016-01-08 17:16:42 -08006077 bool a2dpDeviceChanged = false;
Eric Laurent81784c32012-11-19 14:55:58 -08006078
Eric Laurent10351942014-05-08 18:49:52 -07006079 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08006080
Eric Laurent10351942014-05-08 18:49:52 -07006081 AudioParameter param = AudioParameter(keyValuePair);
6082 int value;
6083 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabin10d86fd2019-10-31 17:20:42 -07006084 LOG_FATAL("Should not set routing device in DirectOutputThread");
Eric Laurent81784c32012-11-19 14:55:58 -08006085 }
Eric Laurent10351942014-05-08 18:49:52 -07006086 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
6087 // do not accept frame count changes if tracks are open as the track buffer
6088 // size depends on frame count and correct behavior would not be garantied
6089 // if frame count is changed after track creation
6090 if (!mTracks.isEmpty()) {
6091 status = INVALID_OPERATION;
6092 } else {
6093 reconfig = true;
6094 }
6095 }
6096 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006097 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006098 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08006099 mOutput->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07006100 if (!mStandby) {
6101 mThreadMetrics.logEndInterval();
6102 mStandby = true;
6103 }
Eric Laurent10351942014-05-08 18:49:52 -07006104 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006105 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07006106 }
6107 if (status == NO_ERROR && reconfig) {
6108 readOutputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07006109 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07006110 }
6111 }
6112
Eric Laurent42537be2016-01-08 17:16:42 -08006113 return reconfig || a2dpDeviceChanged;
Eric Laurent81784c32012-11-19 14:55:58 -08006114}
6115
6116uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
6117{
6118 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006119 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006120 time = PlaybackThread::activeSleepTimeUs();
6121 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006122 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006123 }
6124 return time;
6125}
6126
6127uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
6128{
6129 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006130 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006131 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
6132 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006133 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006134 }
6135 return time;
6136}
6137
6138uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
6139{
6140 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08006141 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08006142 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
6143 } else {
Eric Laurent51716182016-02-29 18:00:56 -08006144 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006145 }
6146 return time;
6147}
6148
6149void AudioFlinger::DirectOutputThread::cacheParameters_l()
6150{
6151 PlaybackThread::cacheParameters_l();
6152
6153 // use shorter standby delay as on normal output to release
6154 // hardware resources as soon as possible
Eric Laurentb369caf2015-03-30 20:51:47 -07006155 // no delay on outputs with HW A/V sync
6156 if (usesHwAvSync()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006157 mStandbyDelayNs = 0;
Phil Burkfdb3c072016-02-09 10:47:02 -08006158 } else if ((mType == OFFLOAD) && !audio_has_proportional_frames(mFormat)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006159 mStandbyDelayNs = kOffloadStandbyDelayNs;
Eric Laurent5cff4032015-05-26 13:49:58 -07006160 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006161 mStandbyDelayNs = microseconds(mActiveSleepTimeUs*2);
Eric Laurent972a1732013-09-04 09:42:59 -07006162 }
Eric Laurent81784c32012-11-19 14:55:58 -08006163}
6164
Eric Laurente659ef42014-09-29 13:06:46 -07006165void AudioFlinger::DirectOutputThread::flushHw_l()
6166{
Phil Burk062e67a2015-02-11 13:40:50 -08006167 mOutput->flush();
Eric Laurentd1f69b02014-12-15 14:33:13 -08006168 mHwPaused = false;
Phil Burk43b4dcc2015-06-09 16:53:44 -07006169 mFlushPending = false;
Andy Hungf3234512018-07-03 14:51:47 -07006170 mTimestampVerifier.discontinuity(); // DIRECT and OFFLOADED flush resets frame count.
Sampath Shetty999f0e82020-01-15 10:19:06 +11006171 mTimestamp.clear();
Eric Laurente659ef42014-09-29 13:06:46 -07006172}
6173
Andy Hung10cbff12017-02-21 17:30:14 -08006174int64_t AudioFlinger::DirectOutputThread::computeWaitTimeNs_l() const {
6175 // If a VolumeShaper is active, we must wake up periodically to update volume.
6176 const int64_t NS_PER_MS = 1000000;
6177 return mVolumeShaperActive ?
6178 kMinNormalSinkBufferSizeMs * NS_PER_MS : PlaybackThread::computeWaitTimeNs_l();
6179}
6180
Eric Laurent81784c32012-11-19 14:55:58 -08006181// ----------------------------------------------------------------------------
6182
Eric Laurentbfb1b832013-01-07 09:53:42 -08006183AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
Eric Laurent4de95592013-09-26 15:28:21 -07006184 const wp<AudioFlinger::PlaybackThread>& playbackThread)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006185 : Thread(false /*canCallJava*/),
Eric Laurent4de95592013-09-26 15:28:21 -07006186 mPlaybackThread(playbackThread),
Eric Laurent3b4529e2013-09-05 18:09:19 -07006187 mWriteAckSequence(0),
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006188 mDrainSequence(0),
6189 mAsyncError(false)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006190{
6191}
6192
6193AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
6194{
6195}
6196
6197void AudioFlinger::AsyncCallbackThread::onFirstRef()
6198{
6199 run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
6200}
6201
6202bool AudioFlinger::AsyncCallbackThread::threadLoop()
6203{
6204 while (!exitPending()) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006205 uint32_t writeAckSequence;
6206 uint32_t drainSequence;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006207 bool asyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006208
6209 {
6210 Mutex::Autolock _l(mLock);
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006211 while (!((mWriteAckSequence & 1) ||
6212 (mDrainSequence & 1) ||
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006213 mAsyncError ||
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006214 exitPending())) {
6215 mWaitWorkCV.wait(mLock);
6216 }
6217
Eric Laurentbfb1b832013-01-07 09:53:42 -08006218 if (exitPending()) {
6219 break;
6220 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006221 ALOGV("AsyncCallbackThread mWriteAckSequence %d mDrainSequence %d",
6222 mWriteAckSequence, mDrainSequence);
6223 writeAckSequence = mWriteAckSequence;
6224 mWriteAckSequence &= ~1;
6225 drainSequence = mDrainSequence;
6226 mDrainSequence &= ~1;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006227 asyncError = mAsyncError;
6228 mAsyncError = false;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006229 }
6230 {
Eric Laurent4de95592013-09-26 15:28:21 -07006231 sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
6232 if (playbackThread != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006233 if (writeAckSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006234 playbackThread->resetWriteBlocked(writeAckSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006235 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006236 if (drainSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006237 playbackThread->resetDraining(drainSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006238 }
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006239 if (asyncError) {
6240 playbackThread->onAsyncError();
6241 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006242 }
6243 }
6244 }
6245 return false;
6246}
6247
6248void AudioFlinger::AsyncCallbackThread::exit()
6249{
6250 ALOGV("AsyncCallbackThread::exit");
6251 Mutex::Autolock _l(mLock);
6252 requestExit();
6253 mWaitWorkCV.broadcast();
6254}
6255
Eric Laurent3b4529e2013-09-05 18:09:19 -07006256void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006257{
6258 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006259 // bit 0 is cleared
6260 mWriteAckSequence = sequence << 1;
6261}
6262
6263void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
6264{
6265 Mutex::Autolock _l(mLock);
6266 // ignore unexpected callbacks
6267 if (mWriteAckSequence & 2) {
6268 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006269 mWaitWorkCV.signal();
6270 }
6271}
6272
Eric Laurent3b4529e2013-09-05 18:09:19 -07006273void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006274{
6275 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006276 // bit 0 is cleared
6277 mDrainSequence = sequence << 1;
6278}
6279
6280void AudioFlinger::AsyncCallbackThread::resetDraining()
6281{
6282 Mutex::Autolock _l(mLock);
6283 // ignore unexpected callbacks
6284 if (mDrainSequence & 2) {
6285 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006286 mWaitWorkCV.signal();
6287 }
6288}
6289
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006290void AudioFlinger::AsyncCallbackThread::setAsyncError()
6291{
6292 Mutex::Autolock _l(mLock);
6293 mAsyncError = true;
6294 mWaitWorkCV.signal();
6295}
6296
Eric Laurentbfb1b832013-01-07 09:53:42 -08006297
6298// ----------------------------------------------------------------------------
6299AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
jiabin10d86fd2019-10-31 17:20:42 -07006300 AudioStreamOut* output, audio_io_handle_t id, bool systemReady)
6301 : DirectOutputThread(audioFlinger, output, id, OFFLOAD, systemReady),
Andy Hungf8044752016-07-27 14:58:11 -07006302 mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true),
6303 mOffloadUnderrunPosition(~0LL)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006304{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07006305 //FIXME: mStandby should be set to true by ThreadBase constructo
Eric Laurentfd477972013-10-25 18:10:40 -07006306 mStandby = true;
Eric Laurent64667972016-03-30 18:19:46 -07006307 mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006308}
6309
Eric Laurentbfb1b832013-01-07 09:53:42 -08006310void AudioFlinger::OffloadThread::threadLoop_exit()
6311{
6312 if (mFlushPending || mHwPaused) {
6313 // If a flush is pending or track was paused, just discard buffered data
6314 flushHw_l();
6315 } else {
6316 mMixerStatus = MIXER_DRAIN_ALL;
6317 threadLoop_drain();
6318 }
Uday Gupta56604aa2014-05-13 11:19:17 -07006319 if (mUseAsyncWrite) {
6320 ALOG_ASSERT(mCallbackThread != 0);
6321 mCallbackThread->exit();
6322 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006323 PlaybackThread::threadLoop_exit();
6324}
6325
6326AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
6327 Vector< sp<Track> > *tracksToRemove
6328)
6329{
Eric Laurentbfb1b832013-01-07 09:53:42 -08006330 size_t count = mActiveTracks.size();
6331
6332 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurent972a1732013-09-04 09:42:59 -07006333 bool doHwPause = false;
6334 bool doHwResume = false;
6335
Glenn Kastenc42e9b42016-03-21 11:35:03 -07006336 ALOGV("OffloadThread::prepareTracks_l active tracks %zu", count);
Eric Laurentede6c3b2013-09-19 14:37:46 -07006337
Eric Laurentbfb1b832013-01-07 09:53:42 -08006338 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07006339 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08006340 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006341#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurentbfb1b832013-01-07 09:53:42 -08006342 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006343#endif
Eric Laurentfd477972013-10-25 18:10:40 -07006344 // Only consider last track started for volume and mixer state control.
6345 // In theory an older track could underrun and restart after the new one starts
6346 // but as we only care about the transition phase between two tracks on a
6347 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07006348 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08006349 bool last = l.get() == track;
Eric Laurentfd477972013-10-25 18:10:40 -07006350
Haynes Mathew George7844f672014-01-15 12:32:55 -08006351 if (track->isInvalid()) {
6352 ALOGW("An invalidated track shouldn't be in active list");
6353 tracksToRemove->add(track);
6354 continue;
6355 }
6356
6357 if (track->mState == TrackBase::IDLE) {
6358 ALOGW("An idle track shouldn't be in active list");
6359 continue;
6360 }
6361
Eric Laurentbfb1b832013-01-07 09:53:42 -08006362 if (track->isPausing()) {
6363 track->setPaused();
6364 if (last) {
Eric Laurent5cff4032015-05-26 13:49:58 -07006365 if (mHwSupportsPause && !mHwPaused) {
Eric Laurent972a1732013-09-04 09:42:59 -07006366 doHwPause = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006367 mHwPaused = true;
6368 }
6369 // If we were part way through writing the mixbuffer to
6370 // the HAL we must save this until we resume
6371 // BUG - this will be wrong if a different track is made active,
6372 // in that case we want to discard the pending data in the
6373 // mixbuffer and tell the client to present it again when the
6374 // track is resumed
6375 mPausedWriteLength = mCurrentWriteLength;
6376 mPausedBytesRemaining = mBytesRemaining;
6377 mBytesRemaining = 0; // stop writing
6378 }
6379 tracksToRemove->add(track);
Haynes Mathew George7844f672014-01-15 12:32:55 -08006380 } else if (track->isFlushPending()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006381 if (track->isStopping_1()) {
6382 track->mRetryCount = kMaxTrackStopRetriesOffload;
6383 } else {
6384 track->mRetryCount = kMaxTrackRetriesOffload;
6385 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08006386 track->flushAck();
6387 if (last) {
6388 mFlushPending = true;
6389 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006390 } else if (track->isResumePending()){
6391 track->resumeAck();
6392 if (last) {
6393 if (mPausedBytesRemaining) {
6394 // Need to continue write that was interrupted
6395 mCurrentWriteLength = mPausedWriteLength;
6396 mBytesRemaining = mPausedBytesRemaining;
6397 mPausedBytesRemaining = 0;
6398 }
6399 if (mHwPaused) {
6400 doHwResume = true;
6401 mHwPaused = false;
6402 // threadLoop_mix() will handle the case that we need to
6403 // resume an interrupted write
6404 }
6405 // enable write to audio HAL
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006406 mSleepTimeUs = 0;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006407
Eric Laurent3df841a2016-07-15 15:15:40 -07006408 mLeftVolFloat = mRightVolFloat = -1.0;
6409
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006410 // Do not handle new data in this iteration even if track->framesReady()
6411 mixerStatus = MIXER_TRACKS_ENABLED;
6412 }
6413 } else if (track->framesReady() && track->isReady() &&
Eric Laurent3b4529e2013-09-05 18:09:19 -07006414 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
Andy Hungc0691382018-09-12 18:01:57 -07006415 ALOGVV("OffloadThread: track(%d) s=%08x [OK]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006416 if (track->mFillingUpStatus == Track::FS_FILLED) {
6417 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07006418 if (last) {
6419 // make sure processVolume_l() will apply new volume even if 0
6420 mLeftVolFloat = mRightVolFloat = -1.0;
6421 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006422 }
6423
6424 if (last) {
Eric Laurentd7e59222013-11-15 12:02:28 -08006425 sp<Track> previousTrack = mPreviousTrack.promote();
6426 if (previousTrack != 0) {
6427 if (track != previousTrack.get()) {
Eric Laurent9da3d952013-11-12 19:25:43 -08006428 // Flush any data still being written from last track
6429 mBytesRemaining = 0;
6430 if (mPausedBytesRemaining) {
6431 // Last track was paused so we also need to flush saved
6432 // mixbuffer state and invalidate track so that it will
6433 // re-submit that unwritten data when it is next resumed
6434 mPausedBytesRemaining = 0;
6435 // Invalidate is a bit drastic - would be more efficient
6436 // to have a flag to tell client that some of the
6437 // previously written data was lost
Eric Laurentd7e59222013-11-15 12:02:28 -08006438 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006439 }
6440 // flush data already sent to the DSP if changing audio session as audio
6441 // comes from a different source. Also invalidate previous track to force a
6442 // seek when resuming.
Eric Laurentd7e59222013-11-15 12:02:28 -08006443 if (previousTrack->sessionId() != track->sessionId()) {
6444 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006445 }
6446 }
6447 }
6448 mPreviousTrack = track;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006449 // reset retry count
Eric Laurente93cc032016-05-05 10:15:10 -07006450 if (track->isStopping_1()) {
6451 track->mRetryCount = kMaxTrackStopRetriesOffload;
6452 } else {
6453 track->mRetryCount = kMaxTrackRetriesOffload;
6454 }
Eric Laurent5850c4c2016-11-10 13:04:31 -08006455 mActiveTrack = t;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006456 mixerStatus = MIXER_TRACKS_READY;
6457 }
6458 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006459 ALOGVV("OffloadThread: track(%d) s=%08x [NOT READY]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006460 if (track->isStopping_1()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006461 if (--(track->mRetryCount) <= 0) {
6462 // Hardware buffer can hold a large amount of audio so we must
6463 // wait for all current track's data to drain before we say
6464 // that the track is stopped.
6465 if (mBytesRemaining == 0) {
6466 // Only start draining when all data in mixbuffer
6467 // has been written
6468 ALOGV("OffloadThread: underrun and STOPPING_1 -> draining, STOPPING_2");
6469 track->mState = TrackBase::STOPPING_2; // so presentation completes after
6470 // drain do not drain if no data was ever sent to HAL (mStandby == true)
6471 if (last && !mStandby) {
6472 // do not modify drain sequence if we are already draining. This happens
6473 // when resuming from pause after drain.
6474 if ((mDrainSequence & 1) == 0) {
6475 mSleepTimeUs = 0;
6476 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
6477 mixerStatus = MIXER_DRAIN_TRACK;
6478 mDrainSequence += 2;
6479 }
6480 if (mHwPaused) {
6481 // It is possible to move from PAUSED to STOPPING_1 without
6482 // a resume so we must ensure hardware is running
6483 doHwResume = true;
6484 mHwPaused = false;
6485 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006486 }
6487 }
Eric Laurente93cc032016-05-05 10:15:10 -07006488 } else if (last) {
6489 ALOGV("stopping1 underrun retries left %d", track->mRetryCount);
6490 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006491 }
6492 } else if (track->isStopping_2()) {
Eric Laurent6a51d7e2013-10-17 18:59:26 -07006493 // Drain has completed or we are in standby, signal presentation complete
6494 if (!(mDrainSequence & 1) || !last || mStandby) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006495 track->mState = TrackBase::STOPPED;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006496 uint32_t latency = 0;
6497 status_t result = mOutput->stream->getLatency(&latency);
6498 ALOGE_IF(result != OK,
6499 "Error when retrieving output stream latency: %d", result);
6500 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08006501 int64_t framesWritten =
Phil Burk062e67a2015-02-11 13:40:50 -08006502 mBytesWritten / mOutput->getFrameSize();
Eric Laurentbfb1b832013-01-07 09:53:42 -08006503 track->presentationComplete(framesWritten, audioHALFrames);
6504 track->reset();
6505 tracksToRemove->add(track);
Andy Hungf3234512018-07-03 14:51:47 -07006506 // DIRECT and OFFLOADED stop resets frame counts.
6507 if (!mUseAsyncWrite) {
6508 // If we don't get explicit drain notification we must
6509 // register discontinuity regardless of whether this is
6510 // the previous (!last) or the upcoming (last) track
6511 // to avoid skipping the discontinuity.
6512 mTimestampVerifier.discontinuity();
6513 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006514 }
6515 } else {
6516 // No buffers for this track. Give it a few chances to
6517 // fill a buffer, then remove it from active list.
6518 if (--(track->mRetryCount) <= 0) {
Andy Hungf8044752016-07-27 14:58:11 -07006519 bool running = false;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006520 uint64_t position = 0;
6521 struct timespec unused;
6522 // The running check restarts the retry counter at least once.
6523 status_t ret = mOutput->stream->getPresentationPosition(&position, &unused);
6524 if (ret == NO_ERROR && position != mOffloadUnderrunPosition) {
6525 running = true;
6526 mOffloadUnderrunPosition = position;
6527 }
6528 if (ret == NO_ERROR) {
Andy Hungf8044752016-07-27 14:58:11 -07006529 ALOGVV("underrun counter, running(%d): %lld vs %lld", running,
6530 (long long)position, (long long)mOffloadUnderrunPosition);
6531 }
6532 if (running) { // still running, give us more time.
6533 track->mRetryCount = kMaxTrackRetriesOffload;
6534 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006535 ALOGV("OffloadThread: BUFFER TIMEOUT: remove track(%d) from active list",
6536 track->id());
Andy Hungf8044752016-07-27 14:58:11 -07006537 tracksToRemove->add(track);
Glenn Kastend3bb6452016-12-05 18:14:37 -08006538 // tell client process that the track was disabled because of underrun;
Andy Hungf8044752016-07-27 14:58:11 -07006539 // it will then automatically call start() when data is available
6540 track->disable();
6541 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006542 } else if (last){
6543 mixerStatus = MIXER_TRACKS_ENABLED;
6544 }
6545 }
6546 }
6547 // compute volume for this track
Wenfeng Sun79458332019-05-29 20:12:43 +08006548 if (track->isReady()) { // check ready to prevent premature start.
6549 processVolume_l(track, last);
6550 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006551 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006552
Eric Laurentea0fade2013-10-04 16:23:48 -07006553 // make sure the pause/flush/resume sequence is executed in the right order.
6554 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
6555 // before flush and then resume HW. This can happen in case of pause/flush/resume
6556 // if resume is received before pause is executed.
Eric Laurentfd477972013-10-25 18:10:40 -07006557 if (!mStandby && (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006558 status_t result = mOutput->stream->pause();
6559 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006560 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006561 if (mFlushPending) {
6562 flushHw_l();
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006563 }
Eric Laurentfd477972013-10-25 18:10:40 -07006564 if (!mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006565 status_t result = mOutput->stream->resume();
6566 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006567 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006568
Eric Laurentbfb1b832013-01-07 09:53:42 -08006569 // remove all the tracks that need to be...
6570 removeTracks_l(*tracksToRemove);
6571
6572 return mixerStatus;
6573}
6574
Eric Laurentbfb1b832013-01-07 09:53:42 -08006575// must be called with thread mutex locked
6576bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
6577{
Eric Laurent3b4529e2013-09-05 18:09:19 -07006578 ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
6579 mWriteAckSequence, mDrainSequence);
6580 if (mUseAsyncWrite && ((mWriteAckSequence & 1) || (mDrainSequence & 1))) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006581 return true;
6582 }
6583 return false;
6584}
6585
Eric Laurentbfb1b832013-01-07 09:53:42 -08006586bool AudioFlinger::OffloadThread::waitingAsyncCallback()
6587{
6588 Mutex::Autolock _l(mLock);
6589 return waitingAsyncCallback_l();
6590}
6591
6592void AudioFlinger::OffloadThread::flushHw_l()
6593{
Eric Laurente659ef42014-09-29 13:06:46 -07006594 DirectOutputThread::flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08006595 // Flush anything still waiting in the mixbuffer
6596 mCurrentWriteLength = 0;
6597 mBytesRemaining = 0;
6598 mPausedWriteLength = 0;
6599 mPausedBytesRemaining = 0;
Eric Laurent3eaf66b2016-04-01 14:44:17 -07006600 // reset bytes written count to reflect that DSP buffers are empty after flush.
6601 mBytesWritten = 0;
Andy Hungf8044752016-07-27 14:58:11 -07006602 mOffloadUnderrunPosition = ~0LL;
Haynes Mathew George0f02f262014-01-11 13:03:57 -08006603
Eric Laurentbfb1b832013-01-07 09:53:42 -08006604 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006605 // discard any pending drain or write ack by incrementing sequence
6606 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
6607 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006608 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006609 mCallbackThread->setWriteBlocked(mWriteAckSequence);
6610 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006611 }
6612}
6613
Haynes Mathew George05317d22016-05-03 16:34:26 -07006614void AudioFlinger::OffloadThread::invalidateTracks(audio_stream_type_t streamType)
6615{
6616 Mutex::Autolock _l(mLock);
Eric Laurent13084622016-05-17 10:51:49 -07006617 if (PlaybackThread::invalidateTracks_l(streamType)) {
6618 mFlushPending = true;
6619 }
Haynes Mathew George05317d22016-05-03 16:34:26 -07006620}
6621
Eric Laurentbfb1b832013-01-07 09:53:42 -08006622// ----------------------------------------------------------------------------
6623
Eric Laurent81784c32012-11-19 14:55:58 -08006624AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurent72e3f392015-05-20 14:43:50 -07006625 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id, bool systemReady)
jiabin10d86fd2019-10-31 17:20:42 -07006626 : MixerThread(audioFlinger, mainThread->getOutput(), id,
Eric Laurent72e3f392015-05-20 14:43:50 -07006627 systemReady, DUPLICATING),
Eric Laurent81784c32012-11-19 14:55:58 -08006628 mWaitTimeMs(UINT_MAX)
6629{
6630 addOutputTrack(mainThread);
6631}
6632
6633AudioFlinger::DuplicatingThread::~DuplicatingThread()
6634{
6635 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6636 mOutputTracks[i]->destroy();
6637 }
6638}
6639
6640void AudioFlinger::DuplicatingThread::threadLoop_mix()
6641{
6642 // mix buffers...
6643 if (outputsReady(outputTracks)) {
Glenn Kastend79072e2016-01-06 08:41:20 -08006644 mAudioMixer->process();
Eric Laurent81784c32012-11-19 14:55:58 -08006645 } else {
Eric Laurent02b57082014-11-07 17:28:28 -08006646 if (mMixerBufferValid) {
6647 memset(mMixerBuffer, 0, mMixerBufferSize);
6648 } else {
6649 memset(mSinkBuffer, 0, mSinkBufferSize);
6650 }
Eric Laurent81784c32012-11-19 14:55:58 -08006651 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006652 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006653 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006654 mCurrentWriteLength = mSinkBufferSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006655 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006656}
6657
6658void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
6659{
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006660 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08006661 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006662 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006663 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006664 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006665 }
6666 } else if (mBytesWritten != 0) {
6667 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
6668 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006669 memset(mSinkBuffer, 0, mSinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08006670 } else {
6671 // flush remaining overflow buffers in output tracks
6672 writeFrames = 0;
6673 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006674 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006675 }
6676}
6677
Eric Laurentbfb1b832013-01-07 09:53:42 -08006678ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08006679{
6680 for (size_t i = 0; i < outputTracks.size(); i++) {
Andy Hung1c86ebe2018-05-29 20:29:08 -07006681 const ssize_t actualWritten = outputTracks[i]->write(mSinkBuffer, writeFrames);
6682
6683 // Consider the first OutputTrack for timestamp and frame counting.
6684
6685 // The threadLoop() generally assumes writing a full sink buffer size at a time.
6686 // Here, we correct for writeFrames of 0 (a stop) or underruns because
6687 // we always claim success.
6688 if (i == 0) {
6689 const ssize_t correction = mSinkBufferSize / mFrameSize - actualWritten;
6690 ALOGD_IF(correction != 0 && writeFrames != 0,
6691 "%s: writeFrames:%u actualWritten:%zd correction:%zd mFramesWritten:%lld",
6692 __func__, writeFrames, actualWritten, correction, (long long)mFramesWritten);
6693 mFramesWritten -= correction;
6694 }
6695
6696 // TODO: Report correction for the other output tracks and show in the dump.
Eric Laurent81784c32012-11-19 14:55:58 -08006697 }
Andy Hungcf10d742020-04-28 15:38:24 -07006698 if (mStandby) {
6699 mThreadMetrics.logBeginInterval();
6700 mStandby = false;
6701 }
Andy Hung25c2dac2014-02-27 14:56:00 -08006702 return (ssize_t)mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08006703}
6704
6705void AudioFlinger::DuplicatingThread::threadLoop_standby()
6706{
6707 // DuplicatingThread implements standby by stopping all tracks
6708 for (size_t i = 0; i < outputTracks.size(); i++) {
6709 outputTracks[i]->stop();
6710 }
6711}
6712
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006713void AudioFlinger::DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Andy Hung1bc088a2018-02-09 15:57:31 -08006714{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006715 MixerThread::dumpInternals_l(fd, args);
Andy Hung1bc088a2018-02-09 15:57:31 -08006716
6717 std::stringstream ss;
6718 const size_t numTracks = mOutputTracks.size();
6719 ss << " " << numTracks << " OutputTracks";
6720 if (numTracks > 0) {
6721 ss << ":";
6722 for (const auto &track : mOutputTracks) {
6723 const sp<ThreadBase> thread = track->thread().promote();
Andy Hungc0691382018-09-12 18:01:57 -07006724 ss << " (" << track->id() << " : ";
Andy Hung1bc088a2018-02-09 15:57:31 -08006725 if (thread.get() != nullptr) {
6726 ss << thread.get() << ", " << thread->id();
6727 } else {
6728 ss << "null";
6729 }
6730 ss << ")";
6731 }
6732 }
6733 ss << "\n";
6734 std::string result = ss.str();
6735 write(fd, result.c_str(), result.size());
6736}
6737
Eric Laurent81784c32012-11-19 14:55:58 -08006738void AudioFlinger::DuplicatingThread::saveOutputTracks()
6739{
6740 outputTracks = mOutputTracks;
6741}
6742
6743void AudioFlinger::DuplicatingThread::clearOutputTracks()
6744{
6745 outputTracks.clear();
6746}
6747
6748void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
6749{
6750 Mutex::Autolock _l(mLock);
Andy Hungc25b84a2015-01-14 19:04:10 -08006751 // The downstream MixerThread consumes thread->frameCount() amount of frames per mix pass.
6752 // Adjust for thread->sampleRate() to determine minimum buffer frame count.
6753 // Then triple buffer because Threads do not run synchronously and may not be clock locked.
6754 const size_t frameCount =
6755 3 * sourceFramesNeeded(mSampleRate, thread->frameCount(), thread->sampleRate());
6756 // TODO: Consider asynchronous sample rate conversion to handle clock disparity
6757 // from different OutputTracks and their associated MixerThreads (e.g. one may
6758 // nearly empty and the other may be dropping data).
6759
6760 sp<OutputTrack> outputTrack = new OutputTrack(thread,
Eric Laurent81784c32012-11-19 14:55:58 -08006761 this,
6762 mSampleRate,
Andy Hungc25b84a2015-01-14 19:04:10 -08006763 mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08006764 mChannelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08006765 frameCount,
6766 IPCThreadState::self()->getCallingUid());
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006767 status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
6768 if (status != NO_ERROR) {
6769 ALOGE("addOutputTrack() initCheck failed %d", status);
6770 return;
Eric Laurent81784c32012-11-19 14:55:58 -08006771 }
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006772 thread->setStreamVolume(AUDIO_STREAM_PATCH, 1.0f);
6773 mOutputTracks.add(outputTrack);
6774 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
6775 updateWaitTime_l();
Eric Laurent81784c32012-11-19 14:55:58 -08006776}
6777
6778void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
6779{
6780 Mutex::Autolock _l(mLock);
6781 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6782 if (mOutputTracks[i]->thread() == thread) {
6783 mOutputTracks[i]->destroy();
6784 mOutputTracks.removeAt(i);
6785 updateWaitTime_l();
Eric Laurentf6870ae2015-05-08 10:50:03 -07006786 if (thread->getOutput() == mOutput) {
6787 mOutput = NULL;
6788 }
Eric Laurent81784c32012-11-19 14:55:58 -08006789 return;
6790 }
6791 }
Eric Laurentf6870ae2015-05-08 10:50:03 -07006792 ALOGV("removeOutputTrack(): unknown thread: %p", thread);
Eric Laurent81784c32012-11-19 14:55:58 -08006793}
6794
6795// caller must hold mLock
6796void AudioFlinger::DuplicatingThread::updateWaitTime_l()
6797{
6798 mWaitTimeMs = UINT_MAX;
6799 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6800 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
6801 if (strong != 0) {
6802 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
6803 if (waitTimeMs < mWaitTimeMs) {
6804 mWaitTimeMs = waitTimeMs;
6805 }
6806 }
6807 }
6808}
6809
6810
6811bool AudioFlinger::DuplicatingThread::outputsReady(
6812 const SortedVector< sp<OutputTrack> > &outputTracks)
6813{
6814 for (size_t i = 0; i < outputTracks.size(); i++) {
6815 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
6816 if (thread == 0) {
6817 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
6818 outputTracks[i].get());
6819 return false;
6820 }
6821 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
6822 // see note at standby() declaration
6823 if (playbackThread->standby() && !playbackThread->isSuspended()) {
6824 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
6825 thread.get());
6826 return false;
6827 }
6828 }
6829 return true;
6830}
6831
Kevin Rocard12381092018-04-11 09:19:59 -07006832void AudioFlinger::DuplicatingThread::sendMetadataToBackend_l(
6833 const StreamOutHalInterface::SourceMetadata& metadata)
Kevin Rocard069c2712018-03-29 19:09:14 -07006834{
Kevin Rocard12381092018-04-11 09:19:59 -07006835 for (auto& outputTrack : outputTracks) { // not mOutputTracks
6836 outputTrack->setMetadatas(metadata.tracks);
6837 }
Kevin Rocard069c2712018-03-29 19:09:14 -07006838}
6839
Eric Laurent81784c32012-11-19 14:55:58 -08006840uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
6841{
6842 return (mWaitTimeMs * 1000) / 2;
6843}
6844
6845void AudioFlinger::DuplicatingThread::cacheParameters_l()
6846{
6847 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
6848 updateWaitTime_l();
6849
6850 MixerThread::cacheParameters_l();
6851}
6852
Eric Laurent6acd1d42017-01-04 14:23:29 -08006853
Eric Laurent81784c32012-11-19 14:55:58 -08006854// ----------------------------------------------------------------------------
6855// Record
6856// ----------------------------------------------------------------------------
6857
6858AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
6859 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08006860 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07006861 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08006862 ) :
Andy Hungcf10d742020-04-28 15:38:24 -07006863 ThreadBase(audioFlinger, id, RECORD, systemReady, false /* isOut */),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07006864 mInput(input),
Mikhail Naganovaf288872019-09-25 13:05:02 -07006865 mSource(mInput),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07006866 mActiveTracks(&this->mLocalLog),
6867 mRsmpInBuffer(NULL),
Glenn Kasten1b291842016-07-18 14:55:21 -07006868 // mRsmpInFrames, mRsmpInFramesP2, and mRsmpInFramesOA are set by readInputParameters_l()
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08006869 mRsmpInRear(0)
Glenn Kastenb880f5e2014-05-07 08:43:45 -07006870 , mReadOnlyHeap(new MemoryDealer(kRecordThreadReadOnlyHeapSize,
6871 "RecordThreadRO", MemoryHeapBase::READ_ONLY))
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006872 // mFastCapture below
6873 , mFastCaptureFutex(0)
6874 // mInputSource
6875 // mPipeSink
6876 // mPipeSource
6877 , mPipeFramesP2(0)
6878 // mPipeMemory
6879 // mFastCaptureNBLogWriter
Glenn Kasten6e6704c2014-07-03 10:20:00 -07006880 , mFastTrackAvail(false)
Eric Laurentd8365c52017-07-16 15:27:05 -07006881 , mBtNrecSuspended(false)
Eric Laurent81784c32012-11-19 14:55:58 -08006882{
Glenn Kastend7dca052015-03-05 16:05:54 -08006883 snprintf(mThreadName, kThreadNameLength, "AudioIn_%X", id);
6884 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08006885
George Burgess IVa8f90c12020-05-14 11:27:19 -07006886 if (mInput->audioHwDev != nullptr) {
Andy Hungc8fddf32018-08-08 18:32:37 -07006887 mIsMsdDevice = strcmp(
6888 mInput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
6889 }
6890
Glenn Kastendeca2ae2014-02-07 10:25:56 -08006891 readInputParameters_l();
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006892
Andy Hungc8fddf32018-08-08 18:32:37 -07006893 // TODO: We may also match on address as well as device type for
6894 // AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_IN_REMOTE_SUBMIX
jiabin10d86fd2019-10-31 17:20:42 -07006895 // TODO: This property should be ensure that only contains one single device type.
6896 mTimestampCorrectedDevice = (audio_devices_t)property_get_int64(
6897 "audio.timestamp.corrected_input_device",
Andy Hungc8fddf32018-08-08 18:32:37 -07006898 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_IN_BUS // turn on by default for MSD
6899 : AUDIO_DEVICE_NONE));
6900
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006901 // create an NBAIO source for the HAL input stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07006902 mInputSource = new AudioStreamInSource(input->stream);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006903 size_t numCounterOffers = 0;
6904 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006905#if !LOG_NDEBUG
6906 ssize_t index =
6907#else
6908 (void)
6909#endif
6910 mInputSource->negotiate(offers, 1, NULL, numCounterOffers);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006911 ALOG_ASSERT(index == 0);
6912
6913 // initialize fast capture depending on configuration
6914 bool initFastCapture;
6915 switch (kUseFastCapture) {
6916 case FastCapture_Never:
6917 initFastCapture = false;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006918 ALOGV("%p kUseFastCapture = Never, initFastCapture = false", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006919 break;
6920 case FastCapture_Always:
6921 initFastCapture = true;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006922 ALOGV("%p kUseFastCapture = Always, initFastCapture = true", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006923 break;
6924 case FastCapture_Static:
Glenn Kasteneb9487e2015-07-22 09:15:17 -07006925 initFastCapture = (mFrameCount * 1000) / mSampleRate < kMinNormalCaptureBufferSizeMs;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006926 ALOGV("%p kUseFastCapture = Static, (%lld * 1000) / %u vs %u, initFastCapture = %d",
6927 this, (long long)mFrameCount, mSampleRate, kMinNormalCaptureBufferSizeMs,
6928 initFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006929 break;
6930 // case FastCapture_Dynamic:
6931 }
6932
6933 if (initFastCapture) {
Glenn Kastend198b852015-03-16 14:55:53 -07006934 // create a Pipe for FastCapture to write to, and for us and fast tracks to read from
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006935 NBAIO_Format format = mInputSource->format();
Glenn Kasten1b291842016-07-18 14:55:21 -07006936 // quadruple-buffering of 20 ms each; this ensures we can sleep for 20ms in RecordThread
6937 size_t pipeFramesP2 = roundup(4 * FMS_20 * mSampleRate / 1000);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006938 size_t pipeSize = pipeFramesP2 * Format_frameSize(format);
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006939 void *pipeBuffer = nullptr;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006940 const sp<MemoryDealer> roHeap(readOnlyHeap());
6941 sp<IMemory> pipeMemory;
6942 if ((roHeap == 0) ||
6943 (pipeMemory = roHeap->allocate(pipeSize)) == 0 ||
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07006944 (pipeBuffer = pipeMemory->unsecurePointer()) == nullptr) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006945 ALOGE("not enough memory for pipe buffer size=%zu; "
6946 "roHeap=%p, pipeMemory=%p, pipeBuffer=%p; roHeapSize: %lld",
6947 pipeSize, roHeap.get(), pipeMemory.get(), pipeBuffer,
6948 (long long)kRecordThreadReadOnlyHeapSize);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006949 goto failed;
6950 }
6951 // pipe will be shared directly with fast clients, so clear to avoid leaking old information
6952 memset(pipeBuffer, 0, pipeSize);
6953 Pipe *pipe = new Pipe(pipeFramesP2, format, pipeBuffer);
6954 const NBAIO_Format offers[1] = {format};
6955 size_t numCounterOffers = 0;
6956 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
6957 ALOG_ASSERT(index == 0);
6958 mPipeSink = pipe;
6959 PipeReader *pipeReader = new PipeReader(*pipe);
6960 numCounterOffers = 0;
6961 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
6962 ALOG_ASSERT(index == 0);
6963 mPipeSource = pipeReader;
6964 mPipeFramesP2 = pipeFramesP2;
6965 mPipeMemory = pipeMemory;
6966
6967 // create fast capture
6968 mFastCapture = new FastCapture();
6969 FastCaptureStateQueue *sq = mFastCapture->sq();
6970#ifdef STATE_QUEUE_DUMP
6971 // FIXME
6972#endif
6973 FastCaptureState *state = sq->begin();
6974 state->mCblk = NULL;
6975 state->mInputSource = mInputSource.get();
6976 state->mInputSourceGen++;
6977 state->mPipeSink = pipe;
6978 state->mPipeSinkGen++;
6979 state->mFrameCount = mFrameCount;
6980 state->mCommand = FastCaptureState::COLD_IDLE;
6981 // already done in constructor initialization list
6982 //mFastCaptureFutex = 0;
6983 state->mColdFutexAddr = &mFastCaptureFutex;
6984 state->mColdGen++;
6985 state->mDumpState = &mFastCaptureDumpState;
6986#ifdef TEE_SINK
6987 // FIXME
6988#endif
6989 mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
6990 state->mNBLogWriter = mFastCaptureNBLogWriter.get();
6991 sq->end();
6992 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
6993
6994 // start the fast capture
6995 mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
6996 pid_t tid = mFastCapture->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07006997 sendPrioConfigEvent(getpid(), tid, kPriorityFastCapture, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08006998 stream()->setHalThreadPriority(kPriorityFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006999#ifdef AUDIO_WATCHDOG
7000 // FIXME
7001#endif
7002
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007003 mFastTrackAvail = true;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007004 }
Andy Hung8946a282018-04-19 20:04:56 -07007005#ifdef TEE_SINK
7006 mTee.set(mInputSource->format(), NBAIO_Tee::TEE_FLAG_INPUT_THREAD);
7007 mTee.setId(std::string("_") + std::to_string(mId) + "_C");
7008#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007009failed: ;
7010
7011 // FIXME mNormalSource
Eric Laurent81784c32012-11-19 14:55:58 -08007012}
7013
Eric Laurent81784c32012-11-19 14:55:58 -08007014AudioFlinger::RecordThread::~RecordThread()
7015{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007016 if (mFastCapture != 0) {
7017 FastCaptureStateQueue *sq = mFastCapture->sq();
7018 FastCaptureState *state = sq->begin();
7019 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7020 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7021 if (old == -1) {
7022 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7023 }
7024 }
7025 state->mCommand = FastCaptureState::EXIT;
7026 sq->end();
7027 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
7028 mFastCapture->join();
7029 mFastCapture.clear();
7030 }
7031 mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
Glenn Kasten481fb672013-09-30 14:39:28 -07007032 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung57446612015-04-19 23:56:46 -07007033 free(mRsmpInBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08007034}
7035
7036void AudioFlinger::RecordThread::onFirstRef()
7037{
Glenn Kastend7dca052015-03-05 16:05:54 -08007038 run(mThreadName, PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08007039}
7040
Eric Laurent555530a2017-02-07 18:17:24 -08007041void AudioFlinger::RecordThread::preExit()
7042{
7043 ALOGV(" preExit()");
7044 Mutex::Autolock _l(mLock);
7045 for (size_t i = 0; i < mTracks.size(); i++) {
7046 sp<RecordTrack> track = mTracks[i];
7047 track->invalidate();
7048 }
7049 mActiveTracks.clear();
7050 mStartStopCond.broadcast();
7051}
7052
Eric Laurent81784c32012-11-19 14:55:58 -08007053bool AudioFlinger::RecordThread::threadLoop()
7054{
Eric Laurent81784c32012-11-19 14:55:58 -08007055 nsecs_t lastWarning = 0;
7056
7057 inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08007058
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007059reacquire_wakelock:
7060 sp<RecordTrack> activeTrack;
7061 {
7062 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -07007063 acquireWakeLock_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007064 }
7065
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007066 // used to request a deferred sleep, to be executed later while mutex is unlocked
7067 uint32_t sleepUs = 0;
7068
Andy Hung446f4df2019-02-21 12:26:41 -08007069 int64_t lastLoopCountRead = -2; // never matches "previous" loop, when loopCount = 0.
7070
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007071 // loop while there is work to do
Andy Hung446f4df2019-02-21 12:26:41 -08007072 for (int64_t loopCount = 0;; ++loopCount) { // loopCount used for statistics tracking
Glenn Kastenc527a7c2013-08-13 15:43:49 -07007073 Vector< sp<EffectChain> > effectChains;
Glenn Kasten2cfbf882013-08-14 13:12:11 -07007074
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007075 // activeTracks accumulates a copy of a subset of mActiveTracks
7076 Vector< sp<RecordTrack> > activeTracks;
7077
Glenn Kasten735f45f2014-08-18 15:51:59 -07007078 // reference to the (first and only) active fast track
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007079 sp<RecordTrack> fastTrack;
Eric Laurent10351942014-05-08 18:49:52 -07007080
Glenn Kasten735f45f2014-08-18 15:51:59 -07007081 // reference to a fast track which is about to be removed
7082 sp<RecordTrack> fastTrackToRemove;
7083
Eric Laurent33403f02020-05-29 18:35:06 -07007084 bool silenceFastCapture = false;
7085
Eric Laurent81784c32012-11-19 14:55:58 -08007086 { // scope for mLock
7087 Mutex::Autolock _l(mLock);
Eric Laurent000a4192014-01-29 15:17:32 -08007088
Eric Laurent021cf962014-05-13 10:18:14 -07007089 processConfigEvents_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007090
Eric Laurent000a4192014-01-29 15:17:32 -08007091 // check exitPending here because checkForNewParameters_l() and
7092 // checkForNewParameters_l() can temporarily release mLock
7093 if (exitPending()) {
7094 break;
7095 }
7096
Eric Laurent5c25d562016-07-13 17:17:45 -07007097 // sleep with mutex unlocked
7098 if (sleepUs > 0) {
Glenn Kastenf9715e42016-07-13 14:02:03 -07007099 ATRACE_BEGIN("sleepC");
Eric Laurent5c25d562016-07-13 17:17:45 -07007100 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)sleepUs));
7101 ATRACE_END();
7102 sleepUs = 0;
7103 continue;
7104 }
7105
Glenn Kasten2b806402013-11-20 16:37:38 -08007106 // if no active track(s), then standby and release wakelock
7107 size_t size = mActiveTracks.size();
7108 if (size == 0) {
Glenn Kasten93e471f2013-08-19 08:40:07 -07007109 standbyIfNotAlreadyInStandby();
Glenn Kasten4ef0b462013-08-14 13:52:27 -07007110 // exitPending() can't become true here
Eric Laurent81784c32012-11-19 14:55:58 -08007111 releaseWakeLock_l();
7112 ALOGV("RecordThread: loop stopping");
7113 // go to sleep
7114 mWaitWorkCV.wait(mLock);
7115 ALOGV("RecordThread: loop starting");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007116 goto reacquire_wakelock;
7117 }
7118
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007119 bool doBroadcast = false;
Eric Laurent5c25d562016-07-13 17:17:45 -07007120 bool allStopped = true;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007121 for (size_t i = 0; i < size; ) {
Glenn Kasten9e982352013-08-14 14:39:50 -07007122
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007123 activeTrack = mActiveTracks[i];
7124 if (activeTrack->isTerminated()) {
Glenn Kasten735f45f2014-08-18 15:51:59 -07007125 if (activeTrack->isFastTrack()) {
7126 ALOG_ASSERT(fastTrackToRemove == 0);
7127 fastTrackToRemove = activeTrack;
7128 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007129 removeTrack_l(activeTrack);
Glenn Kasten2b806402013-11-20 16:37:38 -08007130 mActiveTracks.remove(activeTrack);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007131 size--;
Glenn Kasten9e982352013-08-14 14:39:50 -07007132 continue;
7133 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007134
7135 TrackBase::track_state activeTrackState = activeTrack->mState;
7136 switch (activeTrackState) {
7137
7138 case TrackBase::PAUSING:
7139 mActiveTracks.remove(activeTrack);
Andy Hungce685402018-10-05 17:23:27 -07007140 activeTrack->mState = TrackBase::PAUSED;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007141 doBroadcast = true;
7142 size--;
7143 continue;
7144
7145 case TrackBase::STARTING_1:
7146 sleepUs = 10000;
7147 i++;
Eric Laurent5c25d562016-07-13 17:17:45 -07007148 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007149 continue;
7150
7151 case TrackBase::STARTING_2:
7152 doBroadcast = true;
Andy Hungcf10d742020-04-28 15:38:24 -07007153 if (mStandby) {
7154 mThreadMetrics.logBeginInterval();
7155 mStandby = false;
7156 }
Glenn Kasten9e982352013-08-14 14:39:50 -07007157 activeTrack->mState = TrackBase::ACTIVE;
Eric Laurent5c25d562016-07-13 17:17:45 -07007158 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007159 break;
7160
7161 case TrackBase::ACTIVE:
Eric Laurent5c25d562016-07-13 17:17:45 -07007162 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007163 break;
7164
Andy Hungce685402018-10-05 17:23:27 -07007165 case TrackBase::IDLE: // cannot be on ActiveTracks if idle
7166 case TrackBase::PAUSED: // cannot be on ActiveTracks if paused
7167 case TrackBase::STOPPED: // cannot be on ActiveTracks if destroyed/terminated
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007168 default:
Andy Hungce685402018-10-05 17:23:27 -07007169 LOG_ALWAYS_FATAL("%s: Unexpected active track state:%d, id:%d, tracks:%zu",
7170 __func__, activeTrackState, activeTrack->id(), size);
Glenn Kasten9e982352013-08-14 14:39:50 -07007171 }
Glenn Kasten9e982352013-08-14 14:39:50 -07007172
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007173 if (activeTrack->isFastTrack()) {
7174 ALOG_ASSERT(!mFastTrackAvail);
7175 ALOG_ASSERT(fastTrack == 0);
Eric Laurent33403f02020-05-29 18:35:06 -07007176 // if the active fast track is silenced either:
7177 // 1) silence the whole capture from fast capture buffer if this is
7178 // the only active track
7179 // 2) invalidate this track: this will cause the client to reconnect and possibly
7180 // be invalidated again until unsilenced
7181 if (activeTrack->isSilenced()) {
7182 if (size > 1) {
7183 activeTrack->invalidate();
7184 ALOG_ASSERT(fastTrackToRemove == 0);
7185 fastTrackToRemove = activeTrack;
7186 removeTrack_l(activeTrack);
7187 mActiveTracks.remove(activeTrack);
7188 size--;
7189 continue;
7190 } else {
7191 silenceFastCapture = true;
7192 }
7193 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007194 fastTrack = activeTrack;
7195 }
Eric Laurent33403f02020-05-29 18:35:06 -07007196
7197 activeTracks.add(activeTrack);
7198 i++;
7199
Glenn Kasten9e982352013-08-14 14:39:50 -07007200 }
Eric Laurent5c25d562016-07-13 17:17:45 -07007201
Andy Hungdae27702016-10-31 14:01:16 -07007202 mActiveTracks.updatePowerState(this);
7203
Kevin Rocard069c2712018-03-29 19:09:14 -07007204 updateMetadata_l();
7205
Eric Laurent5c25d562016-07-13 17:17:45 -07007206 if (allStopped) {
7207 standbyIfNotAlreadyInStandby();
7208 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007209 if (doBroadcast) {
7210 mStartStopCond.broadcast();
7211 }
7212
7213 // sleep if there are no active tracks to process
Eric Tan39ec8d62018-07-24 09:49:29 -07007214 if (activeTracks.isEmpty()) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007215 if (sleepUs == 0) {
7216 sleepUs = kRecordThreadSleepUs;
7217 }
7218 continue;
7219 }
7220 sleepUs = 0;
Glenn Kasten9e982352013-08-14 14:39:50 -07007221
Eric Laurent81784c32012-11-19 14:55:58 -08007222 lockEffectChains_l(effectChains);
7223 }
7224
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007225 // thread mutex is now unlocked, mActiveTracks unknown, activeTracks.size() > 0
Glenn Kasten71652682013-08-14 15:17:55 -07007226
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007227 size_t size = effectChains.size();
7228 for (size_t i = 0; i < size; i++) {
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007229 // thread mutex is not locked, but effect chain is locked
7230 effectChains[i]->process_l();
7231 }
7232
Glenn Kasten735f45f2014-08-18 15:51:59 -07007233 // Push a new fast capture state if fast capture is not already running, or cblk change
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007234 if (mFastCapture != 0) {
7235 FastCaptureStateQueue *sq = mFastCapture->sq();
7236 FastCaptureState *state = sq->begin();
Glenn Kasten735f45f2014-08-18 15:51:59 -07007237 bool didModify = false;
7238 FastCaptureStateQueue::block_t block = FastCaptureStateQueue::BLOCK_UNTIL_PUSHED;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007239 if (state->mCommand != FastCaptureState::READ_WRITE /* FIXME &&
7240 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)*/) {
7241 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7242 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7243 if (old == -1) {
7244 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7245 }
7246 }
7247 state->mCommand = FastCaptureState::READ_WRITE;
7248#if 0 // FIXME
7249 mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08007250 FastThreadDumpState::kSamplingNforLowRamDevice :
7251 FastThreadDumpState::kSamplingN);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007252#endif
Glenn Kasten735f45f2014-08-18 15:51:59 -07007253 didModify = true;
7254 }
7255 audio_track_cblk_t *cblkOld = state->mCblk;
7256 audio_track_cblk_t *cblkNew = fastTrack != 0 ? fastTrack->cblk() : NULL;
7257 if (cblkNew != cblkOld) {
7258 state->mCblk = cblkNew;
7259 // block until acked if removing a fast track
7260 if (cblkOld != NULL) {
7261 block = FastCaptureStateQueue::BLOCK_UNTIL_ACKED;
7262 }
7263 didModify = true;
7264 }
jiabin01c8f562018-07-19 17:47:28 -07007265 AudioBufferProvider* abp = (fastTrack != 0 && fastTrack->isPatchTrack()) ?
7266 reinterpret_cast<AudioBufferProvider*>(fastTrack.get()) : nullptr;
7267 if (state->mFastPatchRecordBufferProvider != abp) {
7268 state->mFastPatchRecordBufferProvider = abp;
7269 state->mFastPatchRecordFormat = fastTrack == 0 ?
7270 AUDIO_FORMAT_INVALID : fastTrack->format();
7271 didModify = true;
7272 }
Eric Laurent33403f02020-05-29 18:35:06 -07007273 if (state->mSilenceCapture != silenceFastCapture) {
7274 state->mSilenceCapture = silenceFastCapture;
7275 didModify = true;
7276 }
Glenn Kasten735f45f2014-08-18 15:51:59 -07007277 sq->end(didModify);
7278 if (didModify) {
7279 sq->push(block);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007280#if 0
7281 if (kUseFastCapture == FastCapture_Dynamic) {
7282 mNormalSource = mPipeSource;
7283 }
7284#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007285 }
7286 }
7287
Glenn Kasten735f45f2014-08-18 15:51:59 -07007288 // now run the fast track destructor with thread mutex unlocked
7289 fastTrackToRemove.clear();
7290
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007291 // Read from HAL to keep up with fastest client if multiple active tracks, not slowest one.
7292 // Only the client(s) that are too slow will overrun. But if even the fastest client is too
7293 // slow, then this RecordThread will overrun by not calling HAL read often enough.
7294 // If destination is non-contiguous, first read past the nominal end of buffer, then
7295 // copy to the right place. Permitted because mRsmpInBuffer was over-allocated.
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007296
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007297 int32_t rear = mRsmpInRear & (mRsmpInFramesP2 - 1);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007298 ssize_t framesRead;
Andy Hung446f4df2019-02-21 12:26:41 -08007299 const int64_t lastIoBeginNs = systemTime(); // start IO timing
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007300
7301 // If an NBAIO source is present, use it to read the normal capture's data
7302 if (mPipeSource != 0) {
Andy Hung156317a2018-08-02 11:49:29 -07007303 size_t framesToRead = min(mRsmpInFramesOA - rear, mRsmpInFramesP2 / 2);
Andy Hungd5b638f2018-04-30 13:56:10 -07007304
7305 // The audio fifo read() returns OVERRUN on overflow, and advances the read pointer
7306 // to the full buffer point (clearing the overflow condition). Upon OVERRUN error,
7307 // we immediately retry the read() to get data and prevent another overflow.
7308 for (int retries = 0; retries <= 2; ++retries) {
7309 ALOGW_IF(retries > 0, "overrun on read from pipe, retry #%d", retries);
7310 framesRead = mPipeSource->read((uint8_t*)mRsmpInBuffer + rear * mFrameSize,
7311 framesToRead);
7312 if (framesRead != OVERRUN) break;
7313 }
7314
Andy Hung7a3dc6b2018-05-01 16:39:51 -07007315 const ssize_t availableToRead = mPipeSource->availableToRead();
7316 if (availableToRead >= 0) {
Glenn Kastena2f59b32020-08-03 16:37:24 -07007317 // PipeSource is the primary clock. It is up to the AudioRecord client to keep up.
Andy Hung7a3dc6b2018-05-01 16:39:51 -07007318 LOG_ALWAYS_FATAL_IF((size_t)availableToRead > mPipeFramesP2,
7319 "more frames to read than fifo size, %zd > %zu",
7320 availableToRead, mPipeFramesP2);
7321 const size_t pipeFramesFree = mPipeFramesP2 - availableToRead;
7322 const size_t sleepFrames = min(pipeFramesFree, mRsmpInFramesP2) / 2;
7323 ALOGVV("mPipeFramesP2:%zu mRsmpInFramesP2:%zu sleepFrames:%zu availableToRead:%zd",
7324 mPipeFramesP2, mRsmpInFramesP2, sleepFrames, availableToRead);
Glenn Kasten1b291842016-07-18 14:55:21 -07007325 sleepUs = (sleepFrames * 1000000LL) / mSampleRate;
7326 }
7327 if (framesRead < 0) {
7328 status_t status = (status_t) framesRead;
7329 switch (status) {
7330 case OVERRUN:
7331 ALOGW("overrun on read from pipe");
7332 framesRead = 0;
7333 break;
7334 case NEGOTIATE:
7335 ALOGE("re-negotiation is needed");
7336 framesRead = -1; // Will cause an attempt to recover.
7337 break;
7338 default:
7339 ALOGE("unknown error %d on read from pipe", status);
7340 break;
7341 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007342 }
7343 // otherwise use the HAL / AudioStreamIn directly
7344 } else {
Glenn Kastenec6a7032016-03-14 07:40:23 -07007345 ATRACE_BEGIN("read");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007346 size_t bytesRead;
Mikhail Naganovaf288872019-09-25 13:05:02 -07007347 status_t result = mSource->read(
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007348 (uint8_t*)mRsmpInBuffer + rear * mFrameSize, mBufferSize, &bytesRead);
Glenn Kastenec6a7032016-03-14 07:40:23 -07007349 ATRACE_END();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007350 if (result < 0) {
7351 framesRead = result;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007352 } else {
7353 framesRead = bytesRead / mFrameSize;
7354 }
7355 }
7356
Andy Hung446f4df2019-02-21 12:26:41 -08007357 const int64_t lastIoEndNs = systemTime(); // end IO timing
7358
Andy Hung3f0c9022016-01-15 17:49:46 -08007359 // Update server timestamp with server stats
7360 // systemTime() is optional if the hardware supports timestamps.
Andy Hung743f6402020-06-03 13:17:04 -07007361 if (framesRead >= 0) {
7362 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += framesRead;
7363 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = lastIoEndNs;
7364 }
Andy Hung3f0c9022016-01-15 17:49:46 -08007365
7366 // Update server timestamp with kernel stats
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007367 if (mPipeSource.get() == nullptr /* don't obtain for FastCapture, could block */) {
Andy Hung3f0c9022016-01-15 17:49:46 -08007368 int64_t position, time;
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007369 if (mStandby) {
7370 mTimestampVerifier.discontinuity();
Mikhail Naganovaf288872019-09-25 13:05:02 -07007371 } else if (mSource->getCapturePosition(&position, &time) == NO_ERROR
Andy Hungc8fddf32018-08-08 18:32:37 -07007372 && time > mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]) {
7373
7374 mTimestampVerifier.add(position, time, mSampleRate);
7375
7376 // Correct timestamps
7377 if (isTimestampCorrectionEnabled()) {
Dean Wheatley56a583e2020-05-08 15:12:17 +10007378 ALOGVV("TS_BEFORE: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07007379 id(), (long long)time, (long long)position);
7380 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
7381 position = correctedTimestamp.mFrames;
7382 time = correctedTimestamp.mTimeNs;
Dean Wheatley56a583e2020-05-08 15:12:17 +10007383 ALOGVV("TS_AFTER: %d %lld %lld",
Andy Hungc8fddf32018-08-08 18:32:37 -07007384 id(), (long long)time, (long long)position);
7385 }
7386
Andy Hung3f0c9022016-01-15 17:49:46 -08007387 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = position;
7388 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = time;
7389 // Note: In general record buffers should tend to be empty in
7390 // a properly running pipeline.
7391 //
7392 // Also, it is not advantageous to call get_presentation_position during the read
7393 // as the read obtains a lock, preventing the timestamp call from executing.
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007394 } else {
7395 mTimestampVerifier.error();
Andy Hung3f0c9022016-01-15 17:49:46 -08007396 }
7397 }
Andy Hunge6c37112019-02-26 17:38:10 -08007398
7399 // From the timestamp, input read latency is negative output write latency.
7400 const audio_input_flags_t flags = mInput != NULL ? mInput->flags : AUDIO_INPUT_FLAG_NONE;
7401 const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
7402 ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
7403 if (latencyMs != 0.) { // note 0. means timestamp is empty.
7404 mLatencyMs.add(latencyMs);
7405 }
7406
Andy Hung3f0c9022016-01-15 17:49:46 -08007407 // Use this to track timestamp information
7408 // ALOGD("%s", mTimestamp.toString().c_str());
7409
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007410 if (framesRead < 0 || (framesRead == 0 && mPipeSource == 0)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007411 ALOGE("read failed: framesRead=%zd", framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007412 // Force input into standby so that it tries to recover at next read attempt
7413 inputStandBy();
7414 sleepUs = kRecordThreadSleepUs;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007415 }
7416 if (framesRead <= 0) {
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007417 goto unlock;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007418 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007419 ALOG_ASSERT(framesRead > 0);
Andy Hung6427e442018-08-09 12:51:02 -07007420 mFramesRead += framesRead;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007421
Andy Hung8946a282018-04-19 20:04:56 -07007422#ifdef TEE_SINK
7423 (void)mTee.write((uint8_t*)mRsmpInBuffer + rear * mFrameSize, framesRead);
7424#endif
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007425 // If destination is non-contiguous, we now correct for reading past end of buffer.
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007426 {
7427 size_t part1 = mRsmpInFramesP2 - rear;
7428 if ((size_t) framesRead > part1) {
Andy Hung57446612015-04-19 23:56:46 -07007429 memcpy(mRsmpInBuffer, (uint8_t*)mRsmpInBuffer + mRsmpInFramesP2 * mFrameSize,
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007430 (framesRead - part1) * mFrameSize);
7431 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007432 }
Dean Wheatleyfd56e812020-11-06 22:32:21 +11007433 mRsmpInRear = audio_utils::safe_add_overflow(mRsmpInRear, (int32_t)framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007434
7435 size = activeTracks.size();
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007436
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007437 // loop over each active track
7438 for (size_t i = 0; i < size; i++) {
7439 activeTrack = activeTracks[i];
7440
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007441 // skip fast tracks, as those are handled directly by FastCapture
7442 if (activeTrack->isFastTrack()) {
7443 continue;
7444 }
7445
Andy Hung73c02e42015-03-29 01:13:58 -07007446 // TODO: This code probably should be moved to RecordTrack.
Andy Hung97a893e2015-03-29 01:03:07 -07007447 // TODO: Update the activeTrack buffer converter in case of reconfigure.
7448
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007449 enum {
7450 OVERRUN_UNKNOWN,
7451 OVERRUN_TRUE,
7452 OVERRUN_FALSE
7453 } overrun = OVERRUN_UNKNOWN;
7454
7455 // loop over getNextBuffer to handle circular sink
7456 for (;;) {
7457
7458 activeTrack->mSink.frameCount = ~0;
7459 status_t status = activeTrack->getNextBuffer(&activeTrack->mSink);
7460 size_t framesOut = activeTrack->mSink.frameCount;
7461 LOG_ALWAYS_FATAL_IF((status == OK) != (framesOut > 0));
7462
Andy Hung73c02e42015-03-29 01:13:58 -07007463 // check available frames and handle overrun conditions
7464 // if the record track isn't draining fast enough.
7465 bool hasOverrun;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007466 size_t framesIn;
Andy Hung73c02e42015-03-29 01:13:58 -07007467 activeTrack->mResamplerBufferProvider->sync(&framesIn, &hasOverrun);
7468 if (hasOverrun) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007469 overrun = OVERRUN_TRUE;
7470 }
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007471 if (framesOut == 0 || framesIn == 0) {
7472 break;
7473 }
7474
Andy Hung6770c6f2015-04-07 13:43:36 -07007475 // Don't allow framesOut to be larger than what is possible with resampling
7476 // from framesIn.
7477 // This isn't strictly necessary but helps limit buffer resizing in
7478 // RecordBufferConverter. TODO: remove when no longer needed.
7479 framesOut = min(framesOut,
7480 destinationFramesPossible(
7481 framesIn, mSampleRate, activeTrack->mSampleRate));
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007482
7483 if (activeTrack->isDirect()) {
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007484 // No RecordBufferConverter used for direct streams. Pass
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007485 // straight from RecordThread buffer to RecordTrack buffer.
7486 AudioBufferProvider::Buffer buffer;
7487 buffer.frameCount = framesOut;
7488 status_t status = activeTrack->mResamplerBufferProvider->getNextBuffer(&buffer);
7489 if (status == OK && buffer.frameCount != 0) {
7490 ALOGV_IF(buffer.frameCount != framesOut,
7491 "%s() read less than expected (%zu vs %zu)",
7492 __func__, buffer.frameCount, framesOut);
7493 framesOut = buffer.frameCount;
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007494 memcpy(activeTrack->mSink.raw, buffer.raw, buffer.frameCount * mFrameSize);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007495 activeTrack->mResamplerBufferProvider->releaseBuffer(&buffer);
7496 } else {
7497 framesOut = 0;
7498 ALOGE("%s() cannot fill request, status: %d, frameCount: %zu",
7499 __func__, status, buffer.frameCount);
7500 }
7501 } else {
7502 // process frames from the RecordThread buffer provider to the RecordTrack
7503 // buffer
7504 framesOut = activeTrack->mRecordBufferConverter->convert(
7505 activeTrack->mSink.raw,
7506 activeTrack->mResamplerBufferProvider,
7507 framesOut);
7508 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007509
7510 if (framesOut > 0 && (overrun == OVERRUN_UNKNOWN)) {
7511 overrun = OVERRUN_FALSE;
7512 }
7513
7514 if (activeTrack->mFramesToDrop == 0) {
7515 if (framesOut > 0) {
7516 activeTrack->mSink.frameCount = framesOut;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007517 // Sanitize before releasing if the track has no access to the source data
7518 // An idle UID receives silence from non virtual devices until active
7519 if (activeTrack->isSilenced()) {
Jean-Michel Trivib0de5692019-08-20 15:42:04 -07007520 memset(activeTrack->mSink.raw, 0, framesOut * activeTrack->frameSize());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007521 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007522 activeTrack->releaseBuffer(&activeTrack->mSink);
7523 }
7524 } else {
7525 // FIXME could do a partial drop of framesOut
7526 if (activeTrack->mFramesToDrop > 0) {
Mikhail Naganov6d91ba52019-03-26 14:35:28 -07007527 activeTrack->mFramesToDrop -= (ssize_t)framesOut;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007528 if (activeTrack->mFramesToDrop <= 0) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007529 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007530 }
7531 } else {
7532 activeTrack->mFramesToDrop += framesOut;
7533 if (activeTrack->mFramesToDrop >= 0 || activeTrack->mSyncStartEvent == 0 ||
7534 activeTrack->mSyncStartEvent->isCancelled()) {
7535 ALOGW("Synced record %s, session %d, trigger session %d",
7536 (activeTrack->mFramesToDrop >= 0) ? "timed out" : "cancelled",
7537 activeTrack->sessionId(),
7538 (activeTrack->mSyncStartEvent != 0) ?
Glenn Kastend848eb42016-03-08 13:42:11 -08007539 activeTrack->mSyncStartEvent->triggerSession() :
7540 AUDIO_SESSION_NONE);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007541 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007542 }
7543 }
7544 }
7545
7546 if (framesOut == 0) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007547 break;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007548 }
7549 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007550
7551 switch (overrun) {
7552 case OVERRUN_TRUE:
7553 // client isn't retrieving buffers fast enough
7554 if (!activeTrack->setOverflow()) {
7555 nsecs_t now = systemTime();
7556 // FIXME should lastWarning per track?
7557 if ((now - lastWarning) > kWarningThrottleNs) {
7558 ALOGW("RecordThread: buffer overflow");
7559 lastWarning = now;
7560 }
7561 }
7562 break;
7563 case OVERRUN_FALSE:
7564 activeTrack->clearOverflow();
7565 break;
7566 case OVERRUN_UNKNOWN:
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007567 break;
7568 }
7569
Andy Hung3f0c9022016-01-15 17:49:46 -08007570 // update frame information and push timestamp out
7571 activeTrack->updateTrackFrameInfo(
Andy Hung6ae58432016-02-16 18:32:24 -08007572 activeTrack->mServerProxy->framesReleased(),
Andy Hung3f0c9022016-01-15 17:49:46 -08007573 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER],
7574 mSampleRate, mTimestamp);
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007575 }
7576
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007577unlock:
Eric Laurent81784c32012-11-19 14:55:58 -08007578 // enable changes in effect chain
7579 unlockEffectChains(effectChains);
Glenn Kastenc527a7c2013-08-13 15:43:49 -07007580 // effectChains doesn't need to be cleared, since it is cleared by destructor at scope end
Eric Laurentcccbc762019-04-05 14:20:05 -07007581 if (audio_has_proportional_frames(mFormat)
7582 && loopCount == lastLoopCountRead + 1) {
7583 const int64_t readPeriodNs = lastIoEndNs - mLastIoEndNs;
7584 const double jitterMs =
7585 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
7586 {framesRead, readPeriodNs},
7587 {0, 0} /* lastTimestamp */, mSampleRate);
7588 const double processMs = (lastIoBeginNs - mLastIoEndNs) * 1e-6;
7589
7590 Mutex::Autolock _l(mLock);
7591 mIoJitterMs.add(jitterMs);
7592 mProcessTimeMs.add(processMs);
7593 }
7594 // update timing info.
7595 mLastIoBeginNs = lastIoBeginNs;
7596 mLastIoEndNs = lastIoEndNs;
7597 lastLoopCountRead = loopCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007598 }
7599
Glenn Kasten93e471f2013-08-19 08:40:07 -07007600 standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08007601
7602 {
7603 Mutex::Autolock _l(mLock);
Eric Laurent9a54bc22013-09-09 09:08:44 -07007604 for (size_t i = 0; i < mTracks.size(); i++) {
7605 sp<RecordTrack> track = mTracks[i];
7606 track->invalidate();
7607 }
Glenn Kasten2b806402013-11-20 16:37:38 -08007608 mActiveTracks.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08007609 mStartStopCond.broadcast();
7610 }
7611
7612 releaseWakeLock();
7613
7614 ALOGV("RecordThread %p exiting", this);
7615 return false;
7616}
7617
Glenn Kasten93e471f2013-08-19 08:40:07 -07007618void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
Eric Laurent81784c32012-11-19 14:55:58 -08007619{
7620 if (!mStandby) {
7621 inputStandBy();
Andy Hungcf10d742020-04-28 15:38:24 -07007622 mThreadMetrics.logEndInterval();
Eric Laurent81784c32012-11-19 14:55:58 -08007623 mStandby = true;
7624 }
7625}
7626
7627void AudioFlinger::RecordThread::inputStandBy()
7628{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007629 // Idle the fast capture if it's currently running
7630 if (mFastCapture != 0) {
7631 FastCaptureStateQueue *sq = mFastCapture->sq();
7632 FastCaptureState *state = sq->begin();
7633 if (!(state->mCommand & FastCaptureState::IDLE)) {
7634 state->mCommand = FastCaptureState::COLD_IDLE;
7635 state->mColdFutexAddr = &mFastCaptureFutex;
7636 state->mColdGen++;
7637 mFastCaptureFutex = 0;
7638 sq->end();
7639 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
7640 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_ACKED);
7641#if 0
7642 if (kUseFastCapture == FastCapture_Dynamic) {
7643 // FIXME
7644 }
7645#endif
7646#ifdef AUDIO_WATCHDOG
7647 // FIXME
7648#endif
7649 } else {
7650 sq->end(false /*didModify*/);
7651 }
7652 }
Mikhail Naganovaf288872019-09-25 13:05:02 -07007653 status_t result = mSource->standby();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007654 ALOGE_IF(result != OK, "Error when putting input stream into standby: %d", result);
Andy Hungad6d52d2016-07-18 13:42:03 -07007655
7656 // If going into standby, flush the pipe source.
7657 if (mPipeSource.get() != nullptr) {
7658 const ssize_t flushed = mPipeSource->flush();
7659 if (flushed > 0) {
7660 ALOGV("Input standby flushed PipeSource %zd frames", flushed);
7661 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += flushed;
7662 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = systemTime();
7663 }
7664 }
Eric Laurent81784c32012-11-19 14:55:58 -08007665}
7666
Glenn Kasten05997e22014-03-13 15:08:33 -07007667// RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
Glenn Kastene198c362013-08-13 09:13:36 -07007668sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
Eric Laurent81784c32012-11-19 14:55:58 -08007669 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007670 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007671 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08007672 audio_format_t format,
7673 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08007674 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08007675 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007676 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07007677 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -08007678 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07007679 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08007680 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08007681 status_t *status,
Jean-Michel Trivib0de5692019-08-20 15:42:04 -07007682 audio_port_handle_t portId,
7683 const String16& opPackageName)
Eric Laurent81784c32012-11-19 14:55:58 -08007684{
Glenn Kasten74935e42013-12-19 08:56:45 -08007685 size_t frameCount = *pFrameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007686 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007687 sp<RecordTrack> track;
7688 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07007689 audio_input_flags_t inputFlags = mInput->flags;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007690 audio_input_flags_t requestedFlags = *flags;
7691 uint32_t sampleRate;
7692
7693 lStatus = initCheck();
7694 if (lStatus != NO_ERROR) {
7695 ALOGE("createRecordTrack_l() audio driver not initialized");
7696 goto Exit;
7697 }
7698
Mikhail Naganovce9f2652018-07-16 11:09:24 -07007699 if (!audio_is_linear_pcm(mFormat) && (*flags & AUDIO_INPUT_FLAG_DIRECT) == 0) {
7700 ALOGE("createRecordTrack_l() on an encoded stream requires AUDIO_INPUT_FLAG_DIRECT");
7701 lStatus = BAD_VALUE;
7702 goto Exit;
7703 }
7704
Eric Laurentf14db3c2017-12-08 14:20:36 -08007705 if (*pSampleRate == 0) {
7706 *pSampleRate = mSampleRate;
7707 }
7708 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07007709
7710 // special case for FAST flag considered OK if fast capture is present
7711 if (hasFastCapture()) {
7712 inputFlags = (audio_input_flags_t)(inputFlags | AUDIO_INPUT_FLAG_FAST);
7713 }
7714
Eric Laurentf14db3c2017-12-08 14:20:36 -08007715 // Check if requested flags are compatible with input stream flags
Eric Laurent05067782016-06-01 18:27:28 -07007716 if ((*flags & inputFlags) != *flags) {
7717 ALOGW("createRecordTrack_l(): mismatch between requested flags (%08x) and"
7718 " input flags (%08x)",
7719 *flags, inputFlags);
7720 *flags = (audio_input_flags_t)(*flags & inputFlags);
7721 }
Eric Laurent81784c32012-11-19 14:55:58 -08007722
Glenn Kasten90e58b12013-07-31 16:16:02 -07007723 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07007724 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07007725 if (
Glenn Kastenb7fbf7e2015-03-18 12:57:28 -07007726 // we formerly checked for a callback handler (non-0 tid),
7727 // but that is no longer required for TRANSFER_OBTAIN mode
7728 //
Phil Burk7ed66a12019-04-18 13:20:30 -07007729 // Frame count is not specified (0), or is less than or equal the pipe depth.
7730 // It is OK to provide a higher capacity than requested.
7731 // We will force it to mPipeFramesP2 below.
7732 (frameCount <= mPipeFramesP2) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007733 // PCM data
7734 audio_is_linear_pcm(format) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007735 // hardware format
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007736 (format == mFormat) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007737 // hardware channel mask
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007738 (channelMask == mChannelMask) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007739 // hardware sample rate
Glenn Kasten90e58b12013-07-31 16:16:02 -07007740 (sampleRate == mSampleRate) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007741 // record thread has an associated fast capture
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007742 hasFastCapture() &&
7743 // there are sufficient fast track slots available
7744 mFastTrackAvail
Glenn Kasten90e58b12013-07-31 16:16:02 -07007745 ) {
Eric Laurent4c415062016-06-17 16:14:16 -07007746 // check compatibility with audio effects.
7747 Mutex::Autolock _l(mLock);
7748 // Do not accept FAST flag if the session has software effects
7749 sp<EffectChain> chain = getEffectChain_l(sessionId);
7750 if (chain != 0) {
Andy Hungd3bb0ad2016-10-11 17:16:43 -07007751 audio_input_flags_t old = *flags;
7752 chain->checkInputFlagCompatibility(flags);
7753 if (old != *flags) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007754 ALOGV("%p AUDIO_INPUT_FLAGS denied by effect old=%#x new=%#x",
7755 this, (int)old, (int)*flags);
Eric Laurent4c415062016-06-17 16:14:16 -07007756 }
7757 }
Eric Laurent122f7e72016-06-29 11:53:29 -07007758 ALOGV_IF((*flags & AUDIO_INPUT_FLAG_FAST) != 0,
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007759 "%p AUDIO_INPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
7760 this, frameCount, mFrameCount);
Glenn Kasten90e58b12013-07-31 16:16:02 -07007761 } else {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007762 ALOGV("%p AUDIO_INPUT_FLAG_FAST denied: frameCount=%zu mFrameCount=%zu mPipeFramesP2=%zu "
7763 "format=%#x isLinear=%d mFormat=%#x channelMask=%#x sampleRate=%u mSampleRate=%u "
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007764 "hasFastCapture=%d tid=%d mFastTrackAvail=%d",
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007765 this, frameCount, mFrameCount, mPipeFramesP2,
7766 format, audio_is_linear_pcm(format), mFormat, channelMask, sampleRate, mSampleRate,
Glenn Kasten74105912014-07-03 12:28:53 -07007767 hasFastCapture(), tid, mFastTrackAvail);
Eric Laurent05067782016-06-01 18:27:28 -07007768 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
Glenn Kasten74105912014-07-03 12:28:53 -07007769 }
7770 }
7771
Eric Laurentf14db3c2017-12-08 14:20:36 -08007772 // If FAST or RAW flags were corrected, ask caller to request new input from audio policy
7773 if ((*flags & AUDIO_INPUT_FLAG_FAST) !=
7774 (requestedFlags & AUDIO_INPUT_FLAG_FAST)) {
7775 *flags = (audio_input_flags_t) (*flags & ~(AUDIO_INPUT_FLAG_FAST | AUDIO_INPUT_FLAG_RAW));
7776 lStatus = BAD_TYPE;
7777 goto Exit;
7778 }
7779
Glenn Kasten74105912014-07-03 12:28:53 -07007780 // compute track buffer size in frames, and suggest the notification frame count
Eric Laurent05067782016-06-01 18:27:28 -07007781 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten74105912014-07-03 12:28:53 -07007782 // fast track: frame count is exactly the pipe depth
7783 frameCount = mPipeFramesP2;
7784 // ignore requested notificationFrames, and always notify exactly once every HAL buffer
Eric Laurentf14db3c2017-12-08 14:20:36 -08007785 notificationFrameCount = mFrameCount;
Glenn Kasten74105912014-07-03 12:28:53 -07007786 } else {
Glenn Kasten49d00ad2014-07-21 11:22:03 -07007787 // not fast track: max notification period is resampled equivalent of one HAL buffer time
7788 // or 20 ms if there is a fast capture
7789 // TODO This could be a roundupRatio inline, and const
7790 size_t maxNotificationFrames = ((int64_t) (hasFastCapture() ? mSampleRate/50 : mFrameCount)
7791 * sampleRate + mSampleRate - 1) / mSampleRate;
7792 // minimum number of notification periods is at least kMinNotifications,
7793 // and at least kMinMs rounded up to a whole notification period (minNotificationsByMs)
7794 static const size_t kMinNotifications = 3;
7795 static const uint32_t kMinMs = 30;
7796 // TODO This could be a roundupRatio inline
7797 const size_t minFramesByMs = (sampleRate * kMinMs + 1000 - 1) / 1000;
7798 // TODO This could be a roundupRatio inline
7799 const size_t minNotificationsByMs = (minFramesByMs + maxNotificationFrames - 1) /
7800 maxNotificationFrames;
7801 const size_t minFrameCount = maxNotificationFrames *
7802 max(kMinNotifications, minNotificationsByMs);
7803 frameCount = max(frameCount, minFrameCount);
Eric Laurentf14db3c2017-12-08 14:20:36 -08007804 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
7805 notificationFrameCount = maxNotificationFrames;
Glenn Kasten74105912014-07-03 12:28:53 -07007806 }
Glenn Kasten90e58b12013-07-31 16:16:02 -07007807 }
Glenn Kasten74935e42013-12-19 08:56:45 -08007808 *pFrameCount = frameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007809 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007810
7811 { // scope for mLock
7812 Mutex::Autolock _l(mLock);
7813
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007814 track = new RecordTrack(this, client, attr, sampleRate,
Andy Hung8fe68032017-06-05 16:17:51 -07007815 format, channelMask, frameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07007816 nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid, uid,
Jean-Michel Trivib0de5692019-08-20 15:42:04 -07007817 *flags, TrackBase::TYPE_DEFAULT, opPackageName, portId);
Eric Laurent81784c32012-11-19 14:55:58 -08007818
Glenn Kasten03003332013-08-06 15:40:54 -07007819 lStatus = track->initCheck();
7820 if (lStatus != NO_ERROR) {
Glenn Kasten35295072013-10-07 09:27:06 -07007821 ALOGE("createRecordTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08007822 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08007823 goto Exit;
7824 }
7825 mTracks.add(track);
7826
Eric Laurent05067782016-06-01 18:27:28 -07007827 if ((*flags & AUDIO_INPUT_FLAG_FAST) && (tid != -1)) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07007828 pid_t callingPid = IPCThreadState::self()->getCallingPid();
7829 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
7830 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07007831 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Glenn Kasten90e58b12013-07-31 16:16:02 -07007832 }
Eric Laurent81784c32012-11-19 14:55:58 -08007833 }
Glenn Kasten05997e22014-03-13 15:08:33 -07007834
Eric Laurent81784c32012-11-19 14:55:58 -08007835 lStatus = NO_ERROR;
7836
7837Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07007838 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08007839 return track;
7840}
7841
7842status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
7843 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08007844 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08007845{
7846 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
7847 sp<ThreadBase> strongMe = this;
7848 status_t status = NO_ERROR;
7849
7850 if (event == AudioSystem::SYNC_EVENT_NONE) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007851 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08007852 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007853 recordTrack->mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
Eric Laurent81784c32012-11-19 14:55:58 -08007854 triggerSession,
7855 recordTrack->sessionId(),
7856 syncStartEventCallback,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007857 recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08007858 // Sync event can be cancelled by the trigger session if the track is not in a
7859 // compatible state in which case we start record immediately
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007860 if (recordTrack->mSyncStartEvent->isCancelled()) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007861 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08007862 } else {
7863 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
Ivan Lozano1b35dd62017-12-06 16:55:10 -08007864 recordTrack->mFramesToDrop = -(ssize_t)
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007865 ((AudioSystem::kSyncRecordStartTimeOutMs * recordTrack->mSampleRate) / 1000);
Eric Laurent81784c32012-11-19 14:55:58 -08007866 }
7867 }
7868
7869 {
Glenn Kasten47c20702013-08-13 15:37:35 -07007870 // This section is a rendezvous between binder thread executing start() and RecordThread
Eric Laurent81784c32012-11-19 14:55:58 -08007871 AutoMutex lock(mLock);
Andy Hungce685402018-10-05 17:23:27 -07007872 if (recordTrack->isInvalid()) {
7873 recordTrack->clearSyncStartEvent();
7874 return INVALID_OPERATION;
7875 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007876 if (mActiveTracks.indexOf(recordTrack) >= 0) {
7877 if (recordTrack->mState == TrackBase::PAUSING) {
Andy Hungce685402018-10-05 17:23:27 -07007878 // We haven't stopped yet (moved to PAUSED and not in mActiveTracks)
7879 // so no need to startInput().
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007880 ALOGV("active record track PAUSING -> ACTIVE");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007881 recordTrack->mState = TrackBase::ACTIVE;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007882 } else {
7883 ALOGV("active record track state %d", recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08007884 }
7885 return status;
7886 }
7887
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007888 // TODO consider other ways of handling this, such as changing the state to :STARTING and
7889 // adding the track to mActiveTracks after returning from AudioSystem::startInput(),
7890 // or using a separate command thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007891 recordTrack->mState = TrackBase::STARTING_1;
Glenn Kasten2b806402013-11-20 16:37:38 -08007892 mActiveTracks.add(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07007893 status_t status = NO_ERROR;
7894 if (recordTrack->isExternalTrack()) {
7895 mLock.unlock();
Eric Laurent4eb58f12018-12-07 16:41:02 -08007896 status = AudioSystem::startInput(recordTrack->portId());
Eric Laurent83b88082014-06-20 18:31:16 -07007897 mLock.lock();
Andy Hungce685402018-10-05 17:23:27 -07007898 if (recordTrack->isInvalid()) {
7899 recordTrack->clearSyncStartEvent();
7900 if (status == NO_ERROR && recordTrack->mState == TrackBase::STARTING_1) {
7901 recordTrack->mState = TrackBase::STARTING_2;
7902 // STARTING_2 forces destroy to call stopInput.
7903 }
7904 return INVALID_OPERATION;
7905 }
7906 if (recordTrack->mState != TrackBase::STARTING_1) {
7907 ALOGW("%s(%d): unsynchronized mState:%d change",
7908 __func__, recordTrack->id(), recordTrack->mState);
7909 // Someone else has changed state, let them take over,
7910 // leave mState in the new state.
7911 recordTrack->clearSyncStartEvent();
7912 return INVALID_OPERATION;
7913 }
7914 // we're ok, but perhaps startInput has failed
Eric Laurent83b88082014-06-20 18:31:16 -07007915 if (status != NO_ERROR) {
Andy Hungce685402018-10-05 17:23:27 -07007916 ALOGW("%s(%d): startInput failed, status %d",
7917 __func__, recordTrack->id(), status);
7918 // We are in ActiveTracks if STARTING_1 and valid, so remove from ActiveTracks,
7919 // leave in STARTING_1, so destroy() will not call stopInput.
Eric Laurent83b88082014-06-20 18:31:16 -07007920 mActiveTracks.remove(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07007921 recordTrack->clearSyncStartEvent();
Eric Laurent83b88082014-06-20 18:31:16 -07007922 return status;
7923 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07007924 sendIoConfigEvent_l(
7925 AUDIO_CLIENT_STARTED, recordTrack->creatorPid(), recordTrack->portId());
Eric Laurent81784c32012-11-19 14:55:58 -08007926 }
Andy Hungc2b11cb2020-04-22 09:04:01 -07007927
7928 recordTrack->logBeginInterval(patchSourcesToString(&mPatch)); // log to MediaMetrics
7929
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007930 // Catch up with current buffer indices if thread is already running.
7931 // This is what makes a new client discard all buffered data. If the track's mRsmpInFront
7932 // was initialized to some value closer to the thread's mRsmpInFront, then the track could
7933 // see previously buffered data before it called start(), but with greater risk of overrun.
7934
Andy Hung73c02e42015-03-29 01:13:58 -07007935 recordTrack->mResamplerBufferProvider->reset();
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007936 if (!recordTrack->isDirect()) {
7937 // clear any converter state as new data will be discontinuous
7938 recordTrack->mRecordBufferConverter->reset();
7939 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007940 recordTrack->mState = TrackBase::STARTING_2;
Eric Laurent81784c32012-11-19 14:55:58 -08007941 // signal thread to start
Eric Laurent81784c32012-11-19 14:55:58 -08007942 mWaitWorkCV.broadcast();
Eric Laurent81784c32012-11-19 14:55:58 -08007943 return status;
7944 }
Eric Laurent81784c32012-11-19 14:55:58 -08007945}
7946
Eric Laurent81784c32012-11-19 14:55:58 -08007947void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
7948{
7949 sp<SyncEvent> strongEvent = event.promote();
7950
7951 if (strongEvent != 0) {
Eric Laurent8ea16e42014-02-20 16:26:11 -08007952 sp<RefBase> ptr = strongEvent->cookie().promote();
7953 if (ptr != 0) {
7954 RecordTrack *recordTrack = (RecordTrack *)ptr.get();
7955 recordTrack->handleSyncStartEvent(strongEvent);
7956 }
Eric Laurent81784c32012-11-19 14:55:58 -08007957 }
7958}
7959
Glenn Kastena8356f62013-07-25 14:37:52 -07007960bool AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
Eric Laurent81784c32012-11-19 14:55:58 -08007961 ALOGV("RecordThread::stop");
Glenn Kastena8356f62013-07-25 14:37:52 -07007962 AutoMutex _l(mLock);
Andy Hungce685402018-10-05 17:23:27 -07007963 // if we're invalid, we can't be on the ActiveTracks.
Jean-Michel Trivi38f86712017-04-11 14:10:17 -07007964 if (mActiveTracks.indexOf(recordTrack) < 0 || recordTrack->mState == TrackBase::PAUSING) {
Eric Laurent81784c32012-11-19 14:55:58 -08007965 return false;
7966 }
Glenn Kasten47c20702013-08-13 15:37:35 -07007967 // note that threadLoop may still be processing the track at this point [without lock]
Eric Laurent81784c32012-11-19 14:55:58 -08007968 recordTrack->mState = TrackBase::PAUSING;
Andy Hungce685402018-10-05 17:23:27 -07007969
Andy Hungabfab202019-03-07 19:45:54 -08007970 // NOTE: Waiting here is important to keep stop synchronous.
7971 // This is needed for proper patchRecord peer release.
Andy Hungce685402018-10-05 17:23:27 -07007972 while (recordTrack->mState == TrackBase::PAUSING && !recordTrack->isInvalid()) {
7973 mWaitWorkCV.broadcast(); // signal thread to stop
7974 mStartStopCond.wait(mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08007975 }
Andy Hungce685402018-10-05 17:23:27 -07007976
7977 if (recordTrack->mState == TrackBase::PAUSED) { // successful stop
Eric Laurent81784c32012-11-19 14:55:58 -08007978 ALOGV("Record stopped OK");
7979 return true;
7980 }
Andy Hungce685402018-10-05 17:23:27 -07007981
7982 // don't handle anything - we've been invalidated or restarted and in a different state
7983 ALOGW_IF("%s(%d): unsynchronized stop, state: %d",
7984 __func__, recordTrack->id(), recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08007985 return false;
7986}
7987
Glenn Kasten0f11b512014-01-31 16:18:54 -08007988bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08007989{
7990 return false;
7991}
7992
Glenn Kasten0f11b512014-01-31 16:18:54 -08007993status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08007994{
7995#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
7996 if (!isValidSyncEvent(event)) {
7997 return BAD_VALUE;
7998 }
7999
Glenn Kastend848eb42016-03-08 13:42:11 -08008000 audio_session_t eventSession = event->triggerSession();
Eric Laurent81784c32012-11-19 14:55:58 -08008001 status_t ret = NAME_NOT_FOUND;
8002
8003 Mutex::Autolock _l(mLock);
8004
8005 for (size_t i = 0; i < mTracks.size(); i++) {
8006 sp<RecordTrack> track = mTracks[i];
8007 if (eventSession == track->sessionId()) {
8008 (void) track->setSyncEvent(event);
8009 ret = NO_ERROR;
8010 }
8011 }
8012 return ret;
8013#else
8014 return BAD_VALUE;
8015#endif
8016}
8017
jiabin653cc0a2018-01-17 17:54:10 -08008018status_t AudioFlinger::RecordThread::getActiveMicrophones(
8019 std::vector<media::MicrophoneInfo>* activeMicrophones)
8020{
8021 ALOGV("RecordThread::getActiveMicrophones");
8022 AutoMutex _l(mLock);
jiabin9ff780e2018-03-19 18:19:52 -07008023 status_t status = mInput->stream->getActiveMicrophones(activeMicrophones);
8024 return status;
jiabin653cc0a2018-01-17 17:54:10 -08008025}
8026
Paul McLean12340082019-03-19 09:35:05 -06008027status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
8028 audio_microphone_direction_t direction)
Paul McLean03a6e6a2018-12-04 10:54:13 -07008029{
Paul McLean12340082019-03-19 09:35:05 -06008030 ALOGV("setPreferredMicrophoneDirection(%d)", direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008031 AutoMutex _l(mLock);
Paul McLean12340082019-03-19 09:35:05 -06008032 return mInput->stream->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008033}
8034
Paul McLean12340082019-03-19 09:35:05 -06008035status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
Paul McLean03a6e6a2018-12-04 10:54:13 -07008036{
Paul McLean12340082019-03-19 09:35:05 -06008037 ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008038 AutoMutex _l(mLock);
Paul McLean12340082019-03-19 09:35:05 -06008039 return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07008040}
8041
Kevin Rocard069c2712018-03-29 19:09:14 -07008042void AudioFlinger::RecordThread::updateMetadata_l()
8043{
8044 if (mInput == nullptr || mInput->stream == nullptr ||
8045 !mActiveTracks.readAndClearHasChanged()) {
8046 return;
8047 }
8048 StreamInHalInterface::SinkMetadata metadata;
8049 for (const sp<RecordTrack> &track : mActiveTracks) {
8050 // No track is invalid as this is called after prepareTrack_l in the same critical section
8051 metadata.tracks.push_back({
8052 .source = track->attributes().source,
8053 .gain = 1, // capture tracks do not have volumes
8054 });
8055 }
8056 mInput->stream->updateSinkMetadata(metadata);
8057}
8058
Eric Laurent81784c32012-11-19 14:55:58 -08008059// destroyTrack_l() must be called with ThreadBase::mLock held
8060void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
8061{
Eric Laurentbfb1b832013-01-07 09:53:42 -08008062 track->terminate();
8063 track->mState = TrackBase::STOPPED;
Eric Laurent81784c32012-11-19 14:55:58 -08008064 // active tracks are removed by threadLoop()
Glenn Kasten2b806402013-11-20 16:37:38 -08008065 if (mActiveTracks.indexOf(track) < 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08008066 removeTrack_l(track);
8067 }
8068}
8069
8070void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
8071{
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008072 String8 result;
8073 track->appendDump(result, false /* active */);
8074 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
8075
Eric Laurent81784c32012-11-19 14:55:58 -08008076 mTracks.remove(track);
8077 // need anything related to effects here?
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008078 if (track->isFastTrack()) {
8079 ALOG_ASSERT(!mFastTrackAvail);
8080 mFastTrackAvail = true;
8081 }
Eric Laurent81784c32012-11-19 14:55:58 -08008082}
8083
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07008084void AudioFlinger::RecordThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008085{
Mikhail Naganov913d06c2016-11-01 12:49:22 -07008086 AudioStreamIn *input = mInput;
8087 audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
8088 dprintf(fd, " AudioStreamIn: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08008089 input, flags, toString(flags).c_str());
Andy Hung6427e442018-08-09 12:51:02 -07008090 dprintf(fd, " Frames read: %lld\n", (long long)mFramesRead);
Eric Tan39ec8d62018-07-24 09:49:29 -07008091 if (mActiveTracks.isEmpty()) {
Elliott Hughes87cebad2014-05-22 10:14:43 -07008092 dprintf(fd, " No active record clients\n");
Eric Laurent81784c32012-11-19 14:55:58 -08008093 }
Andy Hungbfa64962017-06-12 14:43:19 -07008094
8095 if (input != nullptr) {
8096 dprintf(fd, " Hal stream dump:\n");
8097 (void)input->stream->dump(fd);
8098 }
8099
Glenn Kasten6e6704c2014-07-03 10:20:00 -07008100 dprintf(fd, " Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07008101 dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
Glenn Kasten17c9c992015-03-02 15:53:01 -08008102
Glenn Kasten2f90c512015-12-02 11:40:09 -08008103 // Make a non-atomic copy of fast capture dump state so it won't change underneath us
8104 // while we are dumping it. It may be inconsistent, but it won't mutate!
8105 // This is a large object so we place it on the heap.
8106 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07008107 const std::unique_ptr<FastCaptureDumpState> copy =
8108 std::make_unique<FastCaptureDumpState>(mFastCaptureDumpState);
Glenn Kasten2f90c512015-12-02 11:40:09 -08008109 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08008110}
8111
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07008112void AudioFlinger::RecordThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08008113{
Eric Laurent81784c32012-11-19 14:55:58 -08008114 String8 result;
Marco Nelissenb2208842014-02-07 14:00:50 -08008115 size_t numtracks = mTracks.size();
8116 size_t numactive = mActiveTracks.size();
8117 size_t numactiveseen = 0;
Glenn Kastenc42e9b42016-03-21 11:35:03 -07008118 dprintf(fd, " %zu Tracks", numtracks);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008119 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08008120 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07008121 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008122 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07008123 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08008124 for (size_t i = 0; i < numtracks ; ++i) {
8125 sp<RecordTrack> track = mTracks[i];
8126 if (track != 0) {
8127 bool active = mActiveTracks.indexOf(track) >= 0;
8128 if (active) {
8129 numactiveseen++;
8130 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008131 result.append(prefix);
8132 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08008133 }
Eric Laurent81784c32012-11-19 14:55:58 -08008134 }
Marco Nelissenb2208842014-02-07 14:00:50 -08008135 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -07008136 dprintf(fd, "\n");
Eric Laurent81784c32012-11-19 14:55:58 -08008137 }
8138
Marco Nelissenb2208842014-02-07 14:00:50 -08008139 if (numactiveseen != numactive) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008140 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08008141 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008142 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07008143 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08008144 for (size_t i = 0; i < numactive; ++i) {
Glenn Kasten2b806402013-11-20 16:37:38 -08008145 sp<RecordTrack> track = mActiveTracks[i];
Marco Nelissenb2208842014-02-07 14:00:50 -08008146 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008147 result.append(prefix);
8148 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08008149 }
Glenn Kasten2b806402013-11-20 16:37:38 -08008150 }
Eric Laurent81784c32012-11-19 14:55:58 -08008151
8152 }
8153 write(fd, result.string(), result.size());
8154}
8155
Eric Laurent5ada82e2019-08-29 17:53:54 -07008156void AudioFlinger::RecordThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008157{
8158 Mutex::Autolock _l(mLock);
8159 for (size_t i = 0; i < mTracks.size() ; i++) {
8160 sp<RecordTrack> track = mTracks[i];
Eric Laurent5ada82e2019-08-29 17:53:54 -07008161 if (track != 0 && track->portId() == portId) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08008162 track->setSilenced(silenced);
8163 }
8164 }
8165}
Andy Hung73c02e42015-03-29 01:13:58 -07008166
8167void AudioFlinger::RecordThread::ResamplerBufferProvider::reset()
8168{
8169 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
8170 RecordThread *recordThread = (RecordThread *) threadBase.get();
8171 mRsmpInFront = recordThread->mRsmpInRear;
8172 mRsmpInUnrel = 0;
8173}
8174
8175void AudioFlinger::RecordThread::ResamplerBufferProvider::sync(
8176 size_t *framesAvailable, bool *hasOverrun)
8177{
8178 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
8179 RecordThread *recordThread = (RecordThread *) threadBase.get();
8180 const int32_t rear = recordThread->mRsmpInRear;
8181 const int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07008182 const ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Andy Hung73c02e42015-03-29 01:13:58 -07008183
8184 size_t framesIn;
8185 bool overrun = false;
8186 if (filled < 0) {
8187 // should not happen, but treat like a massive overrun and re-sync
8188 framesIn = 0;
8189 mRsmpInFront = rear;
8190 overrun = true;
8191 } else if ((size_t) filled <= recordThread->mRsmpInFrames) {
8192 framesIn = (size_t) filled;
8193 } else {
8194 // client is not keeping up with server, but give it latest data
8195 framesIn = recordThread->mRsmpInFrames;
Hongwei Wang95e37682019-04-12 11:13:36 -07008196 mRsmpInFront = /* front = */ audio_utils::safe_sub_overflow(
8197 rear, static_cast<int32_t>(framesIn));
Andy Hung73c02e42015-03-29 01:13:58 -07008198 overrun = true;
8199 }
8200 if (framesAvailable != NULL) {
8201 *framesAvailable = framesIn;
8202 }
8203 if (hasOverrun != NULL) {
8204 *hasOverrun = overrun;
8205 }
8206}
8207
Eric Laurent81784c32012-11-19 14:55:58 -08008208// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008209status_t AudioFlinger::RecordThread::ResamplerBufferProvider::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08008210 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08008211{
Andy Hung73c02e42015-03-29 01:13:58 -07008212 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008213 if (threadBase == 0) {
8214 buffer->frameCount = 0;
Glenn Kasten607fa3e2014-02-21 14:24:58 -08008215 buffer->raw = NULL;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008216 return NOT_ENOUGH_DATA;
8217 }
8218 RecordThread *recordThread = (RecordThread *) threadBase.get();
8219 int32_t rear = recordThread->mRsmpInRear;
Andy Hung73c02e42015-03-29 01:13:58 -07008220 int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07008221 ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008222 // FIXME should not be P2 (don't want to increase latency)
8223 // FIXME if client not keeping up, discard
Glenn Kasten607fa3e2014-02-21 14:24:58 -08008224 LOG_ALWAYS_FATAL_IF(!(0 <= filled && (size_t) filled <= recordThread->mRsmpInFrames));
Glenn Kasten85948432013-08-19 12:09:05 -07008225 // 'filled' may be non-contiguous, so return only the first contiguous chunk
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008226 front &= recordThread->mRsmpInFramesP2 - 1;
8227 size_t part1 = recordThread->mRsmpInFramesP2 - front;
Glenn Kasten85948432013-08-19 12:09:05 -07008228 if (part1 > (size_t) filled) {
8229 part1 = filled;
8230 }
8231 size_t ask = buffer->frameCount;
8232 ALOG_ASSERT(ask > 0);
8233 if (part1 > ask) {
8234 part1 = ask;
8235 }
8236 if (part1 == 0) {
Andy Hung73c02e42015-03-29 01:13:58 -07008237 // out of data is fine since the resampler will return a short-count.
Glenn Kasten85948432013-08-19 12:09:05 -07008238 buffer->raw = NULL;
8239 buffer->frameCount = 0;
Andy Hung73c02e42015-03-29 01:13:58 -07008240 mRsmpInUnrel = 0;
Glenn Kasten85948432013-08-19 12:09:05 -07008241 return NOT_ENOUGH_DATA;
Eric Laurent81784c32012-11-19 14:55:58 -08008242 }
8243
Andy Hung57446612015-04-19 23:56:46 -07008244 buffer->raw = (uint8_t*)recordThread->mRsmpInBuffer + front * recordThread->mFrameSize;
Glenn Kasten85948432013-08-19 12:09:05 -07008245 buffer->frameCount = part1;
Andy Hung73c02e42015-03-29 01:13:58 -07008246 mRsmpInUnrel = part1;
Eric Laurent81784c32012-11-19 14:55:58 -08008247 return NO_ERROR;
8248}
8249
8250// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008251void AudioFlinger::RecordThread::ResamplerBufferProvider::releaseBuffer(
8252 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08008253{
Hongwei Wang95e37682019-04-12 11:13:36 -07008254 int32_t stepCount = static_cast<int32_t>(buffer->frameCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008255 if (stepCount == 0) {
8256 return;
8257 }
Andy Hung73c02e42015-03-29 01:13:58 -07008258 ALOG_ASSERT(stepCount <= mRsmpInUnrel);
8259 mRsmpInUnrel -= stepCount;
Hongwei Wang95e37682019-04-12 11:13:36 -07008260 mRsmpInFront = audio_utils::safe_add_overflow(mRsmpInFront, stepCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008261 buffer->raw = NULL;
Eric Laurent81784c32012-11-19 14:55:58 -08008262 buffer->frameCount = 0;
8263}
8264
Eric Laurentd8365c52017-07-16 15:27:05 -07008265void AudioFlinger::RecordThread::checkBtNrec()
8266{
8267 Mutex::Autolock _l(mLock);
8268 checkBtNrec_l();
8269}
8270
8271void AudioFlinger::RecordThread::checkBtNrec_l()
8272{
8273 // disable AEC and NS if the device is a BT SCO headset supporting those
8274 // pre processings
jiabin10d86fd2019-10-31 17:20:42 -07008275 bool suspend = audio_is_bluetooth_sco_device(inDeviceType()) &&
Eric Laurentd8365c52017-07-16 15:27:05 -07008276 mAudioFlinger->btNrecIsOff();
8277 if (mBtNrecSuspended.exchange(suspend) != suspend) {
8278 for (size_t i = 0; i < mEffectChains.size(); i++) {
8279 setEffectSuspended_l(FX_IID_AEC, suspend, mEffectChains[i]->sessionId());
8280 setEffectSuspended_l(FX_IID_NS, suspend, mEffectChains[i]->sessionId());
8281 }
8282 }
8283}
8284
Andy Hung97a893e2015-03-29 01:03:07 -07008285
Eric Laurent10351942014-05-08 18:49:52 -07008286bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
8287 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08008288{
8289 bool reconfig = false;
8290
Eric Laurent10351942014-05-08 18:49:52 -07008291 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08008292
Eric Laurent10351942014-05-08 18:49:52 -07008293 audio_format_t reqFormat = mFormat;
8294 uint32_t samplingRate = mSampleRate;
Glenn Kastene1635ec2015-06-08 15:46:49 -07008295 // 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 -07008296 audio_channel_mask_t channelMask = audio_channel_in_mask_from_count(mChannelCount);
8297
8298 AudioParameter param = AudioParameter(keyValuePair);
8299 int value;
Haynes Mathew George9ce67b52015-09-30 11:40:47 -07008300
8301 // scope for AutoPark extends to end of method
8302 AutoPark<FastCapture> park(mFastCapture);
8303
Eric Laurent10351942014-05-08 18:49:52 -07008304 // TODO Investigate when this code runs. Check with audio policy when a sample rate and
8305 // channel count change can be requested. Do we mandate the first client defines the
8306 // HAL sampling rate and channel count or do we allow changes on the fly?
8307 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
8308 samplingRate = value;
8309 reconfig = true;
8310 }
8311 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung97a893e2015-03-29 01:03:07 -07008312 if (!audio_is_linear_pcm((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07008313 status = BAD_VALUE;
8314 } else {
8315 reqFormat = (audio_format_t) value;
Eric Laurent81784c32012-11-19 14:55:58 -08008316 reconfig = true;
8317 }
Eric Laurent10351942014-05-08 18:49:52 -07008318 }
8319 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
8320 audio_channel_mask_t mask = (audio_channel_mask_t) value;
Andy Hungd330ee42015-04-20 13:23:41 -07008321 if (!audio_is_input_channel(mask) ||
8322 audio_channel_count_from_in_mask(mask) > FCC_8) {
Eric Laurent10351942014-05-08 18:49:52 -07008323 status = BAD_VALUE;
8324 } else {
8325 channelMask = mask;
8326 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008327 }
Eric Laurent10351942014-05-08 18:49:52 -07008328 }
8329 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
8330 // do not accept frame count changes if tracks are open as the track buffer
8331 // size depends on frame count and correct behavior would not be guaranteed
8332 // if frame count is changed after track creation
8333 if (mActiveTracks.size() > 0) {
8334 status = INVALID_OPERATION;
8335 } else {
8336 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008337 }
Eric Laurent10351942014-05-08 18:49:52 -07008338 }
8339 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabin10d86fd2019-10-31 17:20:42 -07008340 LOG_FATAL("Should not set routing device in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07008341 }
8342 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
8343 mAudioSource != (audio_source_t)value) {
jiabin10d86fd2019-10-31 17:20:42 -07008344 LOG_FATAL("Should not set audio source in RecordThread");
Eric Laurent10351942014-05-08 18:49:52 -07008345 }
Glenn Kastene198c362013-08-13 09:13:36 -07008346
Eric Laurent10351942014-05-08 18:49:52 -07008347 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008348 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008349 if (status == INVALID_OPERATION) {
8350 inputStandBy();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008351 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008352 }
8353 if (reconfig) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008354 if (status == BAD_VALUE) {
8355 uint32_t sRate;
8356 audio_channel_mask_t channelMask;
8357 audio_format_t format;
8358 if (mInput->stream->getAudioProperties(&sRate, &channelMask, &format) == OK &&
8359 audio_is_linear_pcm(format) && audio_is_linear_pcm(reqFormat) &&
8360 sRate <= (AUDIO_RESAMPLER_DOWN_RATIO_MAX * samplingRate) &&
8361 audio_channel_count_from_in_mask(channelMask) <= FCC_8) {
8362 status = NO_ERROR;
8363 }
Eric Laurent81784c32012-11-19 14:55:58 -08008364 }
Eric Laurent10351942014-05-08 18:49:52 -07008365 if (status == NO_ERROR) {
8366 readInputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07008367 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
Eric Laurent81784c32012-11-19 14:55:58 -08008368 }
8369 }
Eric Laurent81784c32012-11-19 14:55:58 -08008370 }
Eric Laurent10351942014-05-08 18:49:52 -07008371
Eric Laurent81784c32012-11-19 14:55:58 -08008372 return reconfig;
8373}
8374
8375String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
8376{
Eric Laurent81784c32012-11-19 14:55:58 -08008377 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008378 if (initCheck() == NO_ERROR) {
8379 String8 out_s8;
8380 if (mInput->stream->getParameters(keys, &out_s8) == OK) {
8381 return out_s8;
8382 }
Eric Laurent81784c32012-11-19 14:55:58 -08008383 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008384 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08008385}
8386
Eric Laurent09f1ed22019-04-24 17:45:17 -07008387void AudioFlinger::RecordThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
8388 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008389 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
8390
8391 desc->mIoHandle = mId;
Eric Laurent81784c32012-11-19 14:55:58 -08008392
8393 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008394 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07008395 case AUDIO_INPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07008396 case AUDIO_INPUT_CONFIG_CHANGED:
Eric Laurent296fb132015-05-01 11:38:42 -07008397 desc->mPatch = mPatch;
Eric Laurent73e26b62015-04-27 16:55:58 -07008398 desc->mChannelMask = mChannelMask;
8399 desc->mSamplingRate = mSampleRate;
8400 desc->mFormat = mFormat;
8401 desc->mFrameCount = mFrameCount;
Glenn Kasten4a8308b2016-04-18 14:10:01 -07008402 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07008403 desc->mLatency = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008404 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07008405 case AUDIO_CLIENT_STARTED:
8406 desc->mPatch = mPatch;
8407 desc->mPortId = portId;
8408 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07008409 case AUDIO_INPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08008410 default:
8411 break;
8412 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07008413 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08008414}
8415
Glenn Kastendeca2ae2014-02-07 10:25:56 -08008416void AudioFlinger::RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08008417{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008418 status_t result = mInput->stream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
8419 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
Andy Hung463be252014-07-10 16:56:07 -07008420 mFormat = mHALFormat;
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008421 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
8422 if (audio_is_linear_pcm(mFormat)) {
8423 LOG_ALWAYS_FATAL_IF(mChannelCount > FCC_8, "HAL channel count %d > %d",
8424 mChannelCount, FCC_8);
8425 } else {
8426 // Can have more that FCC_8 channels in encoded streams.
8427 ALOGI("HAL format %#x is not linear pcm", mFormat);
8428 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008429 result = mInput->stream->getFrameSize(&mFrameSize);
8430 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -07008431 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
8432 mFrameSize);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008433 result = mInput->stream->getBufferSize(&mBufferSize);
8434 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
Glenn Kasten548efc92012-11-29 08:48:51 -08008435 mFrameCount = mBufferSize / mFrameSize;
Hayden Gomes1a89ab32020-06-12 11:05:47 -07008436 ALOGV("%p RecordThread params: mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
8437 "mBufferSize=%zu, mFrameCount=%zu",
8438 this, mChannelCount, mFormat, mFrameSize, mBufferSize, mFrameCount);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008439 // This is the formula for calculating the temporary buffer size.
Glenn Kastene8426142014-02-28 16:45:03 -08008440 // With 7 HAL buffers, we can guarantee ability to down-sample the input by ratio of 6:1 to
Glenn Kasten85948432013-08-19 12:09:05 -07008441 // 1 full output buffer, regardless of the alignment of the available input.
Glenn Kastene8426142014-02-28 16:45:03 -08008442 // The value is somewhat arbitrary, and could probably be even larger.
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008443 // A larger value should allow more old data to be read after a track calls start(),
8444 // without increasing latency.
Andy Hung97a893e2015-03-29 01:03:07 -07008445 //
8446 // Note this is independent of the maximum downsampling ratio permitted for capture.
Glenn Kastene8426142014-02-28 16:45:03 -08008447 mRsmpInFrames = mFrameCount * 7;
Glenn Kasten85948432013-08-19 12:09:05 -07008448 mRsmpInFramesP2 = roundup(mRsmpInFrames);
Andy Hung57446612015-04-19 23:56:46 -07008449 free(mRsmpInBuffer);
Andy Hung0a01c2f2015-09-21 12:44:54 -07008450 mRsmpInBuffer = NULL;
Glenn Kasten49d00ad2014-07-21 11:22:03 -07008451
8452 // TODO optimize audio capture buffer sizes ...
8453 // Here we calculate the size of the sliding buffer used as a source
8454 // for resampling. mRsmpInFramesP2 is currently roundup(mFrameCount * 7).
8455 // For current HAL frame counts, this is usually 2048 = 40 ms. It would
8456 // be better to have it derived from the pipe depth in the long term.
8457 // The current value is higher than necessary. However it should not add to latency.
8458
Glenn Kasten85948432013-08-19 12:09:05 -07008459 // Over-allocate beyond mRsmpInFramesP2 to permit a HAL read past end of buffer
Glenn Kasten1b291842016-07-18 14:55:21 -07008460 mRsmpInFramesOA = mRsmpInFramesP2 + mFrameCount - 1;
8461 (void)posix_memalign(&mRsmpInBuffer, 32, mRsmpInFramesOA * mFrameSize);
Glenn Kastend3bb6452016-12-05 18:14:37 -08008462 // if posix_memalign fails, will segv here.
8463 memset(mRsmpInBuffer, 0, mRsmpInFramesOA * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08008464
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008465 // AudioRecord mSampleRate and mChannelCount are constant due to AudioRecord API constraints.
8466 // But if thread's mSampleRate or mChannelCount changes, how will that affect active tracks?
Andy Hungea840382020-05-05 21:50:17 -07008467
8468 audio_input_flags_t flags = mInput->flags;
8469 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
8470 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
8471 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
8472 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
8473 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
8474 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
8475 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
8476 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
8477 .record();
Eric Laurent81784c32012-11-19 14:55:58 -08008478}
8479
Glenn Kasten5f972c02014-01-13 09:59:31 -08008480uint32_t AudioFlinger::RecordThread::getInputFramesLost()
Eric Laurent81784c32012-11-19 14:55:58 -08008481{
8482 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008483 uint32_t result;
8484 if (initCheck() == NO_ERROR && mInput->stream->getInputFramesLost(&result) == OK) {
8485 return result;
Eric Laurent81784c32012-11-19 14:55:58 -08008486 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008487 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008488}
8489
Glenn Kastend848eb42016-03-08 13:42:11 -08008490KeyedVector<audio_session_t, bool> AudioFlinger::RecordThread::sessionIds() const
Eric Laurent81784c32012-11-19 14:55:58 -08008491{
Glenn Kastend848eb42016-03-08 13:42:11 -08008492 KeyedVector<audio_session_t, bool> ids;
Eric Laurent81784c32012-11-19 14:55:58 -08008493 Mutex::Autolock _l(mLock);
8494 for (size_t j = 0; j < mTracks.size(); ++j) {
8495 sp<RecordThread::RecordTrack> track = mTracks[j];
Glenn Kastend848eb42016-03-08 13:42:11 -08008496 audio_session_t sessionId = track->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08008497 if (ids.indexOfKey(sessionId) < 0) {
8498 ids.add(sessionId, true);
8499 }
8500 }
8501 return ids;
8502}
8503
8504AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
8505{
8506 Mutex::Autolock _l(mLock);
8507 AudioStreamIn *input = mInput;
8508 mInput = NULL;
8509 return input;
8510}
8511
8512// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008513sp<StreamHalInterface> AudioFlinger::RecordThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08008514{
8515 if (mInput == NULL) {
8516 return NULL;
8517 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008518 return mInput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08008519}
8520
8521status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
8522{
Eric Laurent81784c32012-11-19 14:55:58 -08008523 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
Eric Laurentaaa44472014-09-12 17:41:50 -07008524 chain->setThread(this);
Eric Laurent81784c32012-11-19 14:55:58 -08008525 chain->setInBuffer(NULL);
8526 chain->setOutBuffer(NULL);
8527
8528 checkSuspendOnAddEffectChain_l(chain);
8529
Eric Laurent1b928682014-10-02 19:41:47 -07008530 // make sure enabled pre processing effects state is communicated to the HAL as we
8531 // just moved them to a new input stream.
8532 chain->syncHalEffectsState();
8533
Eric Laurent81784c32012-11-19 14:55:58 -08008534 mEffectChains.add(chain);
8535
8536 return NO_ERROR;
8537}
8538
8539size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
8540{
8541 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008542
8543 for (size_t i = 0; i < mEffectChains.size(); i++) {
8544 if (chain == mEffectChains[i]) {
8545 mEffectChains.removeAt(i);
8546 break;
8547 }
Eric Laurent81784c32012-11-19 14:55:58 -08008548 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008549 return mEffectChains.size();
Eric Laurent81784c32012-11-19 14:55:58 -08008550}
8551
Eric Laurent1c333e22014-05-20 10:48:17 -07008552status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
8553 audio_patch_handle_t *handle)
8554{
8555 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008556
8557 // store new device and send to effects
jiabin10d86fd2019-10-31 17:20:42 -07008558 mInDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
8559 mInDeviceTypeAddr.mAddress = patch->sources[0].ext.device.address;
François Gaffie0c280aa2018-07-25 10:02:15 +02008560 audio_port_handle_t deviceId = patch->sources[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07008561 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabinb8269fd2019-11-11 12:16:27 -08008562 mEffectChains[i]->setInputDevice_l(inDeviceTypeAddr());
Eric Laurent054d9d32015-04-24 08:48:48 -07008563 }
8564
Eric Laurentd8365c52017-07-16 15:27:05 -07008565 checkBtNrec_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07008566
8567 // store new source and send to effects
8568 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
8569 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
Eric Laurent1c333e22014-05-20 10:48:17 -07008570 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurent054d9d32015-04-24 08:48:48 -07008571 mEffectChains[i]->setAudioSource_l(mAudioSource);
Eric Laurent1c333e22014-05-20 10:48:17 -07008572 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008573 }
Eric Laurent1c333e22014-05-20 10:48:17 -07008574
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008575 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008576 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8577 status = hwDevice->createAudioPatch(patch->num_sources,
8578 patch->sources,
8579 patch->num_sinks,
8580 patch->sinks,
8581 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008582 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008583 char *address;
8584 if (strcmp(patch->sources[0].ext.device.address, "") != 0) {
8585 address = audio_device_address_to_parameter(
8586 patch->sources[0].ext.device.type,
8587 patch->sources[0].ext.device.address);
8588 } else {
8589 address = (char *)calloc(1, 1);
8590 }
8591 AudioParameter param = AudioParameter(String8(address));
8592 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008593 param.addInt(String8(AudioParameter::keyRouting),
Eric Laurent054d9d32015-04-24 08:48:48 -07008594 (int)patch->sources[0].ext.device.type);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008595 param.addInt(String8(AudioParameter::keyInputSource),
Eric Laurent054d9d32015-04-24 08:48:48 -07008596 (int)patch->sinks[0].ext.mix.usecase.source);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008597 status = mInput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07008598 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07008599 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008600
jiabin10d86fd2019-10-31 17:20:42 -07008601 if ((mPatch.num_sources == 0) || (mPatch.sources[0].id != deviceId)) {
Eric Laurente8726fe2015-06-26 09:39:24 -07008602 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
jiabin10d86fd2019-10-31 17:20:42 -07008603 mPatch = *patch;
Eric Laurente8726fe2015-06-26 09:39:24 -07008604 }
Eric Laurent296fb132015-05-01 11:38:42 -07008605
Andy Hungc2b11cb2020-04-22 09:04:01 -07008606 const std::string pathSourcesAsString = patchSourcesToString(patch);
Andy Hungcf10d742020-04-28 15:38:24 -07008607 mThreadMetrics.logEndInterval();
Andy Hungea840382020-05-05 21:50:17 -07008608 mThreadMetrics.logCreatePatch(pathSourcesAsString, /* outDevices */ {});
Andy Hungcf10d742020-04-28 15:38:24 -07008609 mThreadMetrics.logBeginInterval();
Andy Hungc2b11cb2020-04-22 09:04:01 -07008610 // also dispatch to active AudioRecords
8611 for (const auto &track : mActiveTracks) {
8612 track->logEndInterval();
8613 track->logBeginInterval(pathSourcesAsString);
8614 }
Eric Laurent1c333e22014-05-20 10:48:17 -07008615 return status;
8616}
8617
8618status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
8619{
8620 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008621
jiabin10d86fd2019-10-31 17:20:42 -07008622 mPatch = audio_patch{};
8623 mInDeviceTypeAddr.reset();
Eric Laurent054d9d32015-04-24 08:48:48 -07008624
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008625 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008626 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8627 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008628 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008629 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07008630 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008631 status = mInput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07008632 }
8633 return status;
8634}
8635
jiabin10d86fd2019-10-31 17:20:42 -07008636void AudioFlinger::RecordThread::updateOutDevices(const DeviceDescriptorBaseVector& outDevices)
8637{
wendy lin56aa82b2020-12-02 15:19:55 +08008638 Mutex::Autolock _l(mLock);
jiabin10d86fd2019-10-31 17:20:42 -07008639 mOutDevices = outDevices;
8640 mOutDeviceTypeAddrs = deviceTypeAddrsFromDescriptors(mOutDevices);
8641 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabinb8269fd2019-11-11 12:16:27 -08008642 mEffectChains[i]->setDevices_l(outDeviceTypeAddrs());
jiabin10d86fd2019-10-31 17:20:42 -07008643 }
8644}
8645
Mikhail Naganov444ecc32018-05-01 17:40:05 -07008646void AudioFlinger::RecordThread::addPatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07008647{
8648 Mutex::Autolock _l(mLock);
8649 mTracks.add(record);
Mikhail Naganovaf288872019-09-25 13:05:02 -07008650 if (record->getSource()) {
8651 mSource = record->getSource();
8652 }
Eric Laurent83b88082014-06-20 18:31:16 -07008653}
8654
Mikhail Naganov444ecc32018-05-01 17:40:05 -07008655void AudioFlinger::RecordThread::deletePatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07008656{
8657 Mutex::Autolock _l(mLock);
Mikhail Naganovaf288872019-09-25 13:05:02 -07008658 if (mSource == record->getSource()) {
8659 mSource = mInput;
8660 }
Eric Laurent83b88082014-06-20 18:31:16 -07008661 destroyTrack_l(record);
8662}
8663
Mikhail Naganovdc769682018-05-04 15:34:08 -07008664void AudioFlinger::RecordThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07008665{
Mikhail Naganovdc769682018-05-04 15:34:08 -07008666 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07008667 config->role = AUDIO_PORT_ROLE_SINK;
8668 config->ext.mix.hw_module = mInput->audioHwDev->handle();
8669 config->ext.mix.usecase.source = mAudioSource;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07008670 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
8671 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
8672 config->flags.input = mInput->flags;
8673 }
Eric Laurent83b88082014-06-20 18:31:16 -07008674}
Eric Laurent1c333e22014-05-20 10:48:17 -07008675
Eric Laurent6acd1d42017-01-04 14:23:29 -08008676// ----------------------------------------------------------------------------
8677// Mmap
8678// ----------------------------------------------------------------------------
8679
8680AudioFlinger::MmapThreadHandle::MmapThreadHandle(const sp<MmapThread>& thread)
8681 : mThread(thread)
8682{
Phil Burk9fabbf82017-08-03 12:02:00 -07008683 assert(thread != 0); // thread must start non-null and stay non-null
Eric Laurent6acd1d42017-01-04 14:23:29 -08008684}
8685
8686AudioFlinger::MmapThreadHandle::~MmapThreadHandle()
8687{
Phil Burk9fabbf82017-08-03 12:02:00 -07008688 mThread->disconnect();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008689}
8690
8691status_t AudioFlinger::MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
8692 struct audio_mmap_buffer_info *info)
8693{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008694 return mThread->createMmapBuffer(minSizeFrames, info);
8695}
8696
8697status_t AudioFlinger::MmapThreadHandle::getMmapPosition(struct audio_mmap_position *position)
8698{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008699 return mThread->getMmapPosition(position);
8700}
8701
Eric Laurenta54f1282017-07-01 19:39:32 -07008702status_t AudioFlinger::MmapThreadHandle::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07008703 const audio_attributes_t *attr, audio_port_handle_t *handle)
Eric Laurent6acd1d42017-01-04 14:23:29 -08008704
8705{
jiabind1f1cb62020-03-24 11:57:57 -07008706 return mThread->start(client, attr, handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008707}
8708
8709status_t AudioFlinger::MmapThreadHandle::stop(audio_port_handle_t handle)
8710{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008711 return mThread->stop(handle);
8712}
8713
Eric Laurent18b57012017-02-13 16:23:52 -08008714status_t AudioFlinger::MmapThreadHandle::standby()
8715{
Eric Laurent18b57012017-02-13 16:23:52 -08008716 return mThread->standby();
8717}
8718
Eric Laurent6acd1d42017-01-04 14:23:29 -08008719
8720AudioFlinger::MmapThread::MmapThread(
8721 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -07008722 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, bool systemReady, bool isOut)
Andy Hungea840382020-05-05 21:50:17 -07008723 : ThreadBase(audioFlinger, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008724 mSessionId(AUDIO_SESSION_NONE),
François Gaffie0c280aa2018-07-25 10:02:15 +02008725 mPortId(AUDIO_PORT_HANDLE_NONE),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008726 mHalStream(stream), mHalDevice(hwDev->hwDevice()), mAudioHwDev(hwDev),
Eric Laurent67f97292018-04-20 18:05:41 -07008727 mActiveTracks(&this->mLocalLog),
8728 mHalVolFloat(-1.0f), // Initialize to illegal value so it always gets set properly later.
8729 mNoCallbackWarningCount(0)
Eric Laurent6acd1d42017-01-04 14:23:29 -08008730{
Eric Laurent18b57012017-02-13 16:23:52 -08008731 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008732 readHalParameters_l();
8733}
8734
8735AudioFlinger::MmapThread::~MmapThread()
8736{
Eric Laurent18b57012017-02-13 16:23:52 -08008737 releaseWakeLock_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008738}
8739
8740void AudioFlinger::MmapThread::onFirstRef()
8741{
8742 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
8743}
8744
8745void AudioFlinger::MmapThread::disconnect()
8746{
Eric Laurent331679c2018-04-16 17:03:16 -07008747 ActiveTracks<MmapTrack> activeTracks;
8748 {
8749 Mutex::Autolock _l(mLock);
8750 for (const sp<MmapTrack> &t : mActiveTracks) {
8751 activeTracks.add(t);
8752 }
8753 }
8754 for (const sp<MmapTrack> &t : activeTracks) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008755 stop(t->portId());
8756 }
Phil Burk9fabbf82017-08-03 12:02:00 -07008757 // This will decrement references and may cause the destruction of this thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08008758 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008759 AudioSystem::releaseOutput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008760 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008761 AudioSystem::releaseInput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008762 }
8763}
8764
8765
8766void AudioFlinger::MmapThread::configure(const audio_attributes_t *attr,
8767 audio_stream_type_t streamType __unused,
8768 audio_session_t sessionId,
8769 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008770 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08008771 audio_port_handle_t portId)
8772{
8773 mAttr = *attr;
8774 mSessionId = sessionId;
8775 mCallback = callback;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008776 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008777 mPortId = portId;
8778}
8779
8780status_t AudioFlinger::MmapThread::createMmapBuffer(int32_t minSizeFrames,
8781 struct audio_mmap_buffer_info *info)
8782{
8783 if (mHalStream == 0) {
8784 return NO_INIT;
8785 }
Eric Laurent18b57012017-02-13 16:23:52 -08008786 mStandby = true;
8787 acquireWakeLock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008788 return mHalStream->createMmapBuffer(minSizeFrames, info);
8789}
8790
8791status_t AudioFlinger::MmapThread::getMmapPosition(struct audio_mmap_position *position)
8792{
8793 if (mHalStream == 0) {
8794 return NO_INIT;
8795 }
8796 return mHalStream->getMmapPosition(position);
8797}
8798
Eric Laurent331679c2018-04-16 17:03:16 -07008799status_t AudioFlinger::MmapThread::exitStandby()
8800{
8801 status_t ret = mHalStream->start();
8802 if (ret != NO_ERROR) {
8803 ALOGE("%s: error mHalStream->start() = %d for first track", __FUNCTION__, ret);
8804 return ret;
8805 }
Andy Hungcf10d742020-04-28 15:38:24 -07008806 if (mStandby) {
8807 mThreadMetrics.logBeginInterval();
8808 mStandby = false;
8809 }
Eric Laurent331679c2018-04-16 17:03:16 -07008810 return NO_ERROR;
8811}
8812
Eric Laurenta54f1282017-07-01 19:39:32 -07008813status_t AudioFlinger::MmapThread::start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -07008814 const audio_attributes_t *attr,
Eric Laurent6acd1d42017-01-04 14:23:29 -08008815 audio_port_handle_t *handle)
8816{
Eric Laurenta54f1282017-07-01 19:39:32 -07008817 ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
8818 client.clientUid, mStandby, mPortId, *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008819 if (mHalStream == 0) {
8820 return NO_INIT;
8821 }
8822
8823 status_t ret;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008824
Eric Laurenta54f1282017-07-01 19:39:32 -07008825 if (*handle == mPortId) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008826 // for the first track, reuse portId and session allocated when the stream was opened
Eric Laurent331679c2018-04-16 17:03:16 -07008827 return exitStandby();
Eric Laurenta54f1282017-07-01 19:39:32 -07008828 }
8829
8830 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
8831
8832 audio_io_handle_t io = mId;
8833 if (isOutput()) {
8834 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
8835 config.sample_rate = mSampleRate;
8836 config.channel_mask = mChannelMask;
8837 config.format = mFormat;
8838 audio_stream_type_t stream = streamType();
8839 audio_output_flags_t flags =
8840 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008841 audio_port_handle_t deviceId = mDeviceId;
Kevin Rocard153f92d2018-12-18 18:33:28 -08008842 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurenta54f1282017-07-01 19:39:32 -07008843 ret = AudioSystem::getOutputForAttr(&mAttr, &io,
8844 mSessionId,
8845 &stream,
Nadav Bar766fb022018-01-07 12:18:03 +02008846 client.clientPid,
Eric Laurenta54f1282017-07-01 19:39:32 -07008847 client.clientUid,
8848 &config,
8849 flags,
8850 &deviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08008851 &portId,
8852 &secondaryOutputs);
8853 ALOGD_IF(!secondaryOutputs.empty(),
8854 "MmapThread::start does not support secondary outputs, ignoring them");
Eric Laurent6acd1d42017-01-04 14:23:29 -08008855 } else {
Eric Laurenta54f1282017-07-01 19:39:32 -07008856 audio_config_base_t config;
8857 config.sample_rate = mSampleRate;
8858 config.channel_mask = mChannelMask;
8859 config.format = mFormat;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008860 audio_port_handle_t deviceId = mDeviceId;
Eric Laurenta54f1282017-07-01 19:39:32 -07008861 ret = AudioSystem::getInputForAttr(&mAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -07008862 RECORD_RIID_INVALID,
Eric Laurenta54f1282017-07-01 19:39:32 -07008863 mSessionId,
8864 client.clientPid,
8865 client.clientUid,
Eric Laurentfee19762018-01-29 18:44:13 -08008866 client.packageName,
Eric Laurenta54f1282017-07-01 19:39:32 -07008867 &config,
8868 AUDIO_INPUT_FLAG_MMAP_NOIRQ,
8869 &deviceId,
8870 &portId);
8871 }
8872 // APM should not chose a different input or output stream for the same set of attributes
8873 // and audo configuration
8874 if (ret != NO_ERROR || io != mId) {
8875 ALOGE("%s: error getting output or input from APM (error %d, io %d expected io %d)",
8876 __FUNCTION__, ret, io, mId);
8877 return BAD_VALUE;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008878 }
8879
8880 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008881 ret = AudioSystem::startOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008882 } else {
Eric Laurent4eb58f12018-12-07 16:41:02 -08008883 ret = AudioSystem::startInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008884 }
8885
Eric Laurent331679c2018-04-16 17:03:16 -07008886 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008887 // abort if start is rejected by audio policy manager
8888 if (ret != NO_ERROR) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08008889 ALOGE("%s: error start rejected by AudioPolicyManager = %d", __FUNCTION__, ret);
Eric Tan39ec8d62018-07-24 09:49:29 -07008890 if (!mActiveTracks.isEmpty()) {
Eric Laurent331679c2018-04-16 17:03:16 -07008891 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008892 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008893 AudioSystem::releaseOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008894 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008895 AudioSystem::releaseInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008896 }
Eric Laurent331679c2018-04-16 17:03:16 -07008897 mLock.lock();
Eric Laurent18b57012017-02-13 16:23:52 -08008898 } else {
8899 mHalStream->stop();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008900 }
8901 return PERMISSION_DENIED;
8902 }
8903
Kevin Rocard1f564ac2018-03-29 13:53:10 -07008904 // Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
jiabind1f1cb62020-03-24 11:57:57 -07008905 sp<MmapTrack> track = new MmapTrack(this, attr == nullptr ? mAttr : *attr, mSampleRate, mFormat,
8906 mChannelMask, mSessionId, isOutput(), client.clientUid,
8907 client.clientPid, IPCThreadState::self()->getCallingPid(),
8908 portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008909
Eric Laurent4eb58f12018-12-07 16:41:02 -08008910 if (isOutput()) {
8911 // force volume update when a new track is added
8912 mHalVolFloat = -1.0f;
8913 } else if (!track->isSilenced_l()) {
8914 for (const sp<MmapTrack> &t : mActiveTracks) {
8915 if (t->isSilenced_l() && t->uid() != client.clientUid)
8916 t->invalidate();
8917 }
8918 }
8919
8920
Eric Laurent6acd1d42017-01-04 14:23:29 -08008921 mActiveTracks.add(track);
Eric Laurenta54f1282017-07-01 19:39:32 -07008922 sp<EffectChain> chain = getEffectChain_l(mSessionId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008923 if (chain != 0) {
8924 chain->setStrategy(AudioSystem::getStrategyForStream(streamType()));
8925 chain->incTrackCnt();
8926 chain->incActiveTrackCnt();
8927 }
8928
Andy Hungc2b11cb2020-04-22 09:04:01 -07008929 track->logBeginInterval(patchSinksToString(&mPatch)); // log to MediaMetrics
Eric Laurent6acd1d42017-01-04 14:23:29 -08008930 *handle = portId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008931 broadcast_l();
8932
Eric Laurenta54f1282017-07-01 19:39:32 -07008933 ALOGV("%s DONE handle %d stream %p", __FUNCTION__, *handle, mHalStream.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008934
8935 return NO_ERROR;
8936}
8937
8938status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
8939{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008940 ALOGV("%s handle %d", __FUNCTION__, handle);
8941
8942 if (mHalStream == 0) {
8943 return NO_INIT;
8944 }
8945
Eric Laurenta54f1282017-07-01 19:39:32 -07008946 if (handle == mPortId) {
8947 mHalStream->stop();
8948 return NO_ERROR;
8949 }
8950
Eric Laurent331679c2018-04-16 17:03:16 -07008951 Mutex::Autolock _l(mLock);
8952
Eric Laurent6acd1d42017-01-04 14:23:29 -08008953 sp<MmapTrack> track;
8954 for (const sp<MmapTrack> &t : mActiveTracks) {
8955 if (handle == t->portId()) {
8956 track = t;
8957 break;
8958 }
8959 }
8960 if (track == 0) {
8961 return BAD_VALUE;
8962 }
8963
8964 mActiveTracks.remove(track);
8965
Eric Laurent331679c2018-04-16 17:03:16 -07008966 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008967 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008968 AudioSystem::stopOutput(track->portId());
8969 AudioSystem::releaseOutput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008970 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008971 AudioSystem::stopInput(track->portId());
8972 AudioSystem::releaseInput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008973 }
Eric Laurent331679c2018-04-16 17:03:16 -07008974 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008975
8976 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
8977 if (chain != 0) {
8978 chain->decActiveTrackCnt();
8979 chain->decTrackCnt();
8980 }
8981
8982 broadcast_l();
8983
Eric Laurent6acd1d42017-01-04 14:23:29 -08008984 return NO_ERROR;
8985}
8986
Eric Laurent18b57012017-02-13 16:23:52 -08008987status_t AudioFlinger::MmapThread::standby()
8988{
8989 ALOGV("%s", __FUNCTION__);
8990
8991 if (mHalStream == 0) {
8992 return NO_INIT;
8993 }
Eric Tan39ec8d62018-07-24 09:49:29 -07008994 if (!mActiveTracks.isEmpty()) {
Eric Laurent18b57012017-02-13 16:23:52 -08008995 return INVALID_OPERATION;
8996 }
8997 mHalStream->standby();
Andy Hungcf10d742020-04-28 15:38:24 -07008998 if (!mStandby) {
8999 mThreadMetrics.logEndInterval();
9000 mStandby = true;
9001 }
Eric Laurent18b57012017-02-13 16:23:52 -08009002 releaseWakeLock();
9003 return NO_ERROR;
9004}
9005
Eric Laurent6acd1d42017-01-04 14:23:29 -08009006
9007void AudioFlinger::MmapThread::readHalParameters_l()
9008{
9009 status_t result = mHalStream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
9010 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
9011 mFormat = mHALFormat;
9012 LOG_ALWAYS_FATAL_IF(!audio_is_linear_pcm(mFormat), "HAL format %#x is not linear pcm", mFormat);
9013 result = mHalStream->getFrameSize(&mFrameSize);
9014 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
Hayden Gomes1a89ab32020-06-12 11:05:47 -07009015 LOG_ALWAYS_FATAL_IF(mFrameSize <= 0, "Error frame size was %zu but must be greater than zero",
9016 mFrameSize);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009017 result = mHalStream->getBufferSize(&mBufferSize);
9018 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
9019 mFrameCount = mBufferSize / mFrameSize;
Andy Hungc2b11cb2020-04-22 09:04:01 -07009020
Andy Hungcf10d742020-04-28 15:38:24 -07009021 // TODO: make a readHalParameters call?
9022 mediametrics::LogItem item(mThreadMetrics.getMetricsId());
Andy Hungc2b11cb2020-04-22 09:04:01 -07009023 item.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_READPARAMETERS)
9024 .set(AMEDIAMETRICS_PROP_ENCODING, formatToString(mFormat).c_str())
9025 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
9026 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
9027 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)mChannelCount)
9028 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
9029 /*
9030 .set(AMEDIAMETRICS_PROP_FLAGS, toString(flags).c_str())
9031 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELMASK,
9032 (int32_t)mHapticChannelMask)
9033 .set(AMEDIAMETRICS_PROP_PREFIX_HAPTIC AMEDIAMETRICS_PROP_CHANNELCOUNT,
9034 (int32_t)mHapticChannelCount)
9035 */
9036 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_ENCODING,
9037 formatToString(mHALFormat).c_str())
9038 .set(AMEDIAMETRICS_PROP_PREFIX_HAL AMEDIAMETRICS_PROP_FRAMECOUNT,
9039 (int32_t)mFrameCount) // sic - added HAL
9040 .record();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009041}
9042
9043bool AudioFlinger::MmapThread::threadLoop()
9044{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009045 checkSilentMode_l();
9046
9047 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
9048
9049 while (!exitPending())
9050 {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009051 Vector< sp<EffectChain> > effectChains;
9052
Andy Hung13850be2019-03-14 11:33:09 -07009053 { // under Thread lock
9054 Mutex::Autolock _l(mLock);
9055
Eric Laurent6acd1d42017-01-04 14:23:29 -08009056 if (mSignalPending) {
9057 // A signal was raised while we were unlocked
9058 mSignalPending = false;
9059 } else {
9060 if (mConfigEvents.isEmpty()) {
9061 // we're about to wait, flush the binder command buffer
9062 IPCThreadState::self()->flushCommands();
9063
9064 if (exitPending()) {
9065 break;
9066 }
9067
Eric Laurent6acd1d42017-01-04 14:23:29 -08009068 // wait until we have something to do...
9069 ALOGV("%s going to sleep", myName.string());
9070 mWaitWorkCV.wait(mLock);
9071 ALOGV("%s waking up", myName.string());
Eric Laurent6acd1d42017-01-04 14:23:29 -08009072
9073 checkSilentMode_l();
9074
9075 continue;
9076 }
9077 }
9078
9079 processConfigEvents_l();
9080
9081 processVolume_l();
9082
9083 checkInvalidTracks_l();
9084
9085 mActiveTracks.updatePowerState(this);
9086
Kevin Rocard069c2712018-03-29 19:09:14 -07009087 updateMetadata_l();
9088
Eric Laurent6acd1d42017-01-04 14:23:29 -08009089 lockEffectChains_l(effectChains);
Andy Hung13850be2019-03-14 11:33:09 -07009090 } // release Thread lock
9091
Eric Laurent6acd1d42017-01-04 14:23:29 -08009092 for (size_t i = 0; i < effectChains.size(); i ++) {
Andy Hung13850be2019-03-14 11:33:09 -07009093 effectChains[i]->process_l(); // Thread is not locked, but effect chain is locked
Eric Laurent6acd1d42017-01-04 14:23:29 -08009094 }
Andy Hung13850be2019-03-14 11:33:09 -07009095
9096 // enable changes in effect chain, including moving to another thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08009097 unlockEffectChains(effectChains);
9098 // Effect chains will be actually deleted here if they were removed from
9099 // mEffectChains list during mixing or effects processing
9100 }
9101
9102 threadLoop_exit();
9103
9104 if (!mStandby) {
9105 threadLoop_standby();
9106 mStandby = true;
9107 }
9108
Eric Laurent6acd1d42017-01-04 14:23:29 -08009109 ALOGV("Thread %p type %d exiting", this, mType);
9110 return false;
9111}
9112
9113// checkForNewParameter_l() must be called with ThreadBase::mLock held
9114bool AudioFlinger::MmapThread::checkForNewParameter_l(const String8& keyValuePair,
9115 status_t& status)
9116{
9117 AudioParameter param = AudioParameter(keyValuePair);
9118 int value;
Eric Laurente6e9a482017-07-25 19:26:02 -07009119 bool sendToHal = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009120 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
jiabin10d86fd2019-10-31 17:20:42 -07009121 LOG_FATAL("Should not happen set routing device in MmapThread");
Eric Laurent6acd1d42017-01-04 14:23:29 -08009122 }
Eric Laurente6e9a482017-07-25 19:26:02 -07009123 if (sendToHal) {
9124 status = mHalStream->setParameters(keyValuePair);
9125 } else {
9126 status = NO_ERROR;
9127 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009128
9129 return false;
9130}
9131
9132String8 AudioFlinger::MmapThread::getParameters(const String8& keys)
9133{
9134 Mutex::Autolock _l(mLock);
9135 String8 out_s8;
9136 if (initCheck() == NO_ERROR && mHalStream->getParameters(keys, &out_s8) == OK) {
9137 return out_s8;
9138 }
9139 return String8();
9140}
9141
Eric Laurent09f1ed22019-04-24 17:45:17 -07009142void AudioFlinger::MmapThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
9143 audio_port_handle_t portId __unused) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009144 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
9145
9146 desc->mIoHandle = mId;
9147
9148 switch (event) {
9149 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07009150 case AUDIO_INPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08009151 case AUDIO_INPUT_CONFIG_CHANGED:
9152 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07009153 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08009154 case AUDIO_OUTPUT_CONFIG_CHANGED:
9155 desc->mPatch = mPatch;
9156 desc->mChannelMask = mChannelMask;
9157 desc->mSamplingRate = mSampleRate;
9158 desc->mFormat = mFormat;
9159 desc->mFrameCount = mFrameCount;
9160 desc->mFrameCountHAL = mFrameCount;
9161 desc->mLatency = 0;
9162 break;
9163
9164 case AUDIO_INPUT_CLOSED:
9165 case AUDIO_OUTPUT_CLOSED:
9166 default:
9167 break;
9168 }
9169 mAudioFlinger->ioConfigChanged(event, desc, pid);
9170}
9171
9172status_t AudioFlinger::MmapThread::createAudioPatch_l(const struct audio_patch *patch,
9173 audio_patch_handle_t *handle)
9174{
9175 status_t status = NO_ERROR;
9176
9177 // store new device and send to effects
9178 audio_devices_t type = AUDIO_DEVICE_NONE;
9179 audio_port_handle_t deviceId;
jiabin10d86fd2019-10-31 17:20:42 -07009180 AudioDeviceTypeAddrVector sinkDeviceTypeAddrs;
9181 AudioDeviceTypeAddr sourceDeviceTypeAddr;
9182 uint32_t numDevices = 0;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009183 if (isOutput()) {
9184 for (unsigned int i = 0; i < patch->num_sinks; i++) {
jiabin10d86fd2019-10-31 17:20:42 -07009185 LOG_ALWAYS_FATAL_IF(popcount(patch->sinks[i].ext.device.type) > 1
9186 && !mAudioHwDev->supportsAudioPatches(),
9187 "Enumerated device type(%#x) must not be used "
9188 "as it does not support audio patches",
9189 patch->sinks[i].ext.device.type);
Mikhail Naganove3b59ac2020-10-01 15:08:13 -07009190 type = static_cast<audio_devices_t>(type | patch->sinks[i].ext.device.type);
jiabin10d86fd2019-10-31 17:20:42 -07009191 sinkDeviceTypeAddrs.push_back(AudioDeviceTypeAddr(patch->sinks[i].ext.device.type,
9192 patch->sinks[i].ext.device.address));
Eric Laurent6acd1d42017-01-04 14:23:29 -08009193 }
9194 deviceId = patch->sinks[0].id;
jiabin10d86fd2019-10-31 17:20:42 -07009195 numDevices = mPatch.num_sinks;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009196 } else {
9197 type = patch->sources[0].ext.device.type;
9198 deviceId = patch->sources[0].id;
jiabin10d86fd2019-10-31 17:20:42 -07009199 numDevices = mPatch.num_sources;
9200 sourceDeviceTypeAddr.mType = patch->sources[0].ext.device.type;
9201 sourceDeviceTypeAddr.mAddress = patch->sources[0].ext.device.address;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009202 }
9203
9204 for (size_t i = 0; i < mEffectChains.size(); i++) {
jiabinb8269fd2019-11-11 12:16:27 -08009205 if (isOutput()) {
9206 mEffectChains[i]->setDevices_l(sinkDeviceTypeAddrs);
9207 } else {
9208 mEffectChains[i]->setInputDevice_l(sourceDeviceTypeAddr);
9209 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009210 }
9211
jiabin10d86fd2019-10-31 17:20:42 -07009212 if (!isOutput()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009213 // store new source and send to effects
9214 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
9215 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
9216 for (size_t i = 0; i < mEffectChains.size(); i++) {
9217 mEffectChains[i]->setAudioSource_l(mAudioSource);
9218 }
9219 }
9220 }
9221
9222 if (mAudioHwDev->supportsAudioPatches()) {
9223 status = mHalDevice->createAudioPatch(patch->num_sources,
9224 patch->sources,
9225 patch->num_sinks,
9226 patch->sinks,
9227 handle);
9228 } else {
9229 char *address;
9230 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
9231 //FIXME: we only support address on first sink with HAL version < 3.0
9232 address = audio_device_address_to_parameter(
9233 patch->sinks[0].ext.device.type,
9234 patch->sinks[0].ext.device.address);
9235 } else {
9236 address = (char *)calloc(1, 1);
9237 }
9238 AudioParameter param = AudioParameter(String8(address));
9239 free(address);
9240 param.addInt(String8(AudioParameter::keyRouting), (int)type);
9241 if (!isOutput()) {
9242 param.addInt(String8(AudioParameter::keyInputSource),
9243 (int)patch->sinks[0].ext.mix.usecase.source);
9244 }
9245 status = mHalStream->setParameters(param.toString());
9246 *handle = AUDIO_PATCH_HANDLE_NONE;
9247 }
9248
jiabin10d86fd2019-10-31 17:20:42 -07009249 if (numDevices == 0 || mDeviceId != deviceId) {
9250 if (isOutput()) {
9251 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
9252 mOutDeviceTypeAddrs = sinkDeviceTypeAddrs;
jiabin0a957d32020-04-29 10:56:20 -07009253 checkSilentMode_l();
jiabin10d86fd2019-10-31 17:20:42 -07009254 } else {
9255 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
9256 mInDeviceTypeAddr = sourceDeviceTypeAddr;
9257 }
Phil Burk7f6b40d2017-02-09 13:18:38 -08009258 sp<MmapStreamCallback> callback = mCallback.promote();
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009259 if (mDeviceId != deviceId && callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07009260 mLock.unlock();
Phil Burk7f6b40d2017-02-09 13:18:38 -08009261 callback->onRoutingChanged(deviceId);
Eric Laurent734046e2018-04-16 14:50:52 -07009262 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009263 }
jiabin10d86fd2019-10-31 17:20:42 -07009264 mPatch = *patch;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009265 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009266 }
9267 return status;
9268}
9269
9270status_t AudioFlinger::MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
9271{
9272 status_t status = NO_ERROR;
9273
jiabin10d86fd2019-10-31 17:20:42 -07009274 mPatch = audio_patch{};
9275 mOutDeviceTypeAddrs.clear();
9276 mInDeviceTypeAddr.reset();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009277
9278 bool supportsAudioPatches = mHalDevice->supportsAudioPatches(&supportsAudioPatches) == OK ?
9279 supportsAudioPatches : false;
9280
9281 if (supportsAudioPatches) {
9282 status = mHalDevice->releaseAudioPatch(handle);
9283 } else {
9284 AudioParameter param;
9285 param.addInt(String8(AudioParameter::keyRouting), 0);
9286 status = mHalStream->setParameters(param.toString());
9287 }
9288 return status;
9289}
9290
Mikhail Naganovdc769682018-05-04 15:34:08 -07009291void AudioFlinger::MmapThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009292{
Mikhail Naganovdc769682018-05-04 15:34:08 -07009293 ThreadBase::toAudioPortConfig(config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009294 if (isOutput()) {
9295 config->role = AUDIO_PORT_ROLE_SOURCE;
9296 config->ext.mix.hw_module = mAudioHwDev->handle();
9297 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
9298 } else {
9299 config->role = AUDIO_PORT_ROLE_SINK;
9300 config->ext.mix.hw_module = mAudioHwDev->handle();
9301 config->ext.mix.usecase.source = mAudioSource;
9302 }
9303}
9304
9305status_t AudioFlinger::MmapThread::addEffectChain_l(const sp<EffectChain>& chain)
9306{
9307 audio_session_t session = chain->sessionId();
9308
9309 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
9310 // Attach all tracks with same session ID to this chain.
9311 // indicate all active tracks in the chain
9312 for (const sp<MmapTrack> &track : mActiveTracks) {
9313 if (session == track->sessionId()) {
9314 chain->incTrackCnt();
9315 chain->incActiveTrackCnt();
9316 }
9317 }
9318
9319 chain->setThread(this);
9320 chain->setInBuffer(nullptr);
9321 chain->setOutBuffer(nullptr);
9322 chain->syncHalEffectsState();
9323
9324 mEffectChains.add(chain);
9325 checkSuspendOnAddEffectChain_l(chain);
9326 return NO_ERROR;
9327}
9328
9329size_t AudioFlinger::MmapThread::removeEffectChain_l(const sp<EffectChain>& chain)
9330{
9331 audio_session_t session = chain->sessionId();
9332
9333 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
9334
9335 for (size_t i = 0; i < mEffectChains.size(); i++) {
9336 if (chain == mEffectChains[i]) {
9337 mEffectChains.removeAt(i);
9338 // detach all active tracks from the chain
9339 // detach all tracks with same session ID from this chain
9340 for (const sp<MmapTrack> &track : mActiveTracks) {
9341 if (session == track->sessionId()) {
9342 chain->decActiveTrackCnt();
9343 chain->decTrackCnt();
9344 }
9345 }
9346 break;
9347 }
9348 }
9349 return mEffectChains.size();
9350}
9351
Eric Laurent6acd1d42017-01-04 14:23:29 -08009352void AudioFlinger::MmapThread::threadLoop_standby()
9353{
9354 mHalStream->standby();
9355}
9356
9357void AudioFlinger::MmapThread::threadLoop_exit()
9358{
Phil Burk7dce7282017-09-27 13:51:41 -07009359 // Do not call callback->onTearDown() because it is redundant for thread exit
9360 // and because it can cause a recursive mutex lock on stop().
Eric Laurent6acd1d42017-01-04 14:23:29 -08009361}
9362
9363status_t AudioFlinger::MmapThread::setSyncEvent(const sp<SyncEvent>& event __unused)
9364{
9365 return BAD_VALUE;
9366}
9367
9368bool AudioFlinger::MmapThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
9369{
9370 return false;
9371}
9372
9373status_t AudioFlinger::MmapThread::checkEffectCompatibility_l(
9374 const effect_descriptor_t *desc, audio_session_t sessionId)
9375{
9376 // No global effect sessions on mmap threads
Eric Laurenta20c4e92019-11-12 15:55:51 -08009377 if (audio_is_global_session(sessionId)) {
9378 ALOGW("checkEffectCompatibility_l(): global effect %s on MMAP thread %s",
Eric Laurent6acd1d42017-01-04 14:23:29 -08009379 desc->name, mThreadName);
9380 return BAD_VALUE;
9381 }
9382
9383 if (!isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC)) {
9384 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on capture mmap thread",
9385 desc->name);
9386 return BAD_VALUE;
9387 }
9388 if (isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08009389 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback mmap "
9390 "thread", desc->name);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009391 return BAD_VALUE;
9392 }
9393
9394 // Only allow effects without processing load or latency
9395 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) != EFFECT_FLAG_NO_PROCESS) {
9396 return BAD_VALUE;
9397 }
9398
9399 return NO_ERROR;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009400}
9401
9402void AudioFlinger::MmapThread::checkInvalidTracks_l()
9403{
9404 for (const sp<MmapTrack> &track : mActiveTracks) {
9405 if (track->isInvalid()) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08009406 sp<MmapStreamCallback> callback = mCallback.promote();
9407 if (callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07009408 mLock.unlock();
Eric Laurent331679c2018-04-16 17:03:16 -07009409 callback->onTearDown(track->portId());
Eric Laurent734046e2018-04-16 14:50:52 -07009410 mLock.lock();
Eric Laurent331679c2018-04-16 17:03:16 -07009411 } else if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9412 ALOGW("Could not notify MMAP stream tear down: no onTearDown callback!");
9413 mNoCallbackWarningCount++;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009414 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009415 }
9416 }
9417}
9418
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009419void AudioFlinger::MmapThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009420{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009421 dprintf(fd, " Attributes: content type %d usage %d source %d\n",
9422 mAttr.content_type, mAttr.usage, mAttr.source);
9423 dprintf(fd, " Session: %d port Id: %d\n", mSessionId, mPortId);
Eric Tan39ec8d62018-07-24 09:49:29 -07009424 if (mActiveTracks.isEmpty()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009425 dprintf(fd, " No active clients\n");
9426 }
9427}
9428
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009429void AudioFlinger::MmapThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009430{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009431 String8 result;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009432 size_t numtracks = mActiveTracks.size();
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009433 dprintf(fd, " %zu Tracks\n", numtracks);
9434 const char *prefix = " ";
Eric Laurent6acd1d42017-01-04 14:23:29 -08009435 if (numtracks) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009436 result.append(prefix);
Kevin Rocard5f2136e2018-05-11 22:03:00 -07009437 mActiveTracks[0]->appendDumpHeader(result);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009438 for (size_t i = 0; i < numtracks ; ++i) {
9439 sp<MmapTrack> track = mActiveTracks[i];
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009440 result.append(prefix);
9441 track->appendDump(result, true /* active */);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009442 }
9443 } else {
9444 dprintf(fd, "\n");
9445 }
9446 write(fd, result.string(), result.size());
9447}
9448
9449AudioFlinger::MmapPlaybackThread::MmapPlaybackThread(
9450 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabin10d86fd2019-10-31 17:20:42 -07009451 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -07009452 : MmapThread(audioFlinger, id, hwDev, output->stream, systemReady, true /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -08009453 mStreamType(AUDIO_STREAM_MUSIC),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009454 mStreamVolume(1.0),
9455 mStreamMute(false),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009456 mOutput(output)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009457{
9458 snprintf(mThreadName, kThreadNameLength, "AudioMmapOut_%X", id);
9459 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
9460 mMasterVolume = audioFlinger->masterVolume_l();
9461 mMasterMute = audioFlinger->masterMute_l();
9462 if (mAudioHwDev) {
9463 if (mAudioHwDev->canSetMasterVolume()) {
9464 mMasterVolume = 1.0;
9465 }
9466
9467 if (mAudioHwDev->canSetMasterMute()) {
9468 mMasterMute = false;
9469 }
9470 }
9471}
9472
9473void AudioFlinger::MmapPlaybackThread::configure(const audio_attributes_t *attr,
9474 audio_stream_type_t streamType,
9475 audio_session_t sessionId,
9476 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009477 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009478 audio_port_handle_t portId)
9479{
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009480 MmapThread::configure(attr, streamType, sessionId, callback, deviceId, portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009481 mStreamType = streamType;
9482}
9483
9484AudioStreamOut* AudioFlinger::MmapPlaybackThread::clearOutput()
9485{
9486 Mutex::Autolock _l(mLock);
9487 AudioStreamOut *output = mOutput;
9488 mOutput = NULL;
9489 return output;
9490}
9491
9492void AudioFlinger::MmapPlaybackThread::setMasterVolume(float value)
9493{
9494 Mutex::Autolock _l(mLock);
9495 // Don't apply master volume in SW if our HAL can do it for us.
9496 if (mAudioHwDev &&
9497 mAudioHwDev->canSetMasterVolume()) {
9498 mMasterVolume = 1.0;
9499 } else {
9500 mMasterVolume = value;
9501 }
9502}
9503
9504void AudioFlinger::MmapPlaybackThread::setMasterMute(bool muted)
9505{
9506 Mutex::Autolock _l(mLock);
9507 // Don't apply master mute in SW if our HAL can do it for us.
9508 if (mAudioHwDev && mAudioHwDev->canSetMasterMute()) {
9509 mMasterMute = false;
9510 } else {
9511 mMasterMute = muted;
9512 }
9513}
9514
9515void AudioFlinger::MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
9516{
9517 Mutex::Autolock _l(mLock);
9518 if (stream == mStreamType) {
9519 mStreamVolume = value;
9520 broadcast_l();
9521 }
9522}
9523
9524float AudioFlinger::MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
9525{
9526 Mutex::Autolock _l(mLock);
9527 if (stream == mStreamType) {
9528 return mStreamVolume;
9529 }
9530 return 0.0f;
9531}
9532
9533void AudioFlinger::MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
9534{
9535 Mutex::Autolock _l(mLock);
9536 if (stream == mStreamType) {
9537 mStreamMute= muted;
9538 broadcast_l();
9539 }
9540}
9541
9542void AudioFlinger::MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
9543{
9544 Mutex::Autolock _l(mLock);
9545 if (streamType == mStreamType) {
9546 for (const sp<MmapTrack> &track : mActiveTracks) {
9547 track->invalidate();
9548 }
9549 broadcast_l();
9550 }
9551}
9552
9553void AudioFlinger::MmapPlaybackThread::processVolume_l()
9554{
9555 float volume;
9556
9557 if (mMasterMute || mStreamMute) {
9558 volume = 0;
9559 } else {
9560 volume = mMasterVolume * mStreamVolume;
9561 }
9562
9563 if (volume != mHalVolFloat) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009564
9565 // Convert volumes from float to 8.24
9566 uint32_t vol = (uint32_t)(volume * (1 << 24));
9567
9568 // Delegate volume control to effect in track effect chain if needed
9569 // only one effect chain can be present on DirectOutputThread, so if
9570 // there is one, the track is connected to it
9571 if (!mEffectChains.isEmpty()) {
9572 mEffectChains[0]->setVolume_l(&vol, &vol);
9573 volume = (float)vol / (1 << 24);
9574 }
Eric Laurentdff774a2017-04-21 15:29:38 -07009575 // Try to use HW volume control and fall back to SW control if not implemented
Phil Burk56ecf3e2018-03-12 15:38:17 -07009576 if (mOutput->stream->setVolume(volume, volume) == NO_ERROR) {
9577 mHalVolFloat = volume; // HW volume control worked, so update value.
9578 mNoCallbackWarningCount = 0;
9579 } else {
Eric Laurentdff774a2017-04-21 15:29:38 -07009580 sp<MmapStreamCallback> callback = mCallback.promote();
9581 if (callback != 0) {
9582 int channelCount;
9583 if (isOutput()) {
9584 channelCount = audio_channel_count_from_out_mask(mChannelMask);
9585 } else {
9586 channelCount = audio_channel_count_from_in_mask(mChannelMask);
9587 }
9588 Vector<float> values;
9589 for (int i = 0; i < channelCount; i++) {
9590 values.add(volume);
9591 }
Phil Burk56ecf3e2018-03-12 15:38:17 -07009592 mHalVolFloat = volume; // SW volume control worked, so update value.
9593 mNoCallbackWarningCount = 0;
Eric Laurent734046e2018-04-16 14:50:52 -07009594 mLock.unlock();
9595 callback->onVolumeChanged(mChannelMask, values);
9596 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009597 } else {
Phil Burk56ecf3e2018-03-12 15:38:17 -07009598 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9599 ALOGW("Could not set MMAP stream volume: no volume callback!");
9600 mNoCallbackWarningCount++;
9601 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009602 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009603 }
9604 }
9605}
9606
Kevin Rocard069c2712018-03-29 19:09:14 -07009607void AudioFlinger::MmapPlaybackThread::updateMetadata_l()
9608{
9609 if (mOutput == nullptr || mOutput->stream == nullptr ||
9610 !mActiveTracks.readAndClearHasChanged()) {
9611 return;
9612 }
9613 StreamOutHalInterface::SourceMetadata metadata;
9614 for (const sp<MmapTrack> &track : mActiveTracks) {
9615 // No track is invalid as this is called after prepareTrack_l in the same critical section
9616 metadata.tracks.push_back({
9617 .usage = track->attributes().usage,
9618 .content_type = track->attributes().content_type,
9619 .gain = mHalVolFloat, // TODO: propagate from aaudio pre-mix volume
9620 });
9621 }
9622 mOutput->stream->updateSourceMetadata(metadata);
9623}
9624
Eric Laurent6acd1d42017-01-04 14:23:29 -08009625void AudioFlinger::MmapPlaybackThread::checkSilentMode_l()
9626{
9627 if (!mMasterMute) {
9628 char value[PROPERTY_VALUE_MAX];
9629 if (property_get("ro.audio.silent", value, "0") > 0) {
9630 char *endptr;
9631 unsigned long ul = strtoul(value, &endptr, 0);
9632 if (*endptr == '\0' && ul != 0) {
9633 ALOGD("Silence is golden");
9634 // The setprop command will not allow a property to be changed after
9635 // the first time it is set, so we don't have to worry about un-muting.
9636 setMasterMute_l(true);
9637 }
9638 }
9639 }
9640}
9641
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009642void AudioFlinger::MmapPlaybackThread::toAudioPortConfig(struct audio_port_config *config)
9643{
9644 MmapThread::toAudioPortConfig(config);
9645 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
9646 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9647 config->flags.output = mOutput->flags;
9648 }
9649}
9650
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009651void AudioFlinger::MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009652{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009653 MmapThread::dumpInternals_l(fd, args);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009654
Glenn Kastend3bb6452016-12-05 18:14:37 -08009655 dprintf(fd, " Stream type: %d Stream volume: %f HAL volume: %f Stream mute %d\n",
9656 mStreamType, mStreamVolume, mHalVolFloat, mStreamMute);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009657 dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
9658}
9659
9660AudioFlinger::MmapCaptureThread::MmapCaptureThread(
9661 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabin10d86fd2019-10-31 17:20:42 -07009662 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady)
Andy Hungcf10d742020-04-28 15:38:24 -07009663 : MmapThread(audioFlinger, id, hwDev, input->stream, systemReady, false /* isOut */),
Eric Laurent6acd1d42017-01-04 14:23:29 -08009664 mInput(input)
9665{
9666 snprintf(mThreadName, kThreadNameLength, "AudioMmapIn_%X", id);
9667 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
9668}
9669
Eric Laurent331679c2018-04-16 17:03:16 -07009670status_t AudioFlinger::MmapCaptureThread::exitStandby()
9671{
Phil Burkf054fc32018-12-06 09:45:59 -08009672 {
9673 // mInput might have been cleared by clearInput()
9674 Mutex::Autolock _l(mLock);
9675 if (mInput != nullptr && mInput->stream != nullptr) {
9676 mInput->stream->setGain(1.0f);
9677 }
9678 }
Eric Laurent331679c2018-04-16 17:03:16 -07009679 return MmapThread::exitStandby();
9680}
9681
Eric Laurent6acd1d42017-01-04 14:23:29 -08009682AudioFlinger::AudioStreamIn* AudioFlinger::MmapCaptureThread::clearInput()
9683{
9684 Mutex::Autolock _l(mLock);
9685 AudioStreamIn *input = mInput;
9686 mInput = NULL;
9687 return input;
9688}
Kevin Rocard069c2712018-03-29 19:09:14 -07009689
Eric Laurent331679c2018-04-16 17:03:16 -07009690
9691void AudioFlinger::MmapCaptureThread::processVolume_l()
9692{
9693 bool changed = false;
9694 bool silenced = false;
9695
9696 sp<MmapStreamCallback> callback = mCallback.promote();
9697 if (callback == 0) {
9698 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9699 ALOGW("Could not set MMAP stream silenced: no onStreamSilenced callback!");
9700 mNoCallbackWarningCount++;
9701 }
9702 }
9703
9704 // After a change occurred in track silenced state, mute capture in audio DSP if at least one
9705 // track is silenced and unmute otherwise
9706 for (size_t i = 0; i < mActiveTracks.size() && !silenced; i++) {
9707 if (!mActiveTracks[i]->getAndSetSilencedNotified_l()) {
9708 changed = true;
9709 silenced = mActiveTracks[i]->isSilenced_l();
9710 }
9711 }
9712
9713 if (changed) {
9714 mInput->stream->setGain(silenced ? 0.0f: 1.0f);
9715 }
9716}
9717
Kevin Rocard069c2712018-03-29 19:09:14 -07009718void AudioFlinger::MmapCaptureThread::updateMetadata_l()
9719{
9720 if (mInput == nullptr || mInput->stream == nullptr ||
9721 !mActiveTracks.readAndClearHasChanged()) {
9722 return;
9723 }
9724 StreamInHalInterface::SinkMetadata metadata;
9725 for (const sp<MmapTrack> &track : mActiveTracks) {
9726 // No track is invalid as this is called after prepareTrack_l in the same critical section
9727 metadata.tracks.push_back({
9728 .source = track->attributes().source,
9729 .gain = 1, // capture tracks do not have volumes
9730 });
9731 }
9732 mInput->stream->updateSinkMetadata(metadata);
9733}
9734
Eric Laurent5ada82e2019-08-29 17:53:54 -07009735void AudioFlinger::MmapCaptureThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Eric Laurent331679c2018-04-16 17:03:16 -07009736{
9737 Mutex::Autolock _l(mLock);
9738 for (size_t i = 0; i < mActiveTracks.size() ; i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07009739 if (mActiveTracks[i]->portId() == portId) {
Eric Laurent331679c2018-04-16 17:03:16 -07009740 mActiveTracks[i]->setSilenced_l(silenced);
9741 broadcast_l();
9742 }
9743 }
9744}
9745
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009746void AudioFlinger::MmapCaptureThread::toAudioPortConfig(struct audio_port_config *config)
9747{
9748 MmapThread::toAudioPortConfig(config);
9749 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
9750 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9751 config->flags.input = mInput->flags;
9752 }
9753}
9754
Glenn Kasten63238ef2015-03-02 15:50:29 -08009755} // namespace android