blob: 2e6037b03dbeda467b6759e80627c284ce284363 [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>
27#include <string>
Glenn Kastenad8510a2015-02-17 16:24:07 -080028#include <linux/futex.h>
Eric Laurent81784c32012-11-19 14:55:58 -080029#include <sys/stat.h>
Glenn Kastenad8510a2015-02-17 16:24:07 -080030#include <sys/syscall.h>
Eric Laurent81784c32012-11-19 14:55:58 -080031#include <cutils/properties.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070032#include <media/AudioParameter.h>
Andy Hungcd044842014-08-07 11:04:34 -070033#include <media/AudioResamplerPublic.h>
Andy Hung89816052017-01-11 17:08:23 -080034#include <media/RecordBufferConverter.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070035#include <media/TypeConverter.h>
Eric Laurent81784c32012-11-19 14:55:58 -080036#include <utils/Log.h>
Alex Ray371eb972012-11-30 11:11:54 -080037#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080038
39#include <private/media/AudioTrackShared.h>
Wei Jiaf2ae3e12016-10-27 17:10:59 -070040#include <private/android_filesystem_config.h>
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +010041#include <audio_utils/Balance.h>
jiabin245cdd92018-12-07 17:55:15 -080042#include <audio_utils/channels.h>
Glenn Kasten6bf707f2017-02-23 16:53:58 -080043#include <audio_utils/mono_blend.h>
Eric Laurent81784c32012-11-19 14:55:58 -080044#include <audio_utils/primitives.h>
Andy Hung98ef9782014-03-04 14:46:50 -080045#include <audio_utils/format.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070046#include <audio_utils/minifloat.h>
Hongwei Wang95e37682019-04-12 11:13:36 -070047#include <audio_utils/safe_math.h>
Mikhail Naganov9fe94012016-10-14 14:57:40 -070048#include <system/audio_effects/effect_ns.h>
49#include <system/audio_effects/effect_aec.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070050#include <system/audio.h>
Eric Laurent81784c32012-11-19 14:55:58 -080051
52// NBAIO implementations
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070053#include <media/nbaio/AudioStreamInSource.h>
Eric Laurent81784c32012-11-19 14:55:58 -080054#include <media/nbaio/AudioStreamOutSink.h>
55#include <media/nbaio/MonoPipe.h>
56#include <media/nbaio/MonoPipeReader.h>
57#include <media/nbaio/Pipe.h>
58#include <media/nbaio/PipeReader.h>
59#include <media/nbaio/SourceAudioBufferProvider.h>
Wei Jia3f273d12015-11-24 09:06:49 -080060#include <mediautils/BatteryNotifier.h>
Eric Laurent81784c32012-11-19 14:55:58 -080061
Mikhail Naganov2996f672019-04-18 12:29:59 -070062#include <audiomanager/AudioManager.h>
Eric Laurent81784c32012-11-19 14:55:58 -080063#include <powermanager/PowerManager.h>
64
Kevin Rocard7588ff42018-01-08 11:11:30 -080065#include <media/audiohal/EffectsFactoryHalInterface.h>
Kevin Rocard069c2712018-03-29 19:09:14 -070066#include <media/audiohal/StreamHalInterface.h>
Kevin Rocard7588ff42018-01-08 11:11:30 -080067
Eric Laurent81784c32012-11-19 14:55:58 -080068#include "AudioFlinger.h"
Eric Laurent81784c32012-11-19 14:55:58 -080069#include "FastMixer.h"
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070070#include "FastCapture.h"
Andy Hungab7ef302018-05-15 19:35:29 -070071#include <mediautils/SchedulingPolicyService.h>
72#include <mediautils/ServiceUtilities.h>
Eric Laurent81784c32012-11-19 14:55:58 -080073
Eric Laurent81784c32012-11-19 14:55:58 -080074#ifdef ADD_BATTERY_DATA
75#include <media/IMediaPlayerService.h>
76#include <media/IMediaDeathNotifier.h>
77#endif
78
Eric Laurent81784c32012-11-19 14:55:58 -080079#ifdef DEBUG_CPU_USAGE
Eric Tan5b13ff82018-07-27 11:20:17 -070080#include <audio_utils/Statistics.h>
Eric Laurent81784c32012-11-19 14:55:58 -080081#include <cpustats/ThreadCpuUsage.h>
82#endif
83
Glenn Kastenc05b8d72016-03-24 09:48:17 -070084#include "AutoPark.h"
85
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080086#include <pthread.h>
87#include "TypedLogger.h"
88
Eric Laurent81784c32012-11-19 14:55:58 -080089// ----------------------------------------------------------------------------
90
91// Note: the following macro is used for extremely verbose logging message. In
92// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
93// 0; but one side effect of this is to turn all LOGV's as well. Some messages
94// are so verbose that we want to suppress them even when we have ALOG_ASSERT
95// turned on. Do not uncomment the #def below unless you really know what you
96// are doing and want to see all of the extremely verbose messages.
97//#define VERY_VERY_VERBOSE_LOGGING
98#ifdef VERY_VERY_VERBOSE_LOGGING
99#define ALOGVV ALOGV
100#else
101#define ALOGVV(a...) do { } while(0)
102#endif
103
Andy Hung6770c6f2015-04-07 13:43:36 -0700104// TODO: Move these macro/inlines to a header file.
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700105#define max(a, b) ((a) > (b) ? (a) : (b))
Andy Hung6770c6f2015-04-07 13:43:36 -0700106template <typename T>
107static inline T min(const T& a, const T& b)
108{
109 return a < b ? a : b;
110}
Glenn Kasten49d00ad2014-07-21 11:22:03 -0700111
Eric Laurent81784c32012-11-19 14:55:58 -0800112namespace android {
113
114// retry counts for buffer fill timeout
115// 50 * ~20msecs = 1 second
116static const int8_t kMaxTrackRetries = 50;
117static const int8_t kMaxTrackStartupRetries = 50;
118// allow less retry attempts on direct output thread.
119// direct outputs can be a scarce resource in audio hardware and should
120// be released as quickly as possible.
121static const int8_t kMaxTrackRetriesDirect = 2;
Eric Laurente93cc032016-05-05 10:15:10 -0700122
Eric Laurent51716182016-02-29 18:00:56 -0800123
Eric Laurent81784c32012-11-19 14:55:58 -0800124
125// don't warn about blocked writes or record buffer overflows more often than this
126static const nsecs_t kWarningThrottleNs = seconds(5);
127
128// RecordThread loop sleep time upon application overrun or audio HAL read error
129static const int kRecordThreadSleepUs = 5000;
130
Eric Laurent10351942014-05-08 18:49:52 -0700131// maximum time to wait in sendConfigEvent_l() for a status to be received
132static const nsecs_t kConfigEventTimeoutNs = seconds(2);
Eric Laurent81784c32012-11-19 14:55:58 -0800133
134// minimum sleep time for the mixer thread loop when tracks are active but in underrun
135static const uint32_t kMinThreadSleepTimeUs = 5000;
136// maximum divider applied to the active sleep time in the mixer thread loop
137static const uint32_t kMaxThreadSleepTimeShift = 2;
138
Andy Hung09a50072014-02-27 14:30:47 -0800139// minimum normal sink buffer size, expressed in milliseconds rather than frames
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700140// FIXME This should be based on experimentally observed scheduling jitter
Andy Hung09a50072014-02-27 14:30:47 -0800141static const uint32_t kMinNormalSinkBufferSizeMs = 20;
142// maximum normal sink buffer size
143static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
Eric Laurent81784c32012-11-19 14:55:58 -0800144
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700145// minimum capture buffer size in milliseconds to _not_ need a fast capture thread
146// FIXME This should be based on experimentally observed scheduling jitter
147static const uint32_t kMinNormalCaptureBufferSizeMs = 12;
148
Eric Laurent972a1732013-09-04 09:42:59 -0700149// Offloaded output thread standby delay: allows track transition without going to standby
150static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
151
Eric Laurent51716182016-02-29 18:00:56 -0800152// Direct output thread minimum sleep time in idle or active(underrun) state
153static const nsecs_t kDirectMinSleepTimeUs = 10000;
154
Glenn Kasten1b291842016-07-18 14:55:21 -0700155// The universal constant for ubiquitous 20ms value. The value of 20ms seems to provide a good
156// balance between power consumption and latency, and allows threads to be scheduled reliably
157// by the CFS scheduler.
158// FIXME Express other hardcoded references to 20ms with references to this constant and move
159// it appropriately.
160#define FMS_20 20
Eric Laurent51716182016-02-29 18:00:56 -0800161
Eric Laurent81784c32012-11-19 14:55:58 -0800162// Whether to use fast mixer
163static const enum {
164 FastMixer_Never, // never initialize or use: for debugging only
165 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
166 // normal mixer multiplier is 1
167 FastMixer_Static, // initialize if needed, then use all the time if initialized,
168 // multiplier is calculated based on min & max normal mixer buffer size
169 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
170 // multiplier is calculated based on min & max normal mixer buffer size
171 // FIXME for FastMixer_Dynamic:
172 // Supporting this option will require fixing HALs that can't handle large writes.
173 // For example, one HAL implementation returns an error from a large write,
174 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
175 // We could either fix the HAL implementations, or provide a wrapper that breaks
176 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
177} kUseFastMixer = FastMixer_Static;
178
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700179// Whether to use fast capture
180static const enum {
181 FastCapture_Never, // never initialize or use: for debugging only
182 FastCapture_Always, // always initialize and use, even if not needed: for debugging only
183 FastCapture_Static, // initialize if needed, then use all the time if initialized
184} kUseFastCapture = FastCapture_Static;
185
Eric Laurent81784c32012-11-19 14:55:58 -0800186// Priorities for requestPriority
187static const int kPriorityAudioApp = 2;
188static const int kPriorityFastMixer = 3;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -0700189static const int kPriorityFastCapture = 3;
Eric Laurent81784c32012-11-19 14:55:58 -0800190
Glenn Kastenea38ee72016-04-18 11:08:01 -0700191// IAudioFlinger::createTrack() has an in/out parameter 'pFrameCount' for the total size of the
192// track buffer in shared memory. Zero on input means to use a default value. For fast tracks,
193// AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
Glenn Kasten03490092014-05-27 12:30:54 -0700194
195// This is the default value, if not specified by property.
Glenn Kastenb5fed682013-12-03 09:06:43 -0800196static const int kFastTrackMultiplier = 2;
Eric Laurent81784c32012-11-19 14:55:58 -0800197
Glenn Kasten03490092014-05-27 12:30:54 -0700198// The minimum and maximum allowed values
199static const int kFastTrackMultiplierMin = 1;
200static const int kFastTrackMultiplierMax = 2;
201
202// The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
203static int sFastTrackMultiplier = kFastTrackMultiplier;
204
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700205// See Thread::readOnlyHeap().
206// Initially this heap is used to allocate client buffers for "fast" AudioRecord.
207// Eventually it will be the single buffer that FastCapture writes into via HAL read(),
208// and that all "fast" AudioRecord clients read from. In either case, the size can be small.
Mikhail Naganov79a77822018-05-10 15:57:25 -0700209static const size_t kRecordThreadReadOnlyHeapSize = 0xD000;
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700210
Eric Laurent81784c32012-11-19 14:55:58 -0800211// ----------------------------------------------------------------------------
212
Glenn Kasten03490092014-05-27 12:30:54 -0700213static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
214
215static void sFastTrackMultiplierInit()
216{
217 char value[PROPERTY_VALUE_MAX];
218 if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
219 char *endptr;
220 unsigned long ul = strtoul(value, &endptr, 0);
221 if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
222 sFastTrackMultiplier = (int) ul;
223 }
224 }
225}
226
227// ----------------------------------------------------------------------------
228
Eric Laurent81784c32012-11-19 14:55:58 -0800229#ifdef ADD_BATTERY_DATA
230// To collect the amplifier usage
231static void addBatteryData(uint32_t params) {
232 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
233 if (service == NULL) {
234 // it already logged
235 return;
236 }
237
238 service->addBatteryData(params);
239}
240#endif
241
Andy Hung3f0c9022016-01-15 17:49:46 -0800242// Track the CLOCK_BOOTTIME versus CLOCK_MONOTONIC timebase offset
243struct {
244 // call when you acquire a partial wakelock
245 void acquire(const sp<IBinder> &wakeLockToken) {
246 pthread_mutex_lock(&mLock);
247 if (wakeLockToken.get() == nullptr) {
248 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
249 } else {
250 if (mCount == 0) {
251 adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
252 }
253 ++mCount;
254 }
255 pthread_mutex_unlock(&mLock);
256 }
257
258 // call when you release a partial wakelock.
259 void release(const sp<IBinder> &wakeLockToken) {
260 if (wakeLockToken.get() == nullptr) {
261 return;
262 }
263 pthread_mutex_lock(&mLock);
264 if (--mCount < 0) {
265 ALOGE("negative wakelock count");
266 mCount = 0;
267 }
268 pthread_mutex_unlock(&mLock);
269 }
270
271 // retrieves the boottime timebase offset from monotonic.
272 int64_t getBoottimeOffset() {
273 pthread_mutex_lock(&mLock);
274 int64_t boottimeOffset = mBoottimeOffset;
275 pthread_mutex_unlock(&mLock);
276 return boottimeOffset;
277 }
278
279 // Adjusts the timebase offset between TIMEBASE_MONOTONIC
280 // and the selected timebase.
281 // Currently only TIMEBASE_BOOTTIME is allowed.
282 //
283 // This only needs to be called upon acquiring the first partial wakelock
284 // after all other partial wakelocks are released.
285 //
286 // We do an empirical measurement of the offset rather than parsing
287 // /proc/timer_list since the latter is not a formal kernel ABI.
288 static void adjustTimebaseOffset(int64_t *offset, ExtendedTimestamp::Timebase timebase) {
289 int clockbase;
290 switch (timebase) {
291 case ExtendedTimestamp::TIMEBASE_BOOTTIME:
292 clockbase = SYSTEM_TIME_BOOTTIME;
293 break;
294 default:
295 LOG_ALWAYS_FATAL("invalid timebase %d", timebase);
296 break;
297 }
298 // try three times to get the clock offset, choose the one
299 // with the minimum gap in measurements.
300 const int tries = 3;
301 nsecs_t bestGap, measured;
302 for (int i = 0; i < tries; ++i) {
303 const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
304 const nsecs_t tbase = systemTime(clockbase);
305 const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
306 const nsecs_t gap = tmono2 - tmono;
307 if (i == 0 || gap < bestGap) {
308 bestGap = gap;
309 measured = tbase - ((tmono + tmono2) >> 1);
310 }
311 }
312
313 // to avoid micro-adjusting, we don't change the timebase
314 // unless it is significantly different.
315 //
316 // Assumption: It probably takes more than toleranceNs to
317 // suspend and resume the device.
318 static int64_t toleranceNs = 10000; // 10 us
319 if (llabs(*offset - measured) > toleranceNs) {
320 ALOGV("Adjusting timebase offset old: %lld new: %lld",
321 (long long)*offset, (long long)measured);
322 *offset = measured;
323 }
324 }
325
326 pthread_mutex_t mLock;
327 int32_t mCount;
328 int64_t mBoottimeOffset;
329} gBoottime = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; // static, so use POD initialization
Eric Laurent81784c32012-11-19 14:55:58 -0800330
331// ----------------------------------------------------------------------------
332// CPU Stats
333// ----------------------------------------------------------------------------
334
335class CpuStats {
336public:
337 CpuStats();
338 void sample(const String8 &title);
339#ifdef DEBUG_CPU_USAGE
340private:
341 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
Andy Hung16698b82018-08-01 10:48:38 -0700342 audio_utils::Statistics<double> mWcStats; // statistics on thread CPU usage in wall clock ns
Eric Laurent81784c32012-11-19 14:55:58 -0800343
Andy Hung16698b82018-08-01 10:48:38 -0700344 audio_utils::Statistics<double> mHzStats; // statistics on thread CPU usage in cycles
Eric Laurent81784c32012-11-19 14:55:58 -0800345
346 int mCpuNum; // thread's current CPU number
347 int mCpukHz; // frequency of thread's current CPU in kHz
348#endif
349};
350
351CpuStats::CpuStats()
352#ifdef DEBUG_CPU_USAGE
353 : mCpuNum(-1), mCpukHz(-1)
354#endif
355{
356}
357
Glenn Kasten0f11b512014-01-31 16:18:54 -0800358void CpuStats::sample(const String8 &title
359#ifndef DEBUG_CPU_USAGE
360 __unused
361#endif
362 ) {
Eric Laurent81784c32012-11-19 14:55:58 -0800363#ifdef DEBUG_CPU_USAGE
364 // get current thread's delta CPU time in wall clock ns
365 double wcNs;
366 bool valid = mCpuUsage.sampleAndEnable(wcNs);
367
368 // record sample for wall clock statistics
369 if (valid) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700370 mWcStats.add(wcNs);
Eric Laurent81784c32012-11-19 14:55:58 -0800371 }
372
373 // get the current CPU number
374 int cpuNum = sched_getcpu();
375
376 // get the current CPU frequency in kHz
377 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
378
379 // check if either CPU number or frequency changed
380 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
381 mCpuNum = cpuNum;
382 mCpukHz = cpukHz;
383 // ignore sample for purposes of cycles
384 valid = false;
385 }
386
387 // if no change in CPU number or frequency, then record sample for cycle statistics
388 if (valid && mCpukHz > 0) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700389 const double cycles = wcNs * cpukHz * 0.000001;
390 mHzStats.add(cycles);
Eric Laurent81784c32012-11-19 14:55:58 -0800391 }
392
Eric Tan5b13ff82018-07-27 11:20:17 -0700393 const unsigned n = mWcStats.getN();
Eric Laurent81784c32012-11-19 14:55:58 -0800394 // mCpuUsage.elapsed() is expensive, so don't call it every loop
395 if ((n & 127) == 1) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700396 const long long elapsed = mCpuUsage.elapsed();
Eric Laurent81784c32012-11-19 14:55:58 -0800397 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
Eric Tan5b13ff82018-07-27 11:20:17 -0700398 const double perLoop = elapsed / (double) n;
399 const double perLoop100 = perLoop * 0.01;
400 const double perLoop1k = perLoop * 0.001;
401 const double mean = mWcStats.getMean();
402 const double stddev = mWcStats.getStdDev();
403 const double minimum = mWcStats.getMin();
404 const double maximum = mWcStats.getMax();
405 const double meanCycles = mHzStats.getMean();
406 const double stddevCycles = mHzStats.getStdDev();
407 const double minCycles = mHzStats.getMin();
408 const double maxCycles = mHzStats.getMax();
Eric Laurent81784c32012-11-19 14:55:58 -0800409 mCpuUsage.resetElapsed();
410 mWcStats.reset();
411 mHzStats.reset();
412 ALOGD("CPU usage for %s over past %.1f secs\n"
413 " (%u mixer loops at %.1f mean ms per loop):\n"
414 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
415 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
416 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
417 title.string(),
418 elapsed * .000000001, n, perLoop * .000001,
419 mean * .001,
420 stddev * .001,
421 minimum * .001,
422 maximum * .001,
423 mean / perLoop100,
424 stddev / perLoop100,
425 minimum / perLoop100,
426 maximum / perLoop100,
427 meanCycles / perLoop1k,
428 stddevCycles / perLoop1k,
429 minCycles / perLoop1k,
430 maxCycles / perLoop1k);
431
432 }
433 }
434#endif
435};
436
437// ----------------------------------------------------------------------------
438// ThreadBase
439// ----------------------------------------------------------------------------
440
Glenn Kasten97b7b752014-09-28 13:04:24 -0700441// static
442const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
443{
444 switch (type) {
445 case MIXER:
446 return "MIXER";
447 case DIRECT:
448 return "DIRECT";
449 case DUPLICATING:
450 return "DUPLICATING";
451 case RECORD:
452 return "RECORD";
453 case OFFLOAD:
454 return "OFFLOAD";
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800455 case MMAP:
456 return "MMAP";
Glenn Kasten97b7b752014-09-28 13:04:24 -0700457 default:
458 return "unknown";
459 }
460}
461
Eric Laurent81784c32012-11-19 14:55:58 -0800462AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -0700463 audio_devices_t outDevice, audio_devices_t inDevice, type_t type, bool systemReady)
Eric Laurent81784c32012-11-19 14:55:58 -0800464 : Thread(false /*canCallJava*/),
465 mType(type),
Glenn Kasten9b58f632013-07-16 11:37:48 -0700466 mAudioFlinger(audioFlinger),
Glenn Kasten70949c42013-08-06 07:40:12 -0700467 // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800468 // are set by PlaybackThread::readOutputParameters_l() or
469 // RecordThread::readInputParameters_l()
Eric Laurentfd477972013-10-25 18:10:40 -0700470 //FIXME: mStandby should be true here. Is this some kind of hack?
Eric Laurent81784c32012-11-19 14:55:58 -0800471 mStandby(false), mOutDevice(outDevice), mInDevice(inDevice),
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700472 mPrevOutDevice(AUDIO_DEVICE_NONE), mPrevInDevice(AUDIO_DEVICE_NONE),
473 mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
Eric Laurent81784c32012-11-19 14:55:58 -0800474 // mName will be set by concrete (non-virtual) subclass
Eric Laurent72e3f392015-05-20 14:43:50 -0700475 mDeathRecipient(new PMDeathRecipient(this)),
Eric Laurent6acd1d42017-01-04 14:23:29 -0800476 mSystemReady(systemReady),
477 mSignalPending(false)
Eric Laurent81784c32012-11-19 14:55:58 -0800478{
Eric Laurent296fb132015-05-01 11:38:42 -0700479 memset(&mPatch, 0, sizeof(struct audio_patch));
Eric Laurent81784c32012-11-19 14:55:58 -0800480}
481
482AudioFlinger::ThreadBase::~ThreadBase()
483{
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700484 // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
Glenn Kastenc6ae3c82013-07-17 09:08:51 -0700485 mConfigEvents.clear();
486
Eric Laurent81784c32012-11-19 14:55:58 -0800487 // do not lock the mutex in destructor
488 releaseWakeLock_l();
489 if (mPowerManager != 0) {
Marco Nelissen06b46062014-11-14 07:58:25 -0800490 sp<IBinder> binder = IInterface::asBinder(mPowerManager);
Eric Laurent81784c32012-11-19 14:55:58 -0800491 binder->unlinkToDeath(mDeathRecipient);
492 }
Andy Hungd0979812019-02-21 15:51:44 -0800493
494 sendStatistics(true /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -0800495}
496
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700497status_t AudioFlinger::ThreadBase::readyToRun()
498{
499 status_t status = initCheck();
500 if (status == NO_ERROR) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800501 ALOGI("AudioFlinger's thread %p tid=%d ready to run", this, getTid());
Glenn Kastencf04c2c2013-08-06 07:41:16 -0700502 } else {
503 ALOGE("No working audio driver found.");
504 }
505 return status;
506}
507
Eric Laurent81784c32012-11-19 14:55:58 -0800508void AudioFlinger::ThreadBase::exit()
509{
510 ALOGV("ThreadBase::exit");
511 // do any cleanup required for exit to succeed
512 preExit();
513 {
514 // This lock prevents the following race in thread (uniprocessor for illustration):
515 // if (!exitPending()) {
516 // // context switch from here to exit()
517 // // exit() calls requestExit(), what exitPending() observes
518 // // exit() calls signal(), which is dropped since no waiters
519 // // context switch back from exit() to here
520 // mWaitWorkCV.wait(...);
521 // // now thread is hung
522 // }
523 AutoMutex lock(mLock);
524 requestExit();
525 mWaitWorkCV.broadcast();
526 }
527 // When Thread::requestExitAndWait is made virtual and this method is renamed to
528 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
529 requestExitAndWait();
530}
531
532status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
533{
Eric Laurent81784c32012-11-19 14:55:58 -0800534 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
535 Mutex::Autolock _l(mLock);
536
Eric Laurent10351942014-05-08 18:49:52 -0700537 return sendSetParameterConfigEvent_l(keyValuePairs);
538}
539
540// sendConfigEvent_l() must be called with ThreadBase::mLock held
541// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
542status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
543{
544 status_t status = NO_ERROR;
545
Eric Laurent72e3f392015-05-20 14:43:50 -0700546 if (event->mRequiresSystemReady && !mSystemReady) {
547 event->mWaitStatus = false;
548 mPendingConfigEvents.add(event);
549 return status;
550 }
Eric Laurent10351942014-05-08 18:49:52 -0700551 mConfigEvents.add(event);
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700552 ALOGV("sendConfigEvent_l() num events %zu event %d", mConfigEvents.size(), event->mType);
Eric Laurent81784c32012-11-19 14:55:58 -0800553 mWaitWorkCV.signal();
Eric Laurent10351942014-05-08 18:49:52 -0700554 mLock.unlock();
555 {
556 Mutex::Autolock _l(event->mLock);
557 while (event->mWaitStatus) {
558 if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
559 event->mStatus = TIMED_OUT;
560 event->mWaitStatus = false;
561 }
562 }
563 status = event->mStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800564 }
Eric Laurent10351942014-05-08 18:49:52 -0700565 mLock.lock();
Eric Laurent81784c32012-11-19 14:55:58 -0800566 return status;
567}
568
Eric Laurent09f1ed22019-04-24 17:45:17 -0700569void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event event, pid_t pid,
570 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800571{
572 Mutex::Autolock _l(mLock);
Eric Laurent09f1ed22019-04-24 17:45:17 -0700573 sendIoConfigEvent_l(event, pid, portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800574}
575
576// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
Eric Laurent09f1ed22019-04-24 17:45:17 -0700577void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event event, pid_t pid,
578 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -0800579{
Andy Hungd0979812019-02-21 15:51:44 -0800580 // The audio statistics history is exponentially weighted to forget events
581 // about five or more seconds in the past. In order to have
582 // crisper statistics for mediametrics, we reset the statistics on
583 // an IoConfigEvent, to reflect different properties for a new device.
584 mIoJitterMs.reset();
585 mLatencyMs.reset();
586 mProcessTimeMs.reset();
587 mTimestampVerifier.discontinuity();
588
Eric Laurent09f1ed22019-04-24 17:45:17 -0700589 sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700590 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800591}
592
Mikhail Naganov83f04272017-02-07 10:45:09 -0800593void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent72e3f392015-05-20 14:43:50 -0700594{
595 Mutex::Autolock _l(mLock);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800596 sendPrioConfigEvent_l(pid, tid, prio, forApp);
Eric Laurent72e3f392015-05-20 14:43:50 -0700597}
598
Eric Laurent81784c32012-11-19 14:55:58 -0800599// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
Mikhail Naganov83f04272017-02-07 10:45:09 -0800600void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(
601 pid_t pid, pid_t tid, int32_t prio, bool forApp)
Eric Laurent81784c32012-11-19 14:55:58 -0800602{
Mikhail Naganov83f04272017-02-07 10:45:09 -0800603 sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700604 sendConfigEvent_l(configEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800605}
606
Eric Laurent10351942014-05-08 18:49:52 -0700607// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
608status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
Eric Laurent81784c32012-11-19 14:55:58 -0800609{
Andy Hung2ddee192015-12-18 17:34:44 -0800610 sp<ConfigEvent> configEvent;
611 AudioParameter param(keyValuePair);
612 int value;
Mikhail Naganov00260b52016-10-13 12:54:24 -0700613 if (param.getInt(String8(AudioParameter::keyMonoOutput), value) == NO_ERROR) {
Andy Hung2ddee192015-12-18 17:34:44 -0800614 setMasterMono_l(value != 0);
615 if (param.size() == 1) {
616 return NO_ERROR; // should be a solo parameter - we don't pass down
617 }
Mikhail Naganov00260b52016-10-13 12:54:24 -0700618 param.remove(String8(AudioParameter::keyMonoOutput));
Andy Hung2ddee192015-12-18 17:34:44 -0800619 configEvent = new SetParameterConfigEvent(param.toString());
620 } else {
621 configEvent = new SetParameterConfigEvent(keyValuePair);
622 }
Eric Laurent10351942014-05-08 18:49:52 -0700623 return sendConfigEvent_l(configEvent);
Glenn Kastenf7773312013-08-13 16:00:42 -0700624}
625
Eric Laurent1c333e22014-05-20 10:48:17 -0700626status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
627 const struct audio_patch *patch,
628 audio_patch_handle_t *handle)
629{
630 Mutex::Autolock _l(mLock);
631 sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
632 status_t status = sendConfigEvent_l(configEvent);
633 if (status == NO_ERROR) {
634 CreateAudioPatchConfigEventData *data =
635 (CreateAudioPatchConfigEventData *)configEvent->mData.get();
636 *handle = data->mHandle;
637 }
638 return status;
639}
640
641status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
642 const audio_patch_handle_t handle)
643{
644 Mutex::Autolock _l(mLock);
645 sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
646 return sendConfigEvent_l(configEvent);
647}
648
649
Glenn Kasten2cfbf882013-08-14 13:12:11 -0700650// post condition: mConfigEvents.isEmpty()
Eric Laurent021cf962014-05-13 10:18:14 -0700651void AudioFlinger::ThreadBase::processConfigEvents_l()
Glenn Kastenf7773312013-08-13 16:00:42 -0700652{
Eric Laurent10351942014-05-08 18:49:52 -0700653 bool configChanged = false;
654
Eric Laurent81784c32012-11-19 14:55:58 -0800655 while (!mConfigEvents.isEmpty()) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700656 ALOGV("processConfigEvents_l() remaining events %zu", mConfigEvents.size());
Eric Laurent10351942014-05-08 18:49:52 -0700657 sp<ConfigEvent> event = mConfigEvents[0];
Eric Laurent81784c32012-11-19 14:55:58 -0800658 mConfigEvents.removeAt(0);
Eric Laurent10351942014-05-08 18:49:52 -0700659 switch (event->mType) {
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700660 case CFG_EVENT_PRIO: {
Eric Laurent10351942014-05-08 18:49:52 -0700661 PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
662 // FIXME Need to understand why this has to be done asynchronously
Mikhail Naganov83f04272017-02-07 10:45:09 -0800663 int err = requestPriority(data->mPid, data->mTid, data->mPrio, data->mForApp,
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700664 true /*asynchronous*/);
665 if (err != 0) {
666 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
Eric Laurent10351942014-05-08 18:49:52 -0700667 data->mPrio, data->mPid, data->mTid, err);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700668 }
669 } break;
670 case CFG_EVENT_IO: {
Eric Laurent10351942014-05-08 18:49:52 -0700671 IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
Eric Laurent09f1ed22019-04-24 17:45:17 -0700672 ioConfigChanged(data->mEvent, data->mPid, data->mPortId);
Eric Laurent10351942014-05-08 18:49:52 -0700673 } break;
674 case CFG_EVENT_SET_PARAMETER: {
675 SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
676 if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
677 configChanged = true;
Andy Hung293558a2017-03-21 12:19:20 -0700678 mLocalLog.log("CFG_EVENT_SET_PARAMETER: (%s) configuration changed",
679 data->mKeyValuePairs.string());
Glenn Kastend5418eb2013-08-14 13:11:06 -0700680 }
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700681 } break;
Eric Laurent1c333e22014-05-20 10:48:17 -0700682 case CFG_EVENT_CREATE_AUDIO_PATCH: {
Andy Hung293558a2017-03-21 12:19:20 -0700683 const audio_devices_t oldDevice = getDevice();
Eric Laurent1c333e22014-05-20 10:48:17 -0700684 CreateAudioPatchConfigEventData *data =
685 (CreateAudioPatchConfigEventData *)event->mData.get();
686 event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
Andy Hung293558a2017-03-21 12:19:20 -0700687 const audio_devices_t newDevice = getDevice();
688 mLocalLog.log("CFG_EVENT_CREATE_AUDIO_PATCH: old device %#x (%s) new device %#x (%s)",
Andy Hung9b181952019-02-25 14:53:36 -0800689 (unsigned)oldDevice, toString(oldDevice).c_str(),
690 (unsigned)newDevice, toString(newDevice).c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -0700691 } break;
692 case CFG_EVENT_RELEASE_AUDIO_PATCH: {
Andy Hung293558a2017-03-21 12:19:20 -0700693 const audio_devices_t oldDevice = getDevice();
Eric Laurent1c333e22014-05-20 10:48:17 -0700694 ReleaseAudioPatchConfigEventData *data =
695 (ReleaseAudioPatchConfigEventData *)event->mData.get();
696 event->mStatus = releaseAudioPatch_l(data->mHandle);
Andy Hung293558a2017-03-21 12:19:20 -0700697 const audio_devices_t newDevice = getDevice();
698 mLocalLog.log("CFG_EVENT_RELEASE_AUDIO_PATCH: old device %#x (%s) new device %#x (%s)",
Andy Hung9b181952019-02-25 14:53:36 -0800699 (unsigned)oldDevice, toString(oldDevice).c_str(),
700 (unsigned)newDevice, toString(newDevice).c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -0700701 } break;
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700702 default:
Eric Laurent10351942014-05-08 18:49:52 -0700703 ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
Glenn Kasten3468e8a2013-08-13 16:01:22 -0700704 break;
Eric Laurent81784c32012-11-19 14:55:58 -0800705 }
Eric Laurent10351942014-05-08 18:49:52 -0700706 {
707 Mutex::Autolock _l(event->mLock);
708 if (event->mWaitStatus) {
709 event->mWaitStatus = false;
710 event->mCond.signal();
711 }
712 }
713 ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
714 }
715
716 if (configChanged) {
717 cacheParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800718 }
Eric Laurent81784c32012-11-19 14:55:58 -0800719}
720
Marco Nelissenb2208842014-02-07 14:00:50 -0800721String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
722 String8 s;
Glenn Kastene1635ec2015-06-08 15:46:49 -0700723 const audio_channel_representation_t representation =
724 audio_channel_mask_get_representation(mask);
Andy Hungf98ec8d2015-05-19 12:53:24 -0700725
726 switch (representation) {
jiabin245cdd92018-12-07 17:55:15 -0800727 // Travel all single bit channel mask to convert channel mask to string.
Andy Hungf98ec8d2015-05-19 12:53:24 -0700728 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
729 if (output) {
730 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
731 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
732 if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
733 if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low freq, ");
734 if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
735 if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
736 if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
737 if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
738 if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
739 if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
740 if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
741 if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
742 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
743 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
744 if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
745 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
746 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, " );
747 if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, " );
Mikhail Naganovc9948492018-05-10 17:25:28 -0700748 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT) s.append("top-side-left, " );
749 if (mask & AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT) s.append("top-side-right, " );
jiabin245cdd92018-12-07 17:55:15 -0800750 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_B) s.append("haptic-B, " );
751 if (mask & AUDIO_CHANNEL_OUT_HAPTIC_A) s.append("haptic-A, " );
Andy Hungf98ec8d2015-05-19 12:53:24 -0700752 if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown, ");
753 } else {
754 if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
755 if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
756 if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
757 if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
758 if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
759 if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
760 if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
761 if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
762 if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
763 if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
764 if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
765 if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
Mikhail Naganovc9948492018-05-10 17:25:28 -0700766 if (mask & AUDIO_CHANNEL_IN_BACK_LEFT) s.append("back-left, ");
767 if (mask & AUDIO_CHANNEL_IN_BACK_RIGHT) s.append("back-right, ");
768 if (mask & AUDIO_CHANNEL_IN_CENTER) s.append("center, ");
769 if (mask & AUDIO_CHANNEL_IN_LOW_FREQUENCY) s.append("low freq, ");
770 if (mask & AUDIO_CHANNEL_IN_TOP_LEFT) s.append("top-left, " );
771 if (mask & AUDIO_CHANNEL_IN_TOP_RIGHT) s.append("top-right, " );
Andy Hungf98ec8d2015-05-19 12:53:24 -0700772 if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
773 if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
774 if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown, ");
775 }
776 const int len = s.length();
777 if (len > 2) {
Glenn Kasten57c4e6f2016-03-18 14:54:07 -0700778 (void) s.lockBuffer(len); // needed?
Andy Hungf98ec8d2015-05-19 12:53:24 -0700779 s.unlockBuffer(len - 2); // remove trailing ", "
780 }
781 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800782 }
Andy Hungf98ec8d2015-05-19 12:53:24 -0700783 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
784 s.appendFormat("index mask, bits:%#x", audio_channel_mask_get_bits(mask));
785 return s;
786 default:
787 s.appendFormat("unknown mask, representation:%d bits:%#x",
788 representation, audio_channel_mask_get_bits(mask));
789 return s;
Marco Nelissenb2208842014-02-07 14:00:50 -0800790 }
Marco Nelissenb2208842014-02-07 14:00:50 -0800791}
792
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700793void AudioFlinger::ThreadBase::dump(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800794{
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800795 dprintf(fd, "\n%s thread %p, name %s, tid %d, type %d (%s):\n", isOutput() ? "Output" : "Input",
796 this, mThreadName, getTid(), type(), threadTypeToString(type()));
797
Eric Laurent81784c32012-11-19 14:55:58 -0800798 bool locked = AudioFlinger::dumpTryLock(mLock);
799 if (!locked) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -0800800 dprintf(fd, " Thread may be deadlocked\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800801 }
802
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700803 dumpBase_l(fd, args);
804 dumpInternals_l(fd, args);
805 dumpTracks_l(fd, args);
806 dumpEffectChains_l(fd, args);
807
808 if (locked) {
809 mLock.unlock();
810 }
811
812 dprintf(fd, " Local log:\n");
813 mLocalLog.dump(fd, " " /* prefix */, 40 /* lines */);
814}
815
816void AudioFlinger::ThreadBase::dumpBase_l(int fd, const Vector<String16>& args __unused)
817{
Elliott Hughes87cebad2014-05-22 10:14:43 -0700818 dprintf(fd, " I/O handle: %d\n", mId);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700819 dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
Glenn Kasten97b7b752014-09-28 13:04:24 -0700820 dprintf(fd, " Sample rate: %u Hz\n", mSampleRate);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700821 dprintf(fd, " HAL frame count: %zu\n", mFrameCount);
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700822 dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat).c_str());
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700823 dprintf(fd, " HAL buffer size: %zu bytes\n", mBufferSize);
Glenn Kasten97b7b752014-09-28 13:04:24 -0700824 dprintf(fd, " Channel count: %u\n", mChannelCount);
825 dprintf(fd, " Channel mask: 0x%08x (%s)\n", mChannelMask,
Marco Nelissenb2208842014-02-07 14:00:50 -0800826 channelMaskToString(mChannelMask, mType != RECORD).string());
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700827 dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat).c_str());
Glenn Kastenf87c2f52015-08-21 08:03:57 -0700828 dprintf(fd, " Processing frame size: %zu bytes\n", mFrameSize);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700829 dprintf(fd, " Pending config events:");
Marco Nelissenb2208842014-02-07 14:00:50 -0800830 size_t numConfig = mConfigEvents.size();
831 if (numConfig) {
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700832 const size_t SIZE = 256;
833 char buffer[SIZE];
Marco Nelissenb2208842014-02-07 14:00:50 -0800834 for (size_t i = 0; i < numConfig; i++) {
835 mConfigEvents[i]->dump(buffer, SIZE);
Elliott Hughes87cebad2014-05-22 10:14:43 -0700836 dprintf(fd, "\n %s", buffer);
Marco Nelissenb2208842014-02-07 14:00:50 -0800837 }
Elliott Hughes87cebad2014-05-22 10:14:43 -0700838 dprintf(fd, "\n");
Marco Nelissenb2208842014-02-07 14:00:50 -0800839 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -0700840 dprintf(fd, " none\n");
Eric Laurent81784c32012-11-19 14:55:58 -0800841 }
Andy Hung293558a2017-03-21 12:19:20 -0700842 // Note: output device may be used by capture threads for effects such as AEC.
Andy Hung9b181952019-02-25 14:53:36 -0800843 dprintf(fd, " Output device: %#x (%s)\n", mOutDevice, toString(mOutDevice).c_str());
844 dprintf(fd, " Input device: %#x (%s)\n", mInDevice, toString(mInDevice).c_str());
845 dprintf(fd, " Audio source: %d (%s)\n", mAudioSource, toString(mAudioSource).c_str());
Eric Laurent81784c32012-11-19 14:55:58 -0800846
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700847 // Dump timestamp statistics for the Thread types that support it.
848 if (mType == RECORD
849 || mType == MIXER
850 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -0700851 || mType == DIRECT
852 || mType == OFFLOAD) {
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700853 dprintf(fd, " Timestamp stats: %s\n", mTimestampVerifier.toString().c_str());
Andy Hungc8fddf32018-08-08 18:32:37 -0700854 dprintf(fd, " Timestamp corrected: %s\n", isTimestampCorrectionEnabled() ? "yes" : "no");
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700855 }
856
Andy Hung446f4df2019-02-21 12:26:41 -0800857 if (mLastIoBeginNs > 0) { // MMAP may not set this
858 dprintf(fd, " Last %s occurred (msecs): %lld\n",
859 isOutput() ? "write" : "read",
860 (long long) (systemTime() - mLastIoBeginNs) / NANOS_PER_MILLISECOND);
861 }
862
863 if (mProcessTimeMs.getN() > 0) {
864 dprintf(fd, " Process time ms stats: %s\n", mProcessTimeMs.toString().c_str());
865 }
866
867 if (mIoJitterMs.getN() > 0) {
868 dprintf(fd, " Hal %s jitter ms stats: %s\n",
869 isOutput() ? "write" : "read",
870 mIoJitterMs.toString().c_str());
871 }
872
Andy Hunge6c37112019-02-26 17:38:10 -0800873 if (mLatencyMs.getN() > 0) {
874 dprintf(fd, " Threadloop %s latency stats: %s\n",
875 isOutput() ? "write" : "read",
876 mLatencyMs.toString().c_str());
877 }
Eric Laurent81784c32012-11-19 14:55:58 -0800878}
879
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700880void AudioFlinger::ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -0800881{
882 const size_t SIZE = 256;
883 char buffer[SIZE];
Eric Laurent81784c32012-11-19 14:55:58 -0800884
Marco Nelissenb2208842014-02-07 14:00:50 -0800885 size_t numEffectChains = mEffectChains.size();
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +0000886 snprintf(buffer, SIZE, " %zu Effect Chains\n", numEffectChains);
Eric Laurent81784c32012-11-19 14:55:58 -0800887 write(fd, buffer, strlen(buffer));
888
Marco Nelissenb2208842014-02-07 14:00:50 -0800889 for (size_t i = 0; i < numEffectChains; ++i) {
Eric Laurent81784c32012-11-19 14:55:58 -0800890 sp<EffectChain> chain = mEffectChains[i];
891 if (chain != 0) {
892 chain->dump(fd, args);
893 }
894 }
895}
896
Andy Hungdae27702016-10-31 14:01:16 -0700897void AudioFlinger::ThreadBase::acquireWakeLock()
Eric Laurent81784c32012-11-19 14:55:58 -0800898{
899 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -0700900 acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800901}
902
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100903String16 AudioFlinger::ThreadBase::getWakeLockTag()
904{
905 switch (mType) {
Glenn Kastenbcb14862015-03-05 17:11:21 -0800906 case MIXER:
907 return String16("AudioMix");
908 case DIRECT:
909 return String16("AudioDirectOut");
910 case DUPLICATING:
911 return String16("AudioDup");
912 case RECORD:
913 return String16("AudioIn");
914 case OFFLOAD:
915 return String16("AudioOffload");
Eric Laurent6acd1d42017-01-04 14:23:29 -0800916 case MMAP:
917 return String16("Mmap");
Glenn Kastenbcb14862015-03-05 17:11:21 -0800918 default:
919 ALOG_ASSERT(false);
920 return String16("AudioUnknown");
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100921 }
922}
923
Andy Hungdae27702016-10-31 14:01:16 -0700924void AudioFlinger::ThreadBase::acquireWakeLock_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800925{
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800926 getPowerManager_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800927 if (mPowerManager != 0) {
928 sp<IBinder> binder = new BBinder();
Andy Hungdae27702016-10-31 14:01:16 -0700929 // Uses AID_AUDIOSERVER for wakelock. updateWakeLockUids_l() updates with client uids.
930 status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
Marco Nelissene14a5d62013-10-03 08:51:24 -0700931 binder,
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100932 getWakeLockTag(),
Marco Nelissendcb346b2015-09-09 10:47:29 -0700933 String16("audioserver"),
Glenn Kasten3abc2de2014-09-05 16:45:52 -0700934 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent81784c32012-11-19 14:55:58 -0800935 if (status == NO_ERROR) {
936 mWakeLockToken = binder;
937 }
Glenn Kastend7dca052015-03-05 16:05:54 -0800938 ALOGV("acquireWakeLock_l() %s status %d", mThreadName, status);
Eric Laurent81784c32012-11-19 14:55:58 -0800939 }
Wei Jia3f273d12015-11-24 09:06:49 -0800940
Andy Hung3f0c9022016-01-15 17:49:46 -0800941 gBoottime.acquire(mWakeLockToken);
Andy Hung818e7a32016-02-16 18:08:07 -0800942 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
943 gBoottime.getBoottimeOffset();
Eric Laurent81784c32012-11-19 14:55:58 -0800944}
945
946void AudioFlinger::ThreadBase::releaseWakeLock()
947{
948 Mutex::Autolock _l(mLock);
949 releaseWakeLock_l();
950}
951
952void AudioFlinger::ThreadBase::releaseWakeLock_l()
953{
Andy Hung3f0c9022016-01-15 17:49:46 -0800954 gBoottime.release(mWakeLockToken);
Eric Laurent81784c32012-11-19 14:55:58 -0800955 if (mWakeLockToken != 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -0800956 ALOGV("releaseWakeLock_l() %s", mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -0800957 if (mPowerManager != 0) {
Glenn Kasten3abc2de2014-09-05 16:45:52 -0700958 mPowerManager->releaseWakeLock(mWakeLockToken, 0,
959 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent81784c32012-11-19 14:55:58 -0800960 }
961 mWakeLockToken.clear();
962 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800963}
964
965void AudioFlinger::ThreadBase::getPowerManager_l() {
Eric Laurent72e3f392015-05-20 14:43:50 -0700966 if (mSystemReady && mPowerManager == 0) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800967 // use checkService() to avoid blocking if power service is not up yet
968 sp<IBinder> binder =
969 defaultServiceManager()->checkService(String16("power"));
970 if (binder == 0) {
Glenn Kastend7dca052015-03-05 16:05:54 -0800971 ALOGW("Thread %s cannot connect to the power manager service", mThreadName);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800972 } else {
973 mPowerManager = interface_cast<IPowerManager>(binder);
974 binder->linkToDeath(mDeathRecipient);
975 }
976 }
977}
978
Andy Hungd01b0f12016-11-07 16:10:30 -0800979void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t> &uids) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800980 getPowerManager_l();
Andy Hungdae27702016-10-31 14:01:16 -0700981
982#if !LOG_NDEBUG
983 std::stringstream s;
Andy Hungd01b0f12016-11-07 16:10:30 -0800984 for (uid_t uid : uids) {
Andy Hungdae27702016-10-31 14:01:16 -0700985 s << uid << " ";
986 }
987 ALOGD("updateWakeLockUids_l %s uids:%s", mThreadName, s.str().c_str());
988#endif
989
Andy Hung438e7572015-12-14 15:51:17 -0800990 if (mWakeLockToken == NULL) { // token may be NULL if AudioFlinger::systemReady() not called.
991 if (mSystemReady) {
992 ALOGE("no wake lock to update, but system ready!");
993 } else {
994 ALOGW("no wake lock to update, system not ready yet");
995 }
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800996 return;
997 }
998 if (mPowerManager != 0) {
Andy Hung1f12a8a2016-11-07 16:10:30 -0800999 std::vector<int> uidsAsInt(uids.begin(), uids.end()); // powermanager expects uids as ints
1000 status_t status = mPowerManager->updateWakeLockUids(
1001 mWakeLockToken, uidsAsInt.size(), uidsAsInt.data(),
1002 true /* FIXME force oneway contrary to .aidl */);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001003 ALOGV("updateWakeLockUids_l() %s status %d", mThreadName, status);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001004 }
1005}
1006
Eric Laurent81784c32012-11-19 14:55:58 -08001007void AudioFlinger::ThreadBase::clearPowerManager()
1008{
1009 Mutex::Autolock _l(mLock);
1010 releaseWakeLock_l();
1011 mPowerManager.clear();
1012}
1013
Glenn Kasten0f11b512014-01-31 16:18:54 -08001014void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001015{
1016 sp<ThreadBase> thread = mThread.promote();
1017 if (thread != 0) {
1018 thread->clearPowerManager();
1019 }
1020 ALOGW("power manager service died !!!");
1021}
1022
Eric Laurent81784c32012-11-19 14:55:58 -08001023void AudioFlinger::ThreadBase::setEffectSuspended_l(
Glenn Kastend848eb42016-03-08 13:42:11 -08001024 const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001025{
1026 sp<EffectChain> chain = getEffectChain_l(sessionId);
1027 if (chain != 0) {
1028 if (type != NULL) {
1029 chain->setEffectSuspended_l(type, suspend);
1030 } else {
1031 chain->setEffectSuspendedAll_l(suspend);
1032 }
1033 }
1034
1035 updateSuspendedSessions_l(type, suspend, sessionId);
1036}
1037
1038void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1039{
1040 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
1041 if (index < 0) {
1042 return;
1043 }
1044
1045 const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
1046 mSuspendedSessions.valueAt(index);
1047
1048 for (size_t i = 0; i < sessionEffects.size(); i++) {
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001049 const sp<SuspendedSessionDesc>& desc = sessionEffects.valueAt(i);
Eric Laurent81784c32012-11-19 14:55:58 -08001050 for (int j = 0; j < desc->mRefCount; j++) {
1051 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1052 chain->setEffectSuspendedAll_l(true);
1053 } else {
1054 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1055 desc->mType.timeLow);
1056 chain->setEffectSuspended_l(&desc->mType, true);
1057 }
1058 }
1059 }
1060}
1061
1062void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1063 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -08001064 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001065{
1066 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
1067
1068 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1069
1070 if (suspend) {
1071 if (index >= 0) {
1072 sessionEffects = mSuspendedSessions.valueAt(index);
1073 } else {
1074 mSuspendedSessions.add(sessionId, sessionEffects);
1075 }
1076 } else {
1077 if (index < 0) {
1078 return;
1079 }
1080 sessionEffects = mSuspendedSessions.valueAt(index);
1081 }
1082
1083
1084 int key = EffectChain::kKeyForSuspendAll;
1085 if (type != NULL) {
1086 key = type->timeLow;
1087 }
1088 index = sessionEffects.indexOfKey(key);
1089
1090 sp<SuspendedSessionDesc> desc;
1091 if (suspend) {
1092 if (index >= 0) {
1093 desc = sessionEffects.valueAt(index);
1094 } else {
1095 desc = new SuspendedSessionDesc();
1096 if (type != NULL) {
1097 desc->mType = *type;
1098 }
1099 sessionEffects.add(key, desc);
1100 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1101 }
1102 desc->mRefCount++;
1103 } else {
1104 if (index < 0) {
1105 return;
1106 }
1107 desc = sessionEffects.valueAt(index);
1108 if (--desc->mRefCount == 0) {
1109 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1110 sessionEffects.removeItemsAt(index);
1111 if (sessionEffects.isEmpty()) {
1112 ALOGV("updateSuspendedSessions_l() restore removing session %d",
1113 sessionId);
1114 mSuspendedSessions.removeItem(sessionId);
1115 }
1116 }
1117 }
1118 if (!sessionEffects.isEmpty()) {
1119 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1120 }
1121}
1122
1123void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
1124 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -08001125 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001126{
1127 Mutex::Autolock _l(mLock);
1128 checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
1129}
1130
1131void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
1132 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -08001133 audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001134{
1135 if (mType != RECORD) {
1136 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1137 // another session. This gives the priority to well behaved effect control panels
1138 // and applications not using global effects.
1139 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1140 // global effects
1141 if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) && (sessionId != AUDIO_SESSION_OUTPUT_STAGE)) {
1142 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1143 }
1144 }
1145
1146 sp<EffectChain> chain = getEffectChain_l(sessionId);
1147 if (chain != 0) {
1148 chain->checkSuspendOnEffectEnabled(effect, enabled);
1149 }
1150}
1151
Eric Laurent4c415062016-06-17 16:14:16 -07001152// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1153status_t AudioFlinger::RecordThread::checkEffectCompatibility_l(
1154 const effect_descriptor_t *desc, audio_session_t sessionId)
1155{
1156 // No global effect sessions on record threads
1157 if (sessionId == AUDIO_SESSION_OUTPUT_MIX || sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1158 ALOGW("checkEffectCompatibility_l(): global effect %s on record thread %s",
1159 desc->name, mThreadName);
1160 return BAD_VALUE;
1161 }
1162 // only pre processing effects on record thread
1163 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) {
1164 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on record thread %s",
1165 desc->name, mThreadName);
1166 return BAD_VALUE;
1167 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001168
1169 // always allow effects without processing load or latency
1170 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1171 return NO_ERROR;
1172 }
1173
Eric Laurent4c415062016-06-17 16:14:16 -07001174 audio_input_flags_t flags = mInput->flags;
1175 if (hasFastCapture() || (flags & AUDIO_INPUT_FLAG_FAST)) {
1176 if (flags & AUDIO_INPUT_FLAG_RAW) {
1177 ALOGW("checkEffectCompatibility_l(): effect %s on record thread %s in raw mode",
1178 desc->name, mThreadName);
1179 return BAD_VALUE;
1180 }
1181 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1182 ALOGW("checkEffectCompatibility_l(): non HW effect %s on record thread %s in fast mode",
1183 desc->name, mThreadName);
1184 return BAD_VALUE;
1185 }
1186 }
1187 return NO_ERROR;
1188}
1189
1190// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
1191status_t AudioFlinger::PlaybackThread::checkEffectCompatibility_l(
1192 const effect_descriptor_t *desc, audio_session_t sessionId)
1193{
1194 // no preprocessing on playback threads
1195 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) {
1196 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback"
1197 " thread %s", desc->name, mThreadName);
1198 return BAD_VALUE;
1199 }
1200
Eric Laurent3e4de772017-07-16 16:55:08 -07001201 // always allow effects without processing load or latency
1202 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) == EFFECT_FLAG_NO_PROCESS) {
1203 return NO_ERROR;
1204 }
1205
Eric Laurent4c415062016-06-17 16:14:16 -07001206 switch (mType) {
1207 case MIXER: {
Andy Hung9aad48c2017-11-29 10:29:19 -08001208#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001209 // Reject any effect on mixer multichannel sinks.
1210 // TODO: fix both format and multichannel issues with effects.
1211 if (mChannelCount != FCC_2) {
1212 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d) on MIXER"
1213 " thread %s", desc->name, mChannelCount, mThreadName);
1214 return BAD_VALUE;
1215 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001216#endif
Eric Laurent4c415062016-06-17 16:14:16 -07001217 audio_output_flags_t flags = mOutput->flags;
1218 if (hasFastMixer() || (flags & AUDIO_OUTPUT_FLAG_FAST)) {
1219 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1220 // global effects are applied only to non fast tracks if they are SW
1221 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1222 break;
1223 }
1224 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
1225 // only post processing on output stage session
1226 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_POST_PROC) {
1227 ALOGW("checkEffectCompatibility_l(): non post processing effect %s not allowed"
1228 " on output stage session", desc->name);
1229 return BAD_VALUE;
1230 }
1231 } else {
1232 // no restriction on effects applied on non fast tracks
1233 if ((hasAudioSession_l(sessionId) & ThreadBase::FAST_SESSION) == 0) {
1234 break;
1235 }
1236 }
Eric Laurent6dd0fd92016-09-15 12:44:53 -07001237
Eric Laurent4c415062016-06-17 16:14:16 -07001238 if (flags & AUDIO_OUTPUT_FLAG_RAW) {
1239 ALOGW("checkEffectCompatibility_l(): effect %s on playback thread in raw mode",
1240 desc->name);
1241 return BAD_VALUE;
1242 }
1243 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) == 0) {
1244 ALOGW("checkEffectCompatibility_l(): non HW effect %s on playback thread"
1245 " in fast mode", desc->name);
1246 return BAD_VALUE;
1247 }
1248 }
1249 } break;
1250 case OFFLOAD:
Jean-Michel Trivi773ee952016-07-11 16:53:18 -07001251 // nothing actionable on offload threads, if the effect:
1252 // - is offloadable: the effect can be created
1253 // - is NOT offloadable: the effect should still be created, but EffectHandle::enable()
1254 // will take care of invalidating the tracks of the thread
Eric Laurent4c415062016-06-17 16:14:16 -07001255 break;
1256 case DIRECT:
1257 // Reject any effect on Direct output threads for now, since the format of
1258 // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
1259 ALOGW("checkEffectCompatibility_l(): effect %s on DIRECT output thread %s",
1260 desc->name, mThreadName);
1261 return BAD_VALUE;
1262 case DUPLICATING:
Andy Hung9aad48c2017-11-29 10:29:19 -08001263#ifndef MULTICHANNEL_EFFECT_CHAIN
Eric Laurent4c415062016-06-17 16:14:16 -07001264 // Reject any effect on mixer multichannel sinks.
1265 // TODO: fix both format and multichannel issues with effects.
1266 if (mChannelCount != FCC_2) {
1267 ALOGW("checkEffectCompatibility_l(): effect %s for multichannel(%d)"
1268 " on DUPLICATING thread %s", desc->name, mChannelCount, mThreadName);
1269 return BAD_VALUE;
1270 }
Andy Hung9aad48c2017-11-29 10:29:19 -08001271#endif
Eric Laurent4c415062016-06-17 16:14:16 -07001272 if ((sessionId == AUDIO_SESSION_OUTPUT_STAGE) || (sessionId == AUDIO_SESSION_OUTPUT_MIX)) {
1273 ALOGW("checkEffectCompatibility_l(): global effect %s on DUPLICATING"
1274 " thread %s", desc->name, mThreadName);
1275 return BAD_VALUE;
1276 }
1277 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
1278 ALOGW("checkEffectCompatibility_l(): post processing effect %s on"
1279 " DUPLICATING thread %s", desc->name, mThreadName);
1280 return BAD_VALUE;
1281 }
1282 if ((desc->flags & EFFECT_FLAG_HW_ACC_TUNNEL) != 0) {
1283 ALOGW("checkEffectCompatibility_l(): HW tunneled effect %s on"
1284 " DUPLICATING thread %s", desc->name, mThreadName);
1285 return BAD_VALUE;
1286 }
1287 break;
1288 default:
1289 LOG_ALWAYS_FATAL("checkEffectCompatibility_l(): wrong thread type %d", mType);
1290 }
1291
1292 return NO_ERROR;
1293}
1294
Eric Laurent81784c32012-11-19 14:55:58 -08001295// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
1296sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
1297 const sp<AudioFlinger::Client>& client,
1298 const sp<IEffectClient>& effectClient,
1299 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -08001300 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -08001301 effect_descriptor_t *desc,
1302 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001303 status_t *status,
1304 bool pinned)
Eric Laurent81784c32012-11-19 14:55:58 -08001305{
1306 sp<EffectModule> effect;
1307 sp<EffectHandle> handle;
1308 status_t lStatus;
1309 sp<EffectChain> chain;
1310 bool chainCreated = false;
1311 bool effectCreated = false;
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001312 audio_unique_id_t effectId = AUDIO_UNIQUE_ID_USE_UNSPECIFIED;
Eric Laurent81784c32012-11-19 14:55:58 -08001313
1314 lStatus = initCheck();
1315 if (lStatus != NO_ERROR) {
1316 ALOGW("createEffect_l() Audio driver not initialized.");
1317 goto Exit;
1318 }
1319
Eric Laurent81784c32012-11-19 14:55:58 -08001320 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
1321
1322 { // scope for mLock
1323 Mutex::Autolock _l(mLock);
1324
Eric Laurent4c415062016-06-17 16:14:16 -07001325 lStatus = checkEffectCompatibility_l(desc, sessionId);
1326 if (lStatus != NO_ERROR) {
1327 goto Exit;
1328 }
1329
Eric Laurent81784c32012-11-19 14:55:58 -08001330 // check for existing effect chain with the requested audio session
1331 chain = getEffectChain_l(sessionId);
1332 if (chain == 0) {
1333 // create a new chain for this session
1334 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
1335 chain = new EffectChain(this, sessionId);
1336 addEffectChain_l(chain);
1337 chain->setStrategy(getStrategyForSession_l(sessionId));
1338 chainCreated = true;
1339 } else {
1340 effect = chain->getEffectFromDesc_l(desc);
1341 }
1342
1343 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
1344
1345 if (effect == 0) {
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001346 effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
Eric Laurent81784c32012-11-19 14:55:58 -08001347 // create a new effect module if none present in the chain
Mikhail Naganov2247f7b2017-01-13 11:52:54 -08001348 lStatus = chain->createEffect_l(effect, this, desc, effectId, sessionId, pinned);
Eric Laurent81784c32012-11-19 14:55:58 -08001349 if (lStatus != NO_ERROR) {
1350 goto Exit;
1351 }
1352 effectCreated = true;
1353
1354 effect->setDevice(mOutDevice);
1355 effect->setDevice(mInDevice);
1356 effect->setMode(mAudioFlinger->getMode());
1357 effect->setAudioSource(mAudioSource);
1358 }
1359 // create effect handle and connect it to effect module
1360 handle = new EffectHandle(effect, client, effectClient, priority);
Glenn Kastene75da402013-11-20 13:54:52 -08001361 lStatus = handle->initCheck();
1362 if (lStatus == OK) {
1363 lStatus = effect->addHandle(handle.get());
1364 }
Eric Laurent81784c32012-11-19 14:55:58 -08001365 if (enabled != NULL) {
1366 *enabled = (int)effect->isEnabled();
1367 }
1368 }
1369
1370Exit:
1371 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
1372 Mutex::Autolock _l(mLock);
1373 if (effectCreated) {
1374 chain->removeEffect_l(effect);
1375 }
Eric Laurent81784c32012-11-19 14:55:58 -08001376 if (chainCreated) {
1377 removeEffectChain_l(chain);
1378 }
haobo101735295ff7b0d2017-03-17 17:44:03 +08001379 // handle must be cleared by caller to avoid deadlock.
Eric Laurent81784c32012-11-19 14:55:58 -08001380 }
1381
Glenn Kasten9156ef32013-08-06 15:39:08 -07001382 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08001383 return handle;
1384}
1385
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001386void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
1387 bool unpinIfLast)
1388{
1389 bool remove = false;
1390 sp<EffectModule> effect;
1391 {
1392 Mutex::Autolock _l(mLock);
1393
1394 effect = handle->effect().promote();
1395 if (effect == 0) {
1396 return;
1397 }
1398 // restore suspended effects if the disconnected handle was enabled and the last one.
1399 remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
1400 if (remove) {
1401 removeEffect_l(effect, true);
1402 }
1403 }
1404 if (remove) {
1405 mAudioFlinger->updateOrphanEffectChains(effect);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001406 if (handle->enabled()) {
1407 checkSuspendOnEffectEnabled(effect, false, effect->sessionId());
1408 }
1409 }
1410}
1411
Glenn Kastend848eb42016-03-08 13:42:11 -08001412sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
1413 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001414{
1415 Mutex::Autolock _l(mLock);
1416 return getEffect_l(sessionId, effectId);
1417}
1418
Glenn Kastend848eb42016-03-08 13:42:11 -08001419sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
1420 int effectId)
Eric Laurent81784c32012-11-19 14:55:58 -08001421{
1422 sp<EffectChain> chain = getEffectChain_l(sessionId);
1423 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
1424}
1425
Eric Laurent6c796322019-04-09 14:13:17 -07001426std::vector<int> AudioFlinger::ThreadBase::getEffectIds_l(audio_session_t sessionId)
1427{
1428 sp<EffectChain> chain = getEffectChain_l(sessionId);
1429 return chain != nullptr ? chain->getEffectIds() : std::vector<int>{};
1430}
1431
Eric Laurent81784c32012-11-19 14:55:58 -08001432// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
1433// PlaybackThread::mLock held
1434status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
1435{
1436 // check for existing effect chain with the requested audio session
Glenn Kastend848eb42016-03-08 13:42:11 -08001437 audio_session_t sessionId = effect->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08001438 sp<EffectChain> chain = getEffectChain_l(sessionId);
1439 bool chainCreated = false;
1440
Eric Laurent5baf2af2013-09-12 17:37:00 -07001441 ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001442 "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %#x",
Eric Laurent5baf2af2013-09-12 17:37:00 -07001443 this, effect->desc().name, effect->desc().flags);
1444
Eric Laurent81784c32012-11-19 14:55:58 -08001445 if (chain == 0) {
1446 // create a new chain for this session
1447 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
1448 chain = new EffectChain(this, sessionId);
1449 addEffectChain_l(chain);
1450 chain->setStrategy(getStrategyForSession_l(sessionId));
1451 chainCreated = true;
1452 }
1453 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
1454
1455 if (chain->getEffectFromId_l(effect->id()) != 0) {
1456 ALOGW("addEffect_l() %p effect %s already present in chain %p",
1457 this, effect->desc().name, chain.get());
1458 return BAD_VALUE;
1459 }
1460
Eric Laurent5baf2af2013-09-12 17:37:00 -07001461 effect->setOffloaded(mType == OFFLOAD, mId);
1462
Eric Laurent81784c32012-11-19 14:55:58 -08001463 status_t status = chain->addEffect_l(effect);
1464 if (status != NO_ERROR) {
1465 if (chainCreated) {
1466 removeEffectChain_l(chain);
1467 }
1468 return status;
1469 }
1470
1471 effect->setDevice(mOutDevice);
1472 effect->setDevice(mInDevice);
1473 effect->setMode(mAudioFlinger->getMode());
1474 effect->setAudioSource(mAudioSource);
Eric Laurentd8365c52017-07-16 15:27:05 -07001475
Eric Laurent81784c32012-11-19 14:55:58 -08001476 return NO_ERROR;
1477}
1478
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001479void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect, bool release) {
Eric Laurent81784c32012-11-19 14:55:58 -08001480
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001481 ALOGV("%s %p effect %p", __FUNCTION__, this, effect.get());
Eric Laurent81784c32012-11-19 14:55:58 -08001482 effect_descriptor_t desc = effect->desc();
1483 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1484 detachAuxEffect_l(effect->id());
1485 }
1486
1487 sp<EffectChain> chain = effect->chain().promote();
1488 if (chain != 0) {
1489 // remove effect chain if removing last effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001490 if (chain->removeEffect_l(effect, release) == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08001491 removeEffectChain_l(chain);
1492 }
1493 } else {
1494 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
1495 }
1496}
1497
1498void AudioFlinger::ThreadBase::lockEffectChains_l(
1499 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1500{
1501 effectChains = mEffectChains;
1502 for (size_t i = 0; i < mEffectChains.size(); i++) {
1503 mEffectChains[i]->lock();
1504 }
1505}
1506
1507void AudioFlinger::ThreadBase::unlockEffectChains(
1508 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1509{
1510 for (size_t i = 0; i < effectChains.size(); i++) {
1511 effectChains[i]->unlock();
1512 }
1513}
1514
Glenn Kastend848eb42016-03-08 13:42:11 -08001515sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08001516{
1517 Mutex::Autolock _l(mLock);
1518 return getEffectChain_l(sessionId);
1519}
1520
Glenn Kastend848eb42016-03-08 13:42:11 -08001521sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
1522 const
Eric Laurent81784c32012-11-19 14:55:58 -08001523{
1524 size_t size = mEffectChains.size();
1525 for (size_t i = 0; i < size; i++) {
1526 if (mEffectChains[i]->sessionId() == sessionId) {
1527 return mEffectChains[i];
1528 }
1529 }
1530 return 0;
1531}
1532
1533void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
1534{
1535 Mutex::Autolock _l(mLock);
1536 size_t size = mEffectChains.size();
1537 for (size_t i = 0; i < size; i++) {
1538 mEffectChains[i]->setMode_l(mode);
1539 }
1540}
1541
Mikhail Naganovdc769682018-05-04 15:34:08 -07001542void AudioFlinger::ThreadBase::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07001543{
1544 config->type = AUDIO_PORT_TYPE_MIX;
1545 config->ext.mix.handle = mId;
1546 config->sample_rate = mSampleRate;
1547 config->format = mFormat;
1548 config->channel_mask = mChannelMask;
1549 config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
1550 AUDIO_PORT_CONFIG_FORMAT;
1551}
1552
Eric Laurent72e3f392015-05-20 14:43:50 -07001553void AudioFlinger::ThreadBase::systemReady()
1554{
1555 Mutex::Autolock _l(mLock);
1556 if (mSystemReady) {
1557 return;
1558 }
1559 mSystemReady = true;
1560
1561 for (size_t i = 0; i < mPendingConfigEvents.size(); i++) {
1562 sendConfigEvent_l(mPendingConfigEvents.editItemAt(i));
1563 }
1564 mPendingConfigEvents.clear();
1565}
1566
Andy Hungdae27702016-10-31 14:01:16 -07001567template <typename T>
1568ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::add(const sp<T> &track) {
1569 ssize_t index = mActiveTracks.indexOf(track);
1570 if (index >= 0) {
1571 ALOGW("ActiveTracks<T>::add track %p already there", track.get());
1572 return index;
1573 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001574 logTrack("add", track);
Andy Hungdae27702016-10-31 14:01:16 -07001575 mActiveTracksGeneration++;
1576 mLatestActiveTrack = track;
1577 ++mBatteryCounter[track->uid()].second;
Kevin Rocard069c2712018-03-29 19:09:14 -07001578 mHasChanged = true;
Andy Hungdae27702016-10-31 14:01:16 -07001579 return mActiveTracks.add(track);
1580}
1581
1582template <typename T>
1583ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::remove(const sp<T> &track) {
1584 ssize_t index = mActiveTracks.remove(track);
1585 if (index < 0) {
1586 ALOGW("ActiveTracks<T>::remove nonexistent track %p", track.get());
1587 return index;
1588 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001589 logTrack("remove", track);
Andy Hungdae27702016-10-31 14:01:16 -07001590 mActiveTracksGeneration++;
1591 --mBatteryCounter[track->uid()].second;
1592 // mLatestActiveTrack is not cleared even if is the same as track.
Kevin Rocard069c2712018-03-29 19:09:14 -07001593 mHasChanged = true;
Andy Hung8946a282018-04-19 20:04:56 -07001594#ifdef TEE_SINK
1595 track->dumpTee(-1 /* fd */, "_REMOVE");
1596#endif
Andy Hungdae27702016-10-31 14:01:16 -07001597 return index;
1598}
1599
1600template <typename T>
1601void AudioFlinger::ThreadBase::ActiveTracks<T>::clear() {
1602 for (const sp<T> &track : mActiveTracks) {
1603 BatteryNotifier::getInstance().noteStopAudio(track->uid());
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001604 logTrack("clear", track);
Andy Hungdae27702016-10-31 14:01:16 -07001605 }
1606 mLastActiveTracksGeneration = mActiveTracksGeneration;
Kevin Rocard069c2712018-03-29 19:09:14 -07001607 if (!mActiveTracks.empty()) { mHasChanged = true; }
Andy Hungdae27702016-10-31 14:01:16 -07001608 mActiveTracks.clear();
1609 mLatestActiveTrack.clear();
1610 mBatteryCounter.clear();
1611}
1612
1613template <typename T>
1614void AudioFlinger::ThreadBase::ActiveTracks<T>::updatePowerState(
1615 sp<ThreadBase> thread, bool force) {
1616 // Updates ActiveTracks client uids to the thread wakelock.
1617 if (mActiveTracksGeneration != mLastActiveTracksGeneration || force) {
1618 thread->updateWakeLockUids_l(getWakeLockUids());
1619 mLastActiveTracksGeneration = mActiveTracksGeneration;
1620 }
1621
1622 // Updates BatteryNotifier uids
1623 for (auto it = mBatteryCounter.begin(); it != mBatteryCounter.end();) {
1624 const uid_t uid = it->first;
1625 ssize_t &previous = it->second.first;
1626 ssize_t &current = it->second.second;
1627 if (current > 0) {
1628 if (previous == 0) {
1629 BatteryNotifier::getInstance().noteStartAudio(uid);
1630 }
1631 previous = current;
1632 ++it;
1633 } else if (current == 0) {
1634 if (previous > 0) {
1635 BatteryNotifier::getInstance().noteStopAudio(uid);
1636 }
1637 it = mBatteryCounter.erase(it); // std::map<> is stable on iterator erase.
1638 } else /* (current < 0) */ {
1639 LOG_ALWAYS_FATAL("negative battery count %zd", current);
1640 }
1641 }
1642}
Eric Laurent83b88082014-06-20 18:31:16 -07001643
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001644template <typename T>
Kevin Rocard069c2712018-03-29 19:09:14 -07001645bool AudioFlinger::ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
1646 const bool hasChanged = mHasChanged;
1647 mHasChanged = false;
1648 return hasChanged;
1649}
1650
1651template <typename T>
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001652void AudioFlinger::ThreadBase::ActiveTracks<T>::logTrack(
1653 const char *funcName, const sp<T> &track) const {
1654 if (mLocalLog != nullptr) {
1655 String8 result;
1656 track->appendDump(result, false /* active */);
1657 mLocalLog->log("AT::%-10s(%p) %s", funcName, track.get(), result.string());
1658 }
1659}
1660
Eric Laurent6acd1d42017-01-04 14:23:29 -08001661void AudioFlinger::ThreadBase::broadcast_l()
1662{
1663 // Thread could be blocked waiting for async
1664 // so signal it to handle state changes immediately
1665 // If threadLoop is currently unlocked a signal of mWaitWorkCV will
1666 // be lost so we also flag to prevent it blocking on mWaitWorkCV
1667 mSignalPending = true;
1668 mWaitWorkCV.broadcast();
1669}
1670
Andy Hungd0979812019-02-21 15:51:44 -08001671// Call only from threadLoop() or when it is idle.
1672// Do not call from high performance code as this may do binder rpc to the MediaMetrics service.
1673void AudioFlinger::ThreadBase::sendStatistics(bool force)
1674{
1675 // Do not log if we have no stats.
1676 // We choose the timestamp verifier because it is the most likely item to be present.
1677 const int64_t nstats = mTimestampVerifier.getN() - mLastRecordedTimestampVerifierN;
1678 if (nstats == 0) {
1679 return;
1680 }
1681
1682 // Don't log more frequently than once per 12 hours.
1683 // We use BOOTTIME to include suspend time.
1684 const int64_t timeNs = systemTime(SYSTEM_TIME_BOOTTIME);
1685 const int64_t sinceNs = timeNs - mLastRecordedTimeNs; // ok if mLastRecordedTimeNs = 0
1686 if (!force && sinceNs <= 12 * NANOS_PER_HOUR) {
1687 return;
1688 }
1689
1690 mLastRecordedTimestampVerifierN = mTimestampVerifier.getN();
1691 mLastRecordedTimeNs = timeNs;
1692
1693 std::unique_ptr<MediaAnalyticsItem> item(MediaAnalyticsItem::create("audiothread"));
1694
1695#define MM_PREFIX "android.media.audiothread." // avoid cut-n-paste errors.
1696
1697 // thread configuration
1698 item->setInt32(MM_PREFIX "id", (int32_t)mId); // IO handle
1699 // item->setInt32(MM_PREFIX "portId", (int32_t)mPortId);
1700 item->setCString(MM_PREFIX "type", threadTypeToString(mType));
1701 item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
1702 item->setInt64(MM_PREFIX "channelMask", (int64_t)mChannelMask);
1703 item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
1704 item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
1705 item->setCString(MM_PREFIX "outDevice", toString(mOutDevice).c_str());
1706 item->setCString(MM_PREFIX "inDevice", toString(mInDevice).c_str());
1707
1708 // thread statistics
1709 if (mIoJitterMs.getN() > 0) {
1710 item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
1711 item->setDouble(MM_PREFIX "ioJitterMs.std", mIoJitterMs.getStdDev());
1712 }
1713 if (mProcessTimeMs.getN() > 0) {
1714 item->setDouble(MM_PREFIX "processTimeMs.mean", mProcessTimeMs.getMean());
1715 item->setDouble(MM_PREFIX "processTimeMs.std", mProcessTimeMs.getStdDev());
1716 }
1717 const auto tsjitter = mTimestampVerifier.getJitterMs();
1718 if (tsjitter.getN() > 0) {
1719 item->setDouble(MM_PREFIX "timestampJitterMs.mean", tsjitter.getMean());
1720 item->setDouble(MM_PREFIX "timestampJitterMs.std", tsjitter.getStdDev());
1721 }
1722 if (mLatencyMs.getN() > 0) {
1723 item->setDouble(MM_PREFIX "latencyMs.mean", mLatencyMs.getMean());
1724 item->setDouble(MM_PREFIX "latencyMs.std", mLatencyMs.getStdDev());
1725 }
1726
1727 item->selfrecord();
1728}
1729
Eric Laurent81784c32012-11-19 14:55:58 -08001730// ----------------------------------------------------------------------------
1731// Playback
1732// ----------------------------------------------------------------------------
1733
1734AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1735 AudioStreamOut* output,
1736 audio_io_handle_t id,
1737 audio_devices_t device,
Eric Laurent72e3f392015-05-20 14:43:50 -07001738 type_t type,
Eric Laurente93cc032016-05-05 10:15:10 -07001739 bool systemReady)
Eric Laurent72e3f392015-05-20 14:43:50 -07001740 : ThreadBase(audioFlinger, id, device, AUDIO_DEVICE_NONE, type, systemReady),
Andy Hung2098f272014-02-27 14:00:06 -08001741 mNormalFrameCount(0), mSinkBuffer(NULL),
Andy Hung6146c082014-03-18 11:56:15 -07001742 mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung69aed5f2014-02-25 17:24:40 -08001743 mMixerBuffer(NULL),
1744 mMixerBufferSize(0),
1745 mMixerBufferFormat(AUDIO_FORMAT_INVALID),
1746 mMixerBufferValid(false),
Andy Hung6146c082014-03-18 11:56:15 -07001747 mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
Andy Hung98ef9782014-03-04 14:46:50 -08001748 mEffectBuffer(NULL),
1749 mEffectBufferSize(0),
1750 mEffectBufferFormat(AUDIO_FORMAT_INVALID),
1751 mEffectBufferValid(false),
Glenn Kastenc1fac192013-08-06 07:41:36 -07001752 mSuspended(0), mBytesWritten(0),
Andy Hungc54b1ff2016-02-23 14:07:07 -08001753 mFramesWritten(0),
Andy Hung238fa3d2016-07-28 10:53:22 -07001754 mSuspendedFrames(0),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001755 mActiveTracks(&this->mLocalLog),
Eric Laurent81784c32012-11-19 14:55:58 -08001756 // mStreamTypes[] initialized in constructor body
Andy Hung1bc088a2018-02-09 15:57:31 -08001757 mTracks(type == MIXER),
Eric Laurent81784c32012-11-19 14:55:58 -08001758 mOutput(output),
Andy Hung446f4df2019-02-21 12:26:41 -08001759 mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
Eric Laurent81784c32012-11-19 14:55:58 -08001760 mMixerStatus(MIXER_IDLE),
1761 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001762 mStandbyDelayNs(AudioFlinger::mStandbyTimeInNsecs),
Eric Laurentbfb1b832013-01-07 09:53:42 -08001763 mBytesRemaining(0),
1764 mCurrentWriteLength(0),
1765 mUseAsyncWrite(false),
Eric Laurent3b4529e2013-09-05 18:09:19 -07001766 mWriteAckSequence(0),
1767 mDrainSequence(0),
Eric Laurent81784c32012-11-19 14:55:58 -08001768 mScreenState(AudioFlinger::mScreenState),
1769 // index 0 is reserved for normal mixer's submix
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001770 mFastTrackAvailMask(((1 << FastMixerState::sMaxFastTracks) - 1) & ~1),
Eric Laurent7c29ec92017-09-20 17:54:22 -07001771 mHwSupportsPause(false), mHwPaused(false), mFlushPending(false),
1772 mLeftVolFloat(-1.0), mRightVolFloat(-1.0)
Eric Laurent81784c32012-11-19 14:55:58 -08001773{
Glenn Kastend7dca052015-03-05 16:05:54 -08001774 snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
1775 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08001776
1777 // Assumes constructor is called by AudioFlinger with it's mLock held, but
1778 // it would be safer to explicitly pass initial masterVolume/masterMute as
1779 // parameter.
1780 //
1781 // If the HAL we are using has support for master volume or master mute,
1782 // then do not attenuate or mute during mixing (just leave the volume at 1.0
1783 // and the mute set to false).
1784 mMasterVolume = audioFlinger->masterVolume_l();
1785 mMasterMute = audioFlinger->masterMute_l();
1786 if (mOutput && mOutput->audioHwDev) {
1787 if (mOutput->audioHwDev->canSetMasterVolume()) {
1788 mMasterVolume = 1.0;
1789 }
1790
1791 if (mOutput->audioHwDev->canSetMasterMute()) {
1792 mMasterMute = false;
1793 }
Andy Hungc8fddf32018-08-08 18:32:37 -07001794 mIsMsdDevice = strcmp(
1795 mOutput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
Eric Laurent81784c32012-11-19 14:55:58 -08001796 }
1797
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001798 readOutputParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001799
Andy Hungc8fddf32018-08-08 18:32:37 -07001800 // TODO: We may also match on address as well as device type for
1801 // AUDIO_DEVICE_OUT_BUS, AUDIO_DEVICE_OUT_ALL_A2DP, AUDIO_DEVICE_OUT_REMOTE_SUBMIX
1802 if (type == MIXER || type == DIRECT) {
1803 mTimestampCorrectedDevices = (audio_devices_t)property_get_int64(
1804 "audio.timestamp.corrected_output_devices",
1805 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_OUT_BUS // turn on by default for MSD
1806 : AUDIO_DEVICE_NONE));
1807 }
1808
Eric Laurent223fd5c2014-11-11 13:43:36 -08001809 // ++ operator does not compile
Eric Laurent98e38192018-02-15 18:31:53 -08001810 for (audio_stream_type_t stream = AUDIO_STREAM_MIN; stream < AUDIO_STREAM_FOR_POLICY_CNT;
Eric Laurent81784c32012-11-19 14:55:58 -08001811 stream = (audio_stream_type_t) (stream + 1)) {
Eric Laurent98e38192018-02-15 18:31:53 -08001812 mStreamTypes[stream].volume = 0.0f;
Eric Laurent81784c32012-11-19 14:55:58 -08001813 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
1814 }
Eric Laurent98e38192018-02-15 18:31:53 -08001815 // Audio patch volume is always max
1816 mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
1817 mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001818}
1819
1820AudioFlinger::PlaybackThread::~PlaybackThread()
1821{
Glenn Kasten9e58b552013-01-18 15:09:48 -08001822 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung010a1a12014-03-13 13:57:33 -07001823 free(mSinkBuffer);
Andy Hung69aed5f2014-02-25 17:24:40 -08001824 free(mMixerBuffer);
Andy Hung98ef9782014-03-04 14:46:50 -08001825 free(mEffectBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08001826}
1827
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001828// Thread virtuals
1829
1830void AudioFlinger::PlaybackThread::onFirstRef()
Eric Laurent81784c32012-11-19 14:55:58 -08001831{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001832 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08001833}
1834
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001835// ThreadBase virtuals
1836void AudioFlinger::PlaybackThread::preExit()
1837{
1838 ALOGV(" preExit()");
1839 // FIXME this is using hard-coded strings but in the future, this functionality will be
1840 // converted to use audio HAL extensions required to support tunneling
1841 status_t result = mOutput->stream->setParameters(String8("exiting=1"));
1842 ALOGE_IF(result != OK, "Error when setting parameters on exit: %d", result);
1843}
1844
1845void AudioFlinger::PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001846{
Eric Laurent81784c32012-11-19 14:55:58 -08001847 String8 result;
1848
Marco Nelissenb2208842014-02-07 14:00:50 -08001849 result.appendFormat(" Stream volumes in dB: ");
Eric Laurent81784c32012-11-19 14:55:58 -08001850 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
1851 const stream_type_t *st = &mStreamTypes[i];
1852 if (i > 0) {
1853 result.appendFormat(", ");
1854 }
1855 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
1856 if (st->mute) {
1857 result.append("M");
1858 }
1859 }
1860 result.append("\n");
1861 write(fd, result.string(), result.length());
1862 result.clear();
1863
Eric Laurent81784c32012-11-19 14:55:58 -08001864 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
1865 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
Elliott Hughes87cebad2014-05-22 10:14:43 -07001866 dprintf(fd, " Normal mixer raw underrun counters: partial=%u empty=%u\n",
Eric Laurent81784c32012-11-19 14:55:58 -08001867 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
Marco Nelissenb2208842014-02-07 14:00:50 -08001868
1869 size_t numtracks = mTracks.size();
1870 size_t numactive = mActiveTracks.size();
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001871 dprintf(fd, " %zu Tracks", numtracks);
Marco Nelissenb2208842014-02-07 14:00:50 -08001872 size_t numactiveseen = 0;
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001873 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08001874 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001875 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001876 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07001877 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08001878 for (size_t i = 0; i < numtracks; ++i) {
1879 sp<Track> track = mTracks[i];
1880 if (track != 0) {
1881 bool active = mActiveTracks.indexOf(track) >= 0;
1882 if (active) {
1883 numactiveseen++;
1884 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001885 result.append(prefix);
1886 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08001887 }
1888 }
1889 } else {
1890 result.append("\n");
1891 }
1892 if (numactiveseen != numactive) {
1893 // some tracks in the active list were not in the tracks list
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001894 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08001895 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001896 result.append(prefix);
Andy Hungf6ab58d2018-05-25 12:50:39 -07001897 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08001898 for (size_t i = 0; i < numactive; ++i) {
Andy Hungdae27702016-10-31 14:01:16 -07001899 sp<Track> track = mActiveTracks[i];
1900 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07001901 result.append(prefix);
1902 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08001903 }
1904 }
1905 }
1906
1907 write(fd, result.string(), result.size());
Eric Laurent81784c32012-11-19 14:55:58 -08001908}
1909
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001910void AudioFlinger::PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08001911{
Mikhail Naganovdfb411f2018-09-11 13:39:56 -07001912 dprintf(fd, " Master mute: %s\n", mMasterMute ? "on" : "off");
jiabin245cdd92018-12-07 17:55:15 -08001913 if (mHapticChannelMask != AUDIO_CHANNEL_NONE) {
1914 dprintf(fd, " Haptic channel mask: %#x (%s)\n", mHapticChannelMask,
1915 channelMaskToString(mHapticChannelMask, true /* output */).c_str());
1916 }
Elliott Hughes87cebad2014-05-22 10:14:43 -07001917 dprintf(fd, " Normal frame count: %zu\n", mNormalFrameCount);
Elliott Hughes87cebad2014-05-22 10:14:43 -07001918 dprintf(fd, " Total writes: %d\n", mNumWrites);
1919 dprintf(fd, " Delayed writes: %d\n", mNumDelayedWrites);
1920 dprintf(fd, " Blocked in write: %s\n", mInWrite ? "yes" : "no");
1921 dprintf(fd, " Suspend count: %d\n", mSuspended);
1922 dprintf(fd, " Sink buffer : %p\n", mSinkBuffer);
1923 dprintf(fd, " Mixer buffer: %p\n", mMixerBuffer);
1924 dprintf(fd, " Effect buffer: %p\n", mEffectBuffer);
1925 dprintf(fd, " Fast track availMask=%#x\n", mFastTrackAvailMask);
Eric Laurent42537be2016-01-08 17:16:42 -08001926 dprintf(fd, " Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
Glenn Kasten97b7b752014-09-28 13:04:24 -07001927 AudioStreamOut *output = mOutput;
1928 audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
Mikhail Naganov913d06c2016-11-01 12:49:22 -07001929 dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08001930 output, flags, toString(flags).c_str());
Andy Hungb54c8542016-09-21 12:55:15 -07001931 dprintf(fd, " Frames written: %lld\n", (long long)mFramesWritten);
1932 dprintf(fd, " Suspended frames: %lld\n", (long long)mSuspendedFrames);
1933 if (mPipeSink.get() != nullptr) {
1934 dprintf(fd, " PipeSink frames written: %lld\n", (long long)mPipeSink->framesWritten());
1935 }
1936 if (output != nullptr) {
1937 dprintf(fd, " Hal stream dump:\n");
1938 (void)output->stream->dump(fd);
1939 }
Eric Laurent81784c32012-11-19 14:55:58 -08001940}
1941
Eric Laurent81784c32012-11-19 14:55:58 -08001942// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
1943sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
1944 const sp<AudioFlinger::Client>& client,
1945 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001946 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -08001947 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001948 audio_format_t format,
1949 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001950 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -08001951 size_t *pNotificationFrameCount,
1952 uint32_t notificationsPerBuffer,
1953 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -08001954 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -08001955 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -07001956 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001957 pid_t creatorPid,
Eric Laurent81784c32012-11-19 14:55:58 -08001958 pid_t tid,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001959 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001960 status_t *status,
1961 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -08001962{
Glenn Kasten74935e42013-12-19 08:56:45 -08001963 size_t frameCount = *pFrameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08001964 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08001965 sp<Track> track;
1966 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07001967 audio_output_flags_t outputFlags = mOutput->flags;
Eric Laurent21da6472017-11-09 16:29:26 -08001968 audio_output_flags_t requestedFlags = *flags;
Eric Laurent9b11c022018-06-06 19:19:22 -07001969 uint32_t sampleRate;
1970
1971 if (sharedBuffer != 0 && checkIMemory(sharedBuffer) != NO_ERROR) {
1972 lStatus = BAD_VALUE;
1973 goto Exit;
1974 }
Eric Laurent21da6472017-11-09 16:29:26 -08001975
1976 if (*pSampleRate == 0) {
1977 *pSampleRate = mSampleRate;
1978 }
Eric Laurent9b11c022018-06-06 19:19:22 -07001979 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07001980
1981 // special case for FAST flag considered OK if fast mixer is present
1982 if (hasFastMixer()) {
1983 outputFlags = (audio_output_flags_t)(outputFlags | AUDIO_OUTPUT_FLAG_FAST);
1984 }
1985
1986 // Check if requested flags are compatible with output stream flags
1987 if ((*flags & outputFlags) != *flags) {
1988 ALOGW("createTrack_l(): mismatch between requested flags (%08x) and output flags (%08x)",
1989 *flags, outputFlags);
1990 *flags = (audio_output_flags_t)(*flags & outputFlags);
1991 }
Eric Laurent81784c32012-11-19 14:55:58 -08001992
Eric Laurent81784c32012-11-19 14:55:58 -08001993 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07001994 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent81784c32012-11-19 14:55:58 -08001995 if (
Eric Laurent81784c32012-11-19 14:55:58 -08001996 // PCM data
1997 audio_is_linear_pcm(format) &&
Andy Hung1f439e12015-05-19 12:57:41 -07001998 // TODO: extract as a data library function that checks that a computationally
1999 // expensive downmixer is not required: isFastOutputChannelConversion()
jiabin245cdd92018-12-07 17:55:15 -08002000 (channelMask == (mChannelMask | mHapticChannelMask) ||
Andy Hung1f439e12015-05-19 12:57:41 -07002001 mChannelMask != AUDIO_CHANNEL_OUT_STEREO ||
2002 (channelMask == AUDIO_CHANNEL_OUT_MONO
2003 /* && mChannelMask == AUDIO_CHANNEL_OUT_STEREO */)) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002004 // hardware sample rate
2005 (sampleRate == mSampleRate) &&
Eric Laurent81784c32012-11-19 14:55:58 -08002006 // normal mixer has an associated fast mixer
2007 hasFastMixer() &&
2008 // there are sufficient fast track slots available
2009 (mFastTrackAvailMask != 0)
2010 // FIXME test that MixerThread for this fast track has a capable output HAL
2011 // FIXME add a permission test also?
2012 ) {
Andy Hunge0a269a2016-03-23 15:13:42 -07002013 // static tracks can have any nonzero framecount, streaming tracks check against minimum.
2014 if (sharedBuffer == 0) {
Glenn Kasten03490092014-05-27 12:30:54 -07002015 // read the fast track multiplier property the first time it is needed
2016 int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
2017 if (ok != 0) {
2018 ALOGE("%s pthread_once failed: %d", __func__, ok);
2019 }
Andy Hunge0a269a2016-03-23 15:13:42 -07002020 frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
Eric Laurent81784c32012-11-19 14:55:58 -08002021 }
Eric Laurent4c415062016-06-17 16:14:16 -07002022
2023 // check compatibility with audio effects.
2024 { // scope for mLock
2025 Mutex::Autolock _l(mLock);
Andy Hungd3bb0ad2016-10-11 17:16:43 -07002026 for (audio_session_t session : {
2027 AUDIO_SESSION_OUTPUT_STAGE,
2028 AUDIO_SESSION_OUTPUT_MIX,
2029 sessionId,
2030 }) {
2031 sp<EffectChain> chain = getEffectChain_l(session);
2032 if (chain.get() != nullptr) {
2033 audio_output_flags_t old = *flags;
2034 chain->checkOutputFlagCompatibility(flags);
2035 if (old != *flags) {
2036 ALOGV("AUDIO_OUTPUT_FLAGS denied by effect, session=%d old=%#x new=%#x",
2037 (int)session, (int)old, (int)*flags);
2038 }
Eric Laurent4c415062016-06-17 16:14:16 -07002039 }
2040 }
2041 }
Eric Laurent122f7e72016-06-29 11:53:29 -07002042 ALOGV_IF((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0,
Eric Laurent4c415062016-06-17 16:14:16 -07002043 "AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
2044 frameCount, mFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08002045 } else {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002046 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: sharedBuffer=%p frameCount=%zu "
2047 "mFrameCount=%zu format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
Andy Hung6146c082014-03-18 11:56:15 -07002048 "sampleRate=%u mSampleRate=%u "
Eric Laurent81784c32012-11-19 14:55:58 -08002049 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
Glenn Kastend79072e2016-01-06 08:41:20 -08002050 sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08002051 audio_is_linear_pcm(format),
2052 channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
Eric Laurent4c415062016-06-17 16:14:16 -07002053 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
Andy Hung0e48d252015-01-26 11:43:15 -08002054 }
2055 }
Eric Laurent21da6472017-11-09 16:29:26 -08002056
2057 if (!audio_has_proportional_frames(format)) {
2058 if (sharedBuffer != 0) {
2059 // Same comment as below about ignoring frameCount parameter for set()
2060 frameCount = sharedBuffer->size();
2061 } else if (frameCount == 0) {
2062 frameCount = mNormalFrameCount;
2063 }
2064 if (notificationFrameCount != frameCount) {
2065 notificationFrameCount = frameCount;
2066 }
2067 } else if (sharedBuffer != 0) {
2068 // FIXME: Ensure client side memory buffers need
2069 // not have additional alignment beyond sample
2070 // (e.g. 16 bit stereo accessed as 32 bit frame).
2071 size_t alignment = audio_bytes_per_sample(format);
2072 if (alignment & 1) {
2073 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
2074 alignment = 1;
2075 }
2076 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
2077 size_t frameSize = channelCount * audio_bytes_per_sample(format);
2078 if (channelCount > 1) {
2079 // More than 2 channels does not require stronger alignment than stereo
2080 alignment <<= 1;
2081 }
2082 if (((uintptr_t)sharedBuffer->pointer() & (alignment - 1)) != 0) {
2083 ALOGE("Invalid buffer alignment: address %p, channel count %u",
2084 sharedBuffer->pointer(), channelCount);
2085 lStatus = BAD_VALUE;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002086 goto Exit;
2087 }
Eric Laurent21da6472017-11-09 16:29:26 -08002088
2089 // When initializing a shared buffer AudioTrack via constructors,
2090 // there's no frameCount parameter.
2091 // But when initializing a shared buffer AudioTrack via set(),
2092 // there _is_ a frameCount parameter. We silently ignore it.
2093 frameCount = sharedBuffer->size() / frameSize;
2094 } else {
2095 size_t minFrameCount = 0;
2096 // For fast tracks we try to respect the application's request for notifications per buffer.
2097 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2098 if (notificationsPerBuffer > 0) {
2099 // Avoid possible arithmetic overflow during multiplication.
2100 if (notificationsPerBuffer > SIZE_MAX / mFrameCount) {
2101 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
2102 notificationsPerBuffer, mFrameCount);
2103 } else {
2104 minFrameCount = mFrameCount * notificationsPerBuffer;
2105 }
2106 }
2107 } else {
2108 // For normal PCM streaming tracks, update minimum frame count.
2109 // Buffer depth is forced to be at least 2 x the normal mixer frame count and
2110 // cover audio hardware latency.
2111 // This is probably too conservative, but legacy application code may depend on it.
2112 // If you change this calculation, also review the start threshold which is related.
2113 uint32_t latencyMs = latency_l();
2114 if (latencyMs == 0) {
2115 ALOGE("Error when retrieving output stream latency");
2116 lStatus = UNKNOWN_ERROR;
2117 goto Exit;
2118 }
2119
2120 minFrameCount = AudioSystem::calculateMinFrameCount(latencyMs, mNormalFrameCount,
2121 mSampleRate, sampleRate, speed /*, 0 mNotificationsPerBufferReq*/);
2122
Eric Laurent81784c32012-11-19 14:55:58 -08002123 }
Eric Laurent21da6472017-11-09 16:29:26 -08002124 if (frameCount < minFrameCount) {
Eric Laurent81784c32012-11-19 14:55:58 -08002125 frameCount = minFrameCount;
2126 }
Eric Laurent81784c32012-11-19 14:55:58 -08002127 }
Eric Laurent21da6472017-11-09 16:29:26 -08002128
2129 // Make sure that application is notified with sufficient margin before underrun.
2130 // The client can divide the AudioTrack buffer into sub-buffers,
2131 // and expresses its desire to server as the notification frame count.
2132 if (sharedBuffer == 0 && audio_is_linear_pcm(format)) {
2133 size_t maxNotificationFrames;
2134 if (*flags & AUDIO_OUTPUT_FLAG_FAST) {
2135 // notify every HAL buffer, regardless of the size of the track buffer
2136 maxNotificationFrames = mFrameCount;
2137 } else {
Andy Hungfa117802019-04-12 13:50:39 -07002138 // Triple buffer the notification period for a triple buffered mixer period;
2139 // otherwise, double buffering for the notification period is fine.
2140 //
2141 // TODO: This should be moved to AudioTrack to modify the notification period
2142 // on AudioTrack::setBufferSizeInFrames() changes.
2143 const int nBuffering =
2144 (uint64_t{frameCount} * mSampleRate)
2145 / (uint64_t{mNormalFrameCount} * sampleRate) == 3 ? 3 : 2;
2146
Eric Laurent21da6472017-11-09 16:29:26 -08002147 maxNotificationFrames = frameCount / nBuffering;
2148 // If client requested a fast track but this was denied, then use the smaller maximum.
2149 if (requestedFlags & AUDIO_OUTPUT_FLAG_FAST) {
2150 size_t maxNotificationFramesFastDenied = FMS_20 * sampleRate / 1000;
2151 if (maxNotificationFrames > maxNotificationFramesFastDenied) {
2152 maxNotificationFrames = maxNotificationFramesFastDenied;
2153 }
2154 }
2155 }
2156 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
2157 if (notificationFrameCount == 0) {
2158 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
2159 maxNotificationFrames, frameCount);
2160 } else {
2161 ALOGW("Client adjusted notificationFrames from %zu to %zu for frameCount %zu",
2162 notificationFrameCount, maxNotificationFrames, frameCount);
2163 }
2164 notificationFrameCount = maxNotificationFrames;
2165 }
2166 }
2167
Glenn Kasten74935e42013-12-19 08:56:45 -08002168 *pFrameCount = frameCount;
Eric Laurent21da6472017-11-09 16:29:26 -08002169 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08002170
Glenn Kastenc3df8382014-03-13 15:05:25 -07002171 switch (mType) {
2172
2173 case DIRECT:
Phil Burkfdb3c072016-02-09 10:47:02 -08002174 if (audio_is_linear_pcm(format)) { // TODO maybe use audio_has_proportional_frames()?
Eric Laurent81784c32012-11-19 14:55:58 -08002175 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002176 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
2177 "for output %p with format %#x",
Eric Laurent81784c32012-11-19 14:55:58 -08002178 sampleRate, format, channelMask, mOutput, mFormat);
2179 lStatus = BAD_VALUE;
2180 goto Exit;
2181 }
2182 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002183 break;
2184
2185 case OFFLOAD:
Eric Laurentbfb1b832013-01-07 09:53:42 -08002186 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002187 ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
2188 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002189 sampleRate, format, channelMask, mOutput, mFormat);
2190 lStatus = BAD_VALUE;
2191 goto Exit;
2192 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002193 break;
2194
2195 default:
Glenn Kasten993fa062014-05-02 11:14:34 -07002196 if (!audio_is_linear_pcm(format)) {
Glenn Kastencac3daa2014-02-07 09:47:14 -08002197 ALOGE("createTrack_l() Bad parameter: format %#x \""
2198 "for output %p with format %#x",
Eric Laurentbfb1b832013-01-07 09:53:42 -08002199 format, mOutput, mFormat);
2200 lStatus = BAD_VALUE;
2201 goto Exit;
2202 }
Andy Hungcd044842014-08-07 11:04:34 -07002203 if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Eric Laurent81784c32012-11-19 14:55:58 -08002204 ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
2205 lStatus = BAD_VALUE;
2206 goto Exit;
2207 }
Glenn Kastenc3df8382014-03-13 15:05:25 -07002208 break;
2209
Eric Laurent81784c32012-11-19 14:55:58 -08002210 }
2211
2212 lStatus = initCheck();
2213 if (lStatus != NO_ERROR) {
Glenn Kasten15e57982013-09-24 11:52:37 -07002214 ALOGE("createTrack_l() audio driver not initialized");
Eric Laurent81784c32012-11-19 14:55:58 -08002215 goto Exit;
2216 }
2217
2218 { // scope for mLock
2219 Mutex::Autolock _l(mLock);
2220
2221 // all tracks in same audio session must share the same routing strategy otherwise
2222 // conflicts will happen when tracks are moved from one output to another by audio policy
2223 // manager
2224 uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
2225 for (size_t i = 0; i < mTracks.size(); ++i) {
2226 sp<Track> t = mTracks[i];
Eric Laurent83b88082014-06-20 18:31:16 -07002227 if (t != 0 && t->isExternalTrack()) {
Eric Laurent81784c32012-11-19 14:55:58 -08002228 uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
2229 if (sessionId == t->sessionId() && strategy != actual) {
2230 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
2231 strategy, actual);
2232 lStatus = BAD_VALUE;
2233 goto Exit;
2234 }
2235 }
2236 }
2237
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002238 track = new Track(this, client, streamType, attr, sampleRate, format,
Andy Hung8fe68032017-06-05 16:17:51 -07002239 channelMask, frameCount,
2240 nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002241 sessionId, creatorPid, uid, *flags, TrackBase::TYPE_DEFAULT, portId);
Glenn Kasten03003332013-08-06 15:40:54 -07002242
Glenn Kasten03003332013-08-06 15:40:54 -07002243 lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
2244 if (lStatus != NO_ERROR) {
Glenn Kasten0cde0762014-01-16 15:06:36 -08002245 ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002246 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08002247 goto Exit;
2248 }
2249 mTracks.add(track);
2250
2251 sp<EffectChain> chain = getEffectChain_l(sessionId);
2252 if (chain != 0) {
2253 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
2254 track->setMainBuffer(chain->inBuffer());
2255 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
2256 chain->incTrackCnt();
2257 }
2258
Eric Laurent05067782016-06-01 18:27:28 -07002259 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) && (tid != -1)) {
Eric Laurent81784c32012-11-19 14:55:58 -08002260 pid_t callingPid = IPCThreadState::self()->getCallingPid();
2261 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
2262 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07002263 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08002264 }
2265 }
2266
2267 lStatus = NO_ERROR;
2268
2269Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07002270 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08002271 return track;
2272}
2273
Andy Hung1bc088a2018-02-09 15:57:31 -08002274template<typename T>
Andy Hung1bc088a2018-02-09 15:57:31 -08002275ssize_t AudioFlinger::PlaybackThread::Tracks<T>::remove(const sp<T> &track)
2276{
Andy Hungc0691382018-09-12 18:01:57 -07002277 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08002278 const ssize_t index = mTracks.remove(track);
2279 if (index >= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07002280 if (mSaveDeletedTrackIds) {
Andy Hung1bc088a2018-02-09 15:57:31 -08002281 // We can't directly access mAudioMixer since the caller may be outside of threadLoop.
Andy Hungc0691382018-09-12 18:01:57 -07002282 // Instead, we add to mDeletedTrackIds which is solely used for mAudioMixer update,
Andy Hung1bc088a2018-02-09 15:57:31 -08002283 // to be handled when MixerThread::prepareTracks_l() next changes mAudioMixer.
Andy Hungc0691382018-09-12 18:01:57 -07002284 mDeletedTrackIds.emplace(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08002285 }
Andy Hung1bc088a2018-02-09 15:57:31 -08002286 }
2287 return index;
2288}
2289
Eric Laurent81784c32012-11-19 14:55:58 -08002290uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
2291{
2292 return latency;
2293}
2294
2295uint32_t AudioFlinger::PlaybackThread::latency() const
2296{
2297 Mutex::Autolock _l(mLock);
2298 return latency_l();
2299}
2300uint32_t AudioFlinger::PlaybackThread::latency_l() const
2301{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002302 uint32_t latency;
2303 if (initCheck() == NO_ERROR && mOutput->stream->getLatency(&latency) == OK) {
2304 return correctLatency_l(latency);
Eric Laurent81784c32012-11-19 14:55:58 -08002305 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002306 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08002307}
2308
2309void AudioFlinger::PlaybackThread::setMasterVolume(float value)
2310{
2311 Mutex::Autolock _l(mLock);
2312 // Don't apply master volume in SW if our HAL can do it for us.
2313 if (mOutput && mOutput->audioHwDev &&
2314 mOutput->audioHwDev->canSetMasterVolume()) {
2315 mMasterVolume = 1.0;
2316 } else {
2317 mMasterVolume = value;
2318 }
2319}
2320
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002321void AudioFlinger::PlaybackThread::setMasterBalance(float balance)
2322{
2323 mMasterBalance.store(balance);
2324}
2325
Eric Laurent81784c32012-11-19 14:55:58 -08002326void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
2327{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002328 if (isDuplicating()) {
2329 return;
2330 }
Eric Laurent81784c32012-11-19 14:55:58 -08002331 Mutex::Autolock _l(mLock);
2332 // Don't apply master mute in SW if our HAL can do it for us.
2333 if (mOutput && mOutput->audioHwDev &&
2334 mOutput->audioHwDev->canSetMasterMute()) {
2335 mMasterMute = false;
2336 } else {
2337 mMasterMute = muted;
2338 }
2339}
2340
2341void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
2342{
2343 Mutex::Autolock _l(mLock);
2344 mStreamTypes[stream].volume = value;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002345 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002346}
2347
2348void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
2349{
2350 Mutex::Autolock _l(mLock);
2351 mStreamTypes[stream].mute = muted;
Eric Laurentede6c3b2013-09-19 14:37:46 -07002352 broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002353}
2354
2355float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
2356{
2357 Mutex::Autolock _l(mLock);
2358 return mStreamTypes[stream].volume;
2359}
2360
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09002361void AudioFlinger::PlaybackThread::setVolumeForOutput_l(float left, float right) const
2362{
2363 mOutput->stream->setVolume(left, right);
2364}
2365
Eric Laurent81784c32012-11-19 14:55:58 -08002366// addTrack_l() must be called with ThreadBase::mLock held
2367status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
2368{
2369 status_t status = ALREADY_EXISTS;
2370
Eric Laurent81784c32012-11-19 14:55:58 -08002371 if (mActiveTracks.indexOf(track) < 0) {
2372 // the track is newly added, make sure it fills up all its
2373 // buffers before playing. This is to ensure the client will
2374 // effectively get the latency it requested.
Eric Laurent83b88082014-06-20 18:31:16 -07002375 if (track->isExternalTrack()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002376 TrackBase::track_state state = track->mState;
2377 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002378 status = AudioSystem::startOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002379 mLock.lock();
2380 // abort track was stopped/paused while we released the lock
2381 if (state != track->mState) {
2382 if (status == NO_ERROR) {
2383 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002384 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002385 mLock.lock();
2386 }
2387 return INVALID_OPERATION;
2388 }
2389 // abort if start is rejected by audio policy manager
2390 if (status != NO_ERROR) {
2391 return PERMISSION_DENIED;
2392 }
2393#ifdef ADD_BATTERY_DATA
2394 // to track the speaker usage
2395 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
2396#endif
Eric Laurent09f1ed22019-04-24 17:45:17 -07002397 sendIoConfigEvent_l(AUDIO_CLIENT_STARTED, track->creatorPid(), track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08002398 }
2399
Eric Laurent51716182016-02-29 18:00:56 -08002400 // set retry count for buffer fill
2401 if (track->isOffloaded()) {
Eric Laurente93cc032016-05-05 10:15:10 -07002402 if (track->isStopping_1()) {
2403 track->mRetryCount = kMaxTrackStopRetriesOffload;
2404 } else {
2405 track->mRetryCount = kMaxTrackStartupRetriesOffload;
2406 }
2407 track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
Eric Laurent51716182016-02-29 18:00:56 -08002408 } else {
2409 track->mRetryCount = kMaxTrackStartupRetries;
Eric Laurente93cc032016-05-05 10:15:10 -07002410 track->mFillingUpStatus =
2411 track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
Eric Laurent51716182016-02-29 18:00:56 -08002412 }
2413
jiabin245cdd92018-12-07 17:55:15 -08002414 if ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
2415 && mHapticChannelMask != AUDIO_CHANNEL_NONE) {
jiabin57303cc2018-12-18 15:45:57 -08002416 // Unlock due to VibratorService will lock for this call and will
2417 // call Tracks.mute/unmute which also require thread's lock.
2418 mLock.unlock();
2419 const int intensity = AudioFlinger::onExternalVibrationStart(
2420 track->getExternalVibration());
2421 mLock.lock();
jiabinbf6b0ec2019-02-12 12:30:12 -08002422 track->setHapticIntensity(static_cast<AudioMixer::haptic_intensity_t>(intensity));
jiabin57303cc2018-12-18 15:45:57 -08002423 // Haptic playback should be enabled by vibrator service.
2424 if (track->getHapticPlaybackEnabled()) {
2425 // Disable haptic playback of all active track to ensure only
2426 // one track playing haptic if current track should play haptic.
2427 for (const auto &t : mActiveTracks) {
2428 t->setHapticPlaybackEnabled(false);
2429 }
jiabin245cdd92018-12-07 17:55:15 -08002430 }
jiabin245cdd92018-12-07 17:55:15 -08002431 }
2432
Eric Laurent81784c32012-11-19 14:55:58 -08002433 track->mResetDone = false;
2434 track->mPresentationCompleteFrames = 0;
2435 mActiveTracks.add(track);
Eric Laurentd0107bc2013-06-11 14:38:48 -07002436 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2437 if (chain != 0) {
2438 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2439 track->sessionId());
2440 chain->incActiveTrackCnt();
Eric Laurent81784c32012-11-19 14:55:58 -08002441 }
2442
2443 status = NO_ERROR;
2444 }
2445
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08002446 onAddNewTrack_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002447 return status;
2448}
2449
Eric Laurentbfb1b832013-01-07 09:53:42 -08002450bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
Eric Laurent81784c32012-11-19 14:55:58 -08002451{
Eric Laurentbfb1b832013-01-07 09:53:42 -08002452 track->terminate();
Eric Laurent81784c32012-11-19 14:55:58 -08002453 // active tracks are removed by threadLoop()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002454 bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2455 track->mState = TrackBase::STOPPED;
2456 if (!trackActive) {
Eric Laurent81784c32012-11-19 14:55:58 -08002457 removeTrack_l(track);
Eric Laurentab5cdba2014-06-09 17:22:27 -07002458 } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002459 track->mState = TrackBase::STOPPING_1;
Eric Laurent81784c32012-11-19 14:55:58 -08002460 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002461
2462 return trackActive;
Eric Laurent81784c32012-11-19 14:55:58 -08002463}
2464
2465void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2466{
2467 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Andy Hung2148bf02016-11-28 19:01:02 -08002468
Andy Hung2c6c3bb2017-06-16 14:01:45 -07002469 String8 result;
2470 track->appendDump(result, false /* active */);
2471 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
Andy Hung2148bf02016-11-28 19:01:02 -08002472
Eric Laurent81784c32012-11-19 14:55:58 -08002473 mTracks.remove(track);
Eric Laurent81784c32012-11-19 14:55:58 -08002474 if (track->isFastTrack()) {
2475 int index = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07002476 ALOG_ASSERT(0 < index && index < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08002477 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
2478 mFastTrackAvailMask |= 1 << index;
2479 // redundant as track is about to be destroyed, for dumpsys only
2480 track->mFastIndex = -1;
2481 }
2482 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2483 if (chain != 0) {
2484 chain->decTrackCnt();
2485 }
2486}
2487
2488String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
2489{
Eric Laurent81784c32012-11-19 14:55:58 -08002490 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002491 String8 out_s8;
2492 if (initCheck() == NO_ERROR && mOutput->stream->getParameters(keys, &out_s8) == OK) {
2493 return out_s8;
Eric Laurent81784c32012-11-19 14:55:58 -08002494 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002495 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08002496}
2497
Mikhail Naganovac917ac2018-11-28 14:03:52 -08002498status_t AudioFlinger::DirectOutputThread::selectPresentation(int presentationId, int programId) {
2499 Mutex::Autolock _l(mLock);
2500 if (mOutput == nullptr || mOutput->stream == nullptr) {
2501 return NO_INIT;
2502 }
2503 return mOutput->stream->selectPresentation(presentationId, programId);
2504}
2505
Eric Laurent09f1ed22019-04-24 17:45:17 -07002506void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
2507 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002508 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
2509 ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
Eric Laurent81784c32012-11-19 14:55:58 -08002510
Eric Laurent73e26b62015-04-27 16:55:58 -07002511 desc->mIoHandle = mId;
Eric Laurent81784c32012-11-19 14:55:58 -08002512
2513 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07002514 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002515 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07002516 case AUDIO_OUTPUT_CONFIG_CHANGED:
Eric Laurent296fb132015-05-01 11:38:42 -07002517 desc->mPatch = mPatch;
Eric Laurent73e26b62015-04-27 16:55:58 -07002518 desc->mChannelMask = mChannelMask;
2519 desc->mSamplingRate = mSampleRate;
2520 desc->mFormat = mFormat;
2521 desc->mFrameCount = mNormalFrameCount; // FIXME see
Eric Laurent81784c32012-11-19 14:55:58 -08002522 // AudioFlinger::frameCount(audio_io_handle_t)
Glenn Kasten4a8308b2016-04-18 14:10:01 -07002523 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07002524 desc->mLatency = latency_l();
Eric Laurent81784c32012-11-19 14:55:58 -08002525 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07002526 case AUDIO_CLIENT_STARTED:
2527 desc->mPatch = mPatch;
2528 desc->mPortId = portId;
2529 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07002530 case AUDIO_OUTPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08002531 default:
2532 break;
2533 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002534 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08002535}
2536
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002537void AudioFlinger::PlaybackThread::onWriteReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002538{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002539 mCallbackThread->resetWriteBlocked();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002540}
2541
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002542void AudioFlinger::PlaybackThread::onDrainReady()
Eric Laurentbfb1b832013-01-07 09:53:42 -08002543{
Eric Laurent3b4529e2013-09-05 18:09:19 -07002544 mCallbackThread->resetDraining();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002545}
2546
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002547void AudioFlinger::PlaybackThread::onError()
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002548{
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07002549 mCallbackThread->setAsyncError();
2550}
2551
Eric Laurent3b4529e2013-09-05 18:09:19 -07002552void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002553{
2554 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002555 // reject out of sequence requests
2556 if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
2557 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002558 mWaitWorkCV.signal();
2559 }
2560}
2561
Eric Laurent3b4529e2013-09-05 18:09:19 -07002562void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002563{
2564 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002565 // reject out of sequence requests
2566 if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
Andy Hungf3234512018-07-03 14:51:47 -07002567 // Register discontinuity when HW drain is completed because that can cause
2568 // the timestamp frame position to reset to 0 for direct and offload threads.
2569 // (Out of sequence requests are ignored, since the discontinuity would be handled
2570 // elsewhere, e.g. in flush).
2571 mTimestampVerifier.discontinuity();
Eric Laurent3b4529e2013-09-05 18:09:19 -07002572 mDrainSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002573 mWaitWorkCV.signal();
2574 }
2575}
2576
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002577void AudioFlinger::PlaybackThread::readOutputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08002578{
Glenn Kastenadad3d72014-02-21 14:51:43 -08002579 // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
Phil Burkca5e6142015-07-14 09:42:29 -07002580 mSampleRate = mOutput->getSampleRate();
2581 mChannelMask = mOutput->getChannelMask();
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002582 if (!audio_is_output_channel(mChannelMask)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002583 LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002584 }
Andy Hung9a592762014-07-21 21:56:01 -07002585 if ((mType == MIXER || mType == DUPLICATING)
2586 && !isValidPcmSinkChannelMask(mChannelMask)) {
2587 LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
2588 mChannelMask);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002589 }
Andy Hunge5412692014-05-16 11:25:07 -07002590 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002591 mBalance.setChannelMask(mChannelMask);
Phil Burkca5e6142015-07-14 09:42:29 -07002592
2593 // Get actual HAL format.
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002594 status_t result = mOutput->stream->getFormat(&mHALFormat);
2595 LOG_ALWAYS_FATAL_IF(result != OK, "Error when retrieving output stream format: %d", result);
Phil Burkca5e6142015-07-14 09:42:29 -07002596 // Get format from the shim, which will be different than the HAL format
2597 // if playing compressed audio over HDMI passthrough.
2598 mFormat = mOutput->getFormat();
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002599 if (!audio_is_valid_format(mFormat)) {
Glenn Kastenadad3d72014-02-21 14:51:43 -08002600 LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002601 }
Andy Hung6146c082014-03-18 11:56:15 -07002602 if ((mType == MIXER || mType == DUPLICATING)
2603 && !isValidPcmSinkFormat(mFormat)) {
2604 LOG_FATAL("HAL format %#x not supported for mixed output",
2605 mFormat);
Glenn Kasten7fc97ba2013-07-16 17:18:58 -07002606 }
Phil Burk062e67a2015-02-11 13:40:50 -08002607 mFrameSize = mOutput->getFrameSize();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002608 result = mOutput->stream->getBufferSize(&mBufferSize);
2609 LOG_ALWAYS_FATAL_IF(result != OK,
2610 "Error when retrieving output stream buffer size: %d", result);
Glenn Kasten70949c42013-08-06 07:40:12 -07002611 mFrameCount = mBufferSize / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002612 if (mFrameCount & 15) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002613 ALOGW("HAL output buffer size is %zu frames but AudioMixer requires multiples of 16 frames",
Eric Laurent81784c32012-11-19 14:55:58 -08002614 mFrameCount);
2615 }
2616
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002617 if (mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) {
2618 if (mOutput->stream->setCallback(this) == OK) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002619 mUseAsyncWrite = true;
Eric Laurent4de95592013-09-26 15:28:21 -07002620 mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002621 }
2622 }
2623
Eric Laurentd1f69b02014-12-15 14:33:13 -08002624 mHwSupportsPause = false;
2625 if (mOutput->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002626 bool supportsPause = false, supportsResume = false;
2627 if (mOutput->stream->supportsPauseAndResume(&supportsPause, &supportsResume) == OK) {
2628 if (supportsPause && supportsResume) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002629 mHwSupportsPause = true;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002630 } else if (supportsPause) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08002631 ALOGW("direct output implements pause but not resume");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002632 } else if (supportsResume) {
2633 ALOGW("direct output implements resume but not pause");
Eric Laurentd1f69b02014-12-15 14:33:13 -08002634 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002635 }
2636 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07002637 if (!mHwSupportsPause && mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
2638 LOG_ALWAYS_FATAL("HW_AV_SYNC requested but HAL does not implement pause and resume");
2639 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08002640
Andy Hungfbfc3952015-01-15 13:33:51 -08002641 if (mType == DUPLICATING && mMixerBufferEnabled && mEffectBufferEnabled) {
2642 // For best precision, we use float instead of the associated output
2643 // device format (typically PCM 16 bit).
2644
2645 mFormat = AUDIO_FORMAT_PCM_FLOAT;
2646 mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
2647 mBufferSize = mFrameSize * mFrameCount;
2648
2649 // TODO: We currently use the associated output device channel mask and sample rate.
2650 // (1) Perhaps use the ORed channel mask of all downstream MixerThreads
2651 // (if a valid mask) to avoid premature downmix.
2652 // (2) Perhaps use the maximum sample rate of all downstream MixerThreads
2653 // instead of the output device sample rate to avoid loss of high frequency information.
2654 // This may need to be updated as MixerThread/OutputTracks are added and not here.
2655 }
2656
Andy Hung09a50072014-02-27 14:30:47 -08002657 // Calculate size of normal sink buffer relative to the HAL output buffer size
Eric Laurent81784c32012-11-19 14:55:58 -08002658 double multiplier = 1.0;
2659 if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
2660 kUseFastMixer == FastMixer_Dynamic)) {
Andy Hung09a50072014-02-27 14:30:47 -08002661 size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
2662 size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002663
Eric Laurent81784c32012-11-19 14:55:58 -08002664 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
2665 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
2666 maxNormalFrameCount = maxNormalFrameCount & ~15;
2667 if (maxNormalFrameCount < minNormalFrameCount) {
2668 maxNormalFrameCount = minNormalFrameCount;
2669 }
2670 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
2671 if (multiplier <= 1.0) {
2672 multiplier = 1.0;
2673 } else if (multiplier <= 2.0) {
2674 if (2 * mFrameCount <= maxNormalFrameCount) {
2675 multiplier = 2.0;
2676 } else {
2677 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
2678 }
2679 } else {
Haynes Mathew George227a14b2016-05-09 12:45:48 -07002680 multiplier = floor(multiplier);
Eric Laurent81784c32012-11-19 14:55:58 -08002681 }
2682 }
2683 mNormalFrameCount = multiplier * mFrameCount;
2684 // round up to nearest 16 frames to satisfy AudioMixer
Eric Laurentab5cdba2014-06-09 17:22:27 -07002685 if (mType == MIXER || mType == DUPLICATING) {
2686 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
2687 }
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002688 ALOGI("HAL output buffer size %zu frames, normal sink buffer size %zu frames", mFrameCount,
Eric Laurent81784c32012-11-19 14:55:58 -08002689 mNormalFrameCount);
2690
Andy Hung08fb1742015-05-31 23:22:10 -07002691 // Check if we want to throttle the processing to no more than 2x normal rate
2692 mThreadThrottle = property_get_bool("af.thread.throttle", true /* default_value */);
Andy Hung40eb1a12015-06-18 13:42:02 -07002693 mThreadThrottleTimeMs = 0;
2694 mThreadThrottleEndMs = 0;
Andy Hung08fb1742015-05-31 23:22:10 -07002695 mHalfBufferMs = mNormalFrameCount * 1000 / (2 * mSampleRate);
2696
Andy Hung010a1a12014-03-13 13:57:33 -07002697 // mSinkBuffer is the sink buffer. Size is always multiple-of-16 frames.
2698 // Originally this was int16_t[] array, need to remove legacy implications.
2699 free(mSinkBuffer);
2700 mSinkBuffer = NULL;
Andy Hung5b10a202014-03-13 13:59:29 -07002701 // For sink buffer size, we use the frame size from the downstream sink to avoid problems
2702 // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
2703 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
Andy Hung010a1a12014-03-13 13:57:33 -07002704 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08002705
Andy Hung69aed5f2014-02-25 17:24:40 -08002706 // We resize the mMixerBuffer according to the requirements of the sink buffer which
2707 // drives the output.
2708 free(mMixerBuffer);
2709 mMixerBuffer = NULL;
2710 if (mMixerBufferEnabled) {
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01002711 mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // no longer valid: AUDIO_FORMAT_PCM_16_BIT.
Andy Hung69aed5f2014-02-25 17:24:40 -08002712 mMixerBufferSize = mNormalFrameCount * mChannelCount
2713 * audio_bytes_per_sample(mMixerBufferFormat);
2714 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
2715 }
Andy Hung98ef9782014-03-04 14:46:50 -08002716 free(mEffectBuffer);
2717 mEffectBuffer = NULL;
2718 if (mEffectBufferEnabled) {
rago94a1ee82017-07-21 15:11:02 -07002719 mEffectBufferFormat = EFFECT_BUFFER_FORMAT;
Andy Hung98ef9782014-03-04 14:46:50 -08002720 mEffectBufferSize = mNormalFrameCount * mChannelCount
2721 * audio_bytes_per_sample(mEffectBufferFormat);
2722 (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
2723 }
Andy Hung69aed5f2014-02-25 17:24:40 -08002724
jiabin245cdd92018-12-07 17:55:15 -08002725 mHapticChannelMask = mChannelMask & AUDIO_CHANNEL_HAPTIC_ALL;
2726 mChannelMask &= ~mHapticChannelMask;
2727 mHapticChannelCount = audio_channel_count_from_out_mask(mHapticChannelMask);
2728 mChannelCount -= mHapticChannelCount;
2729
Eric Laurent81784c32012-11-19 14:55:58 -08002730 // force reconfiguration of effect chains and engines to take new buffer size and audio
2731 // parameters into account
Glenn Kastendeca2ae2014-02-07 10:25:56 -08002732 // Note that mLock is not held when readOutputParameters_l() is called from the constructor
Eric Laurent81784c32012-11-19 14:55:58 -08002733 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
2734 // matter.
2735 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
2736 Vector< sp<EffectChain> > effectChains = mEffectChains;
2737 for (size_t i = 0; i < effectChains.size(); i ++) {
Eric Laurent6c796322019-04-09 14:13:17 -07002738 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(),
2739 this/* srcThread */, this/* dstThread */);
Eric Laurent81784c32012-11-19 14:55:58 -08002740 }
2741}
2742
Kevin Rocard069c2712018-03-29 19:09:14 -07002743void AudioFlinger::PlaybackThread::updateMetadata_l()
2744{
Kevin Rocard12381092018-04-11 09:19:59 -07002745 if (mOutput == nullptr || mOutput->stream == nullptr ) {
2746 return; // That should not happen
2747 }
2748 bool hasChanged = mActiveTracks.readAndClearHasChanged();
2749 for (const sp<Track> &track : mActiveTracks) {
2750 // Do not short-circuit as all hasChanged states must be reset
2751 // as all the metadata are going to be sent
2752 hasChanged |= track->readAndClearHasChanged();
2753 }
2754 if (!hasChanged) {
2755 return; // nothing to do
Kevin Rocard069c2712018-03-29 19:09:14 -07002756 }
2757 StreamOutHalInterface::SourceMetadata metadata;
Kevin Rocard12381092018-04-11 09:19:59 -07002758 auto backInserter = std::back_inserter(metadata.tracks);
Kevin Rocard069c2712018-03-29 19:09:14 -07002759 for (const sp<Track> &track : mActiveTracks) {
2760 // No track is invalid as this is called after prepareTrack_l in the same critical section
Kevin Rocard12381092018-04-11 09:19:59 -07002761 track->copyMetadataTo(backInserter);
Kevin Rocard069c2712018-03-29 19:09:14 -07002762 }
Kevin Rocard12381092018-04-11 09:19:59 -07002763 sendMetadataToBackend_l(metadata);
Kevin Rocard80ee2722018-04-11 15:53:48 +00002764}
Kevin Rocardc86a7f72018-04-03 09:00:09 -07002765
Kevin Rocard12381092018-04-11 09:19:59 -07002766void AudioFlinger::PlaybackThread::sendMetadataToBackend_l(
2767 const StreamOutHalInterface::SourceMetadata& metadata)
2768{
2769 mOutput->stream->updateSourceMetadata(metadata);
2770};
2771
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002772status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
Eric Laurent81784c32012-11-19 14:55:58 -08002773{
2774 if (halFrames == NULL || dspFrames == NULL) {
2775 return BAD_VALUE;
2776 }
2777 Mutex::Autolock _l(mLock);
2778 if (initCheck() != NO_ERROR) {
2779 return INVALID_OPERATION;
2780 }
Andy Hung818e7a32016-02-16 18:08:07 -08002781 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08002782 *halFrames = framesWritten;
2783
2784 if (isSuspended()) {
2785 // return an estimation of rendered frames when the output is suspended
2786 size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08002787 *dspFrames = (uint32_t)
2788 (framesWritten >= (int64_t)latencyFrames ? framesWritten - latencyFrames : 0);
Eric Laurent81784c32012-11-19 14:55:58 -08002789 return NO_ERROR;
2790 } else {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002791 status_t status;
2792 uint32_t frames;
Phil Burk062e67a2015-02-11 13:40:50 -08002793 status = mOutput->getRenderPosition(&frames);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002794 *dspFrames = (size_t)frames;
2795 return status;
Eric Laurent81784c32012-11-19 14:55:58 -08002796 }
2797}
2798
Glenn Kastend848eb42016-03-08 13:42:11 -08002799uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
Eric Laurent81784c32012-11-19 14:55:58 -08002800{
2801 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
2802 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
2803 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
2804 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2805 }
2806 for (size_t i = 0; i < mTracks.size(); i++) {
2807 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08002808 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurent81784c32012-11-19 14:55:58 -08002809 return AudioSystem::getStrategyForStream(track->streamType());
2810 }
2811 }
2812 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2813}
2814
2815
Phil Burk062e67a2015-02-11 13:40:50 -08002816AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
Eric Laurent81784c32012-11-19 14:55:58 -08002817{
2818 Mutex::Autolock _l(mLock);
2819 return mOutput;
2820}
2821
Phil Burk062e67a2015-02-11 13:40:50 -08002822AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
Eric Laurent81784c32012-11-19 14:55:58 -08002823{
2824 Mutex::Autolock _l(mLock);
2825 AudioStreamOut *output = mOutput;
2826 mOutput = NULL;
2827 // FIXME FastMixer might also have a raw ptr to mOutputSink;
2828 // must push a NULL and wait for ack
2829 mOutputSink.clear();
2830 mPipeSink.clear();
2831 mNormalSink.clear();
2832 return output;
2833}
2834
2835// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002836sp<StreamHalInterface> AudioFlinger::PlaybackThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08002837{
2838 if (mOutput == NULL) {
2839 return NULL;
2840 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002841 return mOutput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08002842}
2843
2844uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
2845{
2846 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
2847}
2848
2849status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
2850{
2851 if (!isValidSyncEvent(event)) {
2852 return BAD_VALUE;
2853 }
2854
2855 Mutex::Autolock _l(mLock);
2856
2857 for (size_t i = 0; i < mTracks.size(); ++i) {
2858 sp<Track> track = mTracks[i];
2859 if (event->triggerSession() == track->sessionId()) {
2860 (void) track->setSyncEvent(event);
2861 return NO_ERROR;
2862 }
2863 }
2864
2865 return NAME_NOT_FOUND;
2866}
2867
2868bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
2869{
2870 return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
2871}
2872
2873void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
2874 const Vector< sp<Track> >& tracksToRemove)
2875{
Andy Hungfe726a62018-09-27 15:17:25 -07002876 // Miscellaneous track cleanup when removed from the active list,
2877 // called without Thread lock but synchronized with threadLoop processing.
Eric Laurentbfb1b832013-01-07 09:53:42 -08002878#ifdef ADD_BATTERY_DATA
Andy Hungfe726a62018-09-27 15:17:25 -07002879 for (const auto& track : tracksToRemove) {
2880 if (track->isExternalTrack()) {
2881 // to track the speaker usage
2882 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Eric Laurent81784c32012-11-19 14:55:58 -08002883 }
2884 }
Andy Hungfe726a62018-09-27 15:17:25 -07002885#else
2886 (void)tracksToRemove; // suppress unused warning
2887#endif
Eric Laurent81784c32012-11-19 14:55:58 -08002888}
2889
2890void AudioFlinger::PlaybackThread::checkSilentMode_l()
2891{
2892 if (!mMasterMute) {
2893 char value[PROPERTY_VALUE_MAX];
Jean-Michel Trivi32f37c22016-03-31 16:00:32 -07002894 if (mOutDevice == AUDIO_DEVICE_OUT_REMOTE_SUBMIX) {
2895 ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
2896 return;
2897 }
Eric Laurent81784c32012-11-19 14:55:58 -08002898 if (property_get("ro.audio.silent", value, "0") > 0) {
2899 char *endptr;
2900 unsigned long ul = strtoul(value, &endptr, 0);
2901 if (*endptr == '\0' && ul != 0) {
2902 ALOGD("Silence is golden");
2903 // The setprop command will not allow a property to be changed after
2904 // the first time it is set, so we don't have to worry about un-muting.
2905 setMasterMute_l(true);
2906 }
2907 }
2908 }
2909}
2910
2911// shared by MIXER and DIRECT, overridden by DUPLICATING
Eric Laurentbfb1b832013-01-07 09:53:42 -08002912ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08002913{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07002914 LOG_HIST_TS();
Eric Laurent81784c32012-11-19 14:55:58 -08002915 mInWrite = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002916 ssize_t bytesWritten;
Andy Hung010a1a12014-03-13 13:57:33 -07002917 const size_t offset = mCurrentWriteLength - mBytesRemaining;
Eric Laurent81784c32012-11-19 14:55:58 -08002918
2919 // If an NBAIO sink is present, use it to write the normal mixer's submix
2920 if (mNormalSink != 0) {
Glenn Kasten4c053ea2014-09-28 14:41:07 -07002921
Andy Hung010a1a12014-03-13 13:57:33 -07002922 const size_t count = mBytesRemaining / mFrameSize;
2923
Simon Wilson2d590962012-11-29 15:18:50 -08002924 ATRACE_BEGIN("write");
Eric Laurent81784c32012-11-19 14:55:58 -08002925 // update the setpoint when AudioFlinger::mScreenState changes
2926 uint32_t screenState = AudioFlinger::mScreenState;
2927 if (screenState != mScreenState) {
2928 mScreenState = screenState;
2929 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
2930 if (pipe != NULL) {
2931 pipe->setAvgFrames((mScreenState & 1) ?
2932 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
2933 }
2934 }
Andy Hung010a1a12014-03-13 13:57:33 -07002935 ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
Simon Wilson2d590962012-11-29 15:18:50 -08002936 ATRACE_END();
Eric Laurent81784c32012-11-19 14:55:58 -08002937 if (framesWritten > 0) {
Andy Hung010a1a12014-03-13 13:57:33 -07002938 bytesWritten = framesWritten * mFrameSize;
Andy Hung8946a282018-04-19 20:04:56 -07002939#ifdef TEE_SINK
2940 mTee.write((char *)mSinkBuffer + offset, framesWritten);
2941#endif
Eric Laurent81784c32012-11-19 14:55:58 -08002942 } else {
2943 bytesWritten = framesWritten;
2944 }
2945 // otherwise use the HAL / AudioStreamOut directly
2946 } else {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002947 // Direct output and offload threads
Andy Hung010a1a12014-03-13 13:57:33 -07002948
Eric Laurentbfb1b832013-01-07 09:53:42 -08002949 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07002950 ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
2951 mWriteAckSequence += 2;
2952 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002953 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002954 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002955 }
Glenn Kasten767094d2013-08-23 13:51:43 -07002956 // FIXME We should have an implementation of timestamps for direct output threads.
2957 // They are used e.g for multichannel PCM playback over HDMI.
Phil Burk062e67a2015-02-11 13:40:50 -08002958 bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
Eric Laurent51716182016-02-29 18:00:56 -08002959
Eric Laurentbfb1b832013-01-07 09:53:42 -08002960 if (mUseAsyncWrite &&
2961 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
2962 // do not wait for async callback in case of error of full write
Eric Laurent3b4529e2013-09-05 18:09:19 -07002963 mWriteAckSequence &= ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002964 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002965 mCallbackThread->setWriteBlocked(mWriteAckSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002966 }
Eric Laurent81784c32012-11-19 14:55:58 -08002967 }
2968
Eric Laurent81784c32012-11-19 14:55:58 -08002969 mNumWrites++;
2970 mInWrite = false;
Eric Laurentfd477972013-10-25 18:10:40 -07002971 mStandby = false;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002972 return bytesWritten;
2973}
2974
2975void AudioFlinger::PlaybackThread::threadLoop_drain()
2976{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002977 bool supportsDrain = false;
2978 if (mOutput->stream->supportsDrain(&supportsDrain) == OK && supportsDrain) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08002979 ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
2980 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07002981 ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
2982 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002983 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07002984 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002985 }
Mikhail Naganovcbc8f612016-10-11 18:05:13 -07002986 status_t result = mOutput->stream->drain(mMixerStatus == MIXER_DRAIN_TRACK);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002987 ALOGE_IF(result != OK, "Error when draining stream: %d", result);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002988 }
2989}
2990
2991void AudioFlinger::PlaybackThread::threadLoop_exit()
2992{
Eric Laurent275e8e92014-11-30 15:14:47 -08002993 {
2994 Mutex::Autolock _l(mLock);
2995 for (size_t i = 0; i < mTracks.size(); i++) {
2996 sp<Track> track = mTracks[i];
2997 track->invalidate();
2998 }
Andy Hungdae27702016-10-31 14:01:16 -07002999 // Clear ActiveTracks to update BatteryNotifier in case active tracks remain.
3000 // After we exit there are no more track changes sent to BatteryNotifier
3001 // because that requires an active threadLoop.
3002 // TODO: should we decActiveTrackCnt() of the cleared track effect chain?
3003 mActiveTracks.clear();
Eric Laurent275e8e92014-11-30 15:14:47 -08003004 }
Eric Laurent81784c32012-11-19 14:55:58 -08003005}
3006
3007/*
3008The derived values that are cached:
Andy Hung25c2dac2014-02-27 14:56:00 -08003009 - mSinkBufferSize from frame count * frame size
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003010 - mActiveSleepTimeUs from activeSleepTimeUs()
3011 - mIdleSleepTimeUs from idleSleepTimeUs()
Eric Laurent42537be2016-01-08 17:16:42 -08003012 - mStandbyDelayNs from mActiveSleepTimeUs (DIRECT only) or forced to at least
3013 kDefaultStandbyTimeInNsecs when connected to an A2DP device.
Eric Laurent81784c32012-11-19 14:55:58 -08003014 - maxPeriod from frame count and sample rate (MIXER only)
3015
3016The parameters that affect these derived values are:
3017 - frame count
3018 - frame size
3019 - sample rate
3020 - device type: A2DP or not
3021 - device latency
3022 - format: PCM or not
3023 - active sleep time
3024 - idle sleep time
3025*/
3026
3027void AudioFlinger::PlaybackThread::cacheParameters_l()
3028{
Andy Hung25c2dac2014-02-27 14:56:00 -08003029 mSinkBufferSize = mNormalFrameCount * mFrameSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003030 mActiveSleepTimeUs = activeSleepTimeUs();
3031 mIdleSleepTimeUs = idleSleepTimeUs();
Eric Laurent42537be2016-01-08 17:16:42 -08003032
3033 // make sure standby delay is not too short when connected to an A2DP sink to avoid
3034 // truncating audio when going to standby.
3035 mStandbyDelayNs = AudioFlinger::mStandbyTimeInNsecs;
3036 if ((mOutDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0) {
3037 if (mStandbyDelayNs < kDefaultStandbyTimeInNsecs) {
3038 mStandbyDelayNs = kDefaultStandbyTimeInNsecs;
3039 }
3040 }
Eric Laurent81784c32012-11-19 14:55:58 -08003041}
3042
Eric Laurent13084622016-05-17 10:51:49 -07003043bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
Eric Laurent81784c32012-11-19 14:55:58 -08003044{
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003045 ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
Eric Laurent81784c32012-11-19 14:55:58 -08003046 this, streamType, mTracks.size());
Eric Laurent13084622016-05-17 10:51:49 -07003047 bool trackMatch = false;
Eric Laurent81784c32012-11-19 14:55:58 -08003048 size_t size = mTracks.size();
3049 for (size_t i = 0; i < size; i++) {
3050 sp<Track> t = mTracks[i];
Eric Laurentd60560a2015-04-10 11:31:20 -07003051 if (t->streamType() == streamType && t->isExternalTrack()) {
Glenn Kasten5736c352012-12-04 12:12:34 -08003052 t->invalidate();
Eric Laurent13084622016-05-17 10:51:49 -07003053 trackMatch = true;
Eric Laurent81784c32012-11-19 14:55:58 -08003054 }
3055 }
Eric Laurent13084622016-05-17 10:51:49 -07003056 return trackMatch;
Eric Laurent81784c32012-11-19 14:55:58 -08003057}
3058
Haynes Mathew George05317d22016-05-03 16:34:26 -07003059void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
3060{
3061 Mutex::Autolock _l(mLock);
3062 invalidateTracks_l(streamType);
3063}
3064
Eric Laurent81784c32012-11-19 14:55:58 -08003065status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
3066{
Glenn Kastend848eb42016-03-08 13:42:11 -08003067 audio_session_t session = chain->sessionId();
Mikhail Naganov022b9952017-01-04 16:36:51 -08003068 sp<EffectBufferHalInterface> halInBuffer, halOutBuffer;
Kevin Rocard7588ff42018-01-08 11:11:30 -08003069 status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
Mikhail Naganov022b9952017-01-04 16:36:51 -08003070 mEffectBufferEnabled ? mEffectBuffer : mSinkBuffer,
3071 mEffectBufferEnabled ? mEffectBufferSize : mSinkBufferSize,
3072 &halInBuffer);
3073 if (result != OK) return result;
3074 halOutBuffer = halInBuffer;
rago94a1ee82017-07-21 15:11:02 -07003075 effect_buffer_t *buffer = reinterpret_cast<effect_buffer_t*>(halInBuffer->externalData());
Eric Laurent81784c32012-11-19 14:55:58 -08003076 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
Glenn Kastend848eb42016-03-08 13:42:11 -08003077 if (session > AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurent81784c32012-11-19 14:55:58 -08003078 // Only one effect chain can be present in direct output thread and it uses
Andy Hung2098f272014-02-27 14:00:06 -08003079 // the sink buffer as input
Eric Laurent81784c32012-11-19 14:55:58 -08003080 if (mType != DIRECT) {
jiabin245cdd92018-12-07 17:55:15 -08003081 size_t numSamples = mNormalFrameCount * (mChannelCount + mHapticChannelCount);
Kevin Rocard7588ff42018-01-08 11:11:30 -08003082 status_t result = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
rago94a1ee82017-07-21 15:11:02 -07003083 numSamples * sizeof(effect_buffer_t),
Mikhail Naganov022b9952017-01-04 16:36:51 -08003084 &halInBuffer);
3085 if (result != OK) return result;
rago94a1ee82017-07-21 15:11:02 -07003086#ifdef FLOAT_EFFECT_CHAIN
3087 buffer = halInBuffer->audioBuffer()->f32;
3088#else
Mikhail Naganov022b9952017-01-04 16:36:51 -08003089 buffer = halInBuffer->audioBuffer()->s16;
rago94a1ee82017-07-21 15:11:02 -07003090#endif
Mikhail Naganov022b9952017-01-04 16:36:51 -08003091 ALOGV("addEffectChain_l() creating new input buffer %p session %d",
3092 buffer, session);
Eric Laurent81784c32012-11-19 14:55:58 -08003093 }
3094
3095 // Attach all tracks with same session ID to this chain.
3096 for (size_t i = 0; i < mTracks.size(); ++i) {
3097 sp<Track> track = mTracks[i];
3098 if (session == track->sessionId()) {
3099 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
3100 buffer);
3101 track->setMainBuffer(buffer);
3102 chain->incTrackCnt();
3103 }
3104 }
3105
3106 // indicate all active tracks in the chain
Andy Hungdae27702016-10-31 14:01:16 -07003107 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003108 if (session == track->sessionId()) {
3109 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
3110 chain->incActiveTrackCnt();
3111 }
3112 }
3113 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003114 chain->setThread(this);
Mikhail Naganov022b9952017-01-04 16:36:51 -08003115 chain->setInBuffer(halInBuffer);
3116 chain->setOutBuffer(halOutBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08003117 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
Glenn Kastend848eb42016-03-08 13:42:11 -08003118 // chains list in order to be processed last as it contains output stage effects.
Eric Laurent81784c32012-11-19 14:55:58 -08003119 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
3120 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
Glenn Kastend848eb42016-03-08 13:42:11 -08003121 // after track specific effects and before output stage.
Eric Laurent81784c32012-11-19 14:55:58 -08003122 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
Glenn Kastend848eb42016-03-08 13:42:11 -08003123 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX.
Eric Laurent81784c32012-11-19 14:55:58 -08003124 // Effect chain for other sessions are inserted at beginning of effect
3125 // chains list to be processed before output mix effects. Relative order between other
Glenn Kastend848eb42016-03-08 13:42:11 -08003126 // sessions is not important.
3127 static_assert(AUDIO_SESSION_OUTPUT_MIX == 0 &&
3128 AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX,
3129 "audio_session_t constants misdefined");
Eric Laurent81784c32012-11-19 14:55:58 -08003130 size_t size = mEffectChains.size();
3131 size_t i = 0;
3132 for (i = 0; i < size; i++) {
3133 if (mEffectChains[i]->sessionId() < session) {
3134 break;
3135 }
3136 }
3137 mEffectChains.insertAt(chain, i);
3138 checkSuspendOnAddEffectChain_l(chain);
3139
3140 return NO_ERROR;
3141}
3142
3143size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
3144{
Glenn Kastend848eb42016-03-08 13:42:11 -08003145 audio_session_t session = chain->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08003146
3147 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
3148
3149 for (size_t i = 0; i < mEffectChains.size(); i++) {
3150 if (chain == mEffectChains[i]) {
3151 mEffectChains.removeAt(i);
3152 // detach all active tracks from the chain
Andy Hungdae27702016-10-31 14:01:16 -07003153 for (const sp<Track> &track : mActiveTracks) {
Eric Laurent81784c32012-11-19 14:55:58 -08003154 if (session == track->sessionId()) {
3155 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
3156 chain.get(), session);
3157 chain->decActiveTrackCnt();
3158 }
3159 }
3160
3161 // detach all tracks with same session ID from this chain
3162 for (size_t i = 0; i < mTracks.size(); ++i) {
3163 sp<Track> track = mTracks[i];
3164 if (session == track->sessionId()) {
rago94a1ee82017-07-21 15:11:02 -07003165 track->setMainBuffer(reinterpret_cast<effect_buffer_t*>(mSinkBuffer));
Eric Laurent81784c32012-11-19 14:55:58 -08003166 chain->decTrackCnt();
3167 }
3168 }
3169 break;
3170 }
3171 }
3172 return mEffectChains.size();
3173}
3174
3175status_t AudioFlinger::PlaybackThread::attachAuxEffect(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003176 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003177{
3178 Mutex::Autolock _l(mLock);
3179 return attachAuxEffect_l(track, EffectId);
3180}
3181
3182status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003183 const sp<AudioFlinger::PlaybackThread::Track>& track, int EffectId)
Eric Laurent81784c32012-11-19 14:55:58 -08003184{
3185 status_t status = NO_ERROR;
3186
3187 if (EffectId == 0) {
3188 track->setAuxBuffer(0, NULL);
3189 } else {
3190 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
3191 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
3192 if (effect != 0) {
3193 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
3194 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
3195 } else {
3196 status = INVALID_OPERATION;
3197 }
3198 } else {
3199 status = BAD_VALUE;
3200 }
3201 }
3202 return status;
3203}
3204
3205void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
3206{
3207 for (size_t i = 0; i < mTracks.size(); ++i) {
3208 sp<Track> track = mTracks[i];
3209 if (track->auxEffectId() == effectId) {
3210 attachAuxEffect_l(track, 0);
3211 }
3212 }
3213}
3214
3215bool AudioFlinger::PlaybackThread::threadLoop()
3216{
Glenn Kasten388d5712017-04-07 14:38:41 -07003217 tlNBLogWriter = mNBLogWriter.get();
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003218
Eric Laurent81784c32012-11-19 14:55:58 -08003219 Vector< sp<Track> > tracksToRemove;
3220
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003221 mStandbyTimeNs = systemTime();
Andy Hung446f4df2019-02-21 12:26:41 -08003222 int64_t lastLoopCountWritten = -2; // never matches "previous" loop, when loopCount = 0.
3223 int64_t lastFramesWritten = -1; // track changes in timestamp server frames written
Eric Laurent81784c32012-11-19 14:55:58 -08003224
3225 // MIXER
3226 nsecs_t lastWarning = 0;
3227
3228 // DUPLICATING
3229 // FIXME could this be made local to while loop?
3230 writeFrames = 0;
3231
3232 cacheParameters_l();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003233 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003234
3235 if (mType == MIXER) {
3236 sleepTimeShift = 0;
3237 }
3238
3239 CpuStats cpuStats;
3240 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
3241
3242 acquireWakeLock();
3243
Glenn Kasteneef598c2017-04-03 14:41:13 -07003244 // mNBLogWriter logging APIs can only be called by a single thread, typically the
3245 // thread associated with this PlaybackThread.
3246 // If you want to share the mNBLogWriter with other threads (for example, binder threads)
3247 // then all such threads must agree to hold a common mutex before logging.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003248 // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
3249 // and then that string will be logged at the next convenient opportunity.
Glenn Kasteneef598c2017-04-03 14:41:13 -07003250 // See reference to logString below.
Glenn Kasten9e58b552013-01-18 15:09:48 -08003251 const char *logString = NULL;
3252
rago1bb90822017-05-02 18:31:48 -07003253 // Estimated time for next buffer to be written to hal. This is used only on
3254 // suspended mode (for now) to help schedule the wait time until next iteration.
3255 nsecs_t timeLoopNextNs = 0;
3256
Eric Laurent664539d2013-09-23 18:24:31 -07003257 checkSilentMode_l();
Glenn Kasteneef598c2017-04-03 14:41:13 -07003258
Andy Hungf3234512018-07-03 14:51:47 -07003259 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
3260 // TODO: add confirmation checks:
3261 // 1) DIRECT threads and linear PCM format really resets to 0?
3262 // 2) Is frame count really valid if not linear pcm?
3263 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
3264 if (mType == OFFLOAD || mType == DIRECT) {
3265 mTimestampVerifier.setDiscontinuityMode(mTimestampVerifier.DISCONTINUITY_MODE_ZERO);
3266 }
Andy Hung2dbffc22018-08-08 18:50:41 -07003267 audio_patch_handle_t lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Andy Hungf3234512018-07-03 14:51:47 -07003268
Andy Hung446f4df2019-02-21 12:26:41 -08003269 // loopCount is used for statistics and diagnostics.
3270 for (int64_t loopCount = 0; !exitPending(); ++loopCount)
Eric Laurent81784c32012-11-19 14:55:58 -08003271 {
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08003272 // Log merge requests are performed during AudioFlinger binder transactions, but
3273 // that does not cover audio playback. It's requested here for that reason.
3274 mAudioFlinger->requestLogMerge();
3275
Eric Laurent81784c32012-11-19 14:55:58 -08003276 cpuStats.sample(myName);
3277
3278 Vector< sp<EffectChain> > effectChains;
Andy Hung6e6a2e62019-04-30 16:38:41 -07003279 audio_session_t activeHapticSessionId = AUDIO_SESSION_NONE;
Andy Hungc1646382019-04-30 16:12:10 -07003280 std::vector<sp<Track>> activeTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08003281
Andy Hung2dbffc22018-08-08 18:50:41 -07003282 // If the device is AUDIO_DEVICE_OUT_BUS, check for downstream latency.
3283 //
3284 // Note: we access outDevice() outside of mLock.
3285 if (isMsdDevice() && (outDevice() & AUDIO_DEVICE_OUT_BUS) != 0) {
3286 // Here, we try for the AF lock, but do not block on it as the latency
3287 // is more informational.
3288 if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
3289 std::vector<PatchPanel::SoftwarePatch> swPatches;
3290 double latencyMs;
3291 status_t status = INVALID_OPERATION;
3292 audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3293 if (mAudioFlinger->mPatchPanel.getDownstreamSoftwarePatches(id(), &swPatches) == OK
3294 && swPatches.size() > 0) {
3295 status = swPatches[0].getLatencyMs_l(&latencyMs);
3296 downstreamPatchHandle = swPatches[0].getPatchHandle();
3297 }
3298 if (downstreamPatchHandle != lastDownstreamPatchHandle) {
Dean Wheatley30d28422018-11-06 10:27:40 +11003299 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003300 lastDownstreamPatchHandle = downstreamPatchHandle;
3301 }
3302 if (status == OK) {
3303 // verify downstream latency (we assume a max reasonable
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003304 // latency of 5 seconds).
3305 const double minLatency = 0., maxLatency = 5000.;
3306 if (latencyMs >= minLatency && latencyMs <= maxLatency) {
Andy Hung2dbffc22018-08-08 18:50:41 -07003307 ALOGV("new downstream latency %lf ms", latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003308 } else {
3309 ALOGD("out of range downstream latency %lf ms", latencyMs);
Mikhail Naganov6aa0a312018-11-09 11:00:01 -08003310 if (latencyMs < minLatency) latencyMs = minLatency;
3311 else if (latencyMs > maxLatency) latencyMs = maxLatency;
Andy Hung2dbffc22018-08-08 18:50:41 -07003312 }
Dean Wheatley30d28422018-11-06 10:27:40 +11003313 mDownstreamLatencyStatMs.add(latencyMs);
Andy Hung2dbffc22018-08-08 18:50:41 -07003314 }
3315 mAudioFlinger->mLock.unlock();
3316 }
3317 } else {
3318 if (lastDownstreamPatchHandle != AUDIO_PATCH_HANDLE_NONE) {
3319 // our device is no longer AUDIO_DEVICE_OUT_BUS, reset patch handle and stats.
Dean Wheatley30d28422018-11-06 10:27:40 +11003320 mDownstreamLatencyStatMs.reset();
Andy Hung2dbffc22018-08-08 18:50:41 -07003321 lastDownstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3322 }
3323 }
3324
Eric Laurent81784c32012-11-19 14:55:58 -08003325 { // scope for mLock
3326
3327 Mutex::Autolock _l(mLock);
3328
Eric Laurent021cf962014-05-13 10:18:14 -07003329 processConfigEvents_l();
Eric Laurent10351942014-05-08 18:49:52 -07003330
Glenn Kasteneef598c2017-04-03 14:41:13 -07003331 // See comment at declaration of logString for why this is done under mLock
Glenn Kasten9e58b552013-01-18 15:09:48 -08003332 if (logString != NULL) {
3333 mNBLogWriter->logTimestamp();
3334 mNBLogWriter->log(logString);
3335 logString = NULL;
3336 }
3337
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003338 // Collect timestamp statistics for the Playback Thread types that support it.
3339 if (mType == MIXER
3340 || mType == DUPLICATING
Andy Hungf3234512018-07-03 14:51:47 -07003341 || mType == DIRECT
3342 || mType == OFFLOAD) { // no indentation
Glenn Kasten4c053ea2014-09-28 14:41:07 -07003343 // Gather the framesReleased counters for all active tracks,
Andy Hunge10393e2015-06-12 13:59:33 -07003344 // and associate with the sink frames written out. We need
3345 // this to convert the sink timestamp to the track timestamp.
Andy Hung69488c42016-05-16 18:43:33 -07003346 bool kernelLocationUpdate = false;
Andy Hung1c86ebe2018-05-29 20:29:08 -07003347 ExtendedTimestamp timestamp; // use private copy to fetch
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003348 if (mStandby) {
3349 mTimestampVerifier.discontinuity();
3350 } else if (threadloop_getHalTimestamp_l(&timestamp) == OK) {
3351 mTimestampVerifier.add(timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL],
3352 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3353 mSampleRate);
Andy Hungc8fddf32018-08-08 18:32:37 -07003354
3355 if (isTimestampCorrectionEnabled()) {
3356 ALOGV("TS_BEFORE: %d %lld %lld", id(),
3357 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3358 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
3359 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
3360 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3361 = correctedTimestamp.mFrames;
3362 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
3363 = correctedTimestamp.mTimeNs;
3364 ALOGV("TS_AFTER: %d %lld %lld", id(),
3365 (long long)timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL],
3366 (long long)timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]);
Andy Hung2dbffc22018-08-08 18:50:41 -07003367
3368 // Note: Downstream latency only added if timestamp correction enabled.
Dean Wheatley30d28422018-11-06 10:27:40 +11003369 if (mDownstreamLatencyStatMs.getN() > 0) { // we have latency info.
Andy Hung2dbffc22018-08-08 18:50:41 -07003370 const int64_t newPosition =
3371 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
Dean Wheatley30d28422018-11-06 10:27:40 +11003372 - int64_t(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
Andy Hung2dbffc22018-08-08 18:50:41 -07003373 // prevent retrograde
3374 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = max(
3375 newPosition,
3376 (mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3377 - mSuspendedFrames));
3378 }
Andy Hungc8fddf32018-08-08 18:32:37 -07003379 }
3380
Andy Hung818e7a32016-02-16 18:08:07 -08003381 // We always fetch the timestamp here because often the downstream
Andy Hung69488c42016-05-16 18:43:33 -07003382 // sink will block while writing.
Andy Hung6d7b1192016-05-07 22:59:48 -07003383
3384 // We keep track of the last valid kernel position in case we are in underrun
3385 // and the normal mixer period is the same as the fast mixer period, or there
3386 // is some error from the HAL.
3387 if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
3388 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
3389 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
3390 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
3391 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
3392
3393 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
3394 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER];
3395 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
3396 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER];
Andy Hung69488c42016-05-16 18:43:33 -07003397 }
3398
3399 if (timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
3400 kernelLocationUpdate = true;
Andy Hung6d7b1192016-05-07 22:59:48 -07003401 } else {
Eric Laurent122f7e72016-06-29 11:53:29 -07003402 ALOGVV("getTimestamp error - no valid kernel position");
Andy Hung6d7b1192016-05-07 22:59:48 -07003403 }
3404
Andy Hung818e7a32016-02-16 18:08:07 -08003405 // copy over kernel info
3406 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
Andy Hung238fa3d2016-07-28 10:53:22 -07003407 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]
3408 + mSuspendedFrames; // add frames discarded when suspended
Andy Hung818e7a32016-02-16 18:08:07 -08003409 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
3410 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003411 } else {
3412 mTimestampVerifier.error();
Andy Hungc54b1ff2016-02-23 14:07:07 -08003413 }
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003414
Andy Hungc54b1ff2016-02-23 14:07:07 -08003415 // mFramesWritten for non-offloaded tracks are contiguous
3416 // even after standby() is called. This is useful for the track frame
3417 // to sink frame mapping.
Andy Hung69488c42016-05-16 18:43:33 -07003418 bool serverLocationUpdate = false;
3419 if (mFramesWritten != lastFramesWritten) {
3420 serverLocationUpdate = true;
3421 lastFramesWritten = mFramesWritten;
3422 }
3423 // Only update timestamps if there is a meaningful change.
3424 // Either the kernel timestamp must be valid or we have written something.
3425 if (kernelLocationUpdate || serverLocationUpdate) {
3426 if (serverLocationUpdate) {
3427 // use the time before we called the HAL write - it is a bit more accurate
3428 // to when the server last read data than the current time here.
3429 //
Andy Hung446f4df2019-02-21 12:26:41 -08003430 // If we haven't written anything, mLastIoBeginNs will be -1
Andy Hung69488c42016-05-16 18:43:33 -07003431 // and we use systemTime().
3432 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = mFramesWritten;
Andy Hung446f4df2019-02-21 12:26:41 -08003433 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = mLastIoBeginNs == -1
3434 ? systemTime() : mLastIoBeginNs;
Andy Hung69488c42016-05-16 18:43:33 -07003435 }
Andy Hungdae27702016-10-31 14:01:16 -07003436
3437 for (const sp<Track> &t : mActiveTracks) {
3438 if (!t->isFastTrack()) {
Andy Hung69488c42016-05-16 18:43:33 -07003439 t->updateTrackFrameInfo(
3440 t->mAudioTrackServerProxy->framesReleased(),
3441 mFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -07003442 mSampleRate,
Andy Hung69488c42016-05-16 18:43:33 -07003443 mTimestamp);
3444 }
Andy Hunge10393e2015-06-12 13:59:33 -07003445 }
Glenn Kastenbd096fd2013-08-23 13:53:56 -07003446 }
Andy Hunge6c37112019-02-26 17:38:10 -08003447
3448 if (audio_has_proportional_frames(mFormat)) {
3449 const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
3450 if (latencyMs != 0.) { // note 0. means timestamp is empty.
3451 mLatencyMs.add(latencyMs);
3452 }
3453 }
3454
Andy Hung2e2c0bb2018-06-11 19:13:11 -07003455 } // if (mType ... ) { // no indentation
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003456#if 0
3457 // logFormat example
Nicolas Rouletc20cb502017-02-01 12:35:24 -08003458 if (z % 100 == 0) {
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003459 timespec ts;
3460 clock_gettime(CLOCK_MONOTONIC, &ts);
Nicolas Roulet4da78202017-02-03 12:53:39 -08003461 LOGT("This is an integer %d, this is a float %f, this is my "
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003462 "pid %p %% %s %t", 42, 3.14, "and this is a timestamp", ts);
Nicolas Roulet4da78202017-02-03 12:53:39 -08003463 LOGT("A deceptive null-terminated string %\0");
Nicolas Rouletfe1e1442017-01-30 12:02:03 -08003464 }
3465 ++z;
3466#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003467 saveOutputTracks();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003468 if (mSignalPending) {
3469 // A signal was raised while we were unlocked
3470 mSignalPending = false;
3471 } else if (waitingAsyncCallback_l()) {
3472 if (exitPending()) {
3473 break;
3474 }
Marco Nelissen078538c2015-05-12 09:17:57 -07003475 bool released = false;
Eric Laurent64667972016-03-30 18:19:46 -07003476 if (!keepWakeLock()) {
Marco Nelissen078538c2015-05-12 09:17:57 -07003477 releaseWakeLock_l();
3478 released = true;
3479 }
Andy Hung10cbff12017-02-21 17:30:14 -08003480
3481 const int64_t waitNs = computeWaitTimeNs_l();
3482 ALOGV("wait async completion (wait time: %lld)", (long long)waitNs);
3483 status_t status = mWaitWorkCV.waitRelative(mLock, waitNs);
3484 if (status == TIMED_OUT) {
3485 mSignalPending = true; // if timeout recheck everything
3486 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003487 ALOGV("async completion/wake");
Marco Nelissen078538c2015-05-12 09:17:57 -07003488 if (released) {
3489 acquireWakeLock_l();
3490 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003491 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3492 mSleepTimeUs = 0;
Eric Laurentede6c3b2013-09-19 14:37:46 -07003493
3494 continue;
3495 }
Eric Tan39ec8d62018-07-24 09:49:29 -07003496 if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
Eric Laurentbfb1b832013-01-07 09:53:42 -08003497 isSuspended()) {
3498 // put audio hardware into standby after short delay
3499 if (shouldStandby_l()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003500
3501 threadLoop_standby();
3502
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07003503 // This is where we go into standby
3504 if (!mStandby) {
3505 LOG_AUDIO_STATE();
3506 }
Eric Laurent81784c32012-11-19 14:55:58 -08003507 mStandby = true;
Andy Hungd0979812019-02-21 15:51:44 -08003508 sendStatistics(false /* force */);
Eric Laurent81784c32012-11-19 14:55:58 -08003509 }
3510
Eric Tan39ec8d62018-07-24 09:49:29 -07003511 if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
Eric Laurent81784c32012-11-19 14:55:58 -08003512 // we're about to wait, flush the binder command buffer
3513 IPCThreadState::self()->flushCommands();
3514
3515 clearOutputTracks();
3516
3517 if (exitPending()) {
3518 break;
3519 }
3520
3521 releaseWakeLock_l();
3522 // wait until we have something to do...
3523 ALOGV("%s going to sleep", myName.string());
3524 mWaitWorkCV.wait(mLock);
3525 ALOGV("%s waking up", myName.string());
3526 acquireWakeLock_l();
3527
3528 mMixerStatus = MIXER_IDLE;
3529 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
3530 mBytesWritten = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003531 mBytesRemaining = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08003532 checkSilentMode_l();
3533
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003534 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3535 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08003536 if (mType == MIXER) {
3537 sleepTimeShift = 0;
3538 }
3539
3540 continue;
3541 }
3542 }
Eric Laurent81784c32012-11-19 14:55:58 -08003543 // mMixerStatusIgnoringFastTracks is also updated internally
3544 mMixerStatus = prepareTracks_l(&tracksToRemove);
3545
Andy Hungdae27702016-10-31 14:01:16 -07003546 mActiveTracks.updatePowerState(this);
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003547
Kevin Rocard069c2712018-03-29 19:09:14 -07003548 updateMetadata_l();
3549
Eric Laurent81784c32012-11-19 14:55:58 -08003550 // prevent any changes in effect chain list and in each effect chain
3551 // during mixing and effect process as the audio buffers could be deleted
3552 // or modified if an effect is created or deleted
3553 lockEffectChains_l(effectChains);
Andy Hung6e6a2e62019-04-30 16:38:41 -07003554
3555 // Determine which session to pick up haptic data.
3556 // This must be done under the same lock as prepareTracks_l().
3557 // TODO: Write haptic data directly to sink buffer when mixing.
3558 if (mHapticChannelCount > 0 && effectChains.size() > 0) {
3559 for (const auto& track : mActiveTracks) {
3560 if (track->getHapticPlaybackEnabled()) {
3561 activeHapticSessionId = track->sessionId();
3562 break;
3563 }
3564 }
3565 }
3566
Andy Hungc1646382019-04-30 16:12:10 -07003567 // Acquire a local copy of active tracks with lock (release w/o lock).
3568 //
3569 // Control methods on the track acquire the ThreadBase lock (e.g. start()
3570 // stop(), pause(), etc.), but the threadLoop is entitled to call audio
3571 // data / buffer methods on tracks from activeTracks without the ThreadBase lock.
3572 activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
Marco Nelissen462fd2f2013-01-14 14:12:05 -08003573 } // mLock scope ends
Eric Laurent81784c32012-11-19 14:55:58 -08003574
Eric Laurentbfb1b832013-01-07 09:53:42 -08003575 if (mBytesRemaining == 0) {
3576 mCurrentWriteLength = 0;
3577 if (mMixerStatus == MIXER_TRACKS_READY) {
3578 // threadLoop_mix() sets mCurrentWriteLength
3579 threadLoop_mix();
3580 } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
3581 && (mMixerStatus != MIXER_DRAIN_ALL)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003582 // threadLoop_sleepTime sets mSleepTimeUs to 0 if data
Eric Laurentbfb1b832013-01-07 09:53:42 -08003583 // must be written to HAL
3584 threadLoop_sleepTime();
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003585 if (mSleepTimeUs == 0) {
Andy Hung25c2dac2014-02-27 14:56:00 -08003586 mCurrentWriteLength = mSinkBufferSize;
Andy Hungc1646382019-04-30 16:12:10 -07003587
3588 // Tally underrun frames as we are inserting 0s here.
3589 for (const auto& track : activeTracks) {
3590 if (track->mFillingUpStatus == Track::FS_ACTIVE) {
3591 track->mAudioTrackServerProxy->tallyUnderrunFrames(mNormalFrameCount);
3592 }
3593 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003594 }
3595 }
Andy Hung98ef9782014-03-04 14:46:50 -08003596 // Either threadLoop_mix() or threadLoop_sleepTime() should have set
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003597 // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
Andy Hung98ef9782014-03-04 14:46:50 -08003598 // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
3599 // or mSinkBuffer (if there are no effects).
3600 //
3601 // This is done pre-effects computation; if effects change to
3602 // support higher precision, this needs to move.
3603 //
3604 // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003605 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003606 if (mMixerBufferValid) {
3607 void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
3608 audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
3609
Andy Hung2ddee192015-12-18 17:34:44 -08003610 // mono blend occurs for mixer threads only (not direct or offloaded)
3611 // and is handled here if we're going directly to the sink.
3612 if (requireMonoBlend() && !mEffectBufferValid) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003613 mono_blend(mMixerBuffer, mMixerBufferFormat, mChannelCount, mNormalFrameCount,
3614 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003615 }
3616
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003617 if (!hasFastMixer()) {
3618 // Balance must take effect after mono conversion.
3619 // We do it here if there is no FastMixer.
3620 // mBalance detects zero balance within the class for speed (not needed here).
3621 mBalance.setBalance(mMasterBalance.load());
3622 mBalance.process((float *)mMixerBuffer, mNormalFrameCount);
3623 }
3624
Andy Hung98ef9782014-03-04 14:46:50 -08003625 memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003626 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3627
3628 // If we're going directly to the sink and there are haptic channels,
3629 // we should adjust channels as the sample data is partially interleaved
3630 // in this case.
3631 if (!mEffectBufferValid && mHapticChannelCount > 0) {
3632 adjust_channels_non_destructive(buffer, mChannelCount, buffer,
3633 mChannelCount + mHapticChannelCount,
3634 audio_bytes_per_sample(format),
3635 audio_bytes_per_frame(mChannelCount, format) * mNormalFrameCount);
3636 }
Andy Hung98ef9782014-03-04 14:46:50 -08003637 }
3638
Eric Laurentbfb1b832013-01-07 09:53:42 -08003639 mBytesRemaining = mCurrentWriteLength;
3640 if (isSuspended()) {
Andy Hung238fa3d2016-07-28 10:53:22 -07003641 // Simulate write to HAL when suspended (e.g. BT SCO phone call).
3642 mSleepTimeUs = suspendSleepTimeUs(); // assumes full buffer.
3643 const size_t framesRemaining = mBytesRemaining / mFrameSize;
3644 mBytesWritten += mBytesRemaining;
3645 mFramesWritten += framesRemaining;
3646 mSuspendedFrames += framesRemaining; // to adjust kernel HAL position
Eric Laurentbfb1b832013-01-07 09:53:42 -08003647 mBytesRemaining = 0;
3648 }
Eric Laurent81784c32012-11-19 14:55:58 -08003649
Eric Laurentbfb1b832013-01-07 09:53:42 -08003650 // only process effects if we're going to write
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003651 if (mSleepTimeUs == 0 && mType != OFFLOAD) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003652 for (size_t i = 0; i < effectChains.size(); i ++) {
3653 effectChains[i]->process_l();
jiabin47affe52019-04-04 18:02:07 -07003654 // TODO: Write haptic data directly to sink buffer when mixing.
Andy Hung6e6a2e62019-04-30 16:38:41 -07003655 if (activeHapticSessionId != AUDIO_SESSION_NONE
3656 && activeHapticSessionId == effectChains[i]->sessionId()) {
jiabin47affe52019-04-04 18:02:07 -07003657 // Haptic data is active in this case, copy it directly from
3658 // in buffer to out buffer.
3659 const size_t audioBufferSize = mNormalFrameCount
3660 * audio_bytes_per_frame(mChannelCount, EFFECT_BUFFER_FORMAT);
3661 memcpy_by_audio_format(
3662 (uint8_t*)effectChains[i]->outBuffer() + audioBufferSize,
3663 EFFECT_BUFFER_FORMAT,
3664 (const uint8_t*)effectChains[i]->inBuffer() + audioBufferSize,
3665 EFFECT_BUFFER_FORMAT, mNormalFrameCount * mHapticChannelCount);
3666 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003667 }
Eric Laurent81784c32012-11-19 14:55:58 -08003668 }
3669 }
Eric Laurent59fe0102013-09-27 18:48:26 -07003670 // Process effect chains for offloaded thread even if no audio
3671 // was read from audio track: process only updates effect state
3672 // and thus does have to be synchronized with audio writes but may have
3673 // to be called while waiting for async write callback
3674 if (mType == OFFLOAD) {
3675 for (size_t i = 0; i < effectChains.size(); i ++) {
3676 effectChains[i]->process_l();
3677 }
3678 }
Eric Laurent81784c32012-11-19 14:55:58 -08003679
Andy Hung98ef9782014-03-04 14:46:50 -08003680 // Only if the Effects buffer is enabled and there is data in the
3681 // Effects buffer (buffer valid), we need to
3682 // copy into the sink buffer.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003683 // TODO use mSleepTimeUs == 0 as an additional condition.
Andy Hung98ef9782014-03-04 14:46:50 -08003684 if (mEffectBufferValid) {
3685 //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
Andy Hung2ddee192015-12-18 17:34:44 -08003686
3687 if (requireMonoBlend()) {
Glenn Kasten03c48d52016-01-27 17:25:17 -08003688 mono_blend(mEffectBuffer, mEffectBufferFormat, mChannelCount, mNormalFrameCount,
3689 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -08003690 }
3691
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01003692 if (!hasFastMixer()) {
3693 // Balance must take effect after mono conversion.
3694 // We do it here if there is no FastMixer.
3695 // mBalance detects zero balance within the class for speed (not needed here).
3696 mBalance.setBalance(mMasterBalance.load());
3697 mBalance.process((float *)mEffectBuffer, mNormalFrameCount);
3698 }
3699
Andy Hung98ef9782014-03-04 14:46:50 -08003700 memcpy_by_audio_format(mSinkBuffer, mFormat, mEffectBuffer, mEffectBufferFormat,
jiabin245cdd92018-12-07 17:55:15 -08003701 mNormalFrameCount * (mChannelCount + mHapticChannelCount));
3702 // The sample data is partially interleaved when haptic channels exist,
3703 // we need to adjust channels here.
3704 if (mHapticChannelCount > 0) {
3705 adjust_channels_non_destructive(mSinkBuffer, mChannelCount, mSinkBuffer,
3706 mChannelCount + mHapticChannelCount,
3707 audio_bytes_per_sample(mFormat),
3708 audio_bytes_per_frame(mChannelCount, mFormat) * mNormalFrameCount);
3709 }
Andy Hung98ef9782014-03-04 14:46:50 -08003710 }
3711
Eric Laurent81784c32012-11-19 14:55:58 -08003712 // enable changes in effect chain
3713 unlockEffectChains(effectChains);
3714
Eric Laurentbfb1b832013-01-07 09:53:42 -08003715 if (!waitingAsyncCallback()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07003716 // mSleepTimeUs == 0 means we must write to audio hardware
3717 if (mSleepTimeUs == 0) {
Andy Hung08fb1742015-05-31 23:22:10 -07003718 ssize_t ret = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003719 // writePeriodNs is updated >= 0 when ret > 0.
3720 int64_t writePeriodNs = -1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003721 if (mBytesRemaining) {
Andy Hung69488c42016-05-16 18:43:33 -07003722 // FIXME rewrite to reduce number of system calls
Andy Hung446f4df2019-02-21 12:26:41 -08003723 const int64_t lastIoBeginNs = systemTime();
Andy Hung08fb1742015-05-31 23:22:10 -07003724 ret = threadLoop_write();
Andy Hung446f4df2019-02-21 12:26:41 -08003725 const int64_t lastIoEndNs = systemTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003726 if (ret < 0) {
3727 mBytesRemaining = 0;
Andy Hung446f4df2019-02-21 12:26:41 -08003728 } else if (ret > 0) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08003729 mBytesWritten += ret;
3730 mBytesRemaining -= ret;
Andy Hung446f4df2019-02-21 12:26:41 -08003731 const int64_t frames = ret / mFrameSize;
3732 mFramesWritten += frames;
3733
3734 writePeriodNs = lastIoEndNs - mLastIoEndNs;
3735 // process information relating to write time.
3736 if (audio_has_proportional_frames(mFormat)) {
3737 // we are in a continuous mixing cycle
3738 if (mMixerStatus == MIXER_TRACKS_READY &&
3739 loopCount == lastLoopCountWritten + 1) {
3740
3741 const double jitterMs =
3742 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
3743 {frames, writePeriodNs},
3744 {0, 0} /* lastTimestamp */, mSampleRate);
3745 const double processMs =
3746 (lastIoBeginNs - mLastIoEndNs) * 1e-6;
3747
3748 Mutex::Autolock _l(mLock);
3749 mIoJitterMs.add(jitterMs);
3750 mProcessTimeMs.add(processMs);
3751 }
3752
3753 // write blocked detection
3754 const int64_t deltaWriteNs = lastIoEndNs - lastIoBeginNs;
3755 if (mType == MIXER && deltaWriteNs > maxPeriod) {
3756 mNumDelayedWrites++;
3757 if ((lastIoEndNs - lastWarning) > kWarningThrottleNs) {
3758 ATRACE_NAME("underrun");
3759 ALOGW("write blocked for %lld msecs, "
3760 "%d delayed writes, thread %d",
3761 (long long)deltaWriteNs / NANOS_PER_MILLISECOND,
3762 mNumDelayedWrites, mId);
3763 lastWarning = lastIoEndNs;
3764 }
3765 }
3766 }
3767 // update timing info.
3768 mLastIoBeginNs = lastIoBeginNs;
3769 mLastIoEndNs = lastIoEndNs;
3770 lastLoopCountWritten = loopCount;
Eric Laurentbfb1b832013-01-07 09:53:42 -08003771 }
3772 } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
3773 (mMixerStatus == MIXER_DRAIN_ALL)) {
3774 threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -08003775 }
Andy Hung08fb1742015-05-31 23:22:10 -07003776 if (mType == MIXER && !mStandby) {
Andy Hung08fb1742015-05-31 23:22:10 -07003777
3778 if (mThreadThrottle
3779 && mMixerStatus == MIXER_TRACKS_READY // we are mixing (active tracks)
Andy Hung446f4df2019-02-21 12:26:41 -08003780 && writePeriodNs > 0) { // we have write period info
Andy Hung08fb1742015-05-31 23:22:10 -07003781 // Limit MixerThread data processing to no more than twice the
3782 // expected processing rate.
3783 //
3784 // This helps prevent underruns with NuPlayer and other applications
3785 // which may set up buffers that are close to the minimum size, or use
3786 // deep buffers, and rely on a double-buffering sleep strategy to fill.
3787 //
3788 // The throttle smooths out sudden large data drains from the device,
3789 // e.g. when it comes out of standby, which often causes problems with
3790 // (1) mixer threads without a fast mixer (which has its own warm-up)
3791 // (2) minimum buffer sized tracks (even if the track is full,
3792 // the app won't fill fast enough to handle the sudden draw).
Haynes Mathew Georgef92b2172016-05-09 11:34:15 -07003793 //
3794 // Total time spent in last processing cycle equals time spent in
3795 // 1. threadLoop_write, as well as time spent in
3796 // 2. threadLoop_mix (significant for heavy mixing, especially
3797 // on low tier processors)
Andy Hung08fb1742015-05-31 23:22:10 -07003798
Andy Hung446f4df2019-02-21 12:26:41 -08003799 // it's OK if deltaMs is an overestimate.
3800
3801 const int32_t deltaMs = writePeriodNs / NANOS_PER_MILLISECOND;
Ivan Lozanoe02bc542017-10-26 09:51:54 -07003802
Ivan Lozanoea04d392017-11-07 14:37:07 -08003803 const int32_t throttleMs = (int32_t)mHalfBufferMs - deltaMs;
Andy Hung08fb1742015-05-31 23:22:10 -07003804 if ((signed)mHalfBufferMs >= throttleMs && throttleMs > 0) {
3805 usleep(throttleMs * 1000);
Andy Hung40eb1a12015-06-18 13:42:02 -07003806 // notify of throttle start on verbose log
3807 ALOGV_IF(mThreadThrottleEndMs == mThreadThrottleTimeMs,
3808 "mixer(%p) throttle begin:"
3809 " ret(%zd) deltaMs(%d) requires sleep %d ms",
Andy Hung08fb1742015-05-31 23:22:10 -07003810 this, ret, deltaMs, throttleMs);
Andy Hung40eb1a12015-06-18 13:42:02 -07003811 mThreadThrottleTimeMs += throttleMs;
Andy Hung0a31ddd2016-07-06 19:10:29 -07003812 // Throttle must be attributed to the previous mixer loop's write time
3813 // to allow back-to-back throttling.
Andy Hung446f4df2019-02-21 12:26:41 -08003814 // This also ensures proper timing statistics.
3815 mLastIoEndNs = systemTime(); // we fetch the write end time again.
Andy Hung40eb1a12015-06-18 13:42:02 -07003816 } else {
3817 uint32_t diff = mThreadThrottleTimeMs - mThreadThrottleEndMs;
3818 if (diff > 0) {
3819 // notify of throttle end on debug log
Andy Hung3ea004d2016-05-05 16:48:37 -07003820 // but prevent spamming for bluetooth
Jakub Pawlowski0568ded2018-03-14 11:20:05 -07003821 ALOGD_IF(!audio_is_a2dp_out_device(outDevice()) &&
3822 !audio_is_hearing_aid_out_device(outDevice()),
Andy Hung3ea004d2016-05-05 16:48:37 -07003823 "mixer(%p) throttle end: throttle time(%u)", this, diff);
Andy Hung40eb1a12015-06-18 13:42:02 -07003824 mThreadThrottleEndMs = mThreadThrottleTimeMs;
3825 }
Andy Hung08fb1742015-05-31 23:22:10 -07003826 }
3827 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003828 }
Eric Laurent81784c32012-11-19 14:55:58 -08003829
Eric Laurentbfb1b832013-01-07 09:53:42 -08003830 } else {
Glenn Kastene7754022014-10-31 12:11:26 -07003831 ATRACE_BEGIN("sleep");
Eric Laurente93cc032016-05-05 10:15:10 -07003832 Mutex::Autolock _l(mLock);
rago1bb90822017-05-02 18:31:48 -07003833 // suspended requires accurate metering of sleep time.
3834 if (isSuspended()) {
3835 // advance by expected sleepTime
3836 timeLoopNextNs += microseconds((nsecs_t)mSleepTimeUs);
3837 const nsecs_t nowNs = systemTime();
3838
3839 // compute expected next time vs current time.
3840 // (negative deltas are treated as delays).
3841 nsecs_t deltaNs = timeLoopNextNs - nowNs;
3842 if (deltaNs < -kMaxNextBufferDelayNs) {
3843 // Delays longer than the max allowed trigger a reset.
3844 ALOGV("DelayNs: %lld, resetting timeLoopNextNs", (long long) deltaNs);
3845 deltaNs = microseconds((nsecs_t)mSleepTimeUs);
3846 timeLoopNextNs = nowNs + deltaNs;
3847 } else if (deltaNs < 0) {
3848 // Delays within the max delay allowed: zero the delta/sleepTime
3849 // to help the system catch up in the next iteration(s)
3850 ALOGV("DelayNs: %lld, catching-up", (long long) deltaNs);
3851 deltaNs = 0;
3852 }
3853 // update sleep time (which is >= 0)
3854 mSleepTimeUs = deltaNs / 1000;
3855 }
Eric Laurente93cc032016-05-05 10:15:10 -07003856 if (!mSignalPending && mConfigEvents.isEmpty() && !exitPending()) {
3857 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)mSleepTimeUs));
Eric Laurent51716182016-02-29 18:00:56 -08003858 }
Glenn Kastene7754022014-10-31 12:11:26 -07003859 ATRACE_END();
Eric Laurentbfb1b832013-01-07 09:53:42 -08003860 }
Eric Laurent81784c32012-11-19 14:55:58 -08003861 }
3862
3863 // Finally let go of removed track(s), without the lock held
3864 // since we can't guarantee the destructors won't acquire that
3865 // same lock. This will also mutate and push a new fast mixer state.
3866 threadLoop_removeTracks(tracksToRemove);
3867 tracksToRemove.clear();
3868
3869 // FIXME I don't understand the need for this here;
3870 // it was in the original code but maybe the
3871 // assignment in saveOutputTracks() makes this unnecessary?
3872 clearOutputTracks();
3873
3874 // Effect chains will be actually deleted here if they were removed from
3875 // mEffectChains list during mixing or effects processing
3876 effectChains.clear();
3877
3878 // FIXME Note that the above .clear() is no longer necessary since effectChains
3879 // is now local to this block, but will keep it for now (at least until merge done).
3880 }
3881
Eric Laurentbfb1b832013-01-07 09:53:42 -08003882 threadLoop_exit();
3883
Eric Laurentcf817a22014-08-04 20:36:31 -07003884 if (!mStandby) {
3885 threadLoop_standby();
3886 mStandby = true;
Eric Laurent81784c32012-11-19 14:55:58 -08003887 }
3888
3889 releaseWakeLock();
3890
3891 ALOGV("Thread %p type %d exiting", this, mType);
3892 return false;
3893}
3894
Eric Laurentbfb1b832013-01-07 09:53:42 -08003895// removeTracks_l() must be called with ThreadBase::mLock held
3896void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
3897{
Andy Hungfe726a62018-09-27 15:17:25 -07003898 for (const auto& track : tracksToRemove) {
3899 mActiveTracks.remove(track);
3900 ALOGV("%s(%d): removing track on session %d", __func__, track->id(), track->sessionId());
3901 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
3902 if (chain != 0) {
3903 ALOGV("%s(%d): stopping track on chain %p for session Id: %d",
3904 __func__, track->id(), chain.get(), track->sessionId());
3905 chain->decActiveTrackCnt();
3906 }
3907 // If an external client track, inform APM we're no longer active, and remove if needed.
3908 // We do this under lock so that the state is consistent if the Track is destroyed.
3909 if (track->isExternalTrack()) {
3910 AudioSystem::stopOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08003911 if (track->isTerminated()) {
Andy Hungfe726a62018-09-27 15:17:25 -07003912 AudioSystem::releaseOutput(track->portId());
Eric Laurentbfb1b832013-01-07 09:53:42 -08003913 }
3914 }
Andy Hungfe726a62018-09-27 15:17:25 -07003915 if (track->isTerminated()) {
3916 // remove from our tracks vector
3917 removeTrack_l(track);
3918 }
jiabin57303cc2018-12-18 15:45:57 -08003919 if ((track->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
3920 && mHapticChannelCount > 0) {
3921 mLock.unlock();
3922 // Unlock due to VibratorService will lock for this call and will
3923 // call Tracks.mute/unmute which also require thread's lock.
3924 AudioFlinger::onExternalVibrationStop(track->getExternalVibration());
3925 mLock.lock();
jiabin245cdd92018-12-07 17:55:15 -08003926 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003927 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003928}
Eric Laurent81784c32012-11-19 14:55:58 -08003929
Eric Laurentaccc1472013-09-20 09:36:34 -07003930status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
3931{
3932 if (mNormalSink != 0) {
Andy Hung818e7a32016-02-16 18:08:07 -08003933 ExtendedTimestamp ets;
3934 status_t status = mNormalSink->getTimestamp(ets);
3935 if (status == NO_ERROR) {
3936 status = ets.getBestTimestamp(&timestamp);
3937 }
3938 return status;
Eric Laurentaccc1472013-09-20 09:36:34 -07003939 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003940 if ((mType == OFFLOAD || mType == DIRECT) && mOutput != NULL) {
Eric Laurentaccc1472013-09-20 09:36:34 -07003941 uint64_t position64;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003942 if (mOutput->getPresentationPosition(&position64, &timestamp.mTime) == OK) {
Eric Laurentaccc1472013-09-20 09:36:34 -07003943 timestamp.mPosition = (uint32_t)position64;
Dean Wheatley30d28422018-11-06 10:27:40 +11003944 if (mDownstreamLatencyStatMs.getN() > 0) {
3945 const uint32_t positionOffset =
3946 (uint32_t)(mDownstreamLatencyStatMs.getMean() * mSampleRate * 1e-3);
3947 if (positionOffset > timestamp.mPosition) {
3948 timestamp.mPosition = 0;
3949 } else {
3950 timestamp.mPosition -= positionOffset;
3951 }
3952 }
Eric Laurentaccc1472013-09-20 09:36:34 -07003953 return NO_ERROR;
3954 }
3955 }
3956 return INVALID_OPERATION;
3957}
Eric Laurent1c333e22014-05-20 10:48:17 -07003958
Eric Laurent054d9d32015-04-24 08:48:48 -07003959status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
3960 audio_patch_handle_t *handle)
3961{
Andy Hungf60abce2016-08-26 11:37:54 -07003962 status_t status;
3963 if (property_get_bool("af.patch_park", false /* default_value */)) {
3964 // Park FastMixer to avoid potential DOS issues with writing to the HAL
3965 // or if HAL does not properly lock against access.
3966 AutoPark<FastMixer> park(mFastMixer);
3967 status = PlaybackThread::createAudioPatch_l(patch, handle);
3968 } else {
3969 status = PlaybackThread::createAudioPatch_l(patch, handle);
3970 }
Eric Laurent054d9d32015-04-24 08:48:48 -07003971 return status;
3972}
3973
Eric Laurent1c333e22014-05-20 10:48:17 -07003974status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
3975 audio_patch_handle_t *handle)
3976{
3977 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07003978
3979 // store new device and send to effects
3980 audio_devices_t type = AUDIO_DEVICE_NONE;
3981 for (unsigned int i = 0; i < patch->num_sinks; i++) {
3982 type |= patch->sinks[i].ext.device.type;
3983 }
3984
François Gaffie0c280aa2018-07-25 10:02:15 +02003985 audio_port_handle_t sinkPortId = patch->sinks[0].id;
Eric Laurent054d9d32015-04-24 08:48:48 -07003986#ifdef ADD_BATTERY_DATA
3987 // when changing the audio output device, call addBatteryData to notify
3988 // the change
3989 if (mOutDevice != type) {
3990 uint32_t params = 0;
3991 // check whether speaker is on
3992 if (type & AUDIO_DEVICE_OUT_SPEAKER) {
3993 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
Eric Laurent1c333e22014-05-20 10:48:17 -07003994 }
3995
Eric Laurent054d9d32015-04-24 08:48:48 -07003996 audio_devices_t deviceWithoutSpeaker
3997 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
3998 // check if any other device (except speaker) is on
3999 if (type & deviceWithoutSpeaker) {
4000 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
4001 }
4002
4003 if (params != 0) {
4004 addBatteryData(params);
4005 }
4006 }
4007#endif
4008
4009 for (size_t i = 0; i < mEffectChains.size(); i++) {
4010 mEffectChains[i]->setDevice_l(type);
4011 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07004012
4013 // mPrevOutDevice is the latest device set by createAudioPatch_l(). It is not set when
4014 // the thread is created so that the first patch creation triggers an ioConfigChanged callback
François Gaffie0c280aa2018-07-25 10:02:15 +02004015 bool configChanged = (mPrevOutDevice != type) || (mDeviceId != sinkPortId);
Eric Laurent054d9d32015-04-24 08:48:48 -07004016 mOutDevice = type;
Eric Laurent296fb132015-05-01 11:38:42 -07004017 mPatch = *patch;
Eric Laurent054d9d32015-04-24 08:48:48 -07004018
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004019 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004020 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4021 status = hwDevice->createAudioPatch(patch->num_sources,
4022 patch->sources,
4023 patch->num_sinks,
4024 patch->sinks,
4025 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004026 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004027 char *address;
4028 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
4029 //FIXME: we only support address on first sink with HAL version < 3.0
4030 address = audio_device_address_to_parameter(
4031 patch->sinks[0].ext.device.type,
4032 patch->sinks[0].ext.device.address);
4033 } else {
4034 address = (char *)calloc(1, 1);
4035 }
4036 AudioParameter param = AudioParameter(String8(address));
4037 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07004038 param.addInt(String8(AudioParameter::keyRouting), (int)type);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004039 status = mOutput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07004040 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07004041 }
Eric Laurente8726fe2015-06-26 09:39:24 -07004042 if (configChanged) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07004043 mPrevOutDevice = type;
François Gaffie0c280aa2018-07-25 10:02:15 +02004044 mDeviceId = sinkPortId;
Eric Laurente8726fe2015-06-26 09:39:24 -07004045 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
4046 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004047 return status;
4048}
4049
Eric Laurent054d9d32015-04-24 08:48:48 -07004050status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4051{
Andy Hungf60abce2016-08-26 11:37:54 -07004052 status_t status;
4053 if (property_get_bool("af.patch_park", false /* default_value */)) {
4054 // Park FastMixer to avoid potential DOS issues with writing to the HAL
4055 // or if HAL does not properly lock against access.
4056 AutoPark<FastMixer> park(mFastMixer);
4057 status = PlaybackThread::releaseAudioPatch_l(handle);
4058 } else {
4059 status = PlaybackThread::releaseAudioPatch_l(handle);
4060 }
Eric Laurent054d9d32015-04-24 08:48:48 -07004061 return status;
4062}
4063
Eric Laurent1c333e22014-05-20 10:48:17 -07004064status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
4065{
4066 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07004067
4068 mOutDevice = AUDIO_DEVICE_NONE;
4069
Mikhail Naganov9ee05402016-10-13 15:58:17 -07004070 if (mOutput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07004071 sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
4072 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07004073 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07004074 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07004075 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004076 status = mOutput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07004077 }
4078 return status;
4079}
4080
Eric Laurent83b88082014-06-20 18:31:16 -07004081void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
4082{
4083 Mutex::Autolock _l(mLock);
4084 mTracks.add(track);
4085}
4086
4087void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
4088{
4089 Mutex::Autolock _l(mLock);
4090 destroyTrack_l(track);
4091}
4092
Mikhail Naganovdc769682018-05-04 15:34:08 -07004093void AudioFlinger::PlaybackThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07004094{
Mikhail Naganovdc769682018-05-04 15:34:08 -07004095 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07004096 config->role = AUDIO_PORT_ROLE_SOURCE;
4097 config->ext.mix.hw_module = mOutput->audioHwDev->handle();
4098 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07004099 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
4100 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
4101 config->flags.output = mOutput->flags;
4102 }
Eric Laurent83b88082014-06-20 18:31:16 -07004103}
4104
Eric Laurent81784c32012-11-19 14:55:58 -08004105// ----------------------------------------------------------------------------
4106
4107AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurent72e3f392015-05-20 14:43:50 -07004108 audio_io_handle_t id, audio_devices_t device, bool systemReady, type_t type)
4109 : PlaybackThread(audioFlinger, output, id, device, type, systemReady),
Eric Laurent81784c32012-11-19 14:55:58 -08004110 // mAudioMixer below
4111 // mFastMixer below
Andy Hung2ddee192015-12-18 17:34:44 -08004112 mFastMixerFutex(0),
4113 mMasterMono(false)
Eric Laurent81784c32012-11-19 14:55:58 -08004114 // mOutputSink below
4115 // mPipeSink below
4116 // mNormalSink below
4117{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01004118 setMasterBalance(audioFlinger->getMasterBalance_l());
Eric Laurent81784c32012-11-19 14:55:58 -08004119 ALOGV("MixerThread() id=%d device=%#x type=%d", id, device, type);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004120 ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004121 "mFrameCount=%zu, mNormalFrameCount=%zu",
Eric Laurent81784c32012-11-19 14:55:58 -08004122 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
4123 mNormalFrameCount);
4124 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
4125
Andy Hungfbfc3952015-01-15 13:33:51 -08004126 if (type == DUPLICATING) {
4127 // The Duplicating thread uses the AudioMixer and delivers data to OutputTracks
4128 // (downstream MixerThreads) in DuplicatingThread::threadLoop_write().
4129 // Do not create or use mFastMixer, mOutputSink, mPipeSink, or mNormalSink.
4130 return;
4131 }
Eric Laurent81784c32012-11-19 14:55:58 -08004132 // create an NBAIO sink for the HAL output stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07004133 mOutputSink = new AudioStreamOutSink(output->stream);
Eric Laurent81784c32012-11-19 14:55:58 -08004134 size_t numCounterOffers = 0;
jiabin245cdd92018-12-07 17:55:15 -08004135 const NBAIO_Format offers[1] = {Format_from_SR_C(
4136 mSampleRate, mChannelCount + mHapticChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004137#if !LOG_NDEBUG
4138 ssize_t index =
4139#else
4140 (void)
4141#endif
4142 mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004143 ALOG_ASSERT(index == 0);
4144
4145 // initialize fast mixer depending on configuration
4146 bool initFastMixer;
4147 switch (kUseFastMixer) {
4148 case FastMixer_Never:
4149 initFastMixer = false;
4150 break;
4151 case FastMixer_Always:
4152 initFastMixer = true;
4153 break;
4154 case FastMixer_Static:
4155 case FastMixer_Dynamic:
Andy Hungfda69402017-02-15 14:33:12 -08004156 // FastMixer was designed to operate with a HAL that pulls at a regular rate,
4157 // where the period is less than an experimentally determined threshold that can be
4158 // scheduled reliably with CFS. However, the BT A2DP HAL is
4159 // bursty (does not pull at a regular rate) and so cannot operate with FastMixer.
4160 initFastMixer = mFrameCount < mNormalFrameCount
4161 && (mOutDevice & AUDIO_DEVICE_OUT_ALL_A2DP) == 0;
Eric Laurent81784c32012-11-19 14:55:58 -08004162 break;
4163 }
Andy Hungfda69402017-02-15 14:33:12 -08004164 ALOGW_IF(initFastMixer == false && mFrameCount < mNormalFrameCount,
4165 "FastMixer is preferred for this sink as frameCount %zu is less than threshold %zu",
4166 mFrameCount, mNormalFrameCount);
Eric Laurent81784c32012-11-19 14:55:58 -08004167 if (initFastMixer) {
Andy Hung1258c1a2014-05-23 21:22:17 -07004168 audio_format_t fastMixerFormat;
4169 if (mMixerBufferEnabled && mEffectBufferEnabled) {
4170 fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
4171 } else {
4172 fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
4173 }
4174 if (mFormat != fastMixerFormat) {
4175 // change our Sink format to accept our intermediate precision
4176 mFormat = fastMixerFormat;
4177 free(mSinkBuffer);
jiabin245cdd92018-12-07 17:55:15 -08004178 mFrameSize = audio_bytes_per_frame(mChannelCount + mHapticChannelCount, mFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004179 const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
4180 (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
4181 }
Eric Laurent81784c32012-11-19 14:55:58 -08004182
4183 // create a MonoPipe to connect our submix to FastMixer
4184 NBAIO_Format format = mOutputSink->format();
Andy Hung8946a282018-04-19 20:04:56 -07004185
Andy Hung1258c1a2014-05-23 21:22:17 -07004186 // adjust format to match that of the Fast Mixer
Glenn Kasten49f36ba2017-12-06 13:02:02 -08004187 ALOGV("format changed from %#x to %#x", format.mFormat, fastMixerFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -07004188 format.mFormat = fastMixerFormat;
4189 format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
4190
Eric Laurent81784c32012-11-19 14:55:58 -08004191 // This pipe depth compensates for scheduling latency of the normal mixer thread.
4192 // When it wakes up after a maximum latency, it runs a few cycles quickly before
4193 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
4194 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
4195 const NBAIO_Format offers[1] = {format};
4196 size_t numCounterOffers = 0;
Andy Hung8946a282018-04-19 20:04:56 -07004197#if !LOG_NDEBUG
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07004198 ssize_t index =
4199#else
4200 (void)
4201#endif
4202 monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
Eric Laurent81784c32012-11-19 14:55:58 -08004203 ALOG_ASSERT(index == 0);
4204 monoPipe->setAvgFrames((mScreenState & 1) ?
4205 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
4206 mPipeSink = monoPipe;
4207
Eric Laurent81784c32012-11-19 14:55:58 -08004208 // create fast mixer and configure it initially with just one fast track for our submix
Andy Hung8946a282018-04-19 20:04:56 -07004209 mFastMixer = new FastMixer(mId);
Eric Laurent81784c32012-11-19 14:55:58 -08004210 FastMixerStateQueue *sq = mFastMixer->sq();
4211#ifdef STATE_QUEUE_DUMP
4212 sq->setObserverDump(&mStateQueueObserverDump);
4213 sq->setMutatorDump(&mStateQueueMutatorDump);
4214#endif
4215 FastMixerState *state = sq->begin();
4216 FastTrack *fastTrack = &state->mFastTracks[0];
4217 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
4218 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
4219 fastTrack->mVolumeProvider = NULL;
jiabin245cdd92018-12-07 17:55:15 -08004220 fastTrack->mChannelMask = mChannelMask | mHapticChannelMask; // mPipeSink channel mask for
4221 // audio to FastMixer
Andy Hunge8a1ced2014-05-09 15:02:21 -07004222 fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer
jiabin245cdd92018-12-07 17:55:15 -08004223 fastTrack->mHapticPlaybackEnabled = mHapticChannelMask != AUDIO_CHANNEL_NONE;
jiabin84114c32019-04-10 16:38:07 -07004224 fastTrack->mHapticIntensity = AudioMixer::HAPTIC_SCALE_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08004225 fastTrack->mGeneration++;
4226 state->mFastTracksGen++;
4227 state->mTrackMask = 1;
4228 // fast mixer will use the HAL output sink
4229 state->mOutputSink = mOutputSink.get();
4230 state->mOutputSinkGen++;
4231 state->mFrameCount = mFrameCount;
jiabin245cdd92018-12-07 17:55:15 -08004232 // specify sink channel mask when haptic channel mask present as it can not
4233 // be calculated directly from channel count
4234 state->mSinkChannelMask = mHapticChannelMask == AUDIO_CHANNEL_NONE
4235 ? AUDIO_CHANNEL_NONE : mChannelMask | mHapticChannelMask;
Eric Laurent81784c32012-11-19 14:55:58 -08004236 state->mCommand = FastMixerState::COLD_IDLE;
4237 // already done in constructor initialization list
4238 //mFastMixerFutex = 0;
4239 state->mColdFutexAddr = &mFastMixerFutex;
4240 state->mColdGen++;
4241 state->mDumpState = &mFastMixerDumpState;
Glenn Kasten9e58b552013-01-18 15:09:48 -08004242 mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
4243 state->mNBLogWriter = mFastMixerNBLogWriter.get();
Eric Laurent81784c32012-11-19 14:55:58 -08004244 sq->end();
4245 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4246
Eric Tan0513b5d2018-09-17 10:32:48 -07004247 NBLog::thread_info_t info;
4248 info.id = mId;
4249 info.type = NBLog::FASTMIXER;
4250 mFastMixerNBLogWriter->log<NBLog::EVENT_THREAD_INFO>(info);
4251
Eric Laurent81784c32012-11-19 14:55:58 -08004252 // start the fast mixer
4253 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
4254 pid_t tid = mFastMixer->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004255 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08004256 stream()->setHalThreadPriority(kPriorityFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08004257
4258#ifdef AUDIO_WATCHDOG
4259 // create and start the watchdog
4260 mAudioWatchdog = new AudioWatchdog();
4261 mAudioWatchdog->setDump(&mAudioWatchdogDump);
4262 mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
4263 tid = mAudioWatchdog->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07004264 sendPrioConfigEvent(getpid(), tid, kPriorityFastMixer, false /*forApp*/);
Eric Laurent81784c32012-11-19 14:55:58 -08004265#endif
Andy Hung8946a282018-04-19 20:04:56 -07004266 } else {
4267#ifdef TEE_SINK
4268 // Only use the MixerThread tee if there is no FastMixer.
4269 mTee.set(mOutputSink->format(), NBAIO_Tee::TEE_FLAG_OUTPUT_THREAD);
4270 mTee.setId(std::string("_") + std::to_string(mId) + "_M");
4271#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004272 }
4273
4274 switch (kUseFastMixer) {
4275 case FastMixer_Never:
4276 case FastMixer_Dynamic:
4277 mNormalSink = mOutputSink;
4278 break;
4279 case FastMixer_Always:
4280 mNormalSink = mPipeSink;
4281 break;
4282 case FastMixer_Static:
4283 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
4284 break;
4285 }
4286}
4287
4288AudioFlinger::MixerThread::~MixerThread()
4289{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004290 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004291 FastMixerStateQueue *sq = mFastMixer->sq();
4292 FastMixerState *state = sq->begin();
4293 if (state->mCommand == FastMixerState::COLD_IDLE) {
4294 int32_t old = android_atomic_inc(&mFastMixerFutex);
4295 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004296 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004297 }
4298 }
4299 state->mCommand = FastMixerState::EXIT;
4300 sq->end();
4301 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4302 mFastMixer->join();
4303 // Though the fast mixer thread has exited, it's state queue is still valid.
4304 // We'll use that extract the final state which contains one remaining fast track
4305 // corresponding to our sub-mix.
4306 state = sq->begin();
4307 ALOG_ASSERT(state->mTrackMask == 1);
4308 FastTrack *fastTrack = &state->mFastTracks[0];
4309 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
4310 delete fastTrack->mBufferProvider;
4311 sq->end(false /*didModify*/);
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004312 mFastMixer.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08004313#ifdef AUDIO_WATCHDOG
4314 if (mAudioWatchdog != 0) {
4315 mAudioWatchdog->requestExit();
4316 mAudioWatchdog->requestExitAndWait();
4317 mAudioWatchdog.clear();
4318 }
4319#endif
4320 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08004321 mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -08004322 delete mAudioMixer;
4323}
4324
4325
4326uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
4327{
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004328 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004329 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
4330 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
4331 }
4332 return latency;
4333}
4334
Eric Laurentbfb1b832013-01-07 09:53:42 -08004335ssize_t AudioFlinger::MixerThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08004336{
4337 // FIXME we should only do one push per cycle; confirm this is true
4338 // Start the fast mixer if it's not already running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004339 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004340 FastMixerStateQueue *sq = mFastMixer->sq();
4341 FastMixerState *state = sq->begin();
4342 if (state->mCommand != FastMixerState::MIX_WRITE &&
4343 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
4344 if (state->mCommand == FastMixerState::COLD_IDLE) {
Eric Laurenta2ab4502015-09-09 12:25:51 -07004345
4346 // FIXME workaround for first HAL write being CPU bound on some devices
4347 ATRACE_BEGIN("write");
4348 mOutput->write((char *)mSinkBuffer, 0);
4349 ATRACE_END();
4350
Eric Laurent81784c32012-11-19 14:55:58 -08004351 int32_t old = android_atomic_inc(&mFastMixerFutex);
4352 if (old == -1) {
Elliott Hughesee499292014-05-21 17:55:51 -07004353 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
Eric Laurent81784c32012-11-19 14:55:58 -08004354 }
4355#ifdef AUDIO_WATCHDOG
4356 if (mAudioWatchdog != 0) {
4357 mAudioWatchdog->resume();
4358 }
4359#endif
4360 }
4361 state->mCommand = FastMixerState::MIX_WRITE;
Glenn Kastend797a9d2015-03-02 14:19:25 -08004362#ifdef FAST_THREAD_STATISTICS
Glenn Kasten4182c4e2013-07-15 14:45:07 -07004363 mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08004364 FastThreadDumpState::kSamplingNforLowRamDevice : FastThreadDumpState::kSamplingN);
Glenn Kastend797a9d2015-03-02 14:19:25 -08004365#endif
Eric Laurent81784c32012-11-19 14:55:58 -08004366 sq->end();
4367 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
4368 if (kUseFastMixer == FastMixer_Dynamic) {
4369 mNormalSink = mPipeSink;
4370 }
4371 } else {
4372 sq->end(false /*didModify*/);
4373 }
4374 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004375 return PlaybackThread::threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08004376}
4377
4378void AudioFlinger::MixerThread::threadLoop_standby()
4379{
4380 // Idle the fast mixer if it's currently running
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004381 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004382 FastMixerStateQueue *sq = mFastMixer->sq();
4383 FastMixerState *state = sq->begin();
4384 if (!(state->mCommand & FastMixerState::IDLE)) {
Andy Hung2148bf02016-11-28 19:01:02 -08004385 // Report any frames trapped in the Monopipe
4386 MonoPipe *monoPipe = (MonoPipe *)mPipeSink.get();
4387 const long long pipeFrames = monoPipe->maxFrames() - monoPipe->availableToWrite();
4388 mLocalLog.log("threadLoop_standby: framesWritten:%lld suspendedFrames:%lld "
4389 "monoPipeWritten:%lld monoPipeLeft:%lld",
4390 (long long)mFramesWritten, (long long)mSuspendedFrames,
4391 (long long)mPipeSink->framesWritten(), pipeFrames);
4392 mLocalLog.log("threadLoop_standby: %s", mTimestamp.toString().c_str());
4393
Eric Laurent81784c32012-11-19 14:55:58 -08004394 state->mCommand = FastMixerState::COLD_IDLE;
4395 state->mColdFutexAddr = &mFastMixerFutex;
4396 state->mColdGen++;
4397 mFastMixerFutex = 0;
4398 sq->end();
4399 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
4400 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
4401 if (kUseFastMixer == FastMixer_Dynamic) {
4402 mNormalSink = mOutputSink;
4403 }
4404#ifdef AUDIO_WATCHDOG
4405 if (mAudioWatchdog != 0) {
4406 mAudioWatchdog->pause();
4407 }
4408#endif
4409 } else {
4410 sq->end(false /*didModify*/);
4411 }
4412 }
4413 PlaybackThread::threadLoop_standby();
4414}
4415
Eric Laurentbfb1b832013-01-07 09:53:42 -08004416bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
4417{
4418 return false;
4419}
4420
4421bool AudioFlinger::PlaybackThread::shouldStandby_l()
4422{
4423 return !mStandby;
4424}
4425
4426bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
4427{
4428 Mutex::Autolock _l(mLock);
4429 return waitingAsyncCallback_l();
4430}
4431
Eric Laurent81784c32012-11-19 14:55:58 -08004432// shared by MIXER and DIRECT, overridden by DUPLICATING
4433void AudioFlinger::PlaybackThread::threadLoop_standby()
4434{
4435 ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
Phil Burk062e67a2015-02-11 13:40:50 -08004436 mOutput->standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -08004437 if (mUseAsyncWrite != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07004438 // discard any pending drain or write ack by incrementing sequence
4439 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
4440 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08004441 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07004442 mCallbackThread->setWriteBlocked(mWriteAckSequence);
4443 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08004444 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08004445 mHwPaused = false;
Eric Laurent81784c32012-11-19 14:55:58 -08004446}
4447
Haynes Mathew George4c6a4332014-01-15 12:31:39 -08004448void AudioFlinger::PlaybackThread::onAddNewTrack_l()
4449{
4450 ALOGV("signal playback thread");
4451 broadcast_l();
4452}
4453
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07004454void AudioFlinger::PlaybackThread::onAsyncError()
4455{
4456 for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
4457 invalidateTracks((audio_stream_type_t)i);
4458 }
4459}
4460
Eric Laurent81784c32012-11-19 14:55:58 -08004461void AudioFlinger::MixerThread::threadLoop_mix()
4462{
Eric Laurent81784c32012-11-19 14:55:58 -08004463 // mix buffers...
Glenn Kastend79072e2016-01-06 08:41:20 -08004464 mAudioMixer->process();
Andy Hung25c2dac2014-02-27 14:56:00 -08004465 mCurrentWriteLength = mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08004466 // increase sleep time progressively when application underrun condition clears.
4467 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
4468 // that a steady state of alternating ready/not ready conditions keeps the sleep time
4469 // such that we would underrun the audio HAL.
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004470 if ((mSleepTimeUs == 0) && (sleepTimeShift > 0)) {
Eric Laurent81784c32012-11-19 14:55:58 -08004471 sleepTimeShift--;
4472 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004473 mSleepTimeUs = 0;
4474 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08004475 //TODO: delay standby when effects have a tail
Glenn Kasten4c053ea2014-09-28 14:41:07 -07004476
Eric Laurent81784c32012-11-19 14:55:58 -08004477}
4478
4479void AudioFlinger::MixerThread::threadLoop_sleepTime()
4480{
4481 // If no tracks are ready, sleep once for the duration of an output
4482 // buffer size, then write 0s to the output
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004483 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004484 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Andy Hung06d13222018-05-03 20:13:31 -07004485 if (mPipeSink.get() != nullptr && mPipeSink == mNormalSink) {
4486 // Using the Monopipe availableToWrite, we estimate the
4487 // sleep time to retry for more data (before we underrun).
4488 MonoPipe *monoPipe = static_cast<MonoPipe *>(mPipeSink.get());
4489 const ssize_t availableToWrite = mPipeSink->availableToWrite();
4490 const size_t pipeFrames = monoPipe->maxFrames();
4491 const size_t framesLeft = pipeFrames - max(availableToWrite, 0);
4492 // HAL_framecount <= framesDelay ~ framesLeft / 2 <= Normal_Mixer_framecount
4493 const size_t framesDelay = std::min(
4494 mNormalFrameCount, max(framesLeft / 2, mFrameCount));
4495 ALOGV("pipeFrames:%zu framesLeft:%zu framesDelay:%zu",
4496 pipeFrames, framesLeft, framesDelay);
4497 mSleepTimeUs = framesDelay * MICROS_PER_SECOND / mSampleRate;
4498 } else {
4499 mSleepTimeUs = mActiveSleepTimeUs >> sleepTimeShift;
4500 if (mSleepTimeUs < kMinThreadSleepTimeUs) {
4501 mSleepTimeUs = kMinThreadSleepTimeUs;
4502 }
4503 // reduce sleep time in case of consecutive application underruns to avoid
4504 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
4505 // duration we would end up writing less data than needed by the audio HAL if
4506 // the condition persists.
4507 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
4508 sleepTimeShift++;
4509 }
Eric Laurent81784c32012-11-19 14:55:58 -08004510 }
4511 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004512 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08004513 }
4514 } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
Andy Hung98ef9782014-03-04 14:46:50 -08004515 // clear out mMixerBuffer or mSinkBuffer, to ensure buffers are cleared
4516 // before effects processing or output.
4517 if (mMixerBufferValid) {
4518 memset(mMixerBuffer, 0, mMixerBufferSize);
4519 } else {
4520 memset(mSinkBuffer, 0, mSinkBufferSize);
4521 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07004522 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08004523 ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
4524 "anticipated start");
4525 }
4526 // TODO add standby time extension fct of effect tail
4527}
4528
4529// prepareTracks_l() must be called with ThreadBase::mLock held
4530AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
4531 Vector< sp<Track> > *tracksToRemove)
4532{
Andy Hungc0691382018-09-12 18:01:57 -07004533 // clean up deleted track ids in AudioMixer before allocating new tracks
4534 (void)mTracks.processDeletedTrackIds([this](int trackId) {
4535 // for each trackId, destroy it in the AudioMixer
4536 if (mAudioMixer->exists(trackId)) {
4537 mAudioMixer->destroy(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08004538 }
4539 });
Andy Hungc0691382018-09-12 18:01:57 -07004540 mTracks.clearDeletedTrackIds();
Eric Laurent81784c32012-11-19 14:55:58 -08004541
4542 mixer_state mixerStatus = MIXER_IDLE;
4543 // find out which tracks need to be processed
4544 size_t count = mActiveTracks.size();
4545 size_t mixedTracks = 0;
4546 size_t tracksWithEffect = 0;
4547 // counts only _active_ fast tracks
4548 size_t fastTracks = 0;
4549 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
4550
4551 float masterVolume = mMasterVolume;
4552 bool masterMute = mMasterMute;
4553
4554 if (masterMute) {
4555 masterVolume = 0;
4556 }
4557 // Delegate master volume control to effect in output mix effect chain if needed
4558 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4559 if (chain != 0) {
4560 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
4561 chain->setVolume_l(&v, &v);
4562 masterVolume = (float)((v + (1 << 23)) >> 24);
4563 chain.clear();
4564 }
4565
4566 // prepare a new state to push
4567 FastMixerStateQueue *sq = NULL;
4568 FastMixerState *state = NULL;
4569 bool didModify = false;
4570 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
Andy Hungf2285312017-02-14 18:31:59 -08004571 bool coldIdle = false;
Glenn Kasten4d23ca32014-05-13 10:39:51 -07004572 if (mFastMixer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004573 sq = mFastMixer->sq();
4574 state = sq->begin();
Andy Hungf2285312017-02-14 18:31:59 -08004575 coldIdle = state->mCommand == FastMixerState::COLD_IDLE;
Eric Laurent81784c32012-11-19 14:55:58 -08004576 }
4577
Andy Hung69aed5f2014-02-25 17:24:40 -08004578 mMixerBufferValid = false; // mMixerBuffer has no valid data until appropriate tracks found.
Andy Hung98ef9782014-03-04 14:46:50 -08004579 mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found.
Andy Hung69aed5f2014-02-25 17:24:40 -08004580
Andy Hungbd3b2b02018-05-21 10:53:11 -07004581 // DeferredOperations handles statistics after setting mixerStatus.
4582 class DeferredOperations {
4583 public:
4584 DeferredOperations(mixer_state *mixerStatus)
4585 : mMixerStatus(mixerStatus) { }
4586
4587 // when leaving scope, tally frames properly.
4588 ~DeferredOperations() {
4589 // Tally underrun frames only if we are actually mixing (MIXER_TRACKS_READY)
4590 // because that is when the underrun occurs.
4591 // We do not distinguish between FastTracks and NormalTracks here.
4592 if (*mMixerStatus == MIXER_TRACKS_READY) {
4593 for (const auto &underrun : mUnderrunFrames) {
4594 underrun.first->mAudioTrackServerProxy->tallyUnderrunFrames(
4595 underrun.second);
4596 }
4597 }
4598 }
4599
4600 // tallyUnderrunFrames() is called to update the track counters
4601 // with the number of underrun frames for a particular mixer period.
4602 // We defer tallying until we know the final mixer status.
4603 void tallyUnderrunFrames(sp<Track> track, size_t underrunFrames) {
4604 mUnderrunFrames.emplace_back(track, underrunFrames);
4605 }
4606
4607 private:
4608 const mixer_state * const mMixerStatus;
4609 std::vector<std::pair<sp<Track>, size_t>> mUnderrunFrames;
4610 } deferredOperations(&mixerStatus); // implicit nested scope for variable capture
4611
jiabin245cdd92018-12-07 17:55:15 -08004612 bool noFastHapticTrack = true;
Eric Laurent81784c32012-11-19 14:55:58 -08004613 for (size_t i=0 ; i<count ; i++) {
Andy Hungdae27702016-10-31 14:01:16 -07004614 const sp<Track> t = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08004615
4616 // this const just means the local variable doesn't change
4617 Track* const track = t.get();
4618
4619 // process fast tracks
4620 if (track->isFastTrack()) {
Andy Hungae22b482019-05-09 15:38:55 -07004621 LOG_ALWAYS_FATAL_IF(mFastMixer.get() == nullptr,
4622 "%s(%d): FastTrack(%d) present without FastMixer",
4623 __func__, id(), track->id());
4624
jiabin245cdd92018-12-07 17:55:15 -08004625 if (track->getHapticPlaybackEnabled()) {
4626 noFastHapticTrack = false;
4627 }
Eric Laurent81784c32012-11-19 14:55:58 -08004628
4629 // It's theoretically possible (though unlikely) for a fast track to be created
4630 // and then removed within the same normal mix cycle. This is not a problem, as
4631 // the track never becomes active so it's fast mixer slot is never touched.
4632 // The converse, of removing an (active) track and then creating a new track
4633 // at the identical fast mixer slot within the same normal mix cycle,
4634 // is impossible because the slot isn't marked available until the end of each cycle.
4635 int j = track->mFastIndex;
Glenn Kastendc2c50b2016-04-21 08:13:14 -07004636 ALOG_ASSERT(0 < j && j < (int)FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08004637 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
4638 FastTrack *fastTrack = &state->mFastTracks[j];
4639
4640 // Determine whether the track is currently in underrun condition,
4641 // and whether it had a recent underrun.
4642 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
4643 FastTrackUnderruns underruns = ftDump->mUnderruns;
4644 uint32_t recentFull = (underruns.mBitFields.mFull -
4645 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
4646 uint32_t recentPartial = (underruns.mBitFields.mPartial -
4647 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
4648 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
4649 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
4650 uint32_t recentUnderruns = recentPartial + recentEmpty;
4651 track->mObservedUnderruns = underruns;
4652 // don't count underruns that occur while stopping or pausing
4653 // or stopped which can occur when flush() is called while active
Andy Hungbd3b2b02018-05-21 10:53:11 -07004654 size_t underrunFrames = 0;
Glenn Kasten82aaf942013-07-17 16:05:07 -07004655 if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
4656 recentUnderruns > 0) {
4657 // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun
Andy Hungbd3b2b02018-05-21 10:53:11 -07004658 underrunFrames = recentUnderruns * mFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08004659 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07004660 // Immediately account for FastTrack underruns.
4661 track->mAudioTrackServerProxy->tallyUnderrunFrames(underrunFrames);
Eric Laurent81784c32012-11-19 14:55:58 -08004662
4663 // This is similar to the state machine for normal tracks,
4664 // with a few modifications for fast tracks.
4665 bool isActive = true;
4666 switch (track->mState) {
4667 case TrackBase::STOPPING_1:
4668 // track stays active in STOPPING_1 state until first underrun
Eric Laurentbfb1b832013-01-07 09:53:42 -08004669 if (recentUnderruns > 0 || track->isTerminated()) {
Eric Laurent81784c32012-11-19 14:55:58 -08004670 track->mState = TrackBase::STOPPING_2;
4671 }
4672 break;
4673 case TrackBase::PAUSING:
4674 // ramp down is not yet implemented
4675 track->setPaused();
4676 break;
4677 case TrackBase::RESUMING:
4678 // ramp up is not yet implemented
4679 track->mState = TrackBase::ACTIVE;
4680 break;
4681 case TrackBase::ACTIVE:
4682 if (recentFull > 0 || recentPartial > 0) {
4683 // track has provided at least some frames recently: reset retry count
4684 track->mRetryCount = kMaxTrackRetries;
4685 }
4686 if (recentUnderruns == 0) {
4687 // no recent underruns: stay active
4688 break;
4689 }
4690 // there has recently been an underrun of some kind
4691 if (track->sharedBuffer() == 0) {
4692 // were any of the recent underruns "empty" (no frames available)?
4693 if (recentEmpty == 0) {
4694 // no, then ignore the partial underruns as they are allowed indefinitely
4695 break;
4696 }
4697 // there has recently been an "empty" underrun: decrement the retry counter
4698 if (--(track->mRetryCount) > 0) {
4699 break;
4700 }
4701 // indicate to client process that the track was disabled because of underrun;
4702 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08004703 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08004704 // remove from active list, but state remains ACTIVE [confusing but true]
4705 isActive = false;
4706 break;
4707 }
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -07004708 FALLTHROUGH_INTENDED;
Eric Laurent81784c32012-11-19 14:55:58 -08004709 case TrackBase::STOPPING_2:
4710 case TrackBase::PAUSED:
Eric Laurent81784c32012-11-19 14:55:58 -08004711 case TrackBase::STOPPED:
4712 case TrackBase::FLUSHED: // flush() while active
4713 // Check for presentation complete if track is inactive
4714 // We have consumed all the buffers of this track.
4715 // This would be incomplete if we auto-paused on underrun
4716 {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004717 uint32_t latency = 0;
4718 status_t result = mOutput->stream->getLatency(&latency);
4719 ALOGE_IF(result != OK,
4720 "Error when retrieving output stream latency: %d", result);
4721 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08004722 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08004723 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
4724 // track stays in active list until presentation is complete
4725 break;
4726 }
4727 }
4728 if (track->isStopping_2()) {
4729 track->mState = TrackBase::STOPPED;
4730 }
4731 if (track->isStopped()) {
4732 // Can't reset directly, as fast mixer is still polling this track
4733 // track->reset();
4734 // So instead mark this track as needing to be reset after push with ack
4735 resetMask |= 1 << i;
4736 }
4737 isActive = false;
4738 break;
4739 case TrackBase::IDLE:
4740 default:
Glenn Kastenadad3d72014-02-21 14:51:43 -08004741 LOG_ALWAYS_FATAL("unexpected track state %d", track->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08004742 }
4743
4744 if (isActive) {
4745 // was it previously inactive?
4746 if (!(state->mTrackMask & (1 << j))) {
4747 ExtendedAudioBufferProvider *eabp = track;
4748 VolumeProvider *vp = track;
4749 fastTrack->mBufferProvider = eabp;
4750 fastTrack->mVolumeProvider = vp;
Eric Laurent81784c32012-11-19 14:55:58 -08004751 fastTrack->mChannelMask = track->mChannelMask;
Andy Hunge8a1ced2014-05-09 15:02:21 -07004752 fastTrack->mFormat = track->mFormat;
jiabin245cdd92018-12-07 17:55:15 -08004753 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
jiabin77270b82018-12-18 15:41:29 -08004754 fastTrack->mHapticIntensity = track->getHapticIntensity();
Eric Laurent81784c32012-11-19 14:55:58 -08004755 fastTrack->mGeneration++;
4756 state->mTrackMask |= 1 << j;
4757 didModify = true;
4758 // no acknowledgement required for newly active tracks
4759 }
Kevin Rocard12381092018-04-11 09:19:59 -07004760 sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
Eric Laurent81784c32012-11-19 14:55:58 -08004761 // cache the combined master volume and stream type volume for fast mixer; this
4762 // lacks any synchronization or barrier so VolumeProvider may read a stale value
Andy Hung9fc8b5c2017-01-24 13:36:48 -08004763 const float vh = track->getVolumeHandler()->getVolume(
Kevin Rocard12381092018-04-11 09:19:59 -07004764 proxy->framesReleased()).first;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08004765 float volume;
4766 if (track->isPlaybackRestricted()) {
4767 volume = 0.f;
4768 } else {
4769 volume = masterVolume
Andy Hung9fc8b5c2017-01-24 13:36:48 -08004770 * mStreamTypes[track->streamType()].volume
4771 * vh;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08004772 }
Kevin Rocardb0eeaf122018-04-11 08:30:16 -07004773 track->mCachedVolume = volume;
Kevin Rocard12381092018-04-11 09:19:59 -07004774 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
4775 float vlf = volume * float_from_gain(gain_minifloat_unpack_left(vlr));
4776 float vrf = volume * float_from_gain(gain_minifloat_unpack_right(vlr));
4777 track->setFinalVolume((vlf + vrf) / 2.f);
Eric Laurent81784c32012-11-19 14:55:58 -08004778 ++fastTracks;
4779 } else {
4780 // was it previously active?
4781 if (state->mTrackMask & (1 << j)) {
4782 fastTrack->mBufferProvider = NULL;
4783 fastTrack->mGeneration++;
4784 state->mTrackMask &= ~(1 << j);
4785 didModify = true;
4786 // If any fast tracks were removed, we must wait for acknowledgement
4787 // because we're about to decrement the last sp<> on those tracks.
4788 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
4789 } else {
Glenn Kastenbf848af2017-12-22 11:55:01 -08004790 // ALOGW rather than LOG_ALWAYS_FATAL because it seems there are cases where an
4791 // AudioTrack may start (which may not be with a start() but with a write()
4792 // after underrun) and immediately paused or released. In that case the
4793 // FastTrack state hasn't had time to update.
4794 // TODO Remove the ALOGW when this theory is confirmed.
4795 ALOGW("fast track %d should have been active; "
Glenn Kastenf7d65ee2015-12-02 13:45:01 -08004796 "mState=%d, mTrackMask=%#x, recentUnderruns=%u, isShared=%d",
4797 j, track->mState, state->mTrackMask, recentUnderruns,
4798 track->sharedBuffer() != 0);
Glenn Kastenbf848af2017-12-22 11:55:01 -08004799 // Since the FastMixer state already has the track inactive, do nothing here.
Eric Laurent81784c32012-11-19 14:55:58 -08004800 }
4801 tracksToRemove->add(track);
4802 // Avoids a misleading display in dumpsys
4803 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
4804 }
jiabin245cdd92018-12-07 17:55:15 -08004805 if (fastTrack->mHapticPlaybackEnabled != track->getHapticPlaybackEnabled()) {
4806 fastTrack->mHapticPlaybackEnabled = track->getHapticPlaybackEnabled();
4807 didModify = true;
4808 }
Eric Laurent81784c32012-11-19 14:55:58 -08004809 continue;
4810 }
4811
4812 { // local variable scope to avoid goto warning
4813
4814 audio_track_cblk_t* cblk = track->cblk();
4815
4816 // The first time a track is added we wait
4817 // for all its buffers to be filled before processing it
Andy Hungc0691382018-09-12 18:01:57 -07004818 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08004819
4820 // if an active track doesn't exist in the AudioMixer, create it.
Andy Hungc0691382018-09-12 18:01:57 -07004821 // use the trackId as the AudioMixer name.
4822 if (!mAudioMixer->exists(trackId)) {
Andy Hung1bc088a2018-02-09 15:57:31 -08004823 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07004824 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08004825 track->mChannelMask,
4826 track->mFormat,
4827 track->mSessionId);
4828 if (status != OK) {
Andy Hungc0691382018-09-12 18:01:57 -07004829 ALOGW("%s(): AudioMixer cannot create track(%d)"
4830 " mask %#x, format %#x, sessionId %d",
4831 __func__, trackId,
4832 track->mChannelMask, track->mFormat, track->mSessionId);
Andy Hung1bc088a2018-02-09 15:57:31 -08004833 tracksToRemove->add(track);
4834 track->invalidate(); // consider it dead.
4835 continue;
4836 }
4837 }
4838
Eric Laurent81784c32012-11-19 14:55:58 -08004839 // make sure that we have enough frames to mix one full buffer.
4840 // enforce this condition only once to enable draining the buffer in case the client
4841 // app does not call stop() and relies on underrun to stop:
4842 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
4843 // during last round
Glenn Kasten9f80dd22012-12-18 15:57:32 -08004844 size_t desiredFrames;
Andy Hung8edb8dc2015-03-26 19:13:55 -07004845 const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate();
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07004846 AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07004847
4848 desiredFrames = sourceFramesNeededWithTimestretch(
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07004849 sampleRate, mNormalFrameCount, mSampleRate, playbackRate.mSpeed);
Andy Hung8edb8dc2015-03-26 19:13:55 -07004850 // TODO: ONLY USED FOR LEGACY RESAMPLERS, remove when they are removed.
4851 // add frames already consumed but not yet released by the resampler
4852 // because mAudioTrackServerProxy->framesReady() will include these frames
Andy Hungc0691382018-09-12 18:01:57 -07004853 desiredFrames += mAudioMixer->getUnreleasedFrames(trackId);
Andy Hung8edb8dc2015-03-26 19:13:55 -07004854
Eric Laurent81784c32012-11-19 14:55:58 -08004855 uint32_t minFrames = 1;
4856 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
4857 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08004858 minFrames = desiredFrames;
Eric Laurent81784c32012-11-19 14:55:58 -08004859 }
Eric Laurent13e4c962013-12-20 17:36:01 -08004860
4861 size_t framesReady = track->framesReady();
Glenn Kastene7754022014-10-31 12:11:26 -07004862 if (ATRACE_ENABLED()) {
4863 // I wish we had formatted trace names
Andy Hung1bc088a2018-02-09 15:57:31 -08004864 std::string traceName("nRdy");
Andy Hungc0691382018-09-12 18:01:57 -07004865 traceName += std::to_string(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08004866 ATRACE_INT(traceName.c_str(), framesReady);
Glenn Kastene7754022014-10-31 12:11:26 -07004867 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08004868 if ((framesReady >= minFrames) && track->isReady() &&
Eric Laurent81784c32012-11-19 14:55:58 -08004869 !track->isPaused() && !track->isTerminated())
4870 {
Andy Hungc0691382018-09-12 18:01:57 -07004871 ALOGVV("track(%d) s=%08x [OK] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08004872
4873 mixedTracks++;
4874
Andy Hung69aed5f2014-02-25 17:24:40 -08004875 // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
4876 // there is an effect chain connected to the track
Eric Laurent81784c32012-11-19 14:55:58 -08004877 chain.clear();
Andy Hung69aed5f2014-02-25 17:24:40 -08004878 if (track->mainBuffer() != mSinkBuffer &&
4879 track->mainBuffer() != mMixerBuffer) {
Andy Hung98ef9782014-03-04 14:46:50 -08004880 if (mEffectBufferEnabled) {
4881 mEffectBufferValid = true; // Later can set directly.
4882 }
Eric Laurent81784c32012-11-19 14:55:58 -08004883 chain = getEffectChain_l(track->sessionId());
4884 // Delegate volume control to effect in track effect chain if needed
4885 if (chain != 0) {
4886 tracksWithEffect++;
4887 } else {
Andy Hungc0691382018-09-12 18:01:57 -07004888 ALOGW("prepareTracks_l(): track(%d) attached to effect but no chain found on "
Eric Laurent81784c32012-11-19 14:55:58 -08004889 "session %d",
Andy Hungc0691382018-09-12 18:01:57 -07004890 trackId, track->sessionId());
Eric Laurent81784c32012-11-19 14:55:58 -08004891 }
4892 }
4893
4894
4895 int param = AudioMixer::VOLUME;
4896 if (track->mFillingUpStatus == Track::FS_FILLED) {
4897 // no ramp for the first volume setting
4898 track->mFillingUpStatus = Track::FS_ACTIVE;
4899 if (track->mState == TrackBase::RESUMING) {
4900 track->mState = TrackBase::ACTIVE;
Revathi Uddaraju453bcb52017-08-14 14:19:40 +08004901 // If a new track is paused immediately after start, do not ramp on resume.
4902 if (cblk->mServer != 0) {
4903 param = AudioMixer::RAMP_VOLUME;
4904 }
Eric Laurent81784c32012-11-19 14:55:58 -08004905 }
Andy Hungc0691382018-09-12 18:01:57 -07004906 mAudioMixer->setParameter(trackId, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
Eric Laurent7c29ec92017-09-20 17:54:22 -07004907 mLeftVolFloat = -1.0;
Glenn Kastenf20e1d82013-07-12 09:45:18 -07004908 // FIXME should not make a decision based on mServer
4909 } else if (cblk->mServer != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08004910 // If the track is stopped before the first frame was mixed,
4911 // do not apply ramp
4912 param = AudioMixer::RAMP_VOLUME;
4913 }
4914
4915 // compute volume for this track
Andy Hung6be49402014-05-30 10:42:03 -07004916 uint32_t vl, vr; // in U8.24 integer format
4917 float vlf, vrf, vaf; // in [0.0, 1.0] float format
Eric Laurent7c29ec92017-09-20 17:54:22 -07004918 // read original volumes with volume control
4919 float typeVolume = mStreamTypes[track->streamType()].volume;
4920 float v = masterVolume * typeVolume;
Andy Hung333ab962019-05-28 20:23:35 -07004921 // Always fetch volumeshaper volume to ensure state is updated.
4922 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
4923 const float vh = track->getVolumeHandler()->getVolume(
4924 track->mAudioTrackServerProxy->framesReleased()).first;
Eric Laurent7c29ec92017-09-20 17:54:22 -07004925
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08004926 if (track->isPausing() || mStreamTypes[track->streamType()].mute
4927 || track->isPlaybackRestricted()) {
Andy Hung6be49402014-05-30 10:42:03 -07004928 vl = vr = 0;
4929 vlf = vrf = vaf = 0.;
Eric Laurent81784c32012-11-19 14:55:58 -08004930 if (track->isPausing()) {
4931 track->setPaused();
4932 }
4933 } else {
Glenn Kastenc56f3422014-03-21 17:53:17 -07004934 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
Andy Hung6be49402014-05-30 10:42:03 -07004935 vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
4936 vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
Eric Laurent81784c32012-11-19 14:55:58 -08004937 // track volumes come from shared memory, so can't be trusted and must be clamped
Glenn Kastenc56f3422014-03-21 17:53:17 -07004938 if (vlf > GAIN_FLOAT_UNITY) {
4939 ALOGV("Track left volume out of range: %.3g", vlf);
4940 vlf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08004941 }
Glenn Kastenc56f3422014-03-21 17:53:17 -07004942 if (vrf > GAIN_FLOAT_UNITY) {
4943 ALOGV("Track right volume out of range: %.3g", vrf);
4944 vrf = GAIN_FLOAT_UNITY;
Eric Laurent81784c32012-11-19 14:55:58 -08004945 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08004946 // now apply the master volume and stream type volume and shaper volume
4947 vlf *= v * vh;
4948 vrf *= v * vh;
Eric Laurent81784c32012-11-19 14:55:58 -08004949 // assuming master volume and stream type volume each go up to 1.0,
Andy Hung6be49402014-05-30 10:42:03 -07004950 // then derive vl and vr as U8.24 versions for the effect chain
4951 const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT;
4952 vl = (uint32_t) (scaleto8_24 * vlf);
4953 vr = (uint32_t) (scaleto8_24 * vrf);
4954 // vl and vr are now in U8.24 format
Glenn Kastene3aa6592012-12-04 12:22:46 -08004955 uint16_t sendLevel = proxy->getSendLevel_U4_12();
Eric Laurent81784c32012-11-19 14:55:58 -08004956 // send level comes from shared memory and so may be corrupt
4957 if (sendLevel > MAX_GAIN_INT) {
4958 ALOGV("Track send level out of range: %04X", sendLevel);
4959 sendLevel = MAX_GAIN_INT;
4960 }
Andy Hung6be49402014-05-30 10:42:03 -07004961 // vaf is represented as [0.0, 1.0] float by rescaling sendLevel
4962 vaf = v * sendLevel * (1. / MAX_GAIN_INT);
Eric Laurent81784c32012-11-19 14:55:58 -08004963 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08004964
Kevin Rocard12381092018-04-11 09:19:59 -07004965 track->setFinalVolume((vrf + vlf) / 2.f);
4966
Eric Laurent81784c32012-11-19 14:55:58 -08004967 // Delegate volume control to effect in track effect chain if needed
4968 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
4969 // Do not ramp volume if volume is controlled by effect
4970 param = AudioMixer::VOLUME;
Bryant Liub6be7f22014-06-12 22:02:41 +08004971 // Update remaining floating point volume levels
4972 vlf = (float)vl / (1 << 24);
4973 vrf = (float)vr / (1 << 24);
Eric Laurent81784c32012-11-19 14:55:58 -08004974 track->mHasVolumeController = true;
4975 } else {
4976 // force no volume ramp when volume controller was just disabled or removed
4977 // from effect chain to avoid volume spike
4978 if (track->mHasVolumeController) {
4979 param = AudioMixer::VOLUME;
4980 }
4981 track->mHasVolumeController = false;
4982 }
4983
Eric Laurent7c29ec92017-09-20 17:54:22 -07004984 // For dedicated VoIP outputs, let the HAL apply the stream volume. Track volume is
4985 // still applied by the mixer.
4986 if ((mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
4987 v = mStreamTypes[track->streamType()].mute ? 0.0f : v;
4988 if (v != mLeftVolFloat) {
4989 status_t result = mOutput->stream->setVolume(v, v);
4990 ALOGE_IF(result != OK, "Error when setting output stream volume: %d", result);
4991 if (result == OK) {
4992 mLeftVolFloat = v;
4993 }
4994 }
4995 // if stream volume was successfully sent to the HAL, mLeftVolFloat == v here and we
4996 // remove stream volume contribution from software volume.
4997 if (v != 0.0f && mLeftVolFloat == v) {
4998 vlf = min(1.0f, vlf / v);
4999 vrf = min(1.0f, vrf / v);
5000 vaf = min(1.0f, vaf / v);
5001 }
5002 }
Eric Laurent81784c32012-11-19 14:55:58 -08005003 // XXX: these things DON'T need to be done each time
Andy Hungc0691382018-09-12 18:01:57 -07005004 mAudioMixer->setBufferProvider(trackId, track);
5005 mAudioMixer->enable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005006
Andy Hungc0691382018-09-12 18:01:57 -07005007 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME0, &vlf);
5008 mAudioMixer->setParameter(trackId, param, AudioMixer::VOLUME1, &vrf);
5009 mAudioMixer->setParameter(trackId, param, AudioMixer::AUXLEVEL, &vaf);
Eric Laurent81784c32012-11-19 14:55:58 -08005010 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005011 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005012 AudioMixer::TRACK,
5013 AudioMixer::FORMAT, (void *)track->format());
5014 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005015 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005016 AudioMixer::TRACK,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005017 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
Andy Hung9a592762014-07-21 21:56:01 -07005018 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005019 trackId,
Andy Hung9a592762014-07-21 21:56:01 -07005020 AudioMixer::TRACK,
jiabin245cdd92018-12-07 17:55:15 -08005021 AudioMixer::MIXER_CHANNEL_MASK,
5022 (void *)(uintptr_t)(mChannelMask | mHapticChannelMask));
Glenn Kastene3aa6592012-12-04 12:22:46 -08005023 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
Andy Hungcd044842014-08-07 11:04:34 -07005024 uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX;
Andy Hung333ab962019-05-28 20:23:35 -07005025 uint32_t reqSampleRate = proxy->getSampleRate();
Glenn Kastene3aa6592012-12-04 12:22:46 -08005026 if (reqSampleRate == 0) {
5027 reqSampleRate = mSampleRate;
5028 } else if (reqSampleRate > maxSampleRate) {
5029 reqSampleRate = maxSampleRate;
5030 }
Eric Laurent81784c32012-11-19 14:55:58 -08005031 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005032 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005033 AudioMixer::RESAMPLE,
5034 AudioMixer::SAMPLE_RATE,
Kévin PETIT377b2ec2014-02-03 12:35:36 +00005035 (void *)(uintptr_t)reqSampleRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005036
Andy Hung333ab962019-05-28 20:23:35 -07005037 AudioPlaybackRate playbackRate = proxy->getPlaybackRate();
Andy Hung8edb8dc2015-03-26 19:13:55 -07005038 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005039 trackId,
Andy Hung8edb8dc2015-03-26 19:13:55 -07005040 AudioMixer::TIMESTRETCH,
5041 AudioMixer::PLAYBACK_RATE,
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07005042 &playbackRate);
Andy Hung8edb8dc2015-03-26 19:13:55 -07005043
Andy Hung69aed5f2014-02-25 17:24:40 -08005044 /*
5045 * Select the appropriate output buffer for the track.
5046 *
Andy Hung98ef9782014-03-04 14:46:50 -08005047 * Tracks with effects go into their own effects chain buffer
5048 * and from there into either mEffectBuffer or mSinkBuffer.
Andy Hung69aed5f2014-02-25 17:24:40 -08005049 *
5050 * Other tracks can use mMixerBuffer for higher precision
5051 * channel accumulation. If this buffer is enabled
5052 * (mMixerBufferEnabled true), then selected tracks will accumulate
5053 * into it.
5054 *
5055 */
5056 if (mMixerBufferEnabled
5057 && (track->mainBuffer() == mSinkBuffer
5058 || track->mainBuffer() == mMixerBuffer)) {
5059 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005060 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005061 AudioMixer::TRACK,
Andy Hung78820702014-02-28 16:23:02 -08005062 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
Andy Hung69aed5f2014-02-25 17:24:40 -08005063 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005064 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005065 AudioMixer::TRACK,
5066 AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer);
5067 // TODO: override track->mainBuffer()?
5068 mMixerBufferValid = true;
5069 } else {
5070 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005071 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005072 AudioMixer::TRACK,
rago94a1ee82017-07-21 15:11:02 -07005073 AudioMixer::MIXER_FORMAT, (void *)EFFECT_BUFFER_FORMAT);
Andy Hung69aed5f2014-02-25 17:24:40 -08005074 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005075 trackId,
Andy Hung69aed5f2014-02-25 17:24:40 -08005076 AudioMixer::TRACK,
5077 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
5078 }
Eric Laurent81784c32012-11-19 14:55:58 -08005079 mAudioMixer->setParameter(
Andy Hungc0691382018-09-12 18:01:57 -07005080 trackId,
Eric Laurent81784c32012-11-19 14:55:58 -08005081 AudioMixer::TRACK,
5082 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
jiabin245cdd92018-12-07 17:55:15 -08005083 mAudioMixer->setParameter(
5084 trackId,
5085 AudioMixer::TRACK,
5086 AudioMixer::HAPTIC_ENABLED, (void *)(uintptr_t)track->getHapticPlaybackEnabled());
jiabin77270b82018-12-18 15:41:29 -08005087 mAudioMixer->setParameter(
5088 trackId,
5089 AudioMixer::TRACK,
5090 AudioMixer::HAPTIC_INTENSITY, (void *)(uintptr_t)track->getHapticIntensity());
Eric Laurent81784c32012-11-19 14:55:58 -08005091
5092 // reset retry count
5093 track->mRetryCount = kMaxTrackRetries;
5094
5095 // If one track is ready, set the mixer ready if:
5096 // - the mixer was not ready during previous round OR
5097 // - no other track is not ready
5098 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
5099 mixerStatus != MIXER_TRACKS_ENABLED) {
5100 mixerStatus = MIXER_TRACKS_READY;
5101 }
5102 } else {
Andy Hungbd3b2b02018-05-21 10:53:11 -07005103 size_t underrunFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005104 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
Andy Hungc0691382018-09-12 18:01:57 -07005105 ALOGV("track(%d) underrun, framesReady(%zu) < framesDesired(%zd)",
5106 trackId, framesReady, desiredFrames);
Andy Hungbd3b2b02018-05-21 10:53:11 -07005107 underrunFrames = desiredFrames;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08005108 }
Andy Hungbd3b2b02018-05-21 10:53:11 -07005109 deferredOperations.tallyUnderrunFrames(track, underrunFrames);
Phil Burk2812d9e2016-01-04 10:34:30 -08005110
Eric Laurent81784c32012-11-19 14:55:58 -08005111 // clear effect chain input buffer if an active track underruns to avoid sending
5112 // previous audio buffer again to effects
5113 chain = getEffectChain_l(track->sessionId());
5114 if (chain != 0) {
5115 chain->clearInputBuffer();
5116 }
5117
Andy Hungc0691382018-09-12 18:01:57 -07005118 ALOGVV("track(%d) s=%08x [NOT READY] on thread %p", trackId, cblk->mServer, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005119 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
5120 track->isStopped() || track->isPaused()) {
5121 // We have consumed all the buffers of this track.
5122 // Remove it from the list of active tracks.
5123 // TODO: use actual buffer filling status instead of latency when available from
5124 // audio HAL
5125 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08005126 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurent81784c32012-11-19 14:55:58 -08005127 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
5128 if (track->isStopped()) {
5129 track->reset();
5130 }
5131 tracksToRemove->add(track);
5132 }
5133 } else {
Eric Laurent81784c32012-11-19 14:55:58 -08005134 // No buffers for this track. Give it a few chances to
5135 // fill a buffer, then remove it from active list.
5136 if (--(track->mRetryCount) <= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07005137 ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p",
5138 trackId, this);
Eric Laurent81784c32012-11-19 14:55:58 -08005139 tracksToRemove->add(track);
5140 // indicate to client process that the track was disabled because of underrun;
5141 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005142 track->disable();
Eric Laurent81784c32012-11-19 14:55:58 -08005143 // If one track is not ready, mark the mixer also not ready if:
5144 // - the mixer was ready during previous round OR
5145 // - no other track is ready
5146 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
5147 mixerStatus != MIXER_TRACKS_READY) {
5148 mixerStatus = MIXER_TRACKS_ENABLED;
5149 }
5150 }
Andy Hungc0691382018-09-12 18:01:57 -07005151 mAudioMixer->disable(trackId);
Eric Laurent81784c32012-11-19 14:55:58 -08005152 }
5153
5154 } // local variable scope to avoid goto warning
Eric Laurent81784c32012-11-19 14:55:58 -08005155
5156 }
5157
jiabin245cdd92018-12-07 17:55:15 -08005158 if (mHapticChannelMask != AUDIO_CHANNEL_NONE && sq != NULL) {
5159 // When there is no fast track playing haptic and FastMixer exists,
5160 // enabling the first FastTrack, which provides mixed data from normal
5161 // tracks, to play haptic data.
5162 FastTrack *fastTrack = &state->mFastTracks[0];
5163 if (fastTrack->mHapticPlaybackEnabled != noFastHapticTrack) {
5164 fastTrack->mHapticPlaybackEnabled = noFastHapticTrack;
5165 didModify = true;
5166 }
5167 }
5168
Eric Laurent81784c32012-11-19 14:55:58 -08005169 // Push the new FastMixer state if necessary
5170 bool pauseAudioWatchdog = false;
5171 if (didModify) {
5172 state->mFastTracksGen++;
5173 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
5174 if (kUseFastMixer == FastMixer_Dynamic &&
5175 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
5176 state->mCommand = FastMixerState::COLD_IDLE;
5177 state->mColdFutexAddr = &mFastMixerFutex;
5178 state->mColdGen++;
5179 mFastMixerFutex = 0;
5180 if (kUseFastMixer == FastMixer_Dynamic) {
5181 mNormalSink = mOutputSink;
5182 }
5183 // If we go into cold idle, need to wait for acknowledgement
5184 // so that fast mixer stops doing I/O.
5185 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
5186 pauseAudioWatchdog = true;
5187 }
Eric Laurent81784c32012-11-19 14:55:58 -08005188 }
5189 if (sq != NULL) {
5190 sq->end(didModify);
Andy Hungf2285312017-02-14 18:31:59 -08005191 // No need to block if the FastMixer is in COLD_IDLE as the FastThread
5192 // is not active. (We BLOCK_UNTIL_ACKED when entering COLD_IDLE
5193 // when bringing the output sink into standby.)
5194 //
5195 // We will get the latest FastMixer state when we come out of COLD_IDLE.
5196 //
5197 // This occurs with BT suspend when we idle the FastMixer with
5198 // active tracks, which may be added or removed.
5199 sq->push(coldIdle ? FastMixerStateQueue::BLOCK_NEVER : block);
Eric Laurent81784c32012-11-19 14:55:58 -08005200 }
5201#ifdef AUDIO_WATCHDOG
5202 if (pauseAudioWatchdog && mAudioWatchdog != 0) {
5203 mAudioWatchdog->pause();
5204 }
5205#endif
5206
5207 // Now perform the deferred reset on fast tracks that have stopped
5208 while (resetMask != 0) {
5209 size_t i = __builtin_ctz(resetMask);
5210 ALOG_ASSERT(i < count);
5211 resetMask &= ~(1 << i);
Andy Hungdae27702016-10-31 14:01:16 -07005212 sp<Track> track = mActiveTracks[i];
Eric Laurent81784c32012-11-19 14:55:58 -08005213 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
5214 track->reset();
5215 }
5216
Andy Hung80d03d22018-04-10 10:32:11 -07005217 // Track destruction may occur outside of threadLoop once it is removed from active tracks.
5218 // Ensure the AudioMixer doesn't have a raw "buffer provider" pointer to the track if
5219 // it ceases to be active, to allow safe removal from the AudioMixer at the start
5220 // of prepareTracks_l(); this releases any outstanding buffer back to the track.
5221 // See also the implementation of destroyTrack_l().
5222 for (const auto &track : *tracksToRemove) {
Andy Hungc0691382018-09-12 18:01:57 -07005223 const int trackId = track->id();
5224 if (mAudioMixer->exists(trackId)) { // Normal tracks here, fast tracks in FastMixer.
5225 mAudioMixer->setBufferProvider(trackId, nullptr /* bufferProvider */);
Andy Hung80d03d22018-04-10 10:32:11 -07005226 }
5227 }
5228
Eric Laurent81784c32012-11-19 14:55:58 -08005229 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08005230 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08005231
Eric Laurent97d547d2014-09-02 14:45:53 -07005232 if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0) {
5233 mEffectBufferValid = true;
Marco Nelissenac302142014-10-20 13:15:38 -07005234 }
5235
5236 if (mEffectBufferValid) {
Marco Nelissen57088b52014-10-17 16:39:39 -07005237 // as long as there are effects we should clear the effects buffer, to avoid
5238 // passing a non-clean buffer to the effect chain
5239 memset(mEffectBuffer, 0, mEffectBufferSize);
Eric Laurent97d547d2014-09-02 14:45:53 -07005240 }
Andy Hung69aed5f2014-02-25 17:24:40 -08005241 // sink or mix buffer must be cleared if all tracks are connected to an
5242 // effect chain as in this case the mixer will not write to the sink or mix buffer
5243 // and track effects will accumulate into it
Eric Laurentbfb1b832013-01-07 09:53:42 -08005244 if ((mBytesRemaining == 0) && ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5245 (mixedTracks == 0 && fastTracks > 0))) {
Eric Laurent81784c32012-11-19 14:55:58 -08005246 // FIXME as a performance optimization, should remember previous zero status
Andy Hung69aed5f2014-02-25 17:24:40 -08005247 if (mMixerBufferValid) {
5248 memset(mMixerBuffer, 0, mMixerBufferSize);
5249 // TODO: In testing, mSinkBuffer below need not be cleared because
5250 // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer
5251 // after mixing.
5252 //
5253 // To enforce this guarantee:
5254 // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
5255 // (mixedTracks == 0 && fastTracks > 0))
5256 // must imply MIXER_TRACKS_READY.
5257 // Later, we may clear buffers regardless, and skip much of this logic.
5258 }
Andy Hung98ef9782014-03-04 14:46:50 -08005259 // FIXME as a performance optimization, should remember previous zero status
Andy Hung5567aaf2014-07-17 14:00:07 -07005260 memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08005261 }
5262
5263 // if any fast tracks, then status is ready
5264 mMixerStatusIgnoringFastTracks = mixerStatus;
5265 if (fastTracks > 0) {
5266 mixerStatus = MIXER_TRACKS_READY;
5267 }
5268 return mixerStatus;
5269}
5270
Eric Laurentad7dd962016-09-22 12:38:37 -07005271// trackCountForUid_l() must be called with ThreadBase::mLock held
Andy Hung1bc088a2018-02-09 15:57:31 -08005272uint32_t AudioFlinger::PlaybackThread::trackCountForUid_l(uid_t uid) const
Eric Laurentad7dd962016-09-22 12:38:37 -07005273{
5274 uint32_t trackCount = 0;
5275 for (size_t i = 0; i < mTracks.size() ; i++) {
Andy Hung1f12a8a2016-11-07 16:10:30 -08005276 if (mTracks[i]->uid() == uid) {
Eric Laurentad7dd962016-09-22 12:38:37 -07005277 trackCount++;
5278 }
5279 }
5280 return trackCount;
5281}
5282
Andy Hung1bc088a2018-02-09 15:57:31 -08005283// isTrackAllowed_l() must be called with ThreadBase::mLock held
5284bool AudioFlinger::MixerThread::isTrackAllowed_l(
5285 audio_channel_mask_t channelMask, audio_format_t format,
5286 audio_session_t sessionId, uid_t uid) const
Eric Laurent81784c32012-11-19 14:55:58 -08005287{
Andy Hung1bc088a2018-02-09 15:57:31 -08005288 if (!PlaybackThread::isTrackAllowed_l(channelMask, format, sessionId, uid)) {
5289 return false;
Eric Laurentad7dd962016-09-22 12:38:37 -07005290 }
Andy Hung1bc088a2018-02-09 15:57:31 -08005291 // Check validity as we don't call AudioMixer::create() here.
5292 if (!AudioMixer::isValidFormat(format)) {
5293 ALOGW("%s: invalid format: %#x", __func__, format);
5294 return false;
5295 }
5296 if (!AudioMixer::isValidChannelMask(channelMask)) {
5297 ALOGW("%s: invalid channelMask: %#x", __func__, channelMask);
5298 return false;
5299 }
5300 return true;
Eric Laurent81784c32012-11-19 14:55:58 -08005301}
5302
Eric Laurent10351942014-05-08 18:49:52 -07005303// checkForNewParameter_l() must be called with ThreadBase::mLock held
5304bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
5305 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08005306{
Eric Laurent81784c32012-11-19 14:55:58 -08005307 bool reconfig = false;
Eric Laurent42537be2016-01-08 17:16:42 -08005308 bool a2dpDeviceChanged = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005309
Eric Laurent10351942014-05-08 18:49:52 -07005310 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08005311
Glenn Kastenc05b8d72016-03-24 09:48:17 -07005312 AutoPark<FastMixer> park(mFastMixer);
Eric Laurent81784c32012-11-19 14:55:58 -08005313
Eric Laurent10351942014-05-08 18:49:52 -07005314 AudioParameter param = AudioParameter(keyValuePair);
5315 int value;
5316 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
5317 reconfig = true;
5318 }
5319 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005320 if (!isValidPcmSinkFormat((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005321 status = BAD_VALUE;
5322 } else {
5323 // no need to save value, since it's constant
Eric Laurent81784c32012-11-19 14:55:58 -08005324 reconfig = true;
5325 }
Eric Laurent10351942014-05-08 18:49:52 -07005326 }
5327 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Andy Hung9a592762014-07-21 21:56:01 -07005328 if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07005329 status = BAD_VALUE;
5330 } else {
5331 // no need to save value, since it's constant
5332 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005333 }
Eric Laurent10351942014-05-08 18:49:52 -07005334 }
5335 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
5336 // do not accept frame count changes if tracks are open as the track buffer
5337 // size depends on frame count and correct behavior would not be guaranteed
5338 // if frame count is changed after track creation
5339 if (!mTracks.isEmpty()) {
5340 status = INVALID_OPERATION;
5341 } else {
5342 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08005343 }
Eric Laurent10351942014-05-08 18:49:52 -07005344 }
5345 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
Eric Laurent81784c32012-11-19 14:55:58 -08005346#ifdef ADD_BATTERY_DATA
Eric Laurent10351942014-05-08 18:49:52 -07005347 // when changing the audio output device, call addBatteryData to notify
5348 // the change
5349 if (mOutDevice != value) {
5350 uint32_t params = 0;
5351 // check whether speaker is on
5352 if (value & AUDIO_DEVICE_OUT_SPEAKER) {
5353 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
Eric Laurent81784c32012-11-19 14:55:58 -08005354 }
Eric Laurent10351942014-05-08 18:49:52 -07005355
5356 audio_devices_t deviceWithoutSpeaker
5357 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
5358 // check if any other device (except speaker) is on
Eric Laurent054d9d32015-04-24 08:48:48 -07005359 if (value & deviceWithoutSpeaker) {
Eric Laurent10351942014-05-08 18:49:52 -07005360 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
5361 }
5362
5363 if (params != 0) {
5364 addBatteryData(params);
5365 }
5366 }
Eric Laurent81784c32012-11-19 14:55:58 -08005367#endif
5368
Eric Laurent10351942014-05-08 18:49:52 -07005369 // forward device change to effects that have requested to be
5370 // aware of attached audio device.
5371 if (value != AUDIO_DEVICE_NONE) {
Eric Laurent42537be2016-01-08 17:16:42 -08005372 a2dpDeviceChanged =
5373 (mOutDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != (value & AUDIO_DEVICE_OUT_ALL_A2DP);
Eric Laurent10351942014-05-08 18:49:52 -07005374 mOutDevice = value;
5375 for (size_t i = 0; i < mEffectChains.size(); i++) {
5376 mEffectChains[i]->setDevice_l(mOutDevice);
Eric Laurent81784c32012-11-19 14:55:58 -08005377 }
5378 }
Eric Laurent10351942014-05-08 18:49:52 -07005379 }
Eric Laurent81784c32012-11-19 14:55:58 -08005380
Eric Laurent10351942014-05-08 18:49:52 -07005381 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005382 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07005383 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08005384 mOutput->standby();
Eric Laurent10351942014-05-08 18:49:52 -07005385 mStandby = true;
5386 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005387 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent81784c32012-11-19 14:55:58 -08005388 }
Eric Laurent10351942014-05-08 18:49:52 -07005389 if (status == NO_ERROR && reconfig) {
5390 readOutputParameters_l();
5391 delete mAudioMixer;
5392 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
Andy Hung1bc088a2018-02-09 15:57:31 -08005393 for (const auto &track : mTracks) {
Andy Hungc0691382018-09-12 18:01:57 -07005394 const int trackId = track->id();
Andy Hung1bc088a2018-02-09 15:57:31 -08005395 status_t status = mAudioMixer->create(
Andy Hungc0691382018-09-12 18:01:57 -07005396 trackId,
Andy Hung1bc088a2018-02-09 15:57:31 -08005397 track->mChannelMask,
5398 track->mFormat,
5399 track->mSessionId);
5400 ALOGW_IF(status != NO_ERROR,
Andy Hungc0691382018-09-12 18:01:57 -07005401 "%s(): AudioMixer cannot create track(%d)"
5402 " mask %#x, format %#x, sessionId %d",
Andy Hung1bc088a2018-02-09 15:57:31 -08005403 __func__,
Andy Hungc0691382018-09-12 18:01:57 -07005404 trackId, track->mChannelMask, track->mFormat, track->mSessionId);
Eric Laurent10351942014-05-08 18:49:52 -07005405 }
Eric Laurent73e26b62015-04-27 16:55:58 -07005406 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07005407 }
Eric Laurent81784c32012-11-19 14:55:58 -08005408 }
5409
Eric Laurent42537be2016-01-08 17:16:42 -08005410 return reconfig || a2dpDeviceChanged;
Eric Laurent81784c32012-11-19 14:55:58 -08005411}
5412
5413
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005414void AudioFlinger::MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent81784c32012-11-19 14:55:58 -08005415{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005416 PlaybackThread::dumpInternals_l(fd, args);
Andy Hung40eb1a12015-06-18 13:42:02 -07005417 dprintf(fd, " Thread throttle time (msecs): %u\n", mThreadThrottleTimeMs);
Andy Hung8ed196a2018-01-05 13:21:11 -08005418 dprintf(fd, " AudioMixer tracks: %s\n", mAudioMixer->trackNames().c_str());
Andy Hung2ddee192015-12-18 17:34:44 -08005419 dprintf(fd, " Master mono: %s\n", mMasterMono ? "on" : "off");
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005420 dprintf(fd, " Master balance: %f (%s)\n", mMasterBalance.load(),
5421 (hasFastMixer() ? std::to_string(mFastMixer->getMasterBalance())
5422 : mBalance.toString()).c_str());
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005423 if (hasFastMixer()) {
5424 dprintf(fd, " FastMixer thread %p tid=%d", mFastMixer.get(), mFastMixer->getTid());
5425
5426 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
5427 // while we are dumping it. It may be inconsistent, but it won't mutate!
5428 // This is a large object so we place it on the heap.
5429 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07005430 const std::unique_ptr<FastMixerDumpState> copy =
5431 std::make_unique<FastMixerDumpState>(mFastMixerDumpState);
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005432 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005433
5434#ifdef STATE_QUEUE_DUMP
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005435 // Similar for state queue
5436 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
5437 observerCopy.dump(fd);
5438 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
5439 mutatorCopy.dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08005440#endif
5441
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08005442#ifdef AUDIO_WATCHDOG
5443 if (mAudioWatchdog != 0) {
5444 // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
5445 AudioWatchdogDump wdCopy = mAudioWatchdogDump;
5446 wdCopy.dump(fd);
5447 }
5448#endif
5449
5450 } else {
5451 dprintf(fd, " No FastMixer\n");
5452 }
Eric Laurent81784c32012-11-19 14:55:58 -08005453}
5454
5455uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
5456{
5457 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
5458}
5459
5460uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
5461{
5462 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
5463}
5464
5465void AudioFlinger::MixerThread::cacheParameters_l()
5466{
5467 PlaybackThread::cacheParameters_l();
5468
5469 // FIXME: Relaxed timing because of a certain device that can't meet latency
5470 // Should be reduced to 2x after the vendor fixes the driver issue
5471 // increase threshold again due to low power audio mode. The way this warning
5472 // threshold is calculated and its usefulness should be reconsidered anyway.
5473 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
5474}
5475
5476// ----------------------------------------------------------------------------
5477
5478AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
Andy Hung48f59ed2019-01-28 15:06:59 -08005479 AudioStreamOut* output, audio_io_handle_t id, audio_devices_t device,
Eric Laurente93cc032016-05-05 10:15:10 -07005480 ThreadBase::type_t type, bool systemReady)
5481 : PlaybackThread(audioFlinger, output, id, device, type, systemReady)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005482{
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005483 setMasterBalance(audioFlinger->getMasterBalance_l());
Eric Laurentbfb1b832013-01-07 09:53:42 -08005484}
5485
Eric Laurent81784c32012-11-19 14:55:58 -08005486AudioFlinger::DirectOutputThread::~DirectOutputThread()
5487{
5488}
5489
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005490void AudioFlinger::DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005491{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07005492 PlaybackThread::dumpInternals_l(fd, args);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005493 dprintf(fd, " Master balance: %f Left: %f Right: %f\n",
5494 mMasterBalance.load(), mMasterBalanceLeft, mMasterBalanceRight);
5495}
5496
5497void AudioFlinger::DirectOutputThread::setMasterBalance(float balance)
5498{
5499 Mutex::Autolock _l(mLock);
5500 if (mMasterBalance != balance) {
5501 mMasterBalance.store(balance);
5502 mBalance.computeStereoBalance(balance, &mMasterBalanceLeft, &mMasterBalanceRight);
5503 broadcast_l();
5504 }
5505}
5506
Eric Laurent5850c4c2016-11-10 13:04:31 -08005507void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005508{
Eric Laurentbfb1b832013-01-07 09:53:42 -08005509 float left, right;
5510
Andy Hung333ab962019-05-28 20:23:35 -07005511 // Ensure volumeshaper state always advances even when muted.
5512 const sp<AudioTrackServerProxy> proxy = track->mAudioTrackServerProxy;
5513 const auto [shaperVolume, shaperActive] = track->getVolumeHandler()->getVolume(
5514 proxy->framesReleased());
5515 mVolumeShaperActive = shaperActive;
5516
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08005517 if (mMasterMute || mStreamTypes[track->streamType()].mute || track->isPlaybackRestricted()) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08005518 left = right = 0;
5519 } else {
5520 float typeVolume = mStreamTypes[track->streamType()].volume;
Andy Hung333ab962019-05-28 20:23:35 -07005521 const float v = mMasterVolume * typeVolume * shaperVolume;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08005522
Glenn Kastenc56f3422014-03-21 17:53:17 -07005523 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
5524 left = float_from_gain(gain_minifloat_unpack_left(vlr));
5525 if (left > GAIN_FLOAT_UNITY) {
5526 left = GAIN_FLOAT_UNITY;
5527 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005528 left *= v * mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
Glenn Kastenc56f3422014-03-21 17:53:17 -07005529 right = float_from_gain(gain_minifloat_unpack_right(vlr));
5530 if (right > GAIN_FLOAT_UNITY) {
5531 right = GAIN_FLOAT_UNITY;
5532 }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01005533 right *= v * mMasterBalanceRight;
Eric Laurentbfb1b832013-01-07 09:53:42 -08005534 }
5535
5536 if (lastTrack) {
Kevin Rocard12381092018-04-11 09:19:59 -07005537 track->setFinalVolume((left + right) / 2.f);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005538 if (left != mLeftVolFloat || right != mRightVolFloat) {
5539 mLeftVolFloat = left;
5540 mRightVolFloat = right;
5541
Eric Laurentbfb1b832013-01-07 09:53:42 -08005542 // Delegate volume control to effect in track effect chain if needed
5543 // only one effect chain can be present on DirectOutputThread, so if
5544 // there is one, the track is connected to it
5545 if (!mEffectChains.isEmpty()) {
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +09005546 // if effect chain exists, volume is handled by it.
5547 // Convert volumes from float to 8.24
5548 uint32_t vl = (uint32_t)(left * (1 << 24));
5549 uint32_t vr = (uint32_t)(right * (1 << 24));
5550 // Direct/Offload effect chains set output volume in setVolume_l().
5551 (void)mEffectChains[0]->setVolume_l(&vl, &vr);
5552 } else {
5553 // otherwise we directly set the volume.
5554 setVolumeForOutput_l(left, right);
Eric Laurentbfb1b832013-01-07 09:53:42 -08005555 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005556 }
5557 }
5558}
5559
Phil Burk43b4dcc2015-06-09 16:53:44 -07005560void AudioFlinger::DirectOutputThread::onAddNewTrack_l()
5561{
5562 sp<Track> previousTrack = mPreviousTrack.promote();
Andy Hungdae27702016-10-31 14:01:16 -07005563 sp<Track> latestTrack = mActiveTracks.getLatest();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005564
Eric Laurent0f0631e2015-07-06 18:01:25 -07005565 if (previousTrack != 0 && latestTrack != 0) {
5566 if (mType == DIRECT) {
5567 if (previousTrack.get() != latestTrack.get()) {
5568 mFlushPending = true;
5569 }
5570 } else /* mType == OFFLOAD */ {
5571 if (previousTrack->sessionId() != latestTrack->sessionId()) {
5572 mFlushPending = true;
5573 }
5574 }
Revathi Uddaraju20413a92016-10-13 17:16:14 +08005575 } else if (previousTrack == 0) {
5576 // there could be an old track added back during track transition for direct
5577 // output, so always issues flush to flush data of the previous track if it
5578 // was already destroyed with HAL paused, then flush can resume the playback
5579 mFlushPending = true;
Phil Burk43b4dcc2015-06-09 16:53:44 -07005580 }
5581 PlaybackThread::onAddNewTrack_l();
5582}
Eric Laurentbfb1b832013-01-07 09:53:42 -08005583
Eric Laurent81784c32012-11-19 14:55:58 -08005584AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
5585 Vector< sp<Track> > *tracksToRemove
5586)
5587{
Eric Laurentd595b7c2013-04-03 17:27:56 -07005588 size_t count = mActiveTracks.size();
Eric Laurent81784c32012-11-19 14:55:58 -08005589 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005590 bool doHwPause = false;
5591 bool doHwResume = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005592
5593 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07005594 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08005595 if (t->isInvalid()) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005596 ALOGW("An invalidated track shouldn't be in active list");
Eric Laurent5850c4c2016-11-10 13:04:31 -08005597 tracksToRemove->add(t);
Phil Burk43b4dcc2015-06-09 16:53:44 -07005598 continue;
5599 }
5600
Eric Laurent5850c4c2016-11-10 13:04:31 -08005601 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005602#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurent81784c32012-11-19 14:55:58 -08005603 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07005604#endif
Eric Laurentfd477972013-10-25 18:10:40 -07005605 // Only consider last track started for volume and mixer state control.
5606 // In theory an older track could underrun and restart after the new one starts
5607 // but as we only care about the transition phase between two tracks on a
5608 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07005609 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08005610 bool last = l.get() == track;
Eric Laurent81784c32012-11-19 14:55:58 -08005611
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005612 if (track->isPausing()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005613 track->setPaused();
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005614 if (mHwSupportsPause && last && !mHwPaused) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005615 doHwPause = true;
5616 mHwPaused = true;
5617 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005618 } else if (track->isFlushPending()) {
5619 track->flushAck();
5620 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005621 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005622 }
Phil Burk6fc2a7c2015-04-30 16:08:10 -07005623 } else if (track->isResumePending()) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005624 track->resumeAck();
Eric Laurent3df841a2016-07-15 15:15:40 -07005625 if (last) {
5626 mLeftVolFloat = mRightVolFloat = -1.0;
5627 if (mHwPaused) {
5628 doHwResume = true;
5629 mHwPaused = false;
5630 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005631 }
5632 }
5633
Eric Laurent81784c32012-11-19 14:55:58 -08005634 // The first time a track is added we wait
Phil Burk99adee32014-12-10 16:46:30 -08005635 // for all its buffers to be filled before processing it.
5636 // Allow draining the buffer in case the client
5637 // app does not call stop() and relies on underrun to stop:
5638 // hence the test on (track->mRetryCount > 1).
5639 // If retryCount<=1 then track is about to underrun and be removed.
Phil Burkca5e6142015-07-14 09:42:29 -07005640 // Do not use a high threshold for compressed audio.
Eric Laurent81784c32012-11-19 14:55:58 -08005641 uint32_t minFrames;
Phil Burk99adee32014-12-10 16:46:30 -08005642 if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
Phil Burkfdb3c072016-02-09 10:47:02 -08005643 && (track->mRetryCount > 1) && audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005644 minFrames = mNormalFrameCount;
5645 } else {
5646 minFrames = 1;
5647 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08005648
Eric Laurentab5cdba2014-06-09 17:22:27 -07005649 if ((track->framesReady() >= minFrames) && track->isReady() && !track->isPaused() &&
5650 !track->isStopping_2() && !track->isStopped())
Eric Laurent81784c32012-11-19 14:55:58 -08005651 {
Andy Hungc0691382018-09-12 18:01:57 -07005652 ALOGVV("track(%d) s=%08x [OK]", track->id(), cblk->mServer);
Eric Laurent81784c32012-11-19 14:55:58 -08005653
5654 if (track->mFillingUpStatus == Track::FS_FILLED) {
5655 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07005656 if (last) {
5657 // make sure processVolume_l() will apply new volume even if 0
5658 mLeftVolFloat = mRightVolFloat = -1.0;
5659 }
Eric Laurentd1f69b02014-12-15 14:33:13 -08005660 if (!mHwSupportsPause) {
5661 track->resumeAck();
Eric Laurent81784c32012-11-19 14:55:58 -08005662 }
5663 }
5664
5665 // compute volume for this track
Eric Laurentbfb1b832013-01-07 09:53:42 -08005666 processVolume_l(track, last);
5667 if (last) {
Phil Burk43b4dcc2015-06-09 16:53:44 -07005668 sp<Track> previousTrack = mPreviousTrack.promote();
5669 if (previousTrack != 0) {
5670 if (track != previousTrack.get()) {
5671 // Flush any data still being written from last track
5672 mBytesRemaining = 0;
Eric Laurent0f0631e2015-07-06 18:01:25 -07005673 // Invalidate previous track to force a seek when resuming.
5674 previousTrack->invalidate();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005675 }
5676 }
5677 mPreviousTrack = track;
5678
Eric Laurentd595b7c2013-04-03 17:27:56 -07005679 // reset retry count
5680 track->mRetryCount = kMaxTrackRetriesDirect;
Eric Laurent5850c4c2016-11-10 13:04:31 -08005681 mActiveTrack = t;
Eric Laurentd595b7c2013-04-03 17:27:56 -07005682 mixerStatus = MIXER_TRACKS_READY;
Eric Laurent5cff4032015-05-26 13:49:58 -07005683 if (mHwPaused) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08005684 doHwResume = true;
5685 mHwPaused = false;
5686 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07005687 }
Eric Laurent81784c32012-11-19 14:55:58 -08005688 } else {
Eric Laurentd595b7c2013-04-03 17:27:56 -07005689 // clear effect chain input buffer if the last active track started underruns
5690 // to avoid sending previous audio buffer again to effects
Eric Laurentfd477972013-10-25 18:10:40 -07005691 if (!mEffectChains.isEmpty() && last) {
Eric Laurent81784c32012-11-19 14:55:58 -08005692 mEffectChains[0]->clearInputBuffer();
5693 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07005694 if (track->isStopping_1()) {
5695 track->mState = TrackBase::STOPPING_2;
Eric Laurentb369caf2015-03-30 20:51:47 -07005696 if (last && mHwPaused) {
5697 doHwResume = true;
5698 mHwPaused = false;
5699 }
Eric Laurentab5cdba2014-06-09 17:22:27 -07005700 }
5701 if ((track->sharedBuffer() != 0) || track->isStopped() ||
5702 track->isStopping_2() || track->isPaused()) {
Eric Laurent81784c32012-11-19 14:55:58 -08005703 // We have consumed all the buffers of this track.
5704 // Remove it from the list of active tracks.
Eric Laurentab5cdba2014-06-09 17:22:27 -07005705 size_t audioHALFrames;
Phil Burkfdb3c072016-02-09 10:47:02 -08005706 if (audio_has_proportional_frames(mFormat)) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07005707 audioHALFrames = (latency_l() * mSampleRate) / 1000;
5708 } else {
5709 audioHALFrames = 0;
5710 }
5711
Andy Hung818e7a32016-02-16 18:08:07 -08005712 int64_t framesWritten = mBytesWritten / mFrameSize;
Eric Laurentfd477972013-10-25 18:10:40 -07005713 if (mStandby || !last ||
Aniket Kumar Lata179a0742019-01-30 14:16:16 -08005714 track->presentationComplete(framesWritten, audioHALFrames) ||
5715 track->isPaused()) {
Eric Laurentab5cdba2014-06-09 17:22:27 -07005716 if (track->isStopping_2()) {
5717 track->mState = TrackBase::STOPPED;
5718 }
Eric Laurent81784c32012-11-19 14:55:58 -08005719 if (track->isStopped()) {
5720 track->reset();
5721 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07005722 tracksToRemove->add(track);
Eric Laurent81784c32012-11-19 14:55:58 -08005723 }
5724 } else {
5725 // No buffers for this track. Give it a few chances to
5726 // fill a buffer, then remove it from active list.
Eric Laurentd595b7c2013-04-03 17:27:56 -07005727 // Only consider last track started for mixer state control
Eric Laurent81784c32012-11-19 14:55:58 -08005728 if (--(track->mRetryCount) <= 0) {
Andy Hungc0691382018-09-12 18:01:57 -07005729 ALOGV("BUFFER TIMEOUT: remove track(%d) from active list", track->id());
Eric Laurentd595b7c2013-04-03 17:27:56 -07005730 tracksToRemove->add(track);
Eric Laurenta23f17a2013-11-05 18:22:08 -08005731 // indicate to client process that the track was disabled because of underrun;
5732 // it will then automatically call start() when data is available
Eric Laurent4d231dc2016-03-11 18:38:23 -08005733 track->disable();
Eric Laurentbfb1b832013-01-07 09:53:42 -08005734 } else if (last) {
Phil Burkca5e6142015-07-14 09:42:29 -07005735 ALOGW("pause because of UNDERRUN, framesReady = %zu,"
5736 "minFrames = %u, mFormat = %#x",
5737 track->framesReady(), minFrames, mFormat);
Eric Laurent81784c32012-11-19 14:55:58 -08005738 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurent5cff4032015-05-26 13:49:58 -07005739 if (mHwSupportsPause && !mHwPaused && !mStandby) {
Eric Laurent0f7b5f22014-12-19 10:43:21 -08005740 doHwPause = true;
5741 mHwPaused = true;
5742 }
Eric Laurent81784c32012-11-19 14:55:58 -08005743 }
5744 }
5745 }
5746 }
5747
Eric Laurentd1f69b02014-12-15 14:33:13 -08005748 // if an active track did not command a flush, check for pending flush on stopped tracks
Phil Burk43b4dcc2015-06-09 16:53:44 -07005749 if (!mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005750 for (size_t i = 0; i < mTracks.size(); i++) {
5751 if (mTracks[i]->isFlushPending()) {
5752 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005753 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005754 }
5755 }
5756 }
5757
5758 // make sure the pause/flush/resume sequence is executed in the right order.
5759 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
5760 // before flush and then resume HW. This can happen in case of pause/flush/resume
5761 // if resume is received before pause is executed.
5762 if (mHwSupportsPause && !mStandby &&
Phil Burk43b4dcc2015-06-09 16:53:44 -07005763 (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005764 status_t result = mOutput->stream->pause();
5765 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08005766 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07005767 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005768 flushHw_l();
5769 }
5770 if (mHwSupportsPause && !mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005771 status_t result = mOutput->stream->resume();
5772 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurentd1f69b02014-12-15 14:33:13 -08005773 }
Eric Laurent81784c32012-11-19 14:55:58 -08005774 // remove all the tracks that need to be...
Eric Laurentbfb1b832013-01-07 09:53:42 -08005775 removeTracks_l(*tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08005776
5777 return mixerStatus;
5778}
5779
5780void AudioFlinger::DirectOutputThread::threadLoop_mix()
5781{
Eric Laurent81784c32012-11-19 14:55:58 -08005782 size_t frameCount = mFrameCount;
Andy Hung2098f272014-02-27 14:00:06 -08005783 int8_t *curBuf = (int8_t *)mSinkBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -08005784 // output audio to hardware
5785 while (frameCount) {
Glenn Kasten34542ac2013-06-26 11:29:02 -07005786 AudioBufferProvider::Buffer buffer;
Eric Laurent81784c32012-11-19 14:55:58 -08005787 buffer.frameCount = frameCount;
Phil Burk062e67a2015-02-11 13:40:50 -08005788 status_t status = mActiveTrack->getNextBuffer(&buffer);
5789 if (status != NO_ERROR || buffer.raw == NULL) {
Eric Laurent51716182016-02-29 18:00:56 -08005790 // no need to pad with 0 for compressed audio
5791 if (audio_has_proportional_frames(mFormat)) {
5792 memset(curBuf, 0, frameCount * mFrameSize);
5793 }
Eric Laurent81784c32012-11-19 14:55:58 -08005794 break;
5795 }
5796 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
5797 frameCount -= buffer.frameCount;
5798 curBuf += buffer.frameCount * mFrameSize;
5799 mActiveTrack->releaseBuffer(&buffer);
5800 }
Andy Hung2098f272014-02-27 14:00:06 -08005801 mCurrentWriteLength = curBuf - (int8_t *)mSinkBuffer;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005802 mSleepTimeUs = 0;
5803 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08005804 mActiveTrack.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08005805}
5806
5807void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
5808{
Eric Laurentd1f69b02014-12-15 14:33:13 -08005809 // do not write to HAL when paused
Eric Laurent0f7b5f22014-12-19 10:43:21 -08005810 if (mHwPaused || (usesHwAvSync() && mStandby)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005811 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005812 return;
5813 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005814 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08005815 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurente93cc032016-05-05 10:15:10 -07005816 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005817 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005818 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005819 }
Phil Burkfdb3c072016-02-09 10:47:02 -08005820 } else if (mBytesWritten != 0 && audio_has_proportional_frames(mFormat)) {
Andy Hung2098f272014-02-27 14:00:06 -08005821 memset(mSinkBuffer, 0, mFrameCount * mFrameSize);
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005822 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08005823 }
5824}
5825
Eric Laurentd1f69b02014-12-15 14:33:13 -08005826void AudioFlinger::DirectOutputThread::threadLoop_exit()
5827{
5828 {
5829 Mutex::Autolock _l(mLock);
Eric Laurentd1f69b02014-12-15 14:33:13 -08005830 for (size_t i = 0; i < mTracks.size(); i++) {
5831 if (mTracks[i]->isFlushPending()) {
5832 mTracks[i]->flushAck();
Phil Burk43b4dcc2015-06-09 16:53:44 -07005833 mFlushPending = true;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005834 }
5835 }
Phil Burk43b4dcc2015-06-09 16:53:44 -07005836 if (mFlushPending) {
Eric Laurentd1f69b02014-12-15 14:33:13 -08005837 flushHw_l();
5838 }
5839 }
5840 PlaybackThread::threadLoop_exit();
5841}
5842
5843// must be called with thread mutex locked
5844bool AudioFlinger::DirectOutputThread::shouldStandby_l()
5845{
5846 bool trackPaused = false;
Eric Laurentb369caf2015-03-30 20:51:47 -07005847 bool trackStopped = false;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005848
vivek mehta9cd7ad12016-03-17 00:18:29 -07005849 if ((mType == DIRECT) && audio_is_linear_pcm(mFormat) && !usesHwAvSync()) {
5850 return !mStandby;
5851 }
5852
Eric Laurentd1f69b02014-12-15 14:33:13 -08005853 // do not put the HAL in standby when paused. AwesomePlayer clear the offloaded AudioTrack
5854 // after a timeout and we will enter standby then.
5855 if (mTracks.size() > 0) {
5856 trackPaused = mTracks[mTracks.size() - 1]->isPaused();
Eric Laurentb369caf2015-03-30 20:51:47 -07005857 trackStopped = mTracks[mTracks.size() - 1]->isStopped() ||
5858 mTracks[mTracks.size() - 1]->mState == TrackBase::IDLE;
Eric Laurentd1f69b02014-12-15 14:33:13 -08005859 }
5860
Eric Laurent5cff4032015-05-26 13:49:58 -07005861 return !mStandby && !(trackPaused || (mHwPaused && !trackStopped));
Eric Laurentd1f69b02014-12-15 14:33:13 -08005862}
5863
Eric Laurent10351942014-05-08 18:49:52 -07005864// checkForNewParameter_l() must be called with ThreadBase::mLock held
5865bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
5866 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08005867{
5868 bool reconfig = false;
Eric Laurent42537be2016-01-08 17:16:42 -08005869 bool a2dpDeviceChanged = false;
Eric Laurent81784c32012-11-19 14:55:58 -08005870
Eric Laurent10351942014-05-08 18:49:52 -07005871 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08005872
Eric Laurent10351942014-05-08 18:49:52 -07005873 AudioParameter param = AudioParameter(keyValuePair);
5874 int value;
5875 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
5876 // forward device change to effects that have requested to be
5877 // aware of attached audio device.
5878 if (value != AUDIO_DEVICE_NONE) {
Eric Laurent42537be2016-01-08 17:16:42 -08005879 a2dpDeviceChanged =
5880 (mOutDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != (value & AUDIO_DEVICE_OUT_ALL_A2DP);
Eric Laurent10351942014-05-08 18:49:52 -07005881 mOutDevice = value;
5882 for (size_t i = 0; i < mEffectChains.size(); i++) {
5883 mEffectChains[i]->setDevice_l(mOutDevice);
Glenn Kastenc125f382014-04-11 18:37:33 -07005884 }
5885 }
Eric Laurent81784c32012-11-19 14:55:58 -08005886 }
Eric Laurent10351942014-05-08 18:49:52 -07005887 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
5888 // do not accept frame count changes if tracks are open as the track buffer
5889 // size depends on frame count and correct behavior would not be garantied
5890 // if frame count is changed after track creation
5891 if (!mTracks.isEmpty()) {
5892 status = INVALID_OPERATION;
5893 } else {
5894 reconfig = true;
5895 }
5896 }
5897 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005898 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07005899 if (!mStandby && status == INVALID_OPERATION) {
Phil Burk062e67a2015-02-11 13:40:50 -08005900 mOutput->standby();
Eric Laurent10351942014-05-08 18:49:52 -07005901 mStandby = true;
5902 mBytesWritten = 0;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07005903 status = mOutput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07005904 }
5905 if (status == NO_ERROR && reconfig) {
5906 readOutputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07005907 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Eric Laurent10351942014-05-08 18:49:52 -07005908 }
5909 }
5910
Eric Laurent42537be2016-01-08 17:16:42 -08005911 return reconfig || a2dpDeviceChanged;
Eric Laurent81784c32012-11-19 14:55:58 -08005912}
5913
5914uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
5915{
5916 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08005917 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005918 time = PlaybackThread::activeSleepTimeUs();
5919 } else {
Eric Laurent51716182016-02-29 18:00:56 -08005920 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005921 }
5922 return time;
5923}
5924
5925uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
5926{
5927 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08005928 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005929 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
5930 } else {
Eric Laurent51716182016-02-29 18:00:56 -08005931 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005932 }
5933 return time;
5934}
5935
5936uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
5937{
5938 uint32_t time;
Phil Burkfdb3c072016-02-09 10:47:02 -08005939 if (audio_has_proportional_frames(mFormat)) {
Eric Laurent81784c32012-11-19 14:55:58 -08005940 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
5941 } else {
Eric Laurent51716182016-02-29 18:00:56 -08005942 time = kDirectMinSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08005943 }
5944 return time;
5945}
5946
5947void AudioFlinger::DirectOutputThread::cacheParameters_l()
5948{
5949 PlaybackThread::cacheParameters_l();
5950
5951 // use shorter standby delay as on normal output to release
5952 // hardware resources as soon as possible
Eric Laurentb369caf2015-03-30 20:51:47 -07005953 // no delay on outputs with HW A/V sync
5954 if (usesHwAvSync()) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005955 mStandbyDelayNs = 0;
Phil Burkfdb3c072016-02-09 10:47:02 -08005956 } else if ((mType == OFFLOAD) && !audio_has_proportional_frames(mFormat)) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005957 mStandbyDelayNs = kOffloadStandbyDelayNs;
Eric Laurent5cff4032015-05-26 13:49:58 -07005958 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07005959 mStandbyDelayNs = microseconds(mActiveSleepTimeUs*2);
Eric Laurent972a1732013-09-04 09:42:59 -07005960 }
Eric Laurent81784c32012-11-19 14:55:58 -08005961}
5962
Eric Laurente659ef42014-09-29 13:06:46 -07005963void AudioFlinger::DirectOutputThread::flushHw_l()
5964{
Phil Burk062e67a2015-02-11 13:40:50 -08005965 mOutput->flush();
Eric Laurentd1f69b02014-12-15 14:33:13 -08005966 mHwPaused = false;
Phil Burk43b4dcc2015-06-09 16:53:44 -07005967 mFlushPending = false;
Andy Hungf3234512018-07-03 14:51:47 -07005968 mTimestampVerifier.discontinuity(); // DIRECT and OFFLOADED flush resets frame count.
Eric Laurente659ef42014-09-29 13:06:46 -07005969}
5970
Andy Hung10cbff12017-02-21 17:30:14 -08005971int64_t AudioFlinger::DirectOutputThread::computeWaitTimeNs_l() const {
5972 // If a VolumeShaper is active, we must wake up periodically to update volume.
5973 const int64_t NS_PER_MS = 1000000;
5974 return mVolumeShaperActive ?
5975 kMinNormalSinkBufferSizeMs * NS_PER_MS : PlaybackThread::computeWaitTimeNs_l();
5976}
5977
Eric Laurent81784c32012-11-19 14:55:58 -08005978// ----------------------------------------------------------------------------
5979
Eric Laurentbfb1b832013-01-07 09:53:42 -08005980AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
Eric Laurent4de95592013-09-26 15:28:21 -07005981 const wp<AudioFlinger::PlaybackThread>& playbackThread)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005982 : Thread(false /*canCallJava*/),
Eric Laurent4de95592013-09-26 15:28:21 -07005983 mPlaybackThread(playbackThread),
Eric Laurent3b4529e2013-09-05 18:09:19 -07005984 mWriteAckSequence(0),
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07005985 mDrainSequence(0),
5986 mAsyncError(false)
Eric Laurentbfb1b832013-01-07 09:53:42 -08005987{
5988}
5989
5990AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
5991{
5992}
5993
5994void AudioFlinger::AsyncCallbackThread::onFirstRef()
5995{
5996 run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
5997}
5998
5999bool AudioFlinger::AsyncCallbackThread::threadLoop()
6000{
6001 while (!exitPending()) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006002 uint32_t writeAckSequence;
6003 uint32_t drainSequence;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006004 bool asyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006005
6006 {
6007 Mutex::Autolock _l(mLock);
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006008 while (!((mWriteAckSequence & 1) ||
6009 (mDrainSequence & 1) ||
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006010 mAsyncError ||
Haynes Mathew George24a325d2013-12-03 21:26:02 -08006011 exitPending())) {
6012 mWaitWorkCV.wait(mLock);
6013 }
6014
Eric Laurentbfb1b832013-01-07 09:53:42 -08006015 if (exitPending()) {
6016 break;
6017 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006018 ALOGV("AsyncCallbackThread mWriteAckSequence %d mDrainSequence %d",
6019 mWriteAckSequence, mDrainSequence);
6020 writeAckSequence = mWriteAckSequence;
6021 mWriteAckSequence &= ~1;
6022 drainSequence = mDrainSequence;
6023 mDrainSequence &= ~1;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006024 asyncError = mAsyncError;
6025 mAsyncError = false;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006026 }
6027 {
Eric Laurent4de95592013-09-26 15:28:21 -07006028 sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
6029 if (playbackThread != 0) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006030 if (writeAckSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006031 playbackThread->resetWriteBlocked(writeAckSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006032 }
Eric Laurent3b4529e2013-09-05 18:09:19 -07006033 if (drainSequence & 1) {
Eric Laurent4de95592013-09-26 15:28:21 -07006034 playbackThread->resetDraining(drainSequence >> 1);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006035 }
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006036 if (asyncError) {
6037 playbackThread->onAsyncError();
6038 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006039 }
6040 }
6041 }
6042 return false;
6043}
6044
6045void AudioFlinger::AsyncCallbackThread::exit()
6046{
6047 ALOGV("AsyncCallbackThread::exit");
6048 Mutex::Autolock _l(mLock);
6049 requestExit();
6050 mWaitWorkCV.broadcast();
6051}
6052
Eric Laurent3b4529e2013-09-05 18:09:19 -07006053void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006054{
6055 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006056 // bit 0 is cleared
6057 mWriteAckSequence = sequence << 1;
6058}
6059
6060void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
6061{
6062 Mutex::Autolock _l(mLock);
6063 // ignore unexpected callbacks
6064 if (mWriteAckSequence & 2) {
6065 mWriteAckSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006066 mWaitWorkCV.signal();
6067 }
6068}
6069
Eric Laurent3b4529e2013-09-05 18:09:19 -07006070void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006071{
6072 Mutex::Autolock _l(mLock);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006073 // bit 0 is cleared
6074 mDrainSequence = sequence << 1;
6075}
6076
6077void AudioFlinger::AsyncCallbackThread::resetDraining()
6078{
6079 Mutex::Autolock _l(mLock);
6080 // ignore unexpected callbacks
6081 if (mDrainSequence & 2) {
6082 mDrainSequence |= 1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006083 mWaitWorkCV.signal();
6084 }
6085}
6086
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07006087void AudioFlinger::AsyncCallbackThread::setAsyncError()
6088{
6089 Mutex::Autolock _l(mLock);
6090 mAsyncError = true;
6091 mWaitWorkCV.signal();
6092}
6093
Eric Laurentbfb1b832013-01-07 09:53:42 -08006094
6095// ----------------------------------------------------------------------------
6096AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurente93cc032016-05-05 10:15:10 -07006097 AudioStreamOut* output, audio_io_handle_t id, uint32_t device, bool systemReady)
6098 : DirectOutputThread(audioFlinger, output, id, device, OFFLOAD, systemReady),
Andy Hungf8044752016-07-27 14:58:11 -07006099 mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true),
6100 mOffloadUnderrunPosition(~0LL)
Eric Laurentbfb1b832013-01-07 09:53:42 -08006101{
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07006102 //FIXME: mStandby should be set to true by ThreadBase constructo
Eric Laurentfd477972013-10-25 18:10:40 -07006103 mStandby = true;
Eric Laurent64667972016-03-30 18:19:46 -07006104 mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006105}
6106
Eric Laurentbfb1b832013-01-07 09:53:42 -08006107void AudioFlinger::OffloadThread::threadLoop_exit()
6108{
6109 if (mFlushPending || mHwPaused) {
6110 // If a flush is pending or track was paused, just discard buffered data
6111 flushHw_l();
6112 } else {
6113 mMixerStatus = MIXER_DRAIN_ALL;
6114 threadLoop_drain();
6115 }
Uday Gupta56604aa2014-05-13 11:19:17 -07006116 if (mUseAsyncWrite) {
6117 ALOG_ASSERT(mCallbackThread != 0);
6118 mCallbackThread->exit();
6119 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006120 PlaybackThread::threadLoop_exit();
6121}
6122
6123AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
6124 Vector< sp<Track> > *tracksToRemove
6125)
6126{
Eric Laurentbfb1b832013-01-07 09:53:42 -08006127 size_t count = mActiveTracks.size();
6128
6129 mixer_state mixerStatus = MIXER_IDLE;
Eric Laurent972a1732013-09-04 09:42:59 -07006130 bool doHwPause = false;
6131 bool doHwResume = false;
6132
Glenn Kastenc42e9b42016-03-21 11:35:03 -07006133 ALOGV("OffloadThread::prepareTracks_l active tracks %zu", count);
Eric Laurentede6c3b2013-09-19 14:37:46 -07006134
Eric Laurentbfb1b832013-01-07 09:53:42 -08006135 // find out which tracks need to be processed
Andy Hungdae27702016-10-31 14:01:16 -07006136 for (const sp<Track> &t : mActiveTracks) {
Eric Laurent5850c4c2016-11-10 13:04:31 -08006137 Track* const track = t.get();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006138#ifdef VERY_VERY_VERBOSE_LOGGING
Eric Laurentbfb1b832013-01-07 09:53:42 -08006139 audio_track_cblk_t* cblk = track->cblk();
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006140#endif
Eric Laurentfd477972013-10-25 18:10:40 -07006141 // Only consider last track started for volume and mixer state control.
6142 // In theory an older track could underrun and restart after the new one starts
6143 // but as we only care about the transition phase between two tracks on a
6144 // direct output, it is not a problem to ignore the underrun case.
Andy Hungdae27702016-10-31 14:01:16 -07006145 sp<Track> l = mActiveTracks.getLatest();
Eric Laurent5850c4c2016-11-10 13:04:31 -08006146 bool last = l.get() == track;
Eric Laurentfd477972013-10-25 18:10:40 -07006147
Haynes Mathew George7844f672014-01-15 12:32:55 -08006148 if (track->isInvalid()) {
6149 ALOGW("An invalidated track shouldn't be in active list");
6150 tracksToRemove->add(track);
6151 continue;
6152 }
6153
6154 if (track->mState == TrackBase::IDLE) {
6155 ALOGW("An idle track shouldn't be in active list");
6156 continue;
6157 }
6158
Eric Laurentbfb1b832013-01-07 09:53:42 -08006159 if (track->isPausing()) {
6160 track->setPaused();
6161 if (last) {
Eric Laurent5cff4032015-05-26 13:49:58 -07006162 if (mHwSupportsPause && !mHwPaused) {
Eric Laurent972a1732013-09-04 09:42:59 -07006163 doHwPause = true;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006164 mHwPaused = true;
6165 }
6166 // If we were part way through writing the mixbuffer to
6167 // the HAL we must save this until we resume
6168 // BUG - this will be wrong if a different track is made active,
6169 // in that case we want to discard the pending data in the
6170 // mixbuffer and tell the client to present it again when the
6171 // track is resumed
6172 mPausedWriteLength = mCurrentWriteLength;
6173 mPausedBytesRemaining = mBytesRemaining;
6174 mBytesRemaining = 0; // stop writing
6175 }
6176 tracksToRemove->add(track);
Haynes Mathew George7844f672014-01-15 12:32:55 -08006177 } else if (track->isFlushPending()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006178 if (track->isStopping_1()) {
6179 track->mRetryCount = kMaxTrackStopRetriesOffload;
6180 } else {
6181 track->mRetryCount = kMaxTrackRetriesOffload;
6182 }
Haynes Mathew George7844f672014-01-15 12:32:55 -08006183 track->flushAck();
6184 if (last) {
6185 mFlushPending = true;
6186 }
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006187 } else if (track->isResumePending()){
6188 track->resumeAck();
6189 if (last) {
6190 if (mPausedBytesRemaining) {
6191 // Need to continue write that was interrupted
6192 mCurrentWriteLength = mPausedWriteLength;
6193 mBytesRemaining = mPausedBytesRemaining;
6194 mPausedBytesRemaining = 0;
6195 }
6196 if (mHwPaused) {
6197 doHwResume = true;
6198 mHwPaused = false;
6199 // threadLoop_mix() will handle the case that we need to
6200 // resume an interrupted write
6201 }
6202 // enable write to audio HAL
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006203 mSleepTimeUs = 0;
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006204
Eric Laurent3df841a2016-07-15 15:15:40 -07006205 mLeftVolFloat = mRightVolFloat = -1.0;
6206
Haynes Mathew George2d3ca682014-03-07 13:43:49 -08006207 // Do not handle new data in this iteration even if track->framesReady()
6208 mixerStatus = MIXER_TRACKS_ENABLED;
6209 }
6210 } else if (track->framesReady() && track->isReady() &&
Eric Laurent3b4529e2013-09-05 18:09:19 -07006211 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
Andy Hungc0691382018-09-12 18:01:57 -07006212 ALOGVV("OffloadThread: track(%d) s=%08x [OK]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006213 if (track->mFillingUpStatus == Track::FS_FILLED) {
6214 track->mFillingUpStatus = Track::FS_ACTIVE;
Eric Laurent3df841a2016-07-15 15:15:40 -07006215 if (last) {
6216 // make sure processVolume_l() will apply new volume even if 0
6217 mLeftVolFloat = mRightVolFloat = -1.0;
6218 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006219 }
6220
6221 if (last) {
Eric Laurentd7e59222013-11-15 12:02:28 -08006222 sp<Track> previousTrack = mPreviousTrack.promote();
6223 if (previousTrack != 0) {
6224 if (track != previousTrack.get()) {
Eric Laurent9da3d952013-11-12 19:25:43 -08006225 // Flush any data still being written from last track
6226 mBytesRemaining = 0;
6227 if (mPausedBytesRemaining) {
6228 // Last track was paused so we also need to flush saved
6229 // mixbuffer state and invalidate track so that it will
6230 // re-submit that unwritten data when it is next resumed
6231 mPausedBytesRemaining = 0;
6232 // Invalidate is a bit drastic - would be more efficient
6233 // to have a flag to tell client that some of the
6234 // previously written data was lost
Eric Laurentd7e59222013-11-15 12:02:28 -08006235 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006236 }
6237 // flush data already sent to the DSP if changing audio session as audio
6238 // comes from a different source. Also invalidate previous track to force a
6239 // seek when resuming.
Eric Laurentd7e59222013-11-15 12:02:28 -08006240 if (previousTrack->sessionId() != track->sessionId()) {
6241 previousTrack->invalidate();
Eric Laurent9da3d952013-11-12 19:25:43 -08006242 }
6243 }
6244 }
6245 mPreviousTrack = track;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006246 // reset retry count
Eric Laurente93cc032016-05-05 10:15:10 -07006247 if (track->isStopping_1()) {
6248 track->mRetryCount = kMaxTrackStopRetriesOffload;
6249 } else {
6250 track->mRetryCount = kMaxTrackRetriesOffload;
6251 }
Eric Laurent5850c4c2016-11-10 13:04:31 -08006252 mActiveTrack = t;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006253 mixerStatus = MIXER_TRACKS_READY;
6254 }
6255 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006256 ALOGVV("OffloadThread: track(%d) s=%08x [NOT READY]", track->id(), cblk->mServer);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006257 if (track->isStopping_1()) {
Eric Laurente93cc032016-05-05 10:15:10 -07006258 if (--(track->mRetryCount) <= 0) {
6259 // Hardware buffer can hold a large amount of audio so we must
6260 // wait for all current track's data to drain before we say
6261 // that the track is stopped.
6262 if (mBytesRemaining == 0) {
6263 // Only start draining when all data in mixbuffer
6264 // has been written
6265 ALOGV("OffloadThread: underrun and STOPPING_1 -> draining, STOPPING_2");
6266 track->mState = TrackBase::STOPPING_2; // so presentation completes after
6267 // drain do not drain if no data was ever sent to HAL (mStandby == true)
6268 if (last && !mStandby) {
6269 // do not modify drain sequence if we are already draining. This happens
6270 // when resuming from pause after drain.
6271 if ((mDrainSequence & 1) == 0) {
6272 mSleepTimeUs = 0;
6273 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
6274 mixerStatus = MIXER_DRAIN_TRACK;
6275 mDrainSequence += 2;
6276 }
6277 if (mHwPaused) {
6278 // It is possible to move from PAUSED to STOPPING_1 without
6279 // a resume so we must ensure hardware is running
6280 doHwResume = true;
6281 mHwPaused = false;
6282 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006283 }
6284 }
Eric Laurente93cc032016-05-05 10:15:10 -07006285 } else if (last) {
6286 ALOGV("stopping1 underrun retries left %d", track->mRetryCount);
6287 mixerStatus = MIXER_TRACKS_ENABLED;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006288 }
6289 } else if (track->isStopping_2()) {
Eric Laurent6a51d7e2013-10-17 18:59:26 -07006290 // Drain has completed or we are in standby, signal presentation complete
6291 if (!(mDrainSequence & 1) || !last || mStandby) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006292 track->mState = TrackBase::STOPPED;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006293 uint32_t latency = 0;
6294 status_t result = mOutput->stream->getLatency(&latency);
6295 ALOGE_IF(result != OK,
6296 "Error when retrieving output stream latency: %d", result);
6297 size_t audioHALFrames = (latency * mSampleRate) / 1000;
Andy Hung818e7a32016-02-16 18:08:07 -08006298 int64_t framesWritten =
Phil Burk062e67a2015-02-11 13:40:50 -08006299 mBytesWritten / mOutput->getFrameSize();
Eric Laurentbfb1b832013-01-07 09:53:42 -08006300 track->presentationComplete(framesWritten, audioHALFrames);
6301 track->reset();
6302 tracksToRemove->add(track);
Andy Hungf3234512018-07-03 14:51:47 -07006303 // DIRECT and OFFLOADED stop resets frame counts.
6304 if (!mUseAsyncWrite) {
6305 // If we don't get explicit drain notification we must
6306 // register discontinuity regardless of whether this is
6307 // the previous (!last) or the upcoming (last) track
6308 // to avoid skipping the discontinuity.
6309 mTimestampVerifier.discontinuity();
6310 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006311 }
6312 } else {
6313 // No buffers for this track. Give it a few chances to
6314 // fill a buffer, then remove it from active list.
6315 if (--(track->mRetryCount) <= 0) {
Andy Hungf8044752016-07-27 14:58:11 -07006316 bool running = false;
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006317 uint64_t position = 0;
6318 struct timespec unused;
6319 // The running check restarts the retry counter at least once.
6320 status_t ret = mOutput->stream->getPresentationPosition(&position, &unused);
6321 if (ret == NO_ERROR && position != mOffloadUnderrunPosition) {
6322 running = true;
6323 mOffloadUnderrunPosition = position;
6324 }
6325 if (ret == NO_ERROR) {
Andy Hungf8044752016-07-27 14:58:11 -07006326 ALOGVV("underrun counter, running(%d): %lld vs %lld", running,
6327 (long long)position, (long long)mOffloadUnderrunPosition);
6328 }
6329 if (running) { // still running, give us more time.
6330 track->mRetryCount = kMaxTrackRetriesOffload;
6331 } else {
Andy Hungc0691382018-09-12 18:01:57 -07006332 ALOGV("OffloadThread: BUFFER TIMEOUT: remove track(%d) from active list",
6333 track->id());
Andy Hungf8044752016-07-27 14:58:11 -07006334 tracksToRemove->add(track);
Glenn Kastend3bb6452016-12-05 18:14:37 -08006335 // tell client process that the track was disabled because of underrun;
Andy Hungf8044752016-07-27 14:58:11 -07006336 // it will then automatically call start() when data is available
6337 track->disable();
6338 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006339 } else if (last){
6340 mixerStatus = MIXER_TRACKS_ENABLED;
6341 }
6342 }
6343 }
6344 // compute volume for this track
Wenfeng Sun79458332019-05-29 20:12:43 +08006345 if (track->isReady()) { // check ready to prevent premature start.
6346 processVolume_l(track, last);
6347 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08006348 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006349
Eric Laurentea0fade2013-10-04 16:23:48 -07006350 // make sure the pause/flush/resume sequence is executed in the right order.
6351 // If a flush is pending and a track is active but the HW is not paused, force a HW pause
6352 // before flush and then resume HW. This can happen in case of pause/flush/resume
6353 // if resume is received before pause is executed.
Eric Laurentfd477972013-10-25 18:10:40 -07006354 if (!mStandby && (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006355 status_t result = mOutput->stream->pause();
6356 ALOGE_IF(result != OK, "Error when pausing output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006357 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006358 if (mFlushPending) {
6359 flushHw_l();
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006360 }
Eric Laurentfd477972013-10-25 18:10:40 -07006361 if (!mStandby && doHwResume) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07006362 status_t result = mOutput->stream->resume();
6363 ALOGE_IF(result != OK, "Error when resuming output stream: %d", result);
Eric Laurent972a1732013-09-04 09:42:59 -07006364 }
Eric Laurent6bf9ae22013-08-30 15:12:37 -07006365
Eric Laurentbfb1b832013-01-07 09:53:42 -08006366 // remove all the tracks that need to be...
6367 removeTracks_l(*tracksToRemove);
6368
6369 return mixerStatus;
6370}
6371
Eric Laurentbfb1b832013-01-07 09:53:42 -08006372// must be called with thread mutex locked
6373bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
6374{
Eric Laurent3b4529e2013-09-05 18:09:19 -07006375 ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
6376 mWriteAckSequence, mDrainSequence);
6377 if (mUseAsyncWrite && ((mWriteAckSequence & 1) || (mDrainSequence & 1))) {
Eric Laurentbfb1b832013-01-07 09:53:42 -08006378 return true;
6379 }
6380 return false;
6381}
6382
Eric Laurentbfb1b832013-01-07 09:53:42 -08006383bool AudioFlinger::OffloadThread::waitingAsyncCallback()
6384{
6385 Mutex::Autolock _l(mLock);
6386 return waitingAsyncCallback_l();
6387}
6388
6389void AudioFlinger::OffloadThread::flushHw_l()
6390{
Eric Laurente659ef42014-09-29 13:06:46 -07006391 DirectOutputThread::flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08006392 // Flush anything still waiting in the mixbuffer
6393 mCurrentWriteLength = 0;
6394 mBytesRemaining = 0;
6395 mPausedWriteLength = 0;
6396 mPausedBytesRemaining = 0;
Eric Laurent3eaf66b2016-04-01 14:44:17 -07006397 // reset bytes written count to reflect that DSP buffers are empty after flush.
6398 mBytesWritten = 0;
Andy Hungf8044752016-07-27 14:58:11 -07006399 mOffloadUnderrunPosition = ~0LL;
Haynes Mathew George0f02f262014-01-11 13:03:57 -08006400
Eric Laurentbfb1b832013-01-07 09:53:42 -08006401 if (mUseAsyncWrite) {
Eric Laurent3b4529e2013-09-05 18:09:19 -07006402 // discard any pending drain or write ack by incrementing sequence
6403 mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
6404 mDrainSequence = (mDrainSequence + 2) & ~1;
Eric Laurentbfb1b832013-01-07 09:53:42 -08006405 ALOG_ASSERT(mCallbackThread != 0);
Eric Laurent3b4529e2013-09-05 18:09:19 -07006406 mCallbackThread->setWriteBlocked(mWriteAckSequence);
6407 mCallbackThread->setDraining(mDrainSequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -08006408 }
6409}
6410
Haynes Mathew George05317d22016-05-03 16:34:26 -07006411void AudioFlinger::OffloadThread::invalidateTracks(audio_stream_type_t streamType)
6412{
6413 Mutex::Autolock _l(mLock);
Eric Laurent13084622016-05-17 10:51:49 -07006414 if (PlaybackThread::invalidateTracks_l(streamType)) {
6415 mFlushPending = true;
6416 }
Haynes Mathew George05317d22016-05-03 16:34:26 -07006417}
6418
Eric Laurentbfb1b832013-01-07 09:53:42 -08006419// ----------------------------------------------------------------------------
6420
Eric Laurent81784c32012-11-19 14:55:58 -08006421AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurent72e3f392015-05-20 14:43:50 -07006422 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id, bool systemReady)
Eric Laurent81784c32012-11-19 14:55:58 -08006423 : MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->outDevice(),
Eric Laurent72e3f392015-05-20 14:43:50 -07006424 systemReady, DUPLICATING),
Eric Laurent81784c32012-11-19 14:55:58 -08006425 mWaitTimeMs(UINT_MAX)
6426{
6427 addOutputTrack(mainThread);
6428}
6429
6430AudioFlinger::DuplicatingThread::~DuplicatingThread()
6431{
6432 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6433 mOutputTracks[i]->destroy();
6434 }
6435}
6436
6437void AudioFlinger::DuplicatingThread::threadLoop_mix()
6438{
6439 // mix buffers...
6440 if (outputsReady(outputTracks)) {
Glenn Kastend79072e2016-01-06 08:41:20 -08006441 mAudioMixer->process();
Eric Laurent81784c32012-11-19 14:55:58 -08006442 } else {
Eric Laurent02b57082014-11-07 17:28:28 -08006443 if (mMixerBufferValid) {
6444 memset(mMixerBuffer, 0, mMixerBufferSize);
6445 } else {
6446 memset(mSinkBuffer, 0, mSinkBufferSize);
6447 }
Eric Laurent81784c32012-11-19 14:55:58 -08006448 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006449 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006450 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006451 mCurrentWriteLength = mSinkBufferSize;
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006452 mStandbyTimeNs = systemTime() + mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08006453}
6454
6455void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
6456{
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006457 if (mSleepTimeUs == 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08006458 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006459 mSleepTimeUs = mActiveSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006460 } else {
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006461 mSleepTimeUs = mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08006462 }
6463 } else if (mBytesWritten != 0) {
6464 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
6465 writeFrames = mNormalFrameCount;
Andy Hung25c2dac2014-02-27 14:56:00 -08006466 memset(mSinkBuffer, 0, mSinkBufferSize);
Eric Laurent81784c32012-11-19 14:55:58 -08006467 } else {
6468 // flush remaining overflow buffers in output tracks
6469 writeFrames = 0;
6470 }
Eric Laurentad9cb8b2015-05-26 16:38:19 -07006471 mSleepTimeUs = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08006472 }
6473}
6474
Eric Laurentbfb1b832013-01-07 09:53:42 -08006475ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
Eric Laurent81784c32012-11-19 14:55:58 -08006476{
6477 for (size_t i = 0; i < outputTracks.size(); i++) {
Andy Hung1c86ebe2018-05-29 20:29:08 -07006478 const ssize_t actualWritten = outputTracks[i]->write(mSinkBuffer, writeFrames);
6479
6480 // Consider the first OutputTrack for timestamp and frame counting.
6481
6482 // The threadLoop() generally assumes writing a full sink buffer size at a time.
6483 // Here, we correct for writeFrames of 0 (a stop) or underruns because
6484 // we always claim success.
6485 if (i == 0) {
6486 const ssize_t correction = mSinkBufferSize / mFrameSize - actualWritten;
6487 ALOGD_IF(correction != 0 && writeFrames != 0,
6488 "%s: writeFrames:%u actualWritten:%zd correction:%zd mFramesWritten:%lld",
6489 __func__, writeFrames, actualWritten, correction, (long long)mFramesWritten);
6490 mFramesWritten -= correction;
6491 }
6492
6493 // TODO: Report correction for the other output tracks and show in the dump.
Eric Laurent81784c32012-11-19 14:55:58 -08006494 }
Eric Laurent2c3740f2013-10-30 16:57:06 -07006495 mStandby = false;
Andy Hung25c2dac2014-02-27 14:56:00 -08006496 return (ssize_t)mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08006497}
6498
6499void AudioFlinger::DuplicatingThread::threadLoop_standby()
6500{
6501 // DuplicatingThread implements standby by stopping all tracks
6502 for (size_t i = 0; i < outputTracks.size(); i++) {
6503 outputTracks[i]->stop();
6504 }
6505}
6506
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006507void AudioFlinger::DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Andy Hung1bc088a2018-02-09 15:57:31 -08006508{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07006509 MixerThread::dumpInternals_l(fd, args);
Andy Hung1bc088a2018-02-09 15:57:31 -08006510
6511 std::stringstream ss;
6512 const size_t numTracks = mOutputTracks.size();
6513 ss << " " << numTracks << " OutputTracks";
6514 if (numTracks > 0) {
6515 ss << ":";
6516 for (const auto &track : mOutputTracks) {
6517 const sp<ThreadBase> thread = track->thread().promote();
Andy Hungc0691382018-09-12 18:01:57 -07006518 ss << " (" << track->id() << " : ";
Andy Hung1bc088a2018-02-09 15:57:31 -08006519 if (thread.get() != nullptr) {
6520 ss << thread.get() << ", " << thread->id();
6521 } else {
6522 ss << "null";
6523 }
6524 ss << ")";
6525 }
6526 }
6527 ss << "\n";
6528 std::string result = ss.str();
6529 write(fd, result.c_str(), result.size());
6530}
6531
Eric Laurent81784c32012-11-19 14:55:58 -08006532void AudioFlinger::DuplicatingThread::saveOutputTracks()
6533{
6534 outputTracks = mOutputTracks;
6535}
6536
6537void AudioFlinger::DuplicatingThread::clearOutputTracks()
6538{
6539 outputTracks.clear();
6540}
6541
6542void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
6543{
6544 Mutex::Autolock _l(mLock);
Andy Hungc25b84a2015-01-14 19:04:10 -08006545 // The downstream MixerThread consumes thread->frameCount() amount of frames per mix pass.
6546 // Adjust for thread->sampleRate() to determine minimum buffer frame count.
6547 // Then triple buffer because Threads do not run synchronously and may not be clock locked.
6548 const size_t frameCount =
6549 3 * sourceFramesNeeded(mSampleRate, thread->frameCount(), thread->sampleRate());
6550 // TODO: Consider asynchronous sample rate conversion to handle clock disparity
6551 // from different OutputTracks and their associated MixerThreads (e.g. one may
6552 // nearly empty and the other may be dropping data).
6553
6554 sp<OutputTrack> outputTrack = new OutputTrack(thread,
Eric Laurent81784c32012-11-19 14:55:58 -08006555 this,
6556 mSampleRate,
Andy Hungc25b84a2015-01-14 19:04:10 -08006557 mFormat,
Eric Laurent81784c32012-11-19 14:55:58 -08006558 mChannelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08006559 frameCount,
6560 IPCThreadState::self()->getCallingUid());
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006561 status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
6562 if (status != NO_ERROR) {
6563 ALOGE("addOutputTrack() initCheck failed %d", status);
6564 return;
Eric Laurent81784c32012-11-19 14:55:58 -08006565 }
Eric Laurentaf3ec7c2016-08-01 11:25:19 -07006566 thread->setStreamVolume(AUDIO_STREAM_PATCH, 1.0f);
6567 mOutputTracks.add(outputTrack);
6568 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
6569 updateWaitTime_l();
Eric Laurent81784c32012-11-19 14:55:58 -08006570}
6571
6572void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
6573{
6574 Mutex::Autolock _l(mLock);
6575 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6576 if (mOutputTracks[i]->thread() == thread) {
6577 mOutputTracks[i]->destroy();
6578 mOutputTracks.removeAt(i);
6579 updateWaitTime_l();
Eric Laurentf6870ae2015-05-08 10:50:03 -07006580 if (thread->getOutput() == mOutput) {
6581 mOutput = NULL;
6582 }
Eric Laurent81784c32012-11-19 14:55:58 -08006583 return;
6584 }
6585 }
Eric Laurentf6870ae2015-05-08 10:50:03 -07006586 ALOGV("removeOutputTrack(): unknown thread: %p", thread);
Eric Laurent81784c32012-11-19 14:55:58 -08006587}
6588
6589// caller must hold mLock
6590void AudioFlinger::DuplicatingThread::updateWaitTime_l()
6591{
6592 mWaitTimeMs = UINT_MAX;
6593 for (size_t i = 0; i < mOutputTracks.size(); i++) {
6594 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
6595 if (strong != 0) {
6596 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
6597 if (waitTimeMs < mWaitTimeMs) {
6598 mWaitTimeMs = waitTimeMs;
6599 }
6600 }
6601 }
6602}
6603
6604
6605bool AudioFlinger::DuplicatingThread::outputsReady(
6606 const SortedVector< sp<OutputTrack> > &outputTracks)
6607{
6608 for (size_t i = 0; i < outputTracks.size(); i++) {
6609 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
6610 if (thread == 0) {
6611 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
6612 outputTracks[i].get());
6613 return false;
6614 }
6615 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
6616 // see note at standby() declaration
6617 if (playbackThread->standby() && !playbackThread->isSuspended()) {
6618 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
6619 thread.get());
6620 return false;
6621 }
6622 }
6623 return true;
6624}
6625
Kevin Rocard12381092018-04-11 09:19:59 -07006626void AudioFlinger::DuplicatingThread::sendMetadataToBackend_l(
6627 const StreamOutHalInterface::SourceMetadata& metadata)
Kevin Rocard069c2712018-03-29 19:09:14 -07006628{
Kevin Rocard12381092018-04-11 09:19:59 -07006629 for (auto& outputTrack : outputTracks) { // not mOutputTracks
6630 outputTrack->setMetadatas(metadata.tracks);
6631 }
Kevin Rocard069c2712018-03-29 19:09:14 -07006632}
6633
Eric Laurent81784c32012-11-19 14:55:58 -08006634uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
6635{
6636 return (mWaitTimeMs * 1000) / 2;
6637}
6638
6639void AudioFlinger::DuplicatingThread::cacheParameters_l()
6640{
6641 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
6642 updateWaitTime_l();
6643
6644 MixerThread::cacheParameters_l();
6645}
6646
Eric Laurent6acd1d42017-01-04 14:23:29 -08006647
Eric Laurent81784c32012-11-19 14:55:58 -08006648// ----------------------------------------------------------------------------
6649// Record
6650// ----------------------------------------------------------------------------
6651
6652AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
6653 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08006654 audio_io_handle_t id,
Eric Laurentd3922f72013-02-01 17:57:04 -08006655 audio_devices_t outDevice,
Eric Laurent72e3f392015-05-20 14:43:50 -07006656 audio_devices_t inDevice,
6657 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08006658 ) :
Eric Laurent72e3f392015-05-20 14:43:50 -07006659 ThreadBase(audioFlinger, id, outDevice, inDevice, RECORD, systemReady),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07006660 mInput(input),
6661 mActiveTracks(&this->mLocalLog),
6662 mRsmpInBuffer(NULL),
Glenn Kasten1b291842016-07-18 14:55:21 -07006663 // mRsmpInFrames, mRsmpInFramesP2, and mRsmpInFramesOA are set by readInputParameters_l()
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08006664 mRsmpInRear(0)
Glenn Kastenb880f5e2014-05-07 08:43:45 -07006665 , mReadOnlyHeap(new MemoryDealer(kRecordThreadReadOnlyHeapSize,
6666 "RecordThreadRO", MemoryHeapBase::READ_ONLY))
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006667 // mFastCapture below
6668 , mFastCaptureFutex(0)
6669 // mInputSource
6670 // mPipeSink
6671 // mPipeSource
6672 , mPipeFramesP2(0)
6673 // mPipeMemory
6674 // mFastCaptureNBLogWriter
Glenn Kasten6e6704c2014-07-03 10:20:00 -07006675 , mFastTrackAvail(false)
Eric Laurentd8365c52017-07-16 15:27:05 -07006676 , mBtNrecSuspended(false)
Eric Laurent81784c32012-11-19 14:55:58 -08006677{
Glenn Kastend7dca052015-03-05 16:05:54 -08006678 snprintf(mThreadName, kThreadNameLength, "AudioIn_%X", id);
6679 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
Eric Laurent81784c32012-11-19 14:55:58 -08006680
Andy Hungc8fddf32018-08-08 18:32:37 -07006681 if (mInput != nullptr && mInput->audioHwDev != nullptr) {
6682 mIsMsdDevice = strcmp(
6683 mInput->audioHwDev->moduleName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0;
6684 }
6685
Glenn Kastendeca2ae2014-02-07 10:25:56 -08006686 readInputParameters_l();
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006687
Andy Hungc8fddf32018-08-08 18:32:37 -07006688 // TODO: We may also match on address as well as device type for
6689 // AUDIO_DEVICE_IN_BUS, AUDIO_DEVICE_IN_BLUETOOTH_A2DP, AUDIO_DEVICE_IN_REMOTE_SUBMIX
6690 mTimestampCorrectedDevices = (audio_devices_t)property_get_int64(
6691 "audio.timestamp.corrected_input_devices",
6692 (int64_t)(mIsMsdDevice ? AUDIO_DEVICE_IN_BUS // turn on by default for MSD
6693 : AUDIO_DEVICE_NONE));
6694
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006695 // create an NBAIO source for the HAL input stream, and negotiate
Mikhail Naganova0c91332016-09-19 10:01:12 -07006696 mInputSource = new AudioStreamInSource(input->stream);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006697 size_t numCounterOffers = 0;
6698 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
Glenn Kasten57c4e6f2016-03-18 14:54:07 -07006699#if !LOG_NDEBUG
6700 ssize_t index =
6701#else
6702 (void)
6703#endif
6704 mInputSource->negotiate(offers, 1, NULL, numCounterOffers);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006705 ALOG_ASSERT(index == 0);
6706
6707 // initialize fast capture depending on configuration
6708 bool initFastCapture;
6709 switch (kUseFastCapture) {
6710 case FastCapture_Never:
6711 initFastCapture = false;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006712 ALOGV("%p kUseFastCapture = Never, initFastCapture = false", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006713 break;
6714 case FastCapture_Always:
6715 initFastCapture = true;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006716 ALOGV("%p kUseFastCapture = Always, initFastCapture = true", this);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006717 break;
6718 case FastCapture_Static:
Glenn Kasteneb9487e2015-07-22 09:15:17 -07006719 initFastCapture = (mFrameCount * 1000) / mSampleRate < kMinNormalCaptureBufferSizeMs;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006720 ALOGV("%p kUseFastCapture = Static, (%lld * 1000) / %u vs %u, initFastCapture = %d",
6721 this, (long long)mFrameCount, mSampleRate, kMinNormalCaptureBufferSizeMs,
6722 initFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006723 break;
6724 // case FastCapture_Dynamic:
6725 }
6726
6727 if (initFastCapture) {
Glenn Kastend198b852015-03-16 14:55:53 -07006728 // create a Pipe for FastCapture to write to, and for us and fast tracks to read from
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006729 NBAIO_Format format = mInputSource->format();
Glenn Kasten1b291842016-07-18 14:55:21 -07006730 // quadruple-buffering of 20 ms each; this ensures we can sleep for 20ms in RecordThread
6731 size_t pipeFramesP2 = roundup(4 * FMS_20 * mSampleRate / 1000);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006732 size_t pipeSize = pipeFramesP2 * Format_frameSize(format);
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006733 void *pipeBuffer = nullptr;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006734 const sp<MemoryDealer> roHeap(readOnlyHeap());
6735 sp<IMemory> pipeMemory;
6736 if ((roHeap == 0) ||
6737 (pipeMemory = roHeap->allocate(pipeSize)) == 0 ||
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07006738 (pipeBuffer = pipeMemory->pointer()) == nullptr) {
6739 ALOGE("not enough memory for pipe buffer size=%zu; "
6740 "roHeap=%p, pipeMemory=%p, pipeBuffer=%p; roHeapSize: %lld",
6741 pipeSize, roHeap.get(), pipeMemory.get(), pipeBuffer,
6742 (long long)kRecordThreadReadOnlyHeapSize);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006743 goto failed;
6744 }
6745 // pipe will be shared directly with fast clients, so clear to avoid leaking old information
6746 memset(pipeBuffer, 0, pipeSize);
6747 Pipe *pipe = new Pipe(pipeFramesP2, format, pipeBuffer);
6748 const NBAIO_Format offers[1] = {format};
6749 size_t numCounterOffers = 0;
6750 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
6751 ALOG_ASSERT(index == 0);
6752 mPipeSink = pipe;
6753 PipeReader *pipeReader = new PipeReader(*pipe);
6754 numCounterOffers = 0;
6755 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
6756 ALOG_ASSERT(index == 0);
6757 mPipeSource = pipeReader;
6758 mPipeFramesP2 = pipeFramesP2;
6759 mPipeMemory = pipeMemory;
6760
6761 // create fast capture
6762 mFastCapture = new FastCapture();
6763 FastCaptureStateQueue *sq = mFastCapture->sq();
6764#ifdef STATE_QUEUE_DUMP
6765 // FIXME
6766#endif
6767 FastCaptureState *state = sq->begin();
6768 state->mCblk = NULL;
6769 state->mInputSource = mInputSource.get();
6770 state->mInputSourceGen++;
6771 state->mPipeSink = pipe;
6772 state->mPipeSinkGen++;
6773 state->mFrameCount = mFrameCount;
6774 state->mCommand = FastCaptureState::COLD_IDLE;
6775 // already done in constructor initialization list
6776 //mFastCaptureFutex = 0;
6777 state->mColdFutexAddr = &mFastCaptureFutex;
6778 state->mColdGen++;
6779 state->mDumpState = &mFastCaptureDumpState;
6780#ifdef TEE_SINK
6781 // FIXME
6782#endif
6783 mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
6784 state->mNBLogWriter = mFastCaptureNBLogWriter.get();
6785 sq->end();
6786 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
6787
6788 // start the fast capture
6789 mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
6790 pid_t tid = mFastCapture->getTid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07006791 sendPrioConfigEvent(getpid(), tid, kPriorityFastCapture, false /*forApp*/);
Mikhail Naganove1c4b5d2016-12-22 09:22:45 -08006792 stream()->setHalThreadPriority(kPriorityFastCapture);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006793#ifdef AUDIO_WATCHDOG
6794 // FIXME
6795#endif
6796
Glenn Kasten6e6704c2014-07-03 10:20:00 -07006797 mFastTrackAvail = true;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006798 }
Andy Hung8946a282018-04-19 20:04:56 -07006799#ifdef TEE_SINK
6800 mTee.set(mInputSource->format(), NBAIO_Tee::TEE_FLAG_INPUT_THREAD);
6801 mTee.setId(std::string("_") + std::to_string(mId) + "_C");
6802#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006803failed: ;
6804
6805 // FIXME mNormalSource
Eric Laurent81784c32012-11-19 14:55:58 -08006806}
6807
Eric Laurent81784c32012-11-19 14:55:58 -08006808AudioFlinger::RecordThread::~RecordThread()
6809{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006810 if (mFastCapture != 0) {
6811 FastCaptureStateQueue *sq = mFastCapture->sq();
6812 FastCaptureState *state = sq->begin();
6813 if (state->mCommand == FastCaptureState::COLD_IDLE) {
6814 int32_t old = android_atomic_inc(&mFastCaptureFutex);
6815 if (old == -1) {
6816 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
6817 }
6818 }
6819 state->mCommand = FastCaptureState::EXIT;
6820 sq->end();
6821 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
6822 mFastCapture->join();
6823 mFastCapture.clear();
6824 }
6825 mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
Glenn Kasten481fb672013-09-30 14:39:28 -07006826 mAudioFlinger->unregisterWriter(mNBLogWriter);
Andy Hung57446612015-04-19 23:56:46 -07006827 free(mRsmpInBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -08006828}
6829
6830void AudioFlinger::RecordThread::onFirstRef()
6831{
Glenn Kastend7dca052015-03-05 16:05:54 -08006832 run(mThreadName, PRIORITY_URGENT_AUDIO);
Eric Laurent81784c32012-11-19 14:55:58 -08006833}
6834
Eric Laurent555530a2017-02-07 18:17:24 -08006835void AudioFlinger::RecordThread::preExit()
6836{
6837 ALOGV(" preExit()");
6838 Mutex::Autolock _l(mLock);
6839 for (size_t i = 0; i < mTracks.size(); i++) {
6840 sp<RecordTrack> track = mTracks[i];
6841 track->invalidate();
6842 }
6843 mActiveTracks.clear();
6844 mStartStopCond.broadcast();
6845}
6846
Eric Laurent81784c32012-11-19 14:55:58 -08006847bool AudioFlinger::RecordThread::threadLoop()
6848{
Eric Laurent81784c32012-11-19 14:55:58 -08006849 nsecs_t lastWarning = 0;
6850
6851 inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08006852
Glenn Kastenf10ffec2013-11-20 16:40:08 -08006853reacquire_wakelock:
6854 sp<RecordTrack> activeTrack;
6855 {
6856 Mutex::Autolock _l(mLock);
Andy Hungdae27702016-10-31 14:01:16 -07006857 acquireWakeLock_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08006858 }
6859
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006860 // used to request a deferred sleep, to be executed later while mutex is unlocked
6861 uint32_t sleepUs = 0;
6862
Andy Hung446f4df2019-02-21 12:26:41 -08006863 int64_t lastLoopCountRead = -2; // never matches "previous" loop, when loopCount = 0.
6864
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006865 // loop while there is work to do
Andy Hung446f4df2019-02-21 12:26:41 -08006866 for (int64_t loopCount = 0;; ++loopCount) { // loopCount used for statistics tracking
Glenn Kastenc527a7c2013-08-13 15:43:49 -07006867 Vector< sp<EffectChain> > effectChains;
Glenn Kasten2cfbf882013-08-14 13:12:11 -07006868
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006869 // activeTracks accumulates a copy of a subset of mActiveTracks
6870 Vector< sp<RecordTrack> > activeTracks;
6871
Glenn Kasten735f45f2014-08-18 15:51:59 -07006872 // reference to the (first and only) active fast track
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006873 sp<RecordTrack> fastTrack;
Eric Laurent10351942014-05-08 18:49:52 -07006874
Glenn Kasten735f45f2014-08-18 15:51:59 -07006875 // reference to a fast track which is about to be removed
6876 sp<RecordTrack> fastTrackToRemove;
6877
Eric Laurent81784c32012-11-19 14:55:58 -08006878 { // scope for mLock
6879 Mutex::Autolock _l(mLock);
Eric Laurent000a4192014-01-29 15:17:32 -08006880
Eric Laurent021cf962014-05-13 10:18:14 -07006881 processConfigEvents_l();
Glenn Kastenf10ffec2013-11-20 16:40:08 -08006882
Eric Laurent000a4192014-01-29 15:17:32 -08006883 // check exitPending here because checkForNewParameters_l() and
6884 // checkForNewParameters_l() can temporarily release mLock
6885 if (exitPending()) {
6886 break;
6887 }
6888
Eric Laurent5c25d562016-07-13 17:17:45 -07006889 // sleep with mutex unlocked
6890 if (sleepUs > 0) {
Glenn Kastenf9715e42016-07-13 14:02:03 -07006891 ATRACE_BEGIN("sleepC");
Eric Laurent5c25d562016-07-13 17:17:45 -07006892 mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)sleepUs));
6893 ATRACE_END();
6894 sleepUs = 0;
6895 continue;
6896 }
6897
Glenn Kasten2b806402013-11-20 16:37:38 -08006898 // if no active track(s), then standby and release wakelock
6899 size_t size = mActiveTracks.size();
6900 if (size == 0) {
Glenn Kasten93e471f2013-08-19 08:40:07 -07006901 standbyIfNotAlreadyInStandby();
Glenn Kasten4ef0b462013-08-14 13:52:27 -07006902 // exitPending() can't become true here
Eric Laurent81784c32012-11-19 14:55:58 -08006903 releaseWakeLock_l();
6904 ALOGV("RecordThread: loop stopping");
6905 // go to sleep
6906 mWaitWorkCV.wait(mLock);
6907 ALOGV("RecordThread: loop starting");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08006908 goto reacquire_wakelock;
6909 }
6910
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006911 bool doBroadcast = false;
Eric Laurent5c25d562016-07-13 17:17:45 -07006912 bool allStopped = true;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006913 for (size_t i = 0; i < size; ) {
Glenn Kasten9e982352013-08-14 14:39:50 -07006914
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006915 activeTrack = mActiveTracks[i];
6916 if (activeTrack->isTerminated()) {
Glenn Kasten735f45f2014-08-18 15:51:59 -07006917 if (activeTrack->isFastTrack()) {
6918 ALOG_ASSERT(fastTrackToRemove == 0);
6919 fastTrackToRemove = activeTrack;
6920 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006921 removeTrack_l(activeTrack);
Glenn Kasten2b806402013-11-20 16:37:38 -08006922 mActiveTracks.remove(activeTrack);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006923 size--;
Glenn Kasten9e982352013-08-14 14:39:50 -07006924 continue;
6925 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006926
6927 TrackBase::track_state activeTrackState = activeTrack->mState;
6928 switch (activeTrackState) {
6929
6930 case TrackBase::PAUSING:
6931 mActiveTracks.remove(activeTrack);
Andy Hungce685402018-10-05 17:23:27 -07006932 activeTrack->mState = TrackBase::PAUSED;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006933 doBroadcast = true;
6934 size--;
6935 continue;
6936
6937 case TrackBase::STARTING_1:
6938 sleepUs = 10000;
6939 i++;
Eric Laurent5c25d562016-07-13 17:17:45 -07006940 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006941 continue;
6942
6943 case TrackBase::STARTING_2:
6944 doBroadcast = true;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006945 mStandby = false;
Glenn Kasten9e982352013-08-14 14:39:50 -07006946 activeTrack->mState = TrackBase::ACTIVE;
Eric Laurent5c25d562016-07-13 17:17:45 -07006947 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006948 break;
6949
6950 case TrackBase::ACTIVE:
Eric Laurent5c25d562016-07-13 17:17:45 -07006951 allStopped = false;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006952 break;
6953
Andy Hungce685402018-10-05 17:23:27 -07006954 case TrackBase::IDLE: // cannot be on ActiveTracks if idle
6955 case TrackBase::PAUSED: // cannot be on ActiveTracks if paused
6956 case TrackBase::STOPPED: // cannot be on ActiveTracks if destroyed/terminated
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006957 default:
Andy Hungce685402018-10-05 17:23:27 -07006958 LOG_ALWAYS_FATAL("%s: Unexpected active track state:%d, id:%d, tracks:%zu",
6959 __func__, activeTrackState, activeTrack->id(), size);
Glenn Kasten9e982352013-08-14 14:39:50 -07006960 }
Glenn Kasten9e982352013-08-14 14:39:50 -07006961
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006962 activeTracks.add(activeTrack);
6963 i++;
Glenn Kasten9e982352013-08-14 14:39:50 -07006964
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07006965 if (activeTrack->isFastTrack()) {
6966 ALOG_ASSERT(!mFastTrackAvail);
6967 ALOG_ASSERT(fastTrack == 0);
6968 fastTrack = activeTrack;
6969 }
Glenn Kasten9e982352013-08-14 14:39:50 -07006970 }
Eric Laurent5c25d562016-07-13 17:17:45 -07006971
Andy Hungdae27702016-10-31 14:01:16 -07006972 mActiveTracks.updatePowerState(this);
6973
Kevin Rocard069c2712018-03-29 19:09:14 -07006974 updateMetadata_l();
6975
Eric Laurent5c25d562016-07-13 17:17:45 -07006976 if (allStopped) {
6977 standbyIfNotAlreadyInStandby();
6978 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006979 if (doBroadcast) {
6980 mStartStopCond.broadcast();
6981 }
6982
6983 // sleep if there are no active tracks to process
Eric Tan39ec8d62018-07-24 09:49:29 -07006984 if (activeTracks.isEmpty()) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006985 if (sleepUs == 0) {
6986 sleepUs = kRecordThreadSleepUs;
6987 }
6988 continue;
6989 }
6990 sleepUs = 0;
Glenn Kasten9e982352013-08-14 14:39:50 -07006991
Eric Laurent81784c32012-11-19 14:55:58 -08006992 lockEffectChains_l(effectChains);
6993 }
6994
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006995 // thread mutex is now unlocked, mActiveTracks unknown, activeTracks.size() > 0
Glenn Kasten71652682013-08-14 15:17:55 -07006996
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08006997 size_t size = effectChains.size();
6998 for (size_t i = 0; i < size; i++) {
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07006999 // thread mutex is not locked, but effect chain is locked
7000 effectChains[i]->process_l();
7001 }
7002
Glenn Kasten735f45f2014-08-18 15:51:59 -07007003 // Push a new fast capture state if fast capture is not already running, or cblk change
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007004 if (mFastCapture != 0) {
7005 FastCaptureStateQueue *sq = mFastCapture->sq();
7006 FastCaptureState *state = sq->begin();
Glenn Kasten735f45f2014-08-18 15:51:59 -07007007 bool didModify = false;
7008 FastCaptureStateQueue::block_t block = FastCaptureStateQueue::BLOCK_UNTIL_PUSHED;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007009 if (state->mCommand != FastCaptureState::READ_WRITE /* FIXME &&
7010 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)*/) {
7011 if (state->mCommand == FastCaptureState::COLD_IDLE) {
7012 int32_t old = android_atomic_inc(&mFastCaptureFutex);
7013 if (old == -1) {
7014 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
7015 }
7016 }
7017 state->mCommand = FastCaptureState::READ_WRITE;
7018#if 0 // FIXME
7019 mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
Glenn Kastenfbdb2ac2015-03-02 14:47:19 -08007020 FastThreadDumpState::kSamplingNforLowRamDevice :
7021 FastThreadDumpState::kSamplingN);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007022#endif
Glenn Kasten735f45f2014-08-18 15:51:59 -07007023 didModify = true;
7024 }
7025 audio_track_cblk_t *cblkOld = state->mCblk;
7026 audio_track_cblk_t *cblkNew = fastTrack != 0 ? fastTrack->cblk() : NULL;
7027 if (cblkNew != cblkOld) {
7028 state->mCblk = cblkNew;
7029 // block until acked if removing a fast track
7030 if (cblkOld != NULL) {
7031 block = FastCaptureStateQueue::BLOCK_UNTIL_ACKED;
7032 }
7033 didModify = true;
7034 }
jiabin01c8f562018-07-19 17:47:28 -07007035 AudioBufferProvider* abp = (fastTrack != 0 && fastTrack->isPatchTrack()) ?
7036 reinterpret_cast<AudioBufferProvider*>(fastTrack.get()) : nullptr;
7037 if (state->mFastPatchRecordBufferProvider != abp) {
7038 state->mFastPatchRecordBufferProvider = abp;
7039 state->mFastPatchRecordFormat = fastTrack == 0 ?
7040 AUDIO_FORMAT_INVALID : fastTrack->format();
7041 didModify = true;
7042 }
Glenn Kasten735f45f2014-08-18 15:51:59 -07007043 sq->end(didModify);
7044 if (didModify) {
7045 sq->push(block);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007046#if 0
7047 if (kUseFastCapture == FastCapture_Dynamic) {
7048 mNormalSource = mPipeSource;
7049 }
7050#endif
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007051 }
7052 }
7053
Glenn Kasten735f45f2014-08-18 15:51:59 -07007054 // now run the fast track destructor with thread mutex unlocked
7055 fastTrackToRemove.clear();
7056
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007057 // Read from HAL to keep up with fastest client if multiple active tracks, not slowest one.
7058 // Only the client(s) that are too slow will overrun. But if even the fastest client is too
7059 // slow, then this RecordThread will overrun by not calling HAL read often enough.
7060 // If destination is non-contiguous, first read past the nominal end of buffer, then
7061 // copy to the right place. Permitted because mRsmpInBuffer was over-allocated.
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007062
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007063 int32_t rear = mRsmpInRear & (mRsmpInFramesP2 - 1);
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007064 ssize_t framesRead;
Andy Hung446f4df2019-02-21 12:26:41 -08007065 const int64_t lastIoBeginNs = systemTime(); // start IO timing
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007066
7067 // If an NBAIO source is present, use it to read the normal capture's data
7068 if (mPipeSource != 0) {
Andy Hung156317a2018-08-02 11:49:29 -07007069 size_t framesToRead = min(mRsmpInFramesOA - rear, mRsmpInFramesP2 / 2);
Andy Hungd5b638f2018-04-30 13:56:10 -07007070
7071 // The audio fifo read() returns OVERRUN on overflow, and advances the read pointer
7072 // to the full buffer point (clearing the overflow condition). Upon OVERRUN error,
7073 // we immediately retry the read() to get data and prevent another overflow.
7074 for (int retries = 0; retries <= 2; ++retries) {
7075 ALOGW_IF(retries > 0, "overrun on read from pipe, retry #%d", retries);
7076 framesRead = mPipeSource->read((uint8_t*)mRsmpInBuffer + rear * mFrameSize,
7077 framesToRead);
7078 if (framesRead != OVERRUN) break;
7079 }
7080
Andy Hung7a3dc6b2018-05-01 16:39:51 -07007081 const ssize_t availableToRead = mPipeSource->availableToRead();
7082 if (availableToRead >= 0) {
7083 // PipeSource is the master clock. It is up to the AudioRecord client to keep up.
7084 LOG_ALWAYS_FATAL_IF((size_t)availableToRead > mPipeFramesP2,
7085 "more frames to read than fifo size, %zd > %zu",
7086 availableToRead, mPipeFramesP2);
7087 const size_t pipeFramesFree = mPipeFramesP2 - availableToRead;
7088 const size_t sleepFrames = min(pipeFramesFree, mRsmpInFramesP2) / 2;
7089 ALOGVV("mPipeFramesP2:%zu mRsmpInFramesP2:%zu sleepFrames:%zu availableToRead:%zd",
7090 mPipeFramesP2, mRsmpInFramesP2, sleepFrames, availableToRead);
Glenn Kasten1b291842016-07-18 14:55:21 -07007091 sleepUs = (sleepFrames * 1000000LL) / mSampleRate;
7092 }
7093 if (framesRead < 0) {
7094 status_t status = (status_t) framesRead;
7095 switch (status) {
7096 case OVERRUN:
7097 ALOGW("overrun on read from pipe");
7098 framesRead = 0;
7099 break;
7100 case NEGOTIATE:
7101 ALOGE("re-negotiation is needed");
7102 framesRead = -1; // Will cause an attempt to recover.
7103 break;
7104 default:
7105 ALOGE("unknown error %d on read from pipe", status);
7106 break;
7107 }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007108 }
7109 // otherwise use the HAL / AudioStreamIn directly
7110 } else {
Glenn Kastenec6a7032016-03-14 07:40:23 -07007111 ATRACE_BEGIN("read");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007112 size_t bytesRead;
7113 status_t result = mInput->stream->read(
7114 (uint8_t*)mRsmpInBuffer + rear * mFrameSize, mBufferSize, &bytesRead);
Glenn Kastenec6a7032016-03-14 07:40:23 -07007115 ATRACE_END();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007116 if (result < 0) {
7117 framesRead = result;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007118 } else {
7119 framesRead = bytesRead / mFrameSize;
7120 }
7121 }
7122
Andy Hung446f4df2019-02-21 12:26:41 -08007123 const int64_t lastIoEndNs = systemTime(); // end IO timing
7124
Andy Hung3f0c9022016-01-15 17:49:46 -08007125 // Update server timestamp with server stats
7126 // systemTime() is optional if the hardware supports timestamps.
7127 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += framesRead;
Andy Hung446f4df2019-02-21 12:26:41 -08007128 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = lastIoEndNs;
Andy Hung3f0c9022016-01-15 17:49:46 -08007129
7130 // Update server timestamp with kernel stats
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007131 if (mPipeSource.get() == nullptr /* don't obtain for FastCapture, could block */) {
Andy Hung3f0c9022016-01-15 17:49:46 -08007132 int64_t position, time;
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007133 if (mStandby) {
7134 mTimestampVerifier.discontinuity();
Andy Hungc8fddf32018-08-08 18:32:37 -07007135 } else if (mInput->stream->getCapturePosition(&position, &time) == NO_ERROR
7136 && time > mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]) {
7137
7138 mTimestampVerifier.add(position, time, mSampleRate);
7139
7140 // Correct timestamps
7141 if (isTimestampCorrectionEnabled()) {
7142 ALOGV("TS_BEFORE: %d %lld %lld",
7143 id(), (long long)time, (long long)position);
7144 auto correctedTimestamp = mTimestampVerifier.getLastCorrectedTimestamp();
7145 position = correctedTimestamp.mFrames;
7146 time = correctedTimestamp.mTimeNs;
7147 ALOGV("TS_AFTER: %d %lld %lld",
7148 id(), (long long)time, (long long)position);
7149 }
7150
Andy Hung3f0c9022016-01-15 17:49:46 -08007151 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = position;
7152 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = time;
7153 // Note: In general record buffers should tend to be empty in
7154 // a properly running pipeline.
7155 //
7156 // Also, it is not advantageous to call get_presentation_position during the read
7157 // as the read obtains a lock, preventing the timestamp call from executing.
Andy Hung2e2c0bb2018-06-11 19:13:11 -07007158 } else {
7159 mTimestampVerifier.error();
Andy Hung3f0c9022016-01-15 17:49:46 -08007160 }
7161 }
Andy Hunge6c37112019-02-26 17:38:10 -08007162
7163 // From the timestamp, input read latency is negative output write latency.
7164 const audio_input_flags_t flags = mInput != NULL ? mInput->flags : AUDIO_INPUT_FLAG_NONE;
7165 const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
7166 ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
7167 if (latencyMs != 0.) { // note 0. means timestamp is empty.
7168 mLatencyMs.add(latencyMs);
7169 }
7170
Andy Hung3f0c9022016-01-15 17:49:46 -08007171 // Use this to track timestamp information
7172 // ALOGD("%s", mTimestamp.toString().c_str());
7173
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007174 if (framesRead < 0 || (framesRead == 0 && mPipeSource == 0)) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007175 ALOGE("read failed: framesRead=%zd", framesRead);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007176 // Force input into standby so that it tries to recover at next read attempt
7177 inputStandBy();
7178 sleepUs = kRecordThreadSleepUs;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007179 }
7180 if (framesRead <= 0) {
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007181 goto unlock;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007182 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007183 ALOG_ASSERT(framesRead > 0);
Andy Hung6427e442018-08-09 12:51:02 -07007184 mFramesRead += framesRead;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007185
Andy Hung8946a282018-04-19 20:04:56 -07007186#ifdef TEE_SINK
7187 (void)mTee.write((uint8_t*)mRsmpInBuffer + rear * mFrameSize, framesRead);
7188#endif
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007189 // If destination is non-contiguous, we now correct for reading past end of buffer.
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007190 {
7191 size_t part1 = mRsmpInFramesP2 - rear;
7192 if ((size_t) framesRead > part1) {
Andy Hung57446612015-04-19 23:56:46 -07007193 memcpy(mRsmpInBuffer, (uint8_t*)mRsmpInBuffer + mRsmpInFramesP2 * mFrameSize,
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007194 (framesRead - part1) * mFrameSize);
7195 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007196 }
7197 rear = mRsmpInRear += framesRead;
7198
7199 size = activeTracks.size();
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007200
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007201 // loop over each active track
7202 for (size_t i = 0; i < size; i++) {
7203 activeTrack = activeTracks[i];
7204
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007205 // skip fast tracks, as those are handled directly by FastCapture
7206 if (activeTrack->isFastTrack()) {
7207 continue;
7208 }
7209
Andy Hung73c02e42015-03-29 01:13:58 -07007210 // TODO: This code probably should be moved to RecordTrack.
Andy Hung97a893e2015-03-29 01:03:07 -07007211 // TODO: Update the activeTrack buffer converter in case of reconfigure.
7212
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007213 enum {
7214 OVERRUN_UNKNOWN,
7215 OVERRUN_TRUE,
7216 OVERRUN_FALSE
7217 } overrun = OVERRUN_UNKNOWN;
7218
7219 // loop over getNextBuffer to handle circular sink
7220 for (;;) {
7221
7222 activeTrack->mSink.frameCount = ~0;
7223 status_t status = activeTrack->getNextBuffer(&activeTrack->mSink);
7224 size_t framesOut = activeTrack->mSink.frameCount;
7225 LOG_ALWAYS_FATAL_IF((status == OK) != (framesOut > 0));
7226
Andy Hung73c02e42015-03-29 01:13:58 -07007227 // check available frames and handle overrun conditions
7228 // if the record track isn't draining fast enough.
7229 bool hasOverrun;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007230 size_t framesIn;
Andy Hung73c02e42015-03-29 01:13:58 -07007231 activeTrack->mResamplerBufferProvider->sync(&framesIn, &hasOverrun);
7232 if (hasOverrun) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007233 overrun = OVERRUN_TRUE;
7234 }
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007235 if (framesOut == 0 || framesIn == 0) {
7236 break;
7237 }
7238
Andy Hung6770c6f2015-04-07 13:43:36 -07007239 // Don't allow framesOut to be larger than what is possible with resampling
7240 // from framesIn.
7241 // This isn't strictly necessary but helps limit buffer resizing in
7242 // RecordBufferConverter. TODO: remove when no longer needed.
7243 framesOut = min(framesOut,
7244 destinationFramesPossible(
7245 framesIn, mSampleRate, activeTrack->mSampleRate));
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007246
7247 if (activeTrack->isDirect()) {
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007248 // No RecordBufferConverter used for direct streams. Pass
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007249 // straight from RecordThread buffer to RecordTrack buffer.
7250 AudioBufferProvider::Buffer buffer;
7251 buffer.frameCount = framesOut;
7252 status_t status = activeTrack->mResamplerBufferProvider->getNextBuffer(&buffer);
7253 if (status == OK && buffer.frameCount != 0) {
7254 ALOGV_IF(buffer.frameCount != framesOut,
7255 "%s() read less than expected (%zu vs %zu)",
7256 __func__, buffer.frameCount, framesOut);
7257 framesOut = buffer.frameCount;
Daniel Van Veen9e2376e2018-09-27 14:37:58 +10007258 memcpy(activeTrack->mSink.raw, buffer.raw, buffer.frameCount * mFrameSize);
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007259 activeTrack->mResamplerBufferProvider->releaseBuffer(&buffer);
7260 } else {
7261 framesOut = 0;
7262 ALOGE("%s() cannot fill request, status: %d, frameCount: %zu",
7263 __func__, status, buffer.frameCount);
7264 }
7265 } else {
7266 // process frames from the RecordThread buffer provider to the RecordTrack
7267 // buffer
7268 framesOut = activeTrack->mRecordBufferConverter->convert(
7269 activeTrack->mSink.raw,
7270 activeTrack->mResamplerBufferProvider,
7271 framesOut);
7272 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007273
7274 if (framesOut > 0 && (overrun == OVERRUN_UNKNOWN)) {
7275 overrun = OVERRUN_FALSE;
7276 }
7277
7278 if (activeTrack->mFramesToDrop == 0) {
7279 if (framesOut > 0) {
7280 activeTrack->mSink.frameCount = framesOut;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007281 // Sanitize before releasing if the track has no access to the source data
7282 // An idle UID receives silence from non virtual devices until active
7283 if (activeTrack->isSilenced()) {
7284 memset(activeTrack->mSink.raw, 0, framesOut * mFrameSize);
7285 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007286 activeTrack->releaseBuffer(&activeTrack->mSink);
7287 }
7288 } else {
7289 // FIXME could do a partial drop of framesOut
7290 if (activeTrack->mFramesToDrop > 0) {
Mikhail Naganov6d91ba52019-03-26 14:35:28 -07007291 activeTrack->mFramesToDrop -= (ssize_t)framesOut;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007292 if (activeTrack->mFramesToDrop <= 0) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007293 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007294 }
7295 } else {
7296 activeTrack->mFramesToDrop += framesOut;
7297 if (activeTrack->mFramesToDrop >= 0 || activeTrack->mSyncStartEvent == 0 ||
7298 activeTrack->mSyncStartEvent->isCancelled()) {
7299 ALOGW("Synced record %s, session %d, trigger session %d",
7300 (activeTrack->mFramesToDrop >= 0) ? "timed out" : "cancelled",
7301 activeTrack->sessionId(),
7302 (activeTrack->mSyncStartEvent != 0) ?
Glenn Kastend848eb42016-03-08 13:42:11 -08007303 activeTrack->mSyncStartEvent->triggerSession() :
7304 AUDIO_SESSION_NONE);
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007305 activeTrack->clearSyncStartEvent();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007306 }
7307 }
7308 }
7309
7310 if (framesOut == 0) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007311 break;
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007312 }
7313 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007314
7315 switch (overrun) {
7316 case OVERRUN_TRUE:
7317 // client isn't retrieving buffers fast enough
7318 if (!activeTrack->setOverflow()) {
7319 nsecs_t now = systemTime();
7320 // FIXME should lastWarning per track?
7321 if ((now - lastWarning) > kWarningThrottleNs) {
7322 ALOGW("RecordThread: buffer overflow");
7323 lastWarning = now;
7324 }
7325 }
7326 break;
7327 case OVERRUN_FALSE:
7328 activeTrack->clearOverflow();
7329 break;
7330 case OVERRUN_UNKNOWN:
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007331 break;
7332 }
7333
Andy Hung3f0c9022016-01-15 17:49:46 -08007334 // update frame information and push timestamp out
7335 activeTrack->updateTrackFrameInfo(
Andy Hung6ae58432016-02-16 18:32:24 -08007336 activeTrack->mServerProxy->framesReleased(),
Andy Hung3f0c9022016-01-15 17:49:46 -08007337 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER],
7338 mSampleRate, mTimestamp);
Glenn Kasten1ba19cd2013-08-14 14:02:21 -07007339 }
7340
Glenn Kasten3d61bc12014-06-16 10:25:20 -07007341unlock:
Eric Laurent81784c32012-11-19 14:55:58 -08007342 // enable changes in effect chain
7343 unlockEffectChains(effectChains);
Glenn Kastenc527a7c2013-08-13 15:43:49 -07007344 // effectChains doesn't need to be cleared, since it is cleared by destructor at scope end
Eric Laurentcccbc762019-04-05 14:20:05 -07007345 if (audio_has_proportional_frames(mFormat)
7346 && loopCount == lastLoopCountRead + 1) {
7347 const int64_t readPeriodNs = lastIoEndNs - mLastIoEndNs;
7348 const double jitterMs =
7349 TimestampVerifier<int64_t, int64_t>::computeJitterMs(
7350 {framesRead, readPeriodNs},
7351 {0, 0} /* lastTimestamp */, mSampleRate);
7352 const double processMs = (lastIoBeginNs - mLastIoEndNs) * 1e-6;
7353
7354 Mutex::Autolock _l(mLock);
7355 mIoJitterMs.add(jitterMs);
7356 mProcessTimeMs.add(processMs);
7357 }
7358 // update timing info.
7359 mLastIoBeginNs = lastIoBeginNs;
7360 mLastIoEndNs = lastIoEndNs;
7361 lastLoopCountRead = loopCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007362 }
7363
Glenn Kasten93e471f2013-08-19 08:40:07 -07007364 standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08007365
7366 {
7367 Mutex::Autolock _l(mLock);
Eric Laurent9a54bc22013-09-09 09:08:44 -07007368 for (size_t i = 0; i < mTracks.size(); i++) {
7369 sp<RecordTrack> track = mTracks[i];
7370 track->invalidate();
7371 }
Glenn Kasten2b806402013-11-20 16:37:38 -08007372 mActiveTracks.clear();
Eric Laurent81784c32012-11-19 14:55:58 -08007373 mStartStopCond.broadcast();
7374 }
7375
7376 releaseWakeLock();
7377
7378 ALOGV("RecordThread %p exiting", this);
7379 return false;
7380}
7381
Glenn Kasten93e471f2013-08-19 08:40:07 -07007382void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
Eric Laurent81784c32012-11-19 14:55:58 -08007383{
7384 if (!mStandby) {
7385 inputStandBy();
7386 mStandby = true;
7387 }
7388}
7389
7390void AudioFlinger::RecordThread::inputStandBy()
7391{
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007392 // Idle the fast capture if it's currently running
7393 if (mFastCapture != 0) {
7394 FastCaptureStateQueue *sq = mFastCapture->sq();
7395 FastCaptureState *state = sq->begin();
7396 if (!(state->mCommand & FastCaptureState::IDLE)) {
7397 state->mCommand = FastCaptureState::COLD_IDLE;
7398 state->mColdFutexAddr = &mFastCaptureFutex;
7399 state->mColdGen++;
7400 mFastCaptureFutex = 0;
7401 sq->end();
7402 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
7403 sq->push(FastCaptureStateQueue::BLOCK_UNTIL_ACKED);
7404#if 0
7405 if (kUseFastCapture == FastCapture_Dynamic) {
7406 // FIXME
7407 }
7408#endif
7409#ifdef AUDIO_WATCHDOG
7410 // FIXME
7411#endif
7412 } else {
7413 sq->end(false /*didModify*/);
7414 }
7415 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07007416 status_t result = mInput->stream->standby();
7417 ALOGE_IF(result != OK, "Error when putting input stream into standby: %d", result);
Andy Hungad6d52d2016-07-18 13:42:03 -07007418
7419 // If going into standby, flush the pipe source.
7420 if (mPipeSource.get() != nullptr) {
7421 const ssize_t flushed = mPipeSource->flush();
7422 if (flushed > 0) {
7423 ALOGV("Input standby flushed PipeSource %zd frames", flushed);
7424 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] += flushed;
7425 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = systemTime();
7426 }
7427 }
Eric Laurent81784c32012-11-19 14:55:58 -08007428}
7429
Glenn Kasten05997e22014-03-13 15:08:33 -07007430// RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
Glenn Kastene198c362013-08-13 09:13:36 -07007431sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
Eric Laurent81784c32012-11-19 14:55:58 -08007432 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007433 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007434 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08007435 audio_format_t format,
7436 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08007437 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08007438 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08007439 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07007440 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -08007441 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07007442 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08007443 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08007444 status_t *status,
7445 audio_port_handle_t portId)
Eric Laurent81784c32012-11-19 14:55:58 -08007446{
Glenn Kasten74935e42013-12-19 08:56:45 -08007447 size_t frameCount = *pFrameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007448 size_t notificationFrameCount = *pNotificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007449 sp<RecordTrack> track;
7450 status_t lStatus;
Eric Laurent05067782016-06-01 18:27:28 -07007451 audio_input_flags_t inputFlags = mInput->flags;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007452 audio_input_flags_t requestedFlags = *flags;
7453 uint32_t sampleRate;
7454
7455 lStatus = initCheck();
7456 if (lStatus != NO_ERROR) {
7457 ALOGE("createRecordTrack_l() audio driver not initialized");
7458 goto Exit;
7459 }
7460
Mikhail Naganovce9f2652018-07-16 11:09:24 -07007461 if (!audio_is_linear_pcm(mFormat) && (*flags & AUDIO_INPUT_FLAG_DIRECT) == 0) {
7462 ALOGE("createRecordTrack_l() on an encoded stream requires AUDIO_INPUT_FLAG_DIRECT");
7463 lStatus = BAD_VALUE;
7464 goto Exit;
7465 }
7466
Eric Laurentf14db3c2017-12-08 14:20:36 -08007467 if (*pSampleRate == 0) {
7468 *pSampleRate = mSampleRate;
7469 }
7470 sampleRate = *pSampleRate;
Eric Laurent05067782016-06-01 18:27:28 -07007471
7472 // special case for FAST flag considered OK if fast capture is present
7473 if (hasFastCapture()) {
7474 inputFlags = (audio_input_flags_t)(inputFlags | AUDIO_INPUT_FLAG_FAST);
7475 }
7476
Eric Laurentf14db3c2017-12-08 14:20:36 -08007477 // Check if requested flags are compatible with input stream flags
Eric Laurent05067782016-06-01 18:27:28 -07007478 if ((*flags & inputFlags) != *flags) {
7479 ALOGW("createRecordTrack_l(): mismatch between requested flags (%08x) and"
7480 " input flags (%08x)",
7481 *flags, inputFlags);
7482 *flags = (audio_input_flags_t)(*flags & inputFlags);
7483 }
Eric Laurent81784c32012-11-19 14:55:58 -08007484
Glenn Kasten90e58b12013-07-31 16:16:02 -07007485 // client expresses a preference for FAST, but we get the final say
Eric Laurent05067782016-06-01 18:27:28 -07007486 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07007487 if (
Glenn Kastenb7fbf7e2015-03-18 12:57:28 -07007488 // we formerly checked for a callback handler (non-0 tid),
7489 // but that is no longer required for TRANSFER_OBTAIN mode
7490 //
Phil Burk7ed66a12019-04-18 13:20:30 -07007491 // Frame count is not specified (0), or is less than or equal the pipe depth.
7492 // It is OK to provide a higher capacity than requested.
7493 // We will force it to mPipeFramesP2 below.
7494 (frameCount <= mPipeFramesP2) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007495 // PCM data
7496 audio_is_linear_pcm(format) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007497 // hardware format
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007498 (format == mFormat) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007499 // hardware channel mask
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007500 (channelMask == mChannelMask) &&
Glenn Kasten7fd04222016-02-02 12:38:16 -08007501 // hardware sample rate
Glenn Kasten90e58b12013-07-31 16:16:02 -07007502 (sampleRate == mSampleRate) &&
Glenn Kasten3a6c90a2014-03-13 15:07:51 -07007503 // record thread has an associated fast capture
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007504 hasFastCapture() &&
7505 // there are sufficient fast track slots available
7506 mFastTrackAvail
Glenn Kasten90e58b12013-07-31 16:16:02 -07007507 ) {
Eric Laurent4c415062016-06-17 16:14:16 -07007508 // check compatibility with audio effects.
7509 Mutex::Autolock _l(mLock);
7510 // Do not accept FAST flag if the session has software effects
7511 sp<EffectChain> chain = getEffectChain_l(sessionId);
7512 if (chain != 0) {
Andy Hungd3bb0ad2016-10-11 17:16:43 -07007513 audio_input_flags_t old = *flags;
7514 chain->checkInputFlagCompatibility(flags);
7515 if (old != *flags) {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007516 ALOGV("%p AUDIO_INPUT_FLAGS denied by effect old=%#x new=%#x",
7517 this, (int)old, (int)*flags);
Eric Laurent4c415062016-06-17 16:14:16 -07007518 }
7519 }
Eric Laurent122f7e72016-06-29 11:53:29 -07007520 ALOGV_IF((*flags & AUDIO_INPUT_FLAG_FAST) != 0,
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007521 "%p AUDIO_INPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
7522 this, frameCount, mFrameCount);
Glenn Kasten90e58b12013-07-31 16:16:02 -07007523 } else {
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007524 ALOGV("%p AUDIO_INPUT_FLAG_FAST denied: frameCount=%zu mFrameCount=%zu mPipeFramesP2=%zu "
7525 "format=%#x isLinear=%d mFormat=%#x channelMask=%#x sampleRate=%u mSampleRate=%u "
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007526 "hasFastCapture=%d tid=%d mFastTrackAvail=%d",
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07007527 this, frameCount, mFrameCount, mPipeFramesP2,
7528 format, audio_is_linear_pcm(format), mFormat, channelMask, sampleRate, mSampleRate,
Glenn Kasten74105912014-07-03 12:28:53 -07007529 hasFastCapture(), tid, mFastTrackAvail);
Eric Laurent05067782016-06-01 18:27:28 -07007530 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
Glenn Kasten74105912014-07-03 12:28:53 -07007531 }
7532 }
7533
Eric Laurentf14db3c2017-12-08 14:20:36 -08007534 // If FAST or RAW flags were corrected, ask caller to request new input from audio policy
7535 if ((*flags & AUDIO_INPUT_FLAG_FAST) !=
7536 (requestedFlags & AUDIO_INPUT_FLAG_FAST)) {
7537 *flags = (audio_input_flags_t) (*flags & ~(AUDIO_INPUT_FLAG_FAST | AUDIO_INPUT_FLAG_RAW));
7538 lStatus = BAD_TYPE;
7539 goto Exit;
7540 }
7541
Glenn Kasten74105912014-07-03 12:28:53 -07007542 // compute track buffer size in frames, and suggest the notification frame count
Eric Laurent05067782016-06-01 18:27:28 -07007543 if (*flags & AUDIO_INPUT_FLAG_FAST) {
Glenn Kasten74105912014-07-03 12:28:53 -07007544 // fast track: frame count is exactly the pipe depth
7545 frameCount = mPipeFramesP2;
7546 // ignore requested notificationFrames, and always notify exactly once every HAL buffer
Eric Laurentf14db3c2017-12-08 14:20:36 -08007547 notificationFrameCount = mFrameCount;
Glenn Kasten74105912014-07-03 12:28:53 -07007548 } else {
Glenn Kasten49d00ad2014-07-21 11:22:03 -07007549 // not fast track: max notification period is resampled equivalent of one HAL buffer time
7550 // or 20 ms if there is a fast capture
7551 // TODO This could be a roundupRatio inline, and const
7552 size_t maxNotificationFrames = ((int64_t) (hasFastCapture() ? mSampleRate/50 : mFrameCount)
7553 * sampleRate + mSampleRate - 1) / mSampleRate;
7554 // minimum number of notification periods is at least kMinNotifications,
7555 // and at least kMinMs rounded up to a whole notification period (minNotificationsByMs)
7556 static const size_t kMinNotifications = 3;
7557 static const uint32_t kMinMs = 30;
7558 // TODO This could be a roundupRatio inline
7559 const size_t minFramesByMs = (sampleRate * kMinMs + 1000 - 1) / 1000;
7560 // TODO This could be a roundupRatio inline
7561 const size_t minNotificationsByMs = (minFramesByMs + maxNotificationFrames - 1) /
7562 maxNotificationFrames;
7563 const size_t minFrameCount = maxNotificationFrames *
7564 max(kMinNotifications, minNotificationsByMs);
7565 frameCount = max(frameCount, minFrameCount);
Eric Laurentf14db3c2017-12-08 14:20:36 -08007566 if (notificationFrameCount == 0 || notificationFrameCount > maxNotificationFrames) {
7567 notificationFrameCount = maxNotificationFrames;
Glenn Kasten74105912014-07-03 12:28:53 -07007568 }
Glenn Kasten90e58b12013-07-31 16:16:02 -07007569 }
Glenn Kasten74935e42013-12-19 08:56:45 -08007570 *pFrameCount = frameCount;
Eric Laurentf14db3c2017-12-08 14:20:36 -08007571 *pNotificationFrameCount = notificationFrameCount;
Eric Laurent81784c32012-11-19 14:55:58 -08007572
7573 { // scope for mLock
7574 Mutex::Autolock _l(mLock);
7575
Kevin Rocard1f564ac2018-03-29 13:53:10 -07007576 track = new RecordTrack(this, client, attr, sampleRate,
Andy Hung8fe68032017-06-05 16:17:51 -07007577 format, channelMask, frameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07007578 nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08007579 *flags, TrackBase::TYPE_DEFAULT, portId);
Eric Laurent81784c32012-11-19 14:55:58 -08007580
Glenn Kasten03003332013-08-06 15:40:54 -07007581 lStatus = track->initCheck();
7582 if (lStatus != NO_ERROR) {
Glenn Kasten35295072013-10-07 09:27:06 -07007583 ALOGE("createRecordTrack_l() initCheck failed %d; no control block?", lStatus);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08007584 // track must be cleared from the caller as the caller has the AF lock
Eric Laurent81784c32012-11-19 14:55:58 -08007585 goto Exit;
7586 }
7587 mTracks.add(track);
7588
Eric Laurent05067782016-06-01 18:27:28 -07007589 if ((*flags & AUDIO_INPUT_FLAG_FAST) && (tid != -1)) {
Glenn Kasten90e58b12013-07-31 16:16:02 -07007590 pid_t callingPid = IPCThreadState::self()->getCallingPid();
7591 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
7592 // so ask activity manager to do this on our behalf
Glenn Kastenaf9a7b52017-03-29 11:29:39 -07007593 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp, true /*forApp*/);
Glenn Kasten90e58b12013-07-31 16:16:02 -07007594 }
Eric Laurent81784c32012-11-19 14:55:58 -08007595 }
Glenn Kasten05997e22014-03-13 15:08:33 -07007596
Eric Laurent81784c32012-11-19 14:55:58 -08007597 lStatus = NO_ERROR;
7598
7599Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07007600 *status = lStatus;
Eric Laurent81784c32012-11-19 14:55:58 -08007601 return track;
7602}
7603
7604status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
7605 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08007606 audio_session_t triggerSession)
Eric Laurent81784c32012-11-19 14:55:58 -08007607{
7608 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
7609 sp<ThreadBase> strongMe = this;
7610 status_t status = NO_ERROR;
7611
7612 if (event == AudioSystem::SYNC_EVENT_NONE) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007613 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08007614 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007615 recordTrack->mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
Eric Laurent81784c32012-11-19 14:55:58 -08007616 triggerSession,
7617 recordTrack->sessionId(),
7618 syncStartEventCallback,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007619 recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08007620 // Sync event can be cancelled by the trigger session if the track is not in a
7621 // compatible state in which case we start record immediately
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007622 if (recordTrack->mSyncStartEvent->isCancelled()) {
Glenn Kasten25f4aa82014-02-07 10:50:43 -08007623 recordTrack->clearSyncStartEvent();
Eric Laurent81784c32012-11-19 14:55:58 -08007624 } else {
7625 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
Ivan Lozano1b35dd62017-12-06 16:55:10 -08007626 recordTrack->mFramesToDrop = -(ssize_t)
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007627 ((AudioSystem::kSyncRecordStartTimeOutMs * recordTrack->mSampleRate) / 1000);
Eric Laurent81784c32012-11-19 14:55:58 -08007628 }
7629 }
7630
7631 {
Glenn Kasten47c20702013-08-13 15:37:35 -07007632 // This section is a rendezvous between binder thread executing start() and RecordThread
Eric Laurent81784c32012-11-19 14:55:58 -08007633 AutoMutex lock(mLock);
Andy Hungce685402018-10-05 17:23:27 -07007634 if (recordTrack->isInvalid()) {
7635 recordTrack->clearSyncStartEvent();
7636 return INVALID_OPERATION;
7637 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007638 if (mActiveTracks.indexOf(recordTrack) >= 0) {
7639 if (recordTrack->mState == TrackBase::PAUSING) {
Andy Hungce685402018-10-05 17:23:27 -07007640 // We haven't stopped yet (moved to PAUSED and not in mActiveTracks)
7641 // so no need to startInput().
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007642 ALOGV("active record track PAUSING -> ACTIVE");
Glenn Kastenf10ffec2013-11-20 16:40:08 -08007643 recordTrack->mState = TrackBase::ACTIVE;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007644 } else {
7645 ALOGV("active record track state %d", recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08007646 }
7647 return status;
7648 }
7649
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08007650 // TODO consider other ways of handling this, such as changing the state to :STARTING and
7651 // adding the track to mActiveTracks after returning from AudioSystem::startInput(),
7652 // or using a separate command thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007653 recordTrack->mState = TrackBase::STARTING_1;
Glenn Kasten2b806402013-11-20 16:37:38 -08007654 mActiveTracks.add(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07007655 status_t status = NO_ERROR;
7656 if (recordTrack->isExternalTrack()) {
7657 mLock.unlock();
Eric Laurent4eb58f12018-12-07 16:41:02 -08007658 status = AudioSystem::startInput(recordTrack->portId());
Eric Laurent83b88082014-06-20 18:31:16 -07007659 mLock.lock();
Andy Hungce685402018-10-05 17:23:27 -07007660 if (recordTrack->isInvalid()) {
7661 recordTrack->clearSyncStartEvent();
7662 if (status == NO_ERROR && recordTrack->mState == TrackBase::STARTING_1) {
7663 recordTrack->mState = TrackBase::STARTING_2;
7664 // STARTING_2 forces destroy to call stopInput.
7665 }
7666 return INVALID_OPERATION;
7667 }
7668 if (recordTrack->mState != TrackBase::STARTING_1) {
7669 ALOGW("%s(%d): unsynchronized mState:%d change",
7670 __func__, recordTrack->id(), recordTrack->mState);
7671 // Someone else has changed state, let them take over,
7672 // leave mState in the new state.
7673 recordTrack->clearSyncStartEvent();
7674 return INVALID_OPERATION;
7675 }
7676 // we're ok, but perhaps startInput has failed
Eric Laurent83b88082014-06-20 18:31:16 -07007677 if (status != NO_ERROR) {
Andy Hungce685402018-10-05 17:23:27 -07007678 ALOGW("%s(%d): startInput failed, status %d",
7679 __func__, recordTrack->id(), status);
7680 // We are in ActiveTracks if STARTING_1 and valid, so remove from ActiveTracks,
7681 // leave in STARTING_1, so destroy() will not call stopInput.
Eric Laurent83b88082014-06-20 18:31:16 -07007682 mActiveTracks.remove(recordTrack);
Eric Laurent83b88082014-06-20 18:31:16 -07007683 recordTrack->clearSyncStartEvent();
Eric Laurent83b88082014-06-20 18:31:16 -07007684 return status;
7685 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07007686 sendIoConfigEvent_l(
7687 AUDIO_CLIENT_STARTED, recordTrack->creatorPid(), recordTrack->portId());
Eric Laurent81784c32012-11-19 14:55:58 -08007688 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007689 // Catch up with current buffer indices if thread is already running.
7690 // This is what makes a new client discard all buffered data. If the track's mRsmpInFront
7691 // was initialized to some value closer to the thread's mRsmpInFront, then the track could
7692 // see previously buffered data before it called start(), but with greater risk of overrun.
7693
Andy Hung73c02e42015-03-29 01:13:58 -07007694 recordTrack->mResamplerBufferProvider->reset();
Mikhail Naganov7c6ae982018-06-14 12:33:38 -07007695 if (!recordTrack->isDirect()) {
7696 // clear any converter state as new data will be discontinuous
7697 recordTrack->mRecordBufferConverter->reset();
7698 }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007699 recordTrack->mState = TrackBase::STARTING_2;
Eric Laurent81784c32012-11-19 14:55:58 -08007700 // signal thread to start
Eric Laurent81784c32012-11-19 14:55:58 -08007701 mWaitWorkCV.broadcast();
Eric Laurent81784c32012-11-19 14:55:58 -08007702 return status;
7703 }
Eric Laurent81784c32012-11-19 14:55:58 -08007704}
7705
Eric Laurent81784c32012-11-19 14:55:58 -08007706void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
7707{
7708 sp<SyncEvent> strongEvent = event.promote();
7709
7710 if (strongEvent != 0) {
Eric Laurent8ea16e42014-02-20 16:26:11 -08007711 sp<RefBase> ptr = strongEvent->cookie().promote();
7712 if (ptr != 0) {
7713 RecordTrack *recordTrack = (RecordTrack *)ptr.get();
7714 recordTrack->handleSyncStartEvent(strongEvent);
7715 }
Eric Laurent81784c32012-11-19 14:55:58 -08007716 }
7717}
7718
Glenn Kastena8356f62013-07-25 14:37:52 -07007719bool AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
Eric Laurent81784c32012-11-19 14:55:58 -08007720 ALOGV("RecordThread::stop");
Glenn Kastena8356f62013-07-25 14:37:52 -07007721 AutoMutex _l(mLock);
Andy Hungce685402018-10-05 17:23:27 -07007722 // if we're invalid, we can't be on the ActiveTracks.
Jean-Michel Trivi38f86712017-04-11 14:10:17 -07007723 if (mActiveTracks.indexOf(recordTrack) < 0 || recordTrack->mState == TrackBase::PAUSING) {
Eric Laurent81784c32012-11-19 14:55:58 -08007724 return false;
7725 }
Glenn Kasten47c20702013-08-13 15:37:35 -07007726 // note that threadLoop may still be processing the track at this point [without lock]
Eric Laurent81784c32012-11-19 14:55:58 -08007727 recordTrack->mState = TrackBase::PAUSING;
Andy Hungce685402018-10-05 17:23:27 -07007728
Andy Hungabfab202019-03-07 19:45:54 -08007729 // NOTE: Waiting here is important to keep stop synchronous.
7730 // This is needed for proper patchRecord peer release.
Andy Hungce685402018-10-05 17:23:27 -07007731 while (recordTrack->mState == TrackBase::PAUSING && !recordTrack->isInvalid()) {
7732 mWaitWorkCV.broadcast(); // signal thread to stop
7733 mStartStopCond.wait(mLock);
Eric Laurent81784c32012-11-19 14:55:58 -08007734 }
Andy Hungce685402018-10-05 17:23:27 -07007735
7736 if (recordTrack->mState == TrackBase::PAUSED) { // successful stop
Eric Laurent81784c32012-11-19 14:55:58 -08007737 ALOGV("Record stopped OK");
7738 return true;
7739 }
Andy Hungce685402018-10-05 17:23:27 -07007740
7741 // don't handle anything - we've been invalidated or restarted and in a different state
7742 ALOGW_IF("%s(%d): unsynchronized stop, state: %d",
7743 __func__, recordTrack->id(), recordTrack->mState);
Eric Laurent81784c32012-11-19 14:55:58 -08007744 return false;
7745}
7746
Glenn Kasten0f11b512014-01-31 16:18:54 -08007747bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08007748{
7749 return false;
7750}
7751
Glenn Kasten0f11b512014-01-31 16:18:54 -08007752status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08007753{
7754#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
7755 if (!isValidSyncEvent(event)) {
7756 return BAD_VALUE;
7757 }
7758
Glenn Kastend848eb42016-03-08 13:42:11 -08007759 audio_session_t eventSession = event->triggerSession();
Eric Laurent81784c32012-11-19 14:55:58 -08007760 status_t ret = NAME_NOT_FOUND;
7761
7762 Mutex::Autolock _l(mLock);
7763
7764 for (size_t i = 0; i < mTracks.size(); i++) {
7765 sp<RecordTrack> track = mTracks[i];
7766 if (eventSession == track->sessionId()) {
7767 (void) track->setSyncEvent(event);
7768 ret = NO_ERROR;
7769 }
7770 }
7771 return ret;
7772#else
7773 return BAD_VALUE;
7774#endif
7775}
7776
jiabin653cc0a2018-01-17 17:54:10 -08007777status_t AudioFlinger::RecordThread::getActiveMicrophones(
7778 std::vector<media::MicrophoneInfo>* activeMicrophones)
7779{
7780 ALOGV("RecordThread::getActiveMicrophones");
7781 AutoMutex _l(mLock);
jiabin9ff780e2018-03-19 18:19:52 -07007782 status_t status = mInput->stream->getActiveMicrophones(activeMicrophones);
7783 return status;
jiabin653cc0a2018-01-17 17:54:10 -08007784}
7785
Paul McLean12340082019-03-19 09:35:05 -06007786status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
7787 audio_microphone_direction_t direction)
Paul McLean03a6e6a2018-12-04 10:54:13 -07007788{
Paul McLean12340082019-03-19 09:35:05 -06007789 ALOGV("setPreferredMicrophoneDirection(%d)", direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07007790 AutoMutex _l(mLock);
Paul McLean12340082019-03-19 09:35:05 -06007791 return mInput->stream->setPreferredMicrophoneDirection(direction);
Paul McLean03a6e6a2018-12-04 10:54:13 -07007792}
7793
Paul McLean12340082019-03-19 09:35:05 -06007794status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
Paul McLean03a6e6a2018-12-04 10:54:13 -07007795{
Paul McLean12340082019-03-19 09:35:05 -06007796 ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07007797 AutoMutex _l(mLock);
Paul McLean12340082019-03-19 09:35:05 -06007798 return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07007799}
7800
Kevin Rocard069c2712018-03-29 19:09:14 -07007801void AudioFlinger::RecordThread::updateMetadata_l()
7802{
7803 if (mInput == nullptr || mInput->stream == nullptr ||
7804 !mActiveTracks.readAndClearHasChanged()) {
7805 return;
7806 }
7807 StreamInHalInterface::SinkMetadata metadata;
7808 for (const sp<RecordTrack> &track : mActiveTracks) {
7809 // No track is invalid as this is called after prepareTrack_l in the same critical section
7810 metadata.tracks.push_back({
7811 .source = track->attributes().source,
7812 .gain = 1, // capture tracks do not have volumes
7813 });
7814 }
7815 mInput->stream->updateSinkMetadata(metadata);
7816}
7817
Eric Laurent81784c32012-11-19 14:55:58 -08007818// destroyTrack_l() must be called with ThreadBase::mLock held
7819void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
7820{
Eric Laurentbfb1b832013-01-07 09:53:42 -08007821 track->terminate();
7822 track->mState = TrackBase::STOPPED;
Eric Laurent81784c32012-11-19 14:55:58 -08007823 // active tracks are removed by threadLoop()
Glenn Kasten2b806402013-11-20 16:37:38 -08007824 if (mActiveTracks.indexOf(track) < 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08007825 removeTrack_l(track);
7826 }
7827}
7828
7829void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
7830{
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007831 String8 result;
7832 track->appendDump(result, false /* active */);
7833 mLocalLog.log("removeTrack_l (%p) %s", track.get(), result.string());
7834
Eric Laurent81784c32012-11-19 14:55:58 -08007835 mTracks.remove(track);
7836 // need anything related to effects here?
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007837 if (track->isFastTrack()) {
7838 ALOG_ASSERT(!mFastTrackAvail);
7839 mFastTrackAvail = true;
7840 }
Eric Laurent81784c32012-11-19 14:55:58 -08007841}
7842
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07007843void AudioFlinger::RecordThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08007844{
Mikhail Naganov913d06c2016-11-01 12:49:22 -07007845 AudioStreamIn *input = mInput;
7846 audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
7847 dprintf(fd, " AudioStreamIn: %p flags %#x (%s)\n",
Andy Hung9b181952019-02-25 14:53:36 -08007848 input, flags, toString(flags).c_str());
Andy Hung6427e442018-08-09 12:51:02 -07007849 dprintf(fd, " Frames read: %lld\n", (long long)mFramesRead);
Eric Tan39ec8d62018-07-24 09:49:29 -07007850 if (mActiveTracks.isEmpty()) {
Elliott Hughes87cebad2014-05-22 10:14:43 -07007851 dprintf(fd, " No active record clients\n");
Eric Laurent81784c32012-11-19 14:55:58 -08007852 }
Andy Hungbfa64962017-06-12 14:43:19 -07007853
7854 if (input != nullptr) {
7855 dprintf(fd, " Hal stream dump:\n");
7856 (void)input->stream->dump(fd);
7857 }
7858
Glenn Kasten6e6704c2014-07-03 10:20:00 -07007859 dprintf(fd, " Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07007860 dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
Glenn Kasten17c9c992015-03-02 15:53:01 -08007861
Glenn Kasten2f90c512015-12-02 11:40:09 -08007862 // Make a non-atomic copy of fast capture dump state so it won't change underneath us
7863 // while we are dumping it. It may be inconsistent, but it won't mutate!
7864 // This is a large object so we place it on the heap.
7865 // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
Eric Tan2942a4e2018-09-12 17:41:27 -07007866 const std::unique_ptr<FastCaptureDumpState> copy =
7867 std::make_unique<FastCaptureDumpState>(mFastCaptureDumpState);
Glenn Kasten2f90c512015-12-02 11:40:09 -08007868 copy->dump(fd);
Eric Laurent81784c32012-11-19 14:55:58 -08007869}
7870
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07007871void AudioFlinger::RecordThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent81784c32012-11-19 14:55:58 -08007872{
Eric Laurent81784c32012-11-19 14:55:58 -08007873 String8 result;
Marco Nelissenb2208842014-02-07 14:00:50 -08007874 size_t numtracks = mTracks.size();
7875 size_t numactive = mActiveTracks.size();
7876 size_t numactiveseen = 0;
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007877 dprintf(fd, " %zu Tracks", numtracks);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007878 const char *prefix = " ";
Marco Nelissenb2208842014-02-07 14:00:50 -08007879 if (numtracks) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07007880 dprintf(fd, " of which %zu are active\n", numactive);
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007881 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07007882 mTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08007883 for (size_t i = 0; i < numtracks ; ++i) {
7884 sp<RecordTrack> track = mTracks[i];
7885 if (track != 0) {
7886 bool active = mActiveTracks.indexOf(track) >= 0;
7887 if (active) {
7888 numactiveseen++;
7889 }
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007890 result.append(prefix);
7891 track->appendDump(result, active);
Marco Nelissenb2208842014-02-07 14:00:50 -08007892 }
Eric Laurent81784c32012-11-19 14:55:58 -08007893 }
Marco Nelissenb2208842014-02-07 14:00:50 -08007894 } else {
Elliott Hughes87cebad2014-05-22 10:14:43 -07007895 dprintf(fd, "\n");
Eric Laurent81784c32012-11-19 14:55:58 -08007896 }
7897
Marco Nelissenb2208842014-02-07 14:00:50 -08007898 if (numactiveseen != numactive) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007899 result.append(" The following tracks are in the active list but"
Marco Nelissenb2208842014-02-07 14:00:50 -08007900 " not in the track list\n");
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007901 result.append(prefix);
Andy Hung000adb52018-06-01 15:43:26 -07007902 mActiveTracks[0]->appendDumpHeader(result);
Marco Nelissenb2208842014-02-07 14:00:50 -08007903 for (size_t i = 0; i < numactive; ++i) {
Glenn Kasten2b806402013-11-20 16:37:38 -08007904 sp<RecordTrack> track = mActiveTracks[i];
Marco Nelissenb2208842014-02-07 14:00:50 -08007905 if (mTracks.indexOf(track) < 0) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07007906 result.append(prefix);
7907 track->appendDump(result, true /* active */);
Marco Nelissenb2208842014-02-07 14:00:50 -08007908 }
Glenn Kasten2b806402013-11-20 16:37:38 -08007909 }
Eric Laurent81784c32012-11-19 14:55:58 -08007910
7911 }
7912 write(fd, result.string(), result.size());
7913}
7914
Svet Ganovf4ddfef2018-01-16 07:37:58 -08007915void AudioFlinger::RecordThread::setRecordSilenced(uid_t uid, bool silenced)
7916{
7917 Mutex::Autolock _l(mLock);
7918 for (size_t i = 0; i < mTracks.size() ; i++) {
7919 sp<RecordTrack> track = mTracks[i];
7920 if (track != 0 && track->uid() == uid) {
7921 track->setSilenced(silenced);
7922 }
7923 }
7924}
Andy Hung73c02e42015-03-29 01:13:58 -07007925
7926void AudioFlinger::RecordThread::ResamplerBufferProvider::reset()
7927{
7928 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
7929 RecordThread *recordThread = (RecordThread *) threadBase.get();
7930 mRsmpInFront = recordThread->mRsmpInRear;
7931 mRsmpInUnrel = 0;
7932}
7933
7934void AudioFlinger::RecordThread::ResamplerBufferProvider::sync(
7935 size_t *framesAvailable, bool *hasOverrun)
7936{
7937 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
7938 RecordThread *recordThread = (RecordThread *) threadBase.get();
7939 const int32_t rear = recordThread->mRsmpInRear;
7940 const int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07007941 const ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Andy Hung73c02e42015-03-29 01:13:58 -07007942
7943 size_t framesIn;
7944 bool overrun = false;
7945 if (filled < 0) {
7946 // should not happen, but treat like a massive overrun and re-sync
7947 framesIn = 0;
7948 mRsmpInFront = rear;
7949 overrun = true;
7950 } else if ((size_t) filled <= recordThread->mRsmpInFrames) {
7951 framesIn = (size_t) filled;
7952 } else {
7953 // client is not keeping up with server, but give it latest data
7954 framesIn = recordThread->mRsmpInFrames;
Hongwei Wang95e37682019-04-12 11:13:36 -07007955 mRsmpInFront = /* front = */ audio_utils::safe_sub_overflow(
7956 rear, static_cast<int32_t>(framesIn));
Andy Hung73c02e42015-03-29 01:13:58 -07007957 overrun = true;
7958 }
7959 if (framesAvailable != NULL) {
7960 *framesAvailable = framesIn;
7961 }
7962 if (hasOverrun != NULL) {
7963 *hasOverrun = overrun;
7964 }
7965}
7966
Eric Laurent81784c32012-11-19 14:55:58 -08007967// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007968status_t AudioFlinger::RecordThread::ResamplerBufferProvider::getNextBuffer(
Glenn Kastend79072e2016-01-06 08:41:20 -08007969 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08007970{
Andy Hung73c02e42015-03-29 01:13:58 -07007971 sp<ThreadBase> threadBase = mRecordTrack->mThread.promote();
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007972 if (threadBase == 0) {
7973 buffer->frameCount = 0;
Glenn Kasten607fa3e2014-02-21 14:24:58 -08007974 buffer->raw = NULL;
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007975 return NOT_ENOUGH_DATA;
7976 }
7977 RecordThread *recordThread = (RecordThread *) threadBase.get();
7978 int32_t rear = recordThread->mRsmpInRear;
Andy Hung73c02e42015-03-29 01:13:58 -07007979 int32_t front = mRsmpInFront;
Hongwei Wang95e37682019-04-12 11:13:36 -07007980 ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007981 // FIXME should not be P2 (don't want to increase latency)
7982 // FIXME if client not keeping up, discard
Glenn Kasten607fa3e2014-02-21 14:24:58 -08007983 LOG_ALWAYS_FATAL_IF(!(0 <= filled && (size_t) filled <= recordThread->mRsmpInFrames));
Glenn Kasten85948432013-08-19 12:09:05 -07007984 // 'filled' may be non-contiguous, so return only the first contiguous chunk
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08007985 front &= recordThread->mRsmpInFramesP2 - 1;
7986 size_t part1 = recordThread->mRsmpInFramesP2 - front;
Glenn Kasten85948432013-08-19 12:09:05 -07007987 if (part1 > (size_t) filled) {
7988 part1 = filled;
7989 }
7990 size_t ask = buffer->frameCount;
7991 ALOG_ASSERT(ask > 0);
7992 if (part1 > ask) {
7993 part1 = ask;
7994 }
7995 if (part1 == 0) {
Andy Hung73c02e42015-03-29 01:13:58 -07007996 // out of data is fine since the resampler will return a short-count.
Glenn Kasten85948432013-08-19 12:09:05 -07007997 buffer->raw = NULL;
7998 buffer->frameCount = 0;
Andy Hung73c02e42015-03-29 01:13:58 -07007999 mRsmpInUnrel = 0;
Glenn Kasten85948432013-08-19 12:09:05 -07008000 return NOT_ENOUGH_DATA;
Eric Laurent81784c32012-11-19 14:55:58 -08008001 }
8002
Andy Hung57446612015-04-19 23:56:46 -07008003 buffer->raw = (uint8_t*)recordThread->mRsmpInBuffer + front * recordThread->mFrameSize;
Glenn Kasten85948432013-08-19 12:09:05 -07008004 buffer->frameCount = part1;
Andy Hung73c02e42015-03-29 01:13:58 -07008005 mRsmpInUnrel = part1;
Eric Laurent81784c32012-11-19 14:55:58 -08008006 return NO_ERROR;
8007}
8008
8009// AudioBufferProvider interface
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008010void AudioFlinger::RecordThread::ResamplerBufferProvider::releaseBuffer(
8011 AudioBufferProvider::Buffer* buffer)
Eric Laurent81784c32012-11-19 14:55:58 -08008012{
Hongwei Wang95e37682019-04-12 11:13:36 -07008013 int32_t stepCount = static_cast<int32_t>(buffer->frameCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008014 if (stepCount == 0) {
8015 return;
8016 }
Andy Hung73c02e42015-03-29 01:13:58 -07008017 ALOG_ASSERT(stepCount <= mRsmpInUnrel);
8018 mRsmpInUnrel -= stepCount;
Hongwei Wang95e37682019-04-12 11:13:36 -07008019 mRsmpInFront = audio_utils::safe_add_overflow(mRsmpInFront, stepCount);
Glenn Kasten85948432013-08-19 12:09:05 -07008020 buffer->raw = NULL;
Eric Laurent81784c32012-11-19 14:55:58 -08008021 buffer->frameCount = 0;
8022}
8023
Eric Laurentd8365c52017-07-16 15:27:05 -07008024void AudioFlinger::RecordThread::checkBtNrec()
8025{
8026 Mutex::Autolock _l(mLock);
8027 checkBtNrec_l();
8028}
8029
8030void AudioFlinger::RecordThread::checkBtNrec_l()
8031{
8032 // disable AEC and NS if the device is a BT SCO headset supporting those
8033 // pre processings
8034 bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
8035 mAudioFlinger->btNrecIsOff();
8036 if (mBtNrecSuspended.exchange(suspend) != suspend) {
8037 for (size_t i = 0; i < mEffectChains.size(); i++) {
8038 setEffectSuspended_l(FX_IID_AEC, suspend, mEffectChains[i]->sessionId());
8039 setEffectSuspended_l(FX_IID_NS, suspend, mEffectChains[i]->sessionId());
8040 }
8041 }
8042}
8043
Andy Hung97a893e2015-03-29 01:03:07 -07008044
Eric Laurent10351942014-05-08 18:49:52 -07008045bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
8046 status_t& status)
Eric Laurent81784c32012-11-19 14:55:58 -08008047{
8048 bool reconfig = false;
8049
Eric Laurent10351942014-05-08 18:49:52 -07008050 status = NO_ERROR;
Eric Laurent81784c32012-11-19 14:55:58 -08008051
Eric Laurent10351942014-05-08 18:49:52 -07008052 audio_format_t reqFormat = mFormat;
8053 uint32_t samplingRate = mSampleRate;
Glenn Kastene1635ec2015-06-08 15:46:49 -07008054 // 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 -07008055 audio_channel_mask_t channelMask = audio_channel_in_mask_from_count(mChannelCount);
8056
8057 AudioParameter param = AudioParameter(keyValuePair);
8058 int value;
Haynes Mathew George9ce67b52015-09-30 11:40:47 -07008059
8060 // scope for AutoPark extends to end of method
8061 AutoPark<FastCapture> park(mFastCapture);
8062
Eric Laurent10351942014-05-08 18:49:52 -07008063 // TODO Investigate when this code runs. Check with audio policy when a sample rate and
8064 // channel count change can be requested. Do we mandate the first client defines the
8065 // HAL sampling rate and channel count or do we allow changes on the fly?
8066 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
8067 samplingRate = value;
8068 reconfig = true;
8069 }
8070 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Andy Hung97a893e2015-03-29 01:03:07 -07008071 if (!audio_is_linear_pcm((audio_format_t) value)) {
Eric Laurent10351942014-05-08 18:49:52 -07008072 status = BAD_VALUE;
8073 } else {
8074 reqFormat = (audio_format_t) value;
Eric Laurent81784c32012-11-19 14:55:58 -08008075 reconfig = true;
8076 }
Eric Laurent10351942014-05-08 18:49:52 -07008077 }
8078 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
8079 audio_channel_mask_t mask = (audio_channel_mask_t) value;
Andy Hungd330ee42015-04-20 13:23:41 -07008080 if (!audio_is_input_channel(mask) ||
8081 audio_channel_count_from_in_mask(mask) > FCC_8) {
Eric Laurent10351942014-05-08 18:49:52 -07008082 status = BAD_VALUE;
8083 } else {
8084 channelMask = mask;
8085 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008086 }
Eric Laurent10351942014-05-08 18:49:52 -07008087 }
8088 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
8089 // do not accept frame count changes if tracks are open as the track buffer
8090 // size depends on frame count and correct behavior would not be guaranteed
8091 // if frame count is changed after track creation
8092 if (mActiveTracks.size() > 0) {
8093 status = INVALID_OPERATION;
8094 } else {
8095 reconfig = true;
Eric Laurent81784c32012-11-19 14:55:58 -08008096 }
Eric Laurent10351942014-05-08 18:49:52 -07008097 }
8098 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
8099 // forward device change to effects that have requested to be
8100 // aware of attached audio device.
8101 for (size_t i = 0; i < mEffectChains.size(); i++) {
8102 mEffectChains[i]->setDevice_l(value);
Eric Laurent81784c32012-11-19 14:55:58 -08008103 }
Eric Laurent81784c32012-11-19 14:55:58 -08008104
Eric Laurent10351942014-05-08 18:49:52 -07008105 // store input device and output device but do not forward output device to audio HAL.
8106 // Note that status is ignored by the caller for output device
8107 // (see AudioFlinger::setParameters()
8108 if (audio_is_output_devices(value)) {
8109 mOutDevice = value;
8110 status = BAD_VALUE;
8111 } else {
8112 mInDevice = value;
Eric Laurente8726fe2015-06-26 09:39:24 -07008113 if (value != AUDIO_DEVICE_NONE) {
8114 mPrevInDevice = value;
8115 }
Eric Laurentd8365c52017-07-16 15:27:05 -07008116 checkBtNrec_l();
Eric Laurent81784c32012-11-19 14:55:58 -08008117 }
Eric Laurent10351942014-05-08 18:49:52 -07008118 }
8119 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
8120 mAudioSource != (audio_source_t)value) {
8121 // forward device change to effects that have requested to be
8122 // aware of attached audio device.
8123 for (size_t i = 0; i < mEffectChains.size(); i++) {
8124 mEffectChains[i]->setAudioSource_l((audio_source_t)value);
Eric Laurent81784c32012-11-19 14:55:58 -08008125 }
Eric Laurent10351942014-05-08 18:49:52 -07008126 mAudioSource = (audio_source_t)value;
8127 }
Glenn Kastene198c362013-08-13 09:13:36 -07008128
Eric Laurent10351942014-05-08 18:49:52 -07008129 if (status == NO_ERROR) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008130 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008131 if (status == INVALID_OPERATION) {
8132 inputStandBy();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008133 status = mInput->stream->setParameters(keyValuePair);
Eric Laurent10351942014-05-08 18:49:52 -07008134 }
8135 if (reconfig) {
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008136 if (status == BAD_VALUE) {
8137 uint32_t sRate;
8138 audio_channel_mask_t channelMask;
8139 audio_format_t format;
8140 if (mInput->stream->getAudioProperties(&sRate, &channelMask, &format) == OK &&
8141 audio_is_linear_pcm(format) && audio_is_linear_pcm(reqFormat) &&
8142 sRate <= (AUDIO_RESAMPLER_DOWN_RATIO_MAX * samplingRate) &&
8143 audio_channel_count_from_in_mask(channelMask) <= FCC_8) {
8144 status = NO_ERROR;
8145 }
Eric Laurent81784c32012-11-19 14:55:58 -08008146 }
Eric Laurent10351942014-05-08 18:49:52 -07008147 if (status == NO_ERROR) {
8148 readInputParameters_l();
Eric Laurent73e26b62015-04-27 16:55:58 -07008149 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
Eric Laurent81784c32012-11-19 14:55:58 -08008150 }
8151 }
Eric Laurent81784c32012-11-19 14:55:58 -08008152 }
Eric Laurent10351942014-05-08 18:49:52 -07008153
Eric Laurent81784c32012-11-19 14:55:58 -08008154 return reconfig;
8155}
8156
8157String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
8158{
Eric Laurent81784c32012-11-19 14:55:58 -08008159 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008160 if (initCheck() == NO_ERROR) {
8161 String8 out_s8;
8162 if (mInput->stream->getParameters(keys, &out_s8) == OK) {
8163 return out_s8;
8164 }
Eric Laurent81784c32012-11-19 14:55:58 -08008165 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008166 return String8();
Eric Laurent81784c32012-11-19 14:55:58 -08008167}
8168
Eric Laurent09f1ed22019-04-24 17:45:17 -07008169void AudioFlinger::RecordThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
8170 audio_port_handle_t portId) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008171 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
8172
8173 desc->mIoHandle = mId;
Eric Laurent81784c32012-11-19 14:55:58 -08008174
8175 switch (event) {
Eric Laurent73e26b62015-04-27 16:55:58 -07008176 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07008177 case AUDIO_INPUT_REGISTERED:
Eric Laurent73e26b62015-04-27 16:55:58 -07008178 case AUDIO_INPUT_CONFIG_CHANGED:
Eric Laurent296fb132015-05-01 11:38:42 -07008179 desc->mPatch = mPatch;
Eric Laurent73e26b62015-04-27 16:55:58 -07008180 desc->mChannelMask = mChannelMask;
8181 desc->mSamplingRate = mSampleRate;
8182 desc->mFormat = mFormat;
8183 desc->mFrameCount = mFrameCount;
Glenn Kasten4a8308b2016-04-18 14:10:01 -07008184 desc->mFrameCountHAL = mFrameCount;
Eric Laurent73e26b62015-04-27 16:55:58 -07008185 desc->mLatency = 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008186 break;
Eric Laurent09f1ed22019-04-24 17:45:17 -07008187 case AUDIO_CLIENT_STARTED:
8188 desc->mPatch = mPatch;
8189 desc->mPortId = portId;
8190 break;
Eric Laurent73e26b62015-04-27 16:55:58 -07008191 case AUDIO_INPUT_CLOSED:
Eric Laurent81784c32012-11-19 14:55:58 -08008192 default:
8193 break;
8194 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07008195 mAudioFlinger->ioConfigChanged(event, desc, pid);
Eric Laurent81784c32012-11-19 14:55:58 -08008196}
8197
Glenn Kastendeca2ae2014-02-07 10:25:56 -08008198void AudioFlinger::RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -08008199{
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008200 status_t result = mInput->stream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
8201 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
Andy Hung463be252014-07-10 16:56:07 -07008202 mFormat = mHALFormat;
Mikhail Naganovce9f2652018-07-16 11:09:24 -07008203 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
8204 if (audio_is_linear_pcm(mFormat)) {
8205 LOG_ALWAYS_FATAL_IF(mChannelCount > FCC_8, "HAL channel count %d > %d",
8206 mChannelCount, FCC_8);
8207 } else {
8208 // Can have more that FCC_8 channels in encoded streams.
8209 ALOGI("HAL format %#x is not linear pcm", mFormat);
8210 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008211 result = mInput->stream->getFrameSize(&mFrameSize);
8212 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
8213 result = mInput->stream->getBufferSize(&mBufferSize);
8214 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
Glenn Kasten548efc92012-11-29 08:48:51 -08008215 mFrameCount = mBufferSize / mFrameSize;
Mikhail Naganovb3cf7e62017-06-02 10:24:24 -07008216 ALOGV("%p RecordThread params: mChannelCount=%u, mFormat=%#x, mFrameSize=%lld, "
8217 "mBufferSize=%lld, mFrameCount=%lld",
8218 this, mChannelCount, mFormat, (long long)mFrameSize, (long long)mBufferSize,
8219 (long long)mFrameCount);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008220 // This is the formula for calculating the temporary buffer size.
Glenn Kastene8426142014-02-28 16:45:03 -08008221 // 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 -07008222 // 1 full output buffer, regardless of the alignment of the available input.
Glenn Kastene8426142014-02-28 16:45:03 -08008223 // The value is somewhat arbitrary, and could probably be even larger.
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08008224 // A larger value should allow more old data to be read after a track calls start(),
8225 // without increasing latency.
Andy Hung97a893e2015-03-29 01:03:07 -07008226 //
8227 // Note this is independent of the maximum downsampling ratio permitted for capture.
Glenn Kastene8426142014-02-28 16:45:03 -08008228 mRsmpInFrames = mFrameCount * 7;
Glenn Kasten85948432013-08-19 12:09:05 -07008229 mRsmpInFramesP2 = roundup(mRsmpInFrames);
Andy Hung57446612015-04-19 23:56:46 -07008230 free(mRsmpInBuffer);
Andy Hung0a01c2f2015-09-21 12:44:54 -07008231 mRsmpInBuffer = NULL;
Glenn Kasten49d00ad2014-07-21 11:22:03 -07008232
8233 // TODO optimize audio capture buffer sizes ...
8234 // Here we calculate the size of the sliding buffer used as a source
8235 // for resampling. mRsmpInFramesP2 is currently roundup(mFrameCount * 7).
8236 // For current HAL frame counts, this is usually 2048 = 40 ms. It would
8237 // be better to have it derived from the pipe depth in the long term.
8238 // The current value is higher than necessary. However it should not add to latency.
8239
Glenn Kasten85948432013-08-19 12:09:05 -07008240 // Over-allocate beyond mRsmpInFramesP2 to permit a HAL read past end of buffer
Glenn Kasten1b291842016-07-18 14:55:21 -07008241 mRsmpInFramesOA = mRsmpInFramesP2 + mFrameCount - 1;
8242 (void)posix_memalign(&mRsmpInBuffer, 32, mRsmpInFramesOA * mFrameSize);
Glenn Kastend3bb6452016-12-05 18:14:37 -08008243 // if posix_memalign fails, will segv here.
8244 memset(mRsmpInBuffer, 0, mRsmpInFramesOA * mFrameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08008245
Glenn Kasten4cc0a6a2014-02-17 14:31:46 -08008246 // AudioRecord mSampleRate and mChannelCount are constant due to AudioRecord API constraints.
8247 // But if thread's mSampleRate or mChannelCount changes, how will that affect active tracks?
Eric Laurent81784c32012-11-19 14:55:58 -08008248}
8249
Glenn Kasten5f972c02014-01-13 09:59:31 -08008250uint32_t AudioFlinger::RecordThread::getInputFramesLost()
Eric Laurent81784c32012-11-19 14:55:58 -08008251{
8252 Mutex::Autolock _l(mLock);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008253 uint32_t result;
8254 if (initCheck() == NO_ERROR && mInput->stream->getInputFramesLost(&result) == OK) {
8255 return result;
Eric Laurent81784c32012-11-19 14:55:58 -08008256 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008257 return 0;
Eric Laurent81784c32012-11-19 14:55:58 -08008258}
8259
Glenn Kastend848eb42016-03-08 13:42:11 -08008260KeyedVector<audio_session_t, bool> AudioFlinger::RecordThread::sessionIds() const
Eric Laurent81784c32012-11-19 14:55:58 -08008261{
Glenn Kastend848eb42016-03-08 13:42:11 -08008262 KeyedVector<audio_session_t, bool> ids;
Eric Laurent81784c32012-11-19 14:55:58 -08008263 Mutex::Autolock _l(mLock);
8264 for (size_t j = 0; j < mTracks.size(); ++j) {
8265 sp<RecordThread::RecordTrack> track = mTracks[j];
Glenn Kastend848eb42016-03-08 13:42:11 -08008266 audio_session_t sessionId = track->sessionId();
Eric Laurent81784c32012-11-19 14:55:58 -08008267 if (ids.indexOfKey(sessionId) < 0) {
8268 ids.add(sessionId, true);
8269 }
8270 }
8271 return ids;
8272}
8273
8274AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
8275{
8276 Mutex::Autolock _l(mLock);
8277 AudioStreamIn *input = mInput;
8278 mInput = NULL;
8279 return input;
8280}
8281
8282// this method must always be called either with ThreadBase mLock held or inside the thread loop
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008283sp<StreamHalInterface> AudioFlinger::RecordThread::stream() const
Eric Laurent81784c32012-11-19 14:55:58 -08008284{
8285 if (mInput == NULL) {
8286 return NULL;
8287 }
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008288 return mInput->stream;
Eric Laurent81784c32012-11-19 14:55:58 -08008289}
8290
8291status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
8292{
Eric Laurent81784c32012-11-19 14:55:58 -08008293 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
Eric Laurentaaa44472014-09-12 17:41:50 -07008294 chain->setThread(this);
Eric Laurent81784c32012-11-19 14:55:58 -08008295 chain->setInBuffer(NULL);
8296 chain->setOutBuffer(NULL);
8297
8298 checkSuspendOnAddEffectChain_l(chain);
8299
Eric Laurent1b928682014-10-02 19:41:47 -07008300 // make sure enabled pre processing effects state is communicated to the HAL as we
8301 // just moved them to a new input stream.
8302 chain->syncHalEffectsState();
8303
Eric Laurent81784c32012-11-19 14:55:58 -08008304 mEffectChains.add(chain);
8305
8306 return NO_ERROR;
8307}
8308
8309size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
8310{
8311 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008312
8313 for (size_t i = 0; i < mEffectChains.size(); i++) {
8314 if (chain == mEffectChains[i]) {
8315 mEffectChains.removeAt(i);
8316 break;
8317 }
Eric Laurent81784c32012-11-19 14:55:58 -08008318 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07008319 return mEffectChains.size();
Eric Laurent81784c32012-11-19 14:55:58 -08008320}
8321
Eric Laurent1c333e22014-05-20 10:48:17 -07008322status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
8323 audio_patch_handle_t *handle)
8324{
8325 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008326
8327 // store new device and send to effects
8328 mInDevice = patch->sources[0].ext.device.type;
François Gaffie0c280aa2018-07-25 10:02:15 +02008329 audio_port_handle_t deviceId = patch->sources[0].id;
Eric Laurent296fb132015-05-01 11:38:42 -07008330 mPatch = *patch;
Eric Laurent054d9d32015-04-24 08:48:48 -07008331 for (size_t i = 0; i < mEffectChains.size(); i++) {
8332 mEffectChains[i]->setDevice_l(mInDevice);
8333 }
8334
Eric Laurentd8365c52017-07-16 15:27:05 -07008335 checkBtNrec_l();
Eric Laurent054d9d32015-04-24 08:48:48 -07008336
8337 // store new source and send to effects
8338 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
8339 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
Eric Laurent1c333e22014-05-20 10:48:17 -07008340 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurent054d9d32015-04-24 08:48:48 -07008341 mEffectChains[i]->setAudioSource_l(mAudioSource);
Eric Laurent1c333e22014-05-20 10:48:17 -07008342 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008343 }
Eric Laurent1c333e22014-05-20 10:48:17 -07008344
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008345 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008346 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8347 status = hwDevice->createAudioPatch(patch->num_sources,
8348 patch->sources,
8349 patch->num_sinks,
8350 patch->sinks,
8351 handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008352 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008353 char *address;
8354 if (strcmp(patch->sources[0].ext.device.address, "") != 0) {
8355 address = audio_device_address_to_parameter(
8356 patch->sources[0].ext.device.type,
8357 patch->sources[0].ext.device.address);
8358 } else {
8359 address = (char *)calloc(1, 1);
8360 }
8361 AudioParameter param = AudioParameter(String8(address));
8362 free(address);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008363 param.addInt(String8(AudioParameter::keyRouting),
Eric Laurent054d9d32015-04-24 08:48:48 -07008364 (int)patch->sources[0].ext.device.type);
Mikhail Naganov00260b52016-10-13 12:54:24 -07008365 param.addInt(String8(AudioParameter::keyInputSource),
Eric Laurent054d9d32015-04-24 08:48:48 -07008366 (int)patch->sinks[0].ext.mix.usecase.source);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008367 status = mInput->stream->setParameters(param.toString());
Eric Laurent054d9d32015-04-24 08:48:48 -07008368 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent1c333e22014-05-20 10:48:17 -07008369 }
Eric Laurent054d9d32015-04-24 08:48:48 -07008370
François Gaffie0c280aa2018-07-25 10:02:15 +02008371 if ((mInDevice != mPrevInDevice) || (mDeviceId != deviceId)) {
Eric Laurente8726fe2015-06-26 09:39:24 -07008372 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
8373 mPrevInDevice = mInDevice;
François Gaffie0c280aa2018-07-25 10:02:15 +02008374 mDeviceId = deviceId;
Eric Laurente8726fe2015-06-26 09:39:24 -07008375 }
Eric Laurent296fb132015-05-01 11:38:42 -07008376
Eric Laurent1c333e22014-05-20 10:48:17 -07008377 return status;
8378}
8379
8380status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
8381{
8382 status_t status = NO_ERROR;
Eric Laurent054d9d32015-04-24 08:48:48 -07008383
8384 mInDevice = AUDIO_DEVICE_NONE;
8385
Mikhail Naganov9ee05402016-10-13 15:58:17 -07008386 if (mInput->audioHwDev->supportsAudioPatches()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07008387 sp<DeviceHalInterface> hwDevice = mInput->audioHwDev->hwDevice();
8388 status = hwDevice->releaseAudioPatch(handle);
Eric Laurent1c333e22014-05-20 10:48:17 -07008389 } else {
Eric Laurent054d9d32015-04-24 08:48:48 -07008390 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07008391 param.addInt(String8(AudioParameter::keyRouting), 0);
Mikhail Naganov1dc98672016-08-18 17:50:29 -07008392 status = mInput->stream->setParameters(param.toString());
Eric Laurent1c333e22014-05-20 10:48:17 -07008393 }
8394 return status;
8395}
8396
Mikhail Naganov444ecc32018-05-01 17:40:05 -07008397void AudioFlinger::RecordThread::addPatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07008398{
8399 Mutex::Autolock _l(mLock);
8400 mTracks.add(record);
8401}
8402
Mikhail Naganov444ecc32018-05-01 17:40:05 -07008403void AudioFlinger::RecordThread::deletePatchTrack(const sp<PatchRecord>& record)
Eric Laurent83b88082014-06-20 18:31:16 -07008404{
8405 Mutex::Autolock _l(mLock);
8406 destroyTrack_l(record);
8407}
8408
Mikhail Naganovdc769682018-05-04 15:34:08 -07008409void AudioFlinger::RecordThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent83b88082014-06-20 18:31:16 -07008410{
Mikhail Naganovdc769682018-05-04 15:34:08 -07008411 ThreadBase::toAudioPortConfig(config);
Eric Laurent83b88082014-06-20 18:31:16 -07008412 config->role = AUDIO_PORT_ROLE_SINK;
8413 config->ext.mix.hw_module = mInput->audioHwDev->handle();
8414 config->ext.mix.usecase.source = mAudioSource;
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07008415 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
8416 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
8417 config->flags.input = mInput->flags;
8418 }
Eric Laurent83b88082014-06-20 18:31:16 -07008419}
Eric Laurent1c333e22014-05-20 10:48:17 -07008420
Eric Laurent6acd1d42017-01-04 14:23:29 -08008421// ----------------------------------------------------------------------------
8422// Mmap
8423// ----------------------------------------------------------------------------
8424
8425AudioFlinger::MmapThreadHandle::MmapThreadHandle(const sp<MmapThread>& thread)
8426 : mThread(thread)
8427{
Phil Burk9fabbf82017-08-03 12:02:00 -07008428 assert(thread != 0); // thread must start non-null and stay non-null
Eric Laurent6acd1d42017-01-04 14:23:29 -08008429}
8430
8431AudioFlinger::MmapThreadHandle::~MmapThreadHandle()
8432{
Phil Burk9fabbf82017-08-03 12:02:00 -07008433 mThread->disconnect();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008434}
8435
8436status_t AudioFlinger::MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
8437 struct audio_mmap_buffer_info *info)
8438{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008439 return mThread->createMmapBuffer(minSizeFrames, info);
8440}
8441
8442status_t AudioFlinger::MmapThreadHandle::getMmapPosition(struct audio_mmap_position *position)
8443{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008444 return mThread->getMmapPosition(position);
8445}
8446
Eric Laurenta54f1282017-07-01 19:39:32 -07008447status_t AudioFlinger::MmapThreadHandle::start(const AudioClient& client,
Glenn Kastend3bb6452016-12-05 18:14:37 -08008448 audio_port_handle_t *handle)
Eric Laurent6acd1d42017-01-04 14:23:29 -08008449
8450{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008451 return mThread->start(client, handle);
8452}
8453
8454status_t AudioFlinger::MmapThreadHandle::stop(audio_port_handle_t handle)
8455{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008456 return mThread->stop(handle);
8457}
8458
Eric Laurent18b57012017-02-13 16:23:52 -08008459status_t AudioFlinger::MmapThreadHandle::standby()
8460{
Eric Laurent18b57012017-02-13 16:23:52 -08008461 return mThread->standby();
8462}
8463
Eric Laurent6acd1d42017-01-04 14:23:29 -08008464
8465AudioFlinger::MmapThread::MmapThread(
8466 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
8467 AudioHwDevice *hwDev, sp<StreamHalInterface> stream,
8468 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady)
8469 : ThreadBase(audioFlinger, id, outDevice, inDevice, MMAP, systemReady),
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008470 mSessionId(AUDIO_SESSION_NONE),
François Gaffie0c280aa2018-07-25 10:02:15 +02008471 mPortId(AUDIO_PORT_HANDLE_NONE),
Andy Hung2c6c3bb2017-06-16 14:01:45 -07008472 mHalStream(stream), mHalDevice(hwDev->hwDevice()), mAudioHwDev(hwDev),
Eric Laurent67f97292018-04-20 18:05:41 -07008473 mActiveTracks(&this->mLocalLog),
8474 mHalVolFloat(-1.0f), // Initialize to illegal value so it always gets set properly later.
8475 mNoCallbackWarningCount(0)
Eric Laurent6acd1d42017-01-04 14:23:29 -08008476{
Eric Laurent18b57012017-02-13 16:23:52 -08008477 mStandby = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008478 readHalParameters_l();
8479}
8480
8481AudioFlinger::MmapThread::~MmapThread()
8482{
Eric Laurent18b57012017-02-13 16:23:52 -08008483 releaseWakeLock_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008484}
8485
8486void AudioFlinger::MmapThread::onFirstRef()
8487{
8488 run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
8489}
8490
8491void AudioFlinger::MmapThread::disconnect()
8492{
Eric Laurent331679c2018-04-16 17:03:16 -07008493 ActiveTracks<MmapTrack> activeTracks;
8494 {
8495 Mutex::Autolock _l(mLock);
8496 for (const sp<MmapTrack> &t : mActiveTracks) {
8497 activeTracks.add(t);
8498 }
8499 }
8500 for (const sp<MmapTrack> &t : activeTracks) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008501 stop(t->portId());
8502 }
Phil Burk9fabbf82017-08-03 12:02:00 -07008503 // This will decrement references and may cause the destruction of this thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08008504 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008505 AudioSystem::releaseOutput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008506 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008507 AudioSystem::releaseInput(mPortId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008508 }
8509}
8510
8511
8512void AudioFlinger::MmapThread::configure(const audio_attributes_t *attr,
8513 audio_stream_type_t streamType __unused,
8514 audio_session_t sessionId,
8515 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008516 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08008517 audio_port_handle_t portId)
8518{
8519 mAttr = *attr;
8520 mSessionId = sessionId;
8521 mCallback = callback;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008522 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008523 mPortId = portId;
8524}
8525
8526status_t AudioFlinger::MmapThread::createMmapBuffer(int32_t minSizeFrames,
8527 struct audio_mmap_buffer_info *info)
8528{
8529 if (mHalStream == 0) {
8530 return NO_INIT;
8531 }
Eric Laurent18b57012017-02-13 16:23:52 -08008532 mStandby = true;
8533 acquireWakeLock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008534 return mHalStream->createMmapBuffer(minSizeFrames, info);
8535}
8536
8537status_t AudioFlinger::MmapThread::getMmapPosition(struct audio_mmap_position *position)
8538{
8539 if (mHalStream == 0) {
8540 return NO_INIT;
8541 }
8542 return mHalStream->getMmapPosition(position);
8543}
8544
Eric Laurent331679c2018-04-16 17:03:16 -07008545status_t AudioFlinger::MmapThread::exitStandby()
8546{
8547 status_t ret = mHalStream->start();
8548 if (ret != NO_ERROR) {
8549 ALOGE("%s: error mHalStream->start() = %d for first track", __FUNCTION__, ret);
8550 return ret;
8551 }
8552 mStandby = false;
8553 return NO_ERROR;
8554}
8555
Eric Laurenta54f1282017-07-01 19:39:32 -07008556status_t AudioFlinger::MmapThread::start(const AudioClient& client,
Eric Laurent6acd1d42017-01-04 14:23:29 -08008557 audio_port_handle_t *handle)
8558{
Eric Laurenta54f1282017-07-01 19:39:32 -07008559 ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
8560 client.clientUid, mStandby, mPortId, *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008561 if (mHalStream == 0) {
8562 return NO_INIT;
8563 }
8564
8565 status_t ret;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008566
Eric Laurenta54f1282017-07-01 19:39:32 -07008567 if (*handle == mPortId) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008568 // for the first track, reuse portId and session allocated when the stream was opened
Eric Laurent331679c2018-04-16 17:03:16 -07008569 return exitStandby();
Eric Laurenta54f1282017-07-01 19:39:32 -07008570 }
8571
8572 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
8573
8574 audio_io_handle_t io = mId;
8575 if (isOutput()) {
8576 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
8577 config.sample_rate = mSampleRate;
8578 config.channel_mask = mChannelMask;
8579 config.format = mFormat;
8580 audio_stream_type_t stream = streamType();
8581 audio_output_flags_t flags =
8582 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008583 audio_port_handle_t deviceId = mDeviceId;
Kevin Rocard153f92d2018-12-18 18:33:28 -08008584 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurenta54f1282017-07-01 19:39:32 -07008585 ret = AudioSystem::getOutputForAttr(&mAttr, &io,
8586 mSessionId,
8587 &stream,
Nadav Bar766fb022018-01-07 12:18:03 +02008588 client.clientPid,
Eric Laurenta54f1282017-07-01 19:39:32 -07008589 client.clientUid,
8590 &config,
8591 flags,
8592 &deviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08008593 &portId,
8594 &secondaryOutputs);
8595 ALOGD_IF(!secondaryOutputs.empty(),
8596 "MmapThread::start does not support secondary outputs, ignoring them");
Eric Laurent6acd1d42017-01-04 14:23:29 -08008597 } else {
Eric Laurenta54f1282017-07-01 19:39:32 -07008598 audio_config_base_t config;
8599 config.sample_rate = mSampleRate;
8600 config.channel_mask = mChannelMask;
8601 config.format = mFormat;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008602 audio_port_handle_t deviceId = mDeviceId;
Eric Laurenta54f1282017-07-01 19:39:32 -07008603 ret = AudioSystem::getInputForAttr(&mAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -07008604 RECORD_RIID_INVALID,
Eric Laurenta54f1282017-07-01 19:39:32 -07008605 mSessionId,
8606 client.clientPid,
8607 client.clientUid,
Eric Laurentfee19762018-01-29 18:44:13 -08008608 client.packageName,
Eric Laurenta54f1282017-07-01 19:39:32 -07008609 &config,
8610 AUDIO_INPUT_FLAG_MMAP_NOIRQ,
8611 &deviceId,
8612 &portId);
8613 }
8614 // APM should not chose a different input or output stream for the same set of attributes
8615 // and audo configuration
8616 if (ret != NO_ERROR || io != mId) {
8617 ALOGE("%s: error getting output or input from APM (error %d, io %d expected io %d)",
8618 __FUNCTION__, ret, io, mId);
8619 return BAD_VALUE;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008620 }
8621
8622 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008623 ret = AudioSystem::startOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008624 } else {
Eric Laurent4eb58f12018-12-07 16:41:02 -08008625 ret = AudioSystem::startInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008626 }
8627
Eric Laurent331679c2018-04-16 17:03:16 -07008628 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008629 // abort if start is rejected by audio policy manager
8630 if (ret != NO_ERROR) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08008631 ALOGE("%s: error start rejected by AudioPolicyManager = %d", __FUNCTION__, ret);
Eric Tan39ec8d62018-07-24 09:49:29 -07008632 if (!mActiveTracks.isEmpty()) {
Eric Laurent331679c2018-04-16 17:03:16 -07008633 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008634 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008635 AudioSystem::releaseOutput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008636 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008637 AudioSystem::releaseInput(portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008638 }
Eric Laurent331679c2018-04-16 17:03:16 -07008639 mLock.lock();
Eric Laurent18b57012017-02-13 16:23:52 -08008640 } else {
8641 mHalStream->stop();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008642 }
8643 return PERMISSION_DENIED;
8644 }
8645
Kevin Rocard1f564ac2018-03-29 13:53:10 -07008646 // Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
8647 sp<MmapTrack> track = new MmapTrack(this, mAttr, mSampleRate, mFormat, mChannelMask, mSessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -07008648 isOutput(), client.clientUid, client.clientPid,
8649 IPCThreadState::self()->getCallingPid(), portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008650
Eric Laurent4eb58f12018-12-07 16:41:02 -08008651 if (isOutput()) {
8652 // force volume update when a new track is added
8653 mHalVolFloat = -1.0f;
8654 } else if (!track->isSilenced_l()) {
8655 for (const sp<MmapTrack> &t : mActiveTracks) {
8656 if (t->isSilenced_l() && t->uid() != client.clientUid)
8657 t->invalidate();
8658 }
8659 }
8660
8661
Eric Laurent6acd1d42017-01-04 14:23:29 -08008662 mActiveTracks.add(track);
Eric Laurenta54f1282017-07-01 19:39:32 -07008663 sp<EffectChain> chain = getEffectChain_l(mSessionId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008664 if (chain != 0) {
8665 chain->setStrategy(AudioSystem::getStrategyForStream(streamType()));
8666 chain->incTrackCnt();
8667 chain->incActiveTrackCnt();
8668 }
8669
8670 *handle = portId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008671 broadcast_l();
8672
Eric Laurenta54f1282017-07-01 19:39:32 -07008673 ALOGV("%s DONE handle %d stream %p", __FUNCTION__, *handle, mHalStream.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008674
8675 return NO_ERROR;
8676}
8677
8678status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
8679{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008680 ALOGV("%s handle %d", __FUNCTION__, handle);
8681
8682 if (mHalStream == 0) {
8683 return NO_INIT;
8684 }
8685
Eric Laurenta54f1282017-07-01 19:39:32 -07008686 if (handle == mPortId) {
8687 mHalStream->stop();
8688 return NO_ERROR;
8689 }
8690
Eric Laurent331679c2018-04-16 17:03:16 -07008691 Mutex::Autolock _l(mLock);
8692
Eric Laurent6acd1d42017-01-04 14:23:29 -08008693 sp<MmapTrack> track;
8694 for (const sp<MmapTrack> &t : mActiveTracks) {
8695 if (handle == t->portId()) {
8696 track = t;
8697 break;
8698 }
8699 }
8700 if (track == 0) {
8701 return BAD_VALUE;
8702 }
8703
8704 mActiveTracks.remove(track);
8705
Eric Laurent331679c2018-04-16 17:03:16 -07008706 mLock.unlock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008707 if (isOutput()) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07008708 AudioSystem::stopOutput(track->portId());
8709 AudioSystem::releaseOutput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008710 } else {
Eric Laurentfee19762018-01-29 18:44:13 -08008711 AudioSystem::stopInput(track->portId());
8712 AudioSystem::releaseInput(track->portId());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008713 }
Eric Laurent331679c2018-04-16 17:03:16 -07008714 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008715
8716 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
8717 if (chain != 0) {
8718 chain->decActiveTrackCnt();
8719 chain->decTrackCnt();
8720 }
8721
8722 broadcast_l();
8723
Eric Laurent6acd1d42017-01-04 14:23:29 -08008724 return NO_ERROR;
8725}
8726
Eric Laurent18b57012017-02-13 16:23:52 -08008727status_t AudioFlinger::MmapThread::standby()
8728{
8729 ALOGV("%s", __FUNCTION__);
8730
8731 if (mHalStream == 0) {
8732 return NO_INIT;
8733 }
Eric Tan39ec8d62018-07-24 09:49:29 -07008734 if (!mActiveTracks.isEmpty()) {
Eric Laurent18b57012017-02-13 16:23:52 -08008735 return INVALID_OPERATION;
8736 }
8737 mHalStream->standby();
8738 mStandby = true;
8739 releaseWakeLock();
8740 return NO_ERROR;
8741}
8742
Eric Laurent6acd1d42017-01-04 14:23:29 -08008743
8744void AudioFlinger::MmapThread::readHalParameters_l()
8745{
8746 status_t result = mHalStream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
8747 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
8748 mFormat = mHALFormat;
8749 LOG_ALWAYS_FATAL_IF(!audio_is_linear_pcm(mFormat), "HAL format %#x is not linear pcm", mFormat);
8750 result = mHalStream->getFrameSize(&mFrameSize);
8751 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving frame size from HAL: %d", result);
8752 result = mHalStream->getBufferSize(&mBufferSize);
8753 LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving buffer size from HAL: %d", result);
8754 mFrameCount = mBufferSize / mFrameSize;
8755}
8756
8757bool AudioFlinger::MmapThread::threadLoop()
8758{
Eric Laurent6acd1d42017-01-04 14:23:29 -08008759 checkSilentMode_l();
8760
8761 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
8762
8763 while (!exitPending())
8764 {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008765 Vector< sp<EffectChain> > effectChains;
8766
Andy Hung13850be2019-03-14 11:33:09 -07008767 { // under Thread lock
8768 Mutex::Autolock _l(mLock);
8769
Eric Laurent6acd1d42017-01-04 14:23:29 -08008770 if (mSignalPending) {
8771 // A signal was raised while we were unlocked
8772 mSignalPending = false;
8773 } else {
8774 if (mConfigEvents.isEmpty()) {
8775 // we're about to wait, flush the binder command buffer
8776 IPCThreadState::self()->flushCommands();
8777
8778 if (exitPending()) {
8779 break;
8780 }
8781
Eric Laurent6acd1d42017-01-04 14:23:29 -08008782 // wait until we have something to do...
8783 ALOGV("%s going to sleep", myName.string());
8784 mWaitWorkCV.wait(mLock);
8785 ALOGV("%s waking up", myName.string());
Eric Laurent6acd1d42017-01-04 14:23:29 -08008786
8787 checkSilentMode_l();
8788
8789 continue;
8790 }
8791 }
8792
8793 processConfigEvents_l();
8794
8795 processVolume_l();
8796
8797 checkInvalidTracks_l();
8798
8799 mActiveTracks.updatePowerState(this);
8800
Kevin Rocard069c2712018-03-29 19:09:14 -07008801 updateMetadata_l();
8802
Eric Laurent6acd1d42017-01-04 14:23:29 -08008803 lockEffectChains_l(effectChains);
Andy Hung13850be2019-03-14 11:33:09 -07008804 } // release Thread lock
8805
Eric Laurent6acd1d42017-01-04 14:23:29 -08008806 for (size_t i = 0; i < effectChains.size(); i ++) {
Andy Hung13850be2019-03-14 11:33:09 -07008807 effectChains[i]->process_l(); // Thread is not locked, but effect chain is locked
Eric Laurent6acd1d42017-01-04 14:23:29 -08008808 }
Andy Hung13850be2019-03-14 11:33:09 -07008809
8810 // enable changes in effect chain, including moving to another thread.
Eric Laurent6acd1d42017-01-04 14:23:29 -08008811 unlockEffectChains(effectChains);
8812 // Effect chains will be actually deleted here if they were removed from
8813 // mEffectChains list during mixing or effects processing
8814 }
8815
8816 threadLoop_exit();
8817
8818 if (!mStandby) {
8819 threadLoop_standby();
8820 mStandby = true;
8821 }
8822
Eric Laurent6acd1d42017-01-04 14:23:29 -08008823 ALOGV("Thread %p type %d exiting", this, mType);
8824 return false;
8825}
8826
8827// checkForNewParameter_l() must be called with ThreadBase::mLock held
8828bool AudioFlinger::MmapThread::checkForNewParameter_l(const String8& keyValuePair,
8829 status_t& status)
8830{
8831 AudioParameter param = AudioParameter(keyValuePair);
8832 int value;
Eric Laurente6e9a482017-07-25 19:26:02 -07008833 bool sendToHal = true;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008834 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
Eric Laurente6e9a482017-07-25 19:26:02 -07008835 audio_devices_t device = (audio_devices_t)value;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008836 // forward device change to effects that have requested to be
8837 // aware of attached audio device.
Eric Laurente6e9a482017-07-25 19:26:02 -07008838 if (device != AUDIO_DEVICE_NONE) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008839 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurente6e9a482017-07-25 19:26:02 -07008840 mEffectChains[i]->setDevice_l(device);
Eric Laurent6acd1d42017-01-04 14:23:29 -08008841 }
8842 }
Eric Laurente6e9a482017-07-25 19:26:02 -07008843 if (audio_is_output_devices(device)) {
8844 mOutDevice = device;
8845 if (!isOutput()) {
8846 sendToHal = false;
8847 }
8848 } else {
8849 mInDevice = device;
8850 if (device != AUDIO_DEVICE_NONE) {
8851 mPrevInDevice = value;
8852 }
8853 // TODO: implement and call checkBtNrec_l();
8854 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08008855 }
Eric Laurente6e9a482017-07-25 19:26:02 -07008856 if (sendToHal) {
8857 status = mHalStream->setParameters(keyValuePair);
8858 } else {
8859 status = NO_ERROR;
8860 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08008861
8862 return false;
8863}
8864
8865String8 AudioFlinger::MmapThread::getParameters(const String8& keys)
8866{
8867 Mutex::Autolock _l(mLock);
8868 String8 out_s8;
8869 if (initCheck() == NO_ERROR && mHalStream->getParameters(keys, &out_s8) == OK) {
8870 return out_s8;
8871 }
8872 return String8();
8873}
8874
Eric Laurent09f1ed22019-04-24 17:45:17 -07008875void AudioFlinger::MmapThread::ioConfigChanged(audio_io_config_event event, pid_t pid,
8876 audio_port_handle_t portId __unused) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008877 sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
8878
8879 desc->mIoHandle = mId;
8880
8881 switch (event) {
8882 case AUDIO_INPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07008883 case AUDIO_INPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08008884 case AUDIO_INPUT_CONFIG_CHANGED:
8885 case AUDIO_OUTPUT_OPENED:
Eric Laurentad2e7b92017-09-14 20:06:42 -07008886 case AUDIO_OUTPUT_REGISTERED:
Eric Laurent6acd1d42017-01-04 14:23:29 -08008887 case AUDIO_OUTPUT_CONFIG_CHANGED:
8888 desc->mPatch = mPatch;
8889 desc->mChannelMask = mChannelMask;
8890 desc->mSamplingRate = mSampleRate;
8891 desc->mFormat = mFormat;
8892 desc->mFrameCount = mFrameCount;
8893 desc->mFrameCountHAL = mFrameCount;
8894 desc->mLatency = 0;
8895 break;
8896
8897 case AUDIO_INPUT_CLOSED:
8898 case AUDIO_OUTPUT_CLOSED:
8899 default:
8900 break;
8901 }
8902 mAudioFlinger->ioConfigChanged(event, desc, pid);
8903}
8904
8905status_t AudioFlinger::MmapThread::createAudioPatch_l(const struct audio_patch *patch,
8906 audio_patch_handle_t *handle)
8907{
8908 status_t status = NO_ERROR;
8909
8910 // store new device and send to effects
8911 audio_devices_t type = AUDIO_DEVICE_NONE;
8912 audio_port_handle_t deviceId;
8913 if (isOutput()) {
8914 for (unsigned int i = 0; i < patch->num_sinks; i++) {
8915 type |= patch->sinks[i].ext.device.type;
8916 }
8917 deviceId = patch->sinks[0].id;
8918 } else {
8919 type = patch->sources[0].ext.device.type;
8920 deviceId = patch->sources[0].id;
8921 }
8922
8923 for (size_t i = 0; i < mEffectChains.size(); i++) {
8924 mEffectChains[i]->setDevice_l(type);
8925 }
8926
8927 if (isOutput()) {
8928 mOutDevice = type;
8929 } else {
8930 mInDevice = type;
8931 // store new source and send to effects
8932 if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
8933 mAudioSource = patch->sinks[0].ext.mix.usecase.source;
8934 for (size_t i = 0; i < mEffectChains.size(); i++) {
8935 mEffectChains[i]->setAudioSource_l(mAudioSource);
8936 }
8937 }
8938 }
8939
8940 if (mAudioHwDev->supportsAudioPatches()) {
8941 status = mHalDevice->createAudioPatch(patch->num_sources,
8942 patch->sources,
8943 patch->num_sinks,
8944 patch->sinks,
8945 handle);
8946 } else {
8947 char *address;
8948 if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
8949 //FIXME: we only support address on first sink with HAL version < 3.0
8950 address = audio_device_address_to_parameter(
8951 patch->sinks[0].ext.device.type,
8952 patch->sinks[0].ext.device.address);
8953 } else {
8954 address = (char *)calloc(1, 1);
8955 }
8956 AudioParameter param = AudioParameter(String8(address));
8957 free(address);
8958 param.addInt(String8(AudioParameter::keyRouting), (int)type);
8959 if (!isOutput()) {
8960 param.addInt(String8(AudioParameter::keyInputSource),
8961 (int)patch->sinks[0].ext.mix.usecase.source);
8962 }
8963 status = mHalStream->setParameters(param.toString());
8964 *handle = AUDIO_PATCH_HANDLE_NONE;
8965 }
8966
François Gaffie0c280aa2018-07-25 10:02:15 +02008967 if (isOutput() && (mPrevOutDevice != mOutDevice || mDeviceId != deviceId)) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008968 mPrevOutDevice = type;
8969 sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
Phil Burk7f6b40d2017-02-09 13:18:38 -08008970 sp<MmapStreamCallback> callback = mCallback.promote();
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008971 if (mDeviceId != deviceId && callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07008972 mLock.unlock();
Phil Burk7f6b40d2017-02-09 13:18:38 -08008973 callback->onRoutingChanged(deviceId);
Eric Laurent734046e2018-04-16 14:50:52 -07008974 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008975 }
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008976 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008977 }
François Gaffie0c280aa2018-07-25 10:02:15 +02008978 if (!isOutput() && (mPrevInDevice != mInDevice || mDeviceId != deviceId)) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08008979 mPrevInDevice = type;
8980 sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
Phil Burk7f6b40d2017-02-09 13:18:38 -08008981 sp<MmapStreamCallback> callback = mCallback.promote();
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008982 if (mDeviceId != deviceId && callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07008983 mLock.unlock();
Phil Burk7f6b40d2017-02-09 13:18:38 -08008984 callback->onRoutingChanged(deviceId);
Eric Laurent734046e2018-04-16 14:50:52 -07008985 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08008986 }
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07008987 mDeviceId = deviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08008988 }
8989 return status;
8990}
8991
8992status_t AudioFlinger::MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
8993{
8994 status_t status = NO_ERROR;
8995
8996 mInDevice = AUDIO_DEVICE_NONE;
8997
8998 bool supportsAudioPatches = mHalDevice->supportsAudioPatches(&supportsAudioPatches) == OK ?
8999 supportsAudioPatches : false;
9000
9001 if (supportsAudioPatches) {
9002 status = mHalDevice->releaseAudioPatch(handle);
9003 } else {
9004 AudioParameter param;
9005 param.addInt(String8(AudioParameter::keyRouting), 0);
9006 status = mHalStream->setParameters(param.toString());
9007 }
9008 return status;
9009}
9010
Mikhail Naganovdc769682018-05-04 15:34:08 -07009011void AudioFlinger::MmapThread::toAudioPortConfig(struct audio_port_config *config)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009012{
Mikhail Naganovdc769682018-05-04 15:34:08 -07009013 ThreadBase::toAudioPortConfig(config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009014 if (isOutput()) {
9015 config->role = AUDIO_PORT_ROLE_SOURCE;
9016 config->ext.mix.hw_module = mAudioHwDev->handle();
9017 config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
9018 } else {
9019 config->role = AUDIO_PORT_ROLE_SINK;
9020 config->ext.mix.hw_module = mAudioHwDev->handle();
9021 config->ext.mix.usecase.source = mAudioSource;
9022 }
9023}
9024
9025status_t AudioFlinger::MmapThread::addEffectChain_l(const sp<EffectChain>& chain)
9026{
9027 audio_session_t session = chain->sessionId();
9028
9029 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
9030 // Attach all tracks with same session ID to this chain.
9031 // indicate all active tracks in the chain
9032 for (const sp<MmapTrack> &track : mActiveTracks) {
9033 if (session == track->sessionId()) {
9034 chain->incTrackCnt();
9035 chain->incActiveTrackCnt();
9036 }
9037 }
9038
9039 chain->setThread(this);
9040 chain->setInBuffer(nullptr);
9041 chain->setOutBuffer(nullptr);
9042 chain->syncHalEffectsState();
9043
9044 mEffectChains.add(chain);
9045 checkSuspendOnAddEffectChain_l(chain);
9046 return NO_ERROR;
9047}
9048
9049size_t AudioFlinger::MmapThread::removeEffectChain_l(const sp<EffectChain>& chain)
9050{
9051 audio_session_t session = chain->sessionId();
9052
9053 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
9054
9055 for (size_t i = 0; i < mEffectChains.size(); i++) {
9056 if (chain == mEffectChains[i]) {
9057 mEffectChains.removeAt(i);
9058 // detach all active tracks from the chain
9059 // detach all tracks with same session ID from this chain
9060 for (const sp<MmapTrack> &track : mActiveTracks) {
9061 if (session == track->sessionId()) {
9062 chain->decActiveTrackCnt();
9063 chain->decTrackCnt();
9064 }
9065 }
9066 break;
9067 }
9068 }
9069 return mEffectChains.size();
9070}
9071
Eric Laurent6acd1d42017-01-04 14:23:29 -08009072void AudioFlinger::MmapThread::threadLoop_standby()
9073{
9074 mHalStream->standby();
9075}
9076
9077void AudioFlinger::MmapThread::threadLoop_exit()
9078{
Phil Burk7dce7282017-09-27 13:51:41 -07009079 // Do not call callback->onTearDown() because it is redundant for thread exit
9080 // and because it can cause a recursive mutex lock on stop().
Eric Laurent6acd1d42017-01-04 14:23:29 -08009081}
9082
9083status_t AudioFlinger::MmapThread::setSyncEvent(const sp<SyncEvent>& event __unused)
9084{
9085 return BAD_VALUE;
9086}
9087
9088bool AudioFlinger::MmapThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
9089{
9090 return false;
9091}
9092
9093status_t AudioFlinger::MmapThread::checkEffectCompatibility_l(
9094 const effect_descriptor_t *desc, audio_session_t sessionId)
9095{
9096 // No global effect sessions on mmap threads
9097 if (sessionId == AUDIO_SESSION_OUTPUT_MIX || sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
9098 ALOGW("checkEffectCompatibility_l(): global effect %s on record thread %s",
9099 desc->name, mThreadName);
9100 return BAD_VALUE;
9101 }
9102
9103 if (!isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC)) {
9104 ALOGW("checkEffectCompatibility_l(): non pre processing effect %s on capture mmap thread",
9105 desc->name);
9106 return BAD_VALUE;
9107 }
9108 if (isOutput() && ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08009109 ALOGW("checkEffectCompatibility_l(): pre processing effect %s created on playback mmap "
9110 "thread", desc->name);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009111 return BAD_VALUE;
9112 }
9113
9114 // Only allow effects without processing load or latency
9115 if ((desc->flags & EFFECT_FLAG_NO_PROCESS_MASK) != EFFECT_FLAG_NO_PROCESS) {
9116 return BAD_VALUE;
9117 }
9118
9119 return NO_ERROR;
9120
9121}
9122
9123void AudioFlinger::MmapThread::checkInvalidTracks_l()
9124{
9125 for (const sp<MmapTrack> &track : mActiveTracks) {
9126 if (track->isInvalid()) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08009127 sp<MmapStreamCallback> callback = mCallback.promote();
9128 if (callback != 0) {
Eric Laurent734046e2018-04-16 14:50:52 -07009129 mLock.unlock();
Eric Laurent331679c2018-04-16 17:03:16 -07009130 callback->onTearDown(track->portId());
Eric Laurent734046e2018-04-16 14:50:52 -07009131 mLock.lock();
Eric Laurent331679c2018-04-16 17:03:16 -07009132 } else if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9133 ALOGW("Could not notify MMAP stream tear down: no onTearDown callback!");
9134 mNoCallbackWarningCount++;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009135 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009136 }
9137 }
9138}
9139
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009140void AudioFlinger::MmapThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009141{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009142 dprintf(fd, " Attributes: content type %d usage %d source %d\n",
9143 mAttr.content_type, mAttr.usage, mAttr.source);
9144 dprintf(fd, " Session: %d port Id: %d\n", mSessionId, mPortId);
Eric Tan39ec8d62018-07-24 09:49:29 -07009145 if (mActiveTracks.isEmpty()) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009146 dprintf(fd, " No active clients\n");
9147 }
9148}
9149
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009150void AudioFlinger::MmapThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009151{
Eric Laurent6acd1d42017-01-04 14:23:29 -08009152 String8 result;
Eric Laurent6acd1d42017-01-04 14:23:29 -08009153 size_t numtracks = mActiveTracks.size();
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009154 dprintf(fd, " %zu Tracks\n", numtracks);
9155 const char *prefix = " ";
Eric Laurent6acd1d42017-01-04 14:23:29 -08009156 if (numtracks) {
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009157 result.append(prefix);
Kevin Rocard5f2136e2018-05-11 22:03:00 -07009158 mActiveTracks[0]->appendDumpHeader(result);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009159 for (size_t i = 0; i < numtracks ; ++i) {
9160 sp<MmapTrack> track = mActiveTracks[i];
Andy Hung2c6c3bb2017-06-16 14:01:45 -07009161 result.append(prefix);
9162 track->appendDump(result, true /* active */);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009163 }
9164 } else {
9165 dprintf(fd, "\n");
9166 }
9167 write(fd, result.string(), result.size());
9168}
9169
9170AudioFlinger::MmapPlaybackThread::MmapPlaybackThread(
9171 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
9172 AudioHwDevice *hwDev, AudioStreamOut *output,
9173 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady)
9174 : MmapThread(audioFlinger, id, hwDev, output->stream, outDevice, inDevice, systemReady),
9175 mStreamType(AUDIO_STREAM_MUSIC),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009176 mStreamVolume(1.0),
9177 mStreamMute(false),
Phil Burk56ecf3e2018-03-12 15:38:17 -07009178 mOutput(output)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009179{
9180 snprintf(mThreadName, kThreadNameLength, "AudioMmapOut_%X", id);
9181 mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
9182 mMasterVolume = audioFlinger->masterVolume_l();
9183 mMasterMute = audioFlinger->masterMute_l();
9184 if (mAudioHwDev) {
9185 if (mAudioHwDev->canSetMasterVolume()) {
9186 mMasterVolume = 1.0;
9187 }
9188
9189 if (mAudioHwDev->canSetMasterMute()) {
9190 mMasterMute = false;
9191 }
9192 }
9193}
9194
9195void AudioFlinger::MmapPlaybackThread::configure(const audio_attributes_t *attr,
9196 audio_stream_type_t streamType,
9197 audio_session_t sessionId,
9198 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009199 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08009200 audio_port_handle_t portId)
9201{
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07009202 MmapThread::configure(attr, streamType, sessionId, callback, deviceId, portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009203 mStreamType = streamType;
9204}
9205
9206AudioStreamOut* AudioFlinger::MmapPlaybackThread::clearOutput()
9207{
9208 Mutex::Autolock _l(mLock);
9209 AudioStreamOut *output = mOutput;
9210 mOutput = NULL;
9211 return output;
9212}
9213
9214void AudioFlinger::MmapPlaybackThread::setMasterVolume(float value)
9215{
9216 Mutex::Autolock _l(mLock);
9217 // Don't apply master volume in SW if our HAL can do it for us.
9218 if (mAudioHwDev &&
9219 mAudioHwDev->canSetMasterVolume()) {
9220 mMasterVolume = 1.0;
9221 } else {
9222 mMasterVolume = value;
9223 }
9224}
9225
9226void AudioFlinger::MmapPlaybackThread::setMasterMute(bool muted)
9227{
9228 Mutex::Autolock _l(mLock);
9229 // Don't apply master mute in SW if our HAL can do it for us.
9230 if (mAudioHwDev && mAudioHwDev->canSetMasterMute()) {
9231 mMasterMute = false;
9232 } else {
9233 mMasterMute = muted;
9234 }
9235}
9236
9237void AudioFlinger::MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
9238{
9239 Mutex::Autolock _l(mLock);
9240 if (stream == mStreamType) {
9241 mStreamVolume = value;
9242 broadcast_l();
9243 }
9244}
9245
9246float AudioFlinger::MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
9247{
9248 Mutex::Autolock _l(mLock);
9249 if (stream == mStreamType) {
9250 return mStreamVolume;
9251 }
9252 return 0.0f;
9253}
9254
9255void AudioFlinger::MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
9256{
9257 Mutex::Autolock _l(mLock);
9258 if (stream == mStreamType) {
9259 mStreamMute= muted;
9260 broadcast_l();
9261 }
9262}
9263
9264void AudioFlinger::MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
9265{
9266 Mutex::Autolock _l(mLock);
9267 if (streamType == mStreamType) {
9268 for (const sp<MmapTrack> &track : mActiveTracks) {
9269 track->invalidate();
9270 }
9271 broadcast_l();
9272 }
9273}
9274
9275void AudioFlinger::MmapPlaybackThread::processVolume_l()
9276{
9277 float volume;
9278
9279 if (mMasterMute || mStreamMute) {
9280 volume = 0;
9281 } else {
9282 volume = mMasterVolume * mStreamVolume;
9283 }
9284
9285 if (volume != mHalVolFloat) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08009286
9287 // Convert volumes from float to 8.24
9288 uint32_t vol = (uint32_t)(volume * (1 << 24));
9289
9290 // Delegate volume control to effect in track effect chain if needed
9291 // only one effect chain can be present on DirectOutputThread, so if
9292 // there is one, the track is connected to it
9293 if (!mEffectChains.isEmpty()) {
9294 mEffectChains[0]->setVolume_l(&vol, &vol);
9295 volume = (float)vol / (1 << 24);
9296 }
Eric Laurentdff774a2017-04-21 15:29:38 -07009297 // Try to use HW volume control and fall back to SW control if not implemented
Phil Burk56ecf3e2018-03-12 15:38:17 -07009298 if (mOutput->stream->setVolume(volume, volume) == NO_ERROR) {
9299 mHalVolFloat = volume; // HW volume control worked, so update value.
9300 mNoCallbackWarningCount = 0;
9301 } else {
Eric Laurentdff774a2017-04-21 15:29:38 -07009302 sp<MmapStreamCallback> callback = mCallback.promote();
9303 if (callback != 0) {
9304 int channelCount;
9305 if (isOutput()) {
9306 channelCount = audio_channel_count_from_out_mask(mChannelMask);
9307 } else {
9308 channelCount = audio_channel_count_from_in_mask(mChannelMask);
9309 }
9310 Vector<float> values;
9311 for (int i = 0; i < channelCount; i++) {
9312 values.add(volume);
9313 }
Phil Burk56ecf3e2018-03-12 15:38:17 -07009314 mHalVolFloat = volume; // SW volume control worked, so update value.
9315 mNoCallbackWarningCount = 0;
Eric Laurent734046e2018-04-16 14:50:52 -07009316 mLock.unlock();
9317 callback->onVolumeChanged(mChannelMask, values);
9318 mLock.lock();
Eric Laurent6acd1d42017-01-04 14:23:29 -08009319 } else {
Phil Burk56ecf3e2018-03-12 15:38:17 -07009320 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9321 ALOGW("Could not set MMAP stream volume: no volume callback!");
9322 mNoCallbackWarningCount++;
9323 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009324 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08009325 }
9326 }
9327}
9328
Kevin Rocard069c2712018-03-29 19:09:14 -07009329void AudioFlinger::MmapPlaybackThread::updateMetadata_l()
9330{
9331 if (mOutput == nullptr || mOutput->stream == nullptr ||
9332 !mActiveTracks.readAndClearHasChanged()) {
9333 return;
9334 }
9335 StreamOutHalInterface::SourceMetadata metadata;
9336 for (const sp<MmapTrack> &track : mActiveTracks) {
9337 // No track is invalid as this is called after prepareTrack_l in the same critical section
9338 metadata.tracks.push_back({
9339 .usage = track->attributes().usage,
9340 .content_type = track->attributes().content_type,
9341 .gain = mHalVolFloat, // TODO: propagate from aaudio pre-mix volume
9342 });
9343 }
9344 mOutput->stream->updateSourceMetadata(metadata);
9345}
9346
Eric Laurent6acd1d42017-01-04 14:23:29 -08009347void AudioFlinger::MmapPlaybackThread::checkSilentMode_l()
9348{
9349 if (!mMasterMute) {
9350 char value[PROPERTY_VALUE_MAX];
9351 if (property_get("ro.audio.silent", value, "0") > 0) {
9352 char *endptr;
9353 unsigned long ul = strtoul(value, &endptr, 0);
9354 if (*endptr == '\0' && ul != 0) {
9355 ALOGD("Silence is golden");
9356 // The setprop command will not allow a property to be changed after
9357 // the first time it is set, so we don't have to worry about un-muting.
9358 setMasterMute_l(true);
9359 }
9360 }
9361 }
9362}
9363
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009364void AudioFlinger::MmapPlaybackThread::toAudioPortConfig(struct audio_port_config *config)
9365{
9366 MmapThread::toAudioPortConfig(config);
9367 if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
9368 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9369 config->flags.output = mOutput->flags;
9370 }
9371}
9372
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009373void AudioFlinger::MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
Eric Laurent6acd1d42017-01-04 14:23:29 -08009374{
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07009375 MmapThread::dumpInternals_l(fd, args);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009376
Glenn Kastend3bb6452016-12-05 18:14:37 -08009377 dprintf(fd, " Stream type: %d Stream volume: %f HAL volume: %f Stream mute %d\n",
9378 mStreamType, mStreamVolume, mHalVolFloat, mStreamMute);
Eric Laurent6acd1d42017-01-04 14:23:29 -08009379 dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
9380}
9381
9382AudioFlinger::MmapCaptureThread::MmapCaptureThread(
9383 const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
9384 AudioHwDevice *hwDev, AudioStreamIn *input,
9385 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady)
9386 : MmapThread(audioFlinger, id, hwDev, input->stream, outDevice, inDevice, systemReady),
9387 mInput(input)
9388{
9389 snprintf(mThreadName, kThreadNameLength, "AudioMmapIn_%X", id);
9390 mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
9391}
9392
Eric Laurent331679c2018-04-16 17:03:16 -07009393status_t AudioFlinger::MmapCaptureThread::exitStandby()
9394{
Phil Burkf054fc32018-12-06 09:45:59 -08009395 {
9396 // mInput might have been cleared by clearInput()
9397 Mutex::Autolock _l(mLock);
9398 if (mInput != nullptr && mInput->stream != nullptr) {
9399 mInput->stream->setGain(1.0f);
9400 }
9401 }
Eric Laurent331679c2018-04-16 17:03:16 -07009402 return MmapThread::exitStandby();
9403}
9404
Eric Laurent6acd1d42017-01-04 14:23:29 -08009405AudioFlinger::AudioStreamIn* AudioFlinger::MmapCaptureThread::clearInput()
9406{
9407 Mutex::Autolock _l(mLock);
9408 AudioStreamIn *input = mInput;
9409 mInput = NULL;
9410 return input;
9411}
Kevin Rocard069c2712018-03-29 19:09:14 -07009412
Eric Laurent331679c2018-04-16 17:03:16 -07009413
9414void AudioFlinger::MmapCaptureThread::processVolume_l()
9415{
9416 bool changed = false;
9417 bool silenced = false;
9418
9419 sp<MmapStreamCallback> callback = mCallback.promote();
9420 if (callback == 0) {
9421 if (mNoCallbackWarningCount < kMaxNoCallbackWarnings) {
9422 ALOGW("Could not set MMAP stream silenced: no onStreamSilenced callback!");
9423 mNoCallbackWarningCount++;
9424 }
9425 }
9426
9427 // After a change occurred in track silenced state, mute capture in audio DSP if at least one
9428 // track is silenced and unmute otherwise
9429 for (size_t i = 0; i < mActiveTracks.size() && !silenced; i++) {
9430 if (!mActiveTracks[i]->getAndSetSilencedNotified_l()) {
9431 changed = true;
9432 silenced = mActiveTracks[i]->isSilenced_l();
9433 }
9434 }
9435
9436 if (changed) {
9437 mInput->stream->setGain(silenced ? 0.0f: 1.0f);
9438 }
9439}
9440
Kevin Rocard069c2712018-03-29 19:09:14 -07009441void AudioFlinger::MmapCaptureThread::updateMetadata_l()
9442{
9443 if (mInput == nullptr || mInput->stream == nullptr ||
9444 !mActiveTracks.readAndClearHasChanged()) {
9445 return;
9446 }
9447 StreamInHalInterface::SinkMetadata metadata;
9448 for (const sp<MmapTrack> &track : mActiveTracks) {
9449 // No track is invalid as this is called after prepareTrack_l in the same critical section
9450 metadata.tracks.push_back({
9451 .source = track->attributes().source,
9452 .gain = 1, // capture tracks do not have volumes
9453 });
9454 }
9455 mInput->stream->updateSinkMetadata(metadata);
9456}
9457
Eric Laurent331679c2018-04-16 17:03:16 -07009458void AudioFlinger::MmapCaptureThread::setRecordSilenced(uid_t uid, bool silenced)
9459{
9460 Mutex::Autolock _l(mLock);
9461 for (size_t i = 0; i < mActiveTracks.size() ; i++) {
9462 if (mActiveTracks[i]->uid() == uid) {
9463 mActiveTracks[i]->setSilenced_l(silenced);
9464 broadcast_l();
9465 }
9466 }
9467}
9468
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07009469void AudioFlinger::MmapCaptureThread::toAudioPortConfig(struct audio_port_config *config)
9470{
9471 MmapThread::toAudioPortConfig(config);
9472 if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
9473 config->config_mask |= AUDIO_PORT_CONFIG_FLAGS;
9474 config->flags.input = mInput->flags;
9475 }
9476}
9477
Glenn Kasten63238ef2015-03-02 15:50:29 -08009478} // namespace android