blob: ef466a26dd18470bbcc22d35bcb72ce5a879992f [file] [log] [blame]
Glenn Kasten97b5d0d2012-03-23 18:54:19 -07001/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Glenn Kastena3d26282012-11-30 07:57:43 -080017// <IMPORTANT_WARNING>
18// Design rules for threadLoop() are given in the comments at section "Fast mixer thread" of
19// StateQueue.h. In particular, avoid library and system calls except at well-known points.
20// The design rules are only for threadLoop(), and don't apply to FastMixerDumpState methods.
21// </IMPORTANT_WARNING>
22
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070023#define LOG_TAG "FastMixer"
Glenn Kasten7f5d3352013-02-15 23:55:04 +000024//#define LOG_NDEBUG 0
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070025
Alex Rayb3a83642012-11-30 19:42:28 -080026#define ATRACE_TAG ATRACE_TAG_AUDIO
Alex Ray371eb972012-11-30 11:11:54 -080027
Glenn Kasten153b9fe2013-07-15 11:23:36 -070028#include "Configuration.h"
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070029#include <time.h>
Glenn Kastenad8510a2015-02-17 16:24:07 -080030#include <utils/Debug.h>
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070031#include <utils/Log.h>
Glenn Kastend8e6fd32012-05-07 11:07:57 -070032#include <utils/Trace.h>
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070033#include <system/audio.h>
Glenn Kasten214b4062015-03-02 14:15:47 -080034#ifdef FAST_THREAD_STATISTICS
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070035#include <cpustats/CentralTendencyStatistics.h>
Glenn Kasten0a14c4c2012-06-13 14:58:49 -070036#ifdef CPU_FREQUENCY_STATISTICS
Glenn Kasten42d45cf2012-05-02 10:34:47 -070037#include <cpustats/ThreadCpuUsage.h>
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070038#endif
Glenn Kasten0a14c4c2012-06-13 14:58:49 -070039#endif
Glenn Kasten6bf707f2017-02-23 16:53:58 -080040#include <audio_utils/mono_blend.h>
Andy Hung1258c1a2014-05-23 21:22:17 -070041#include <audio_utils/format.h>
Andy Hung068561c2017-01-03 17:09:32 -080042#include <media/AudioMixer.h>
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070043#include "FastMixer.h"
Glenn Kasteneef598c2017-04-03 14:41:13 -070044#include "TypedLogger.h"
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070045
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070046namespace android {
47
Glenn Kastene4a7ce22015-03-03 11:23:17 -080048/*static*/ const FastMixerState FastMixer::sInitial;
Glenn Kasten22340022014-04-07 12:04:41 -070049
Glenn Kastenf9715e42016-07-13 14:02:03 -070050FastMixer::FastMixer() : FastThread("cycle_ms", "load_us"),
Glenn Kastene4a7ce22015-03-03 11:23:17 -080051 // mFastTrackNames
52 // mGenerations
53 mOutputSink(NULL),
54 mOutputSinkGen(0),
55 mMixer(NULL),
Andy Hung1258c1a2014-05-23 21:22:17 -070056 mSinkBuffer(NULL),
57 mSinkBufferSize(0),
Andy Hung9a592762014-07-21 21:56:01 -070058 mSinkChannelCount(FCC_2),
Andy Hung45d68d32014-05-23 21:13:31 -070059 mMixerBuffer(NULL),
Andy Hung1258c1a2014-05-23 21:22:17 -070060 mMixerBufferSize(0),
61 mMixerBufferFormat(AUDIO_FORMAT_PCM_16_BIT),
Andy Hung45d68d32014-05-23 21:13:31 -070062 mMixerBufferState(UNDEFINED),
Glenn Kastene4a7ce22015-03-03 11:23:17 -080063 mFormat(Format_Invalid),
64 mSampleRate(0),
65 mFastTracksGen(0),
66 mTotalNativeFramesWritten(0),
Glenn Kasten22340022014-04-07 12:04:41 -070067 // timestamp
Andy Hung2ddee192015-12-18 17:34:44 -080068 mNativeFramesWrittenButNotPresented(0), // the = 0 is to silence the compiler
69 mMasterMono(false)
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070070{
Glenn Kastene4a7ce22015-03-03 11:23:17 -080071 // FIXME pass sInitial as parameter to base class constructor, and make it static local
72 mPrevious = &sInitial;
73 mCurrent = &sInitial;
Glenn Kasten22340022014-04-07 12:04:41 -070074
Glenn Kastene4a7ce22015-03-03 11:23:17 -080075 mDummyDumpState = &mDummyFastMixerDumpState;
Andy Hung9a592762014-07-21 21:56:01 -070076 // TODO: Add channel mask to NBAIO_Format.
77 // We assume that the channel mask must be a valid positional channel mask.
78 mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount);
Glenn Kasten22340022014-04-07 12:04:41 -070079
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070080 unsigned i;
Glenn Kastendc2c50b2016-04-21 08:13:14 -070081 for (i = 0; i < FastMixerState::sMaxFastTracks; ++i) {
Glenn Kastene4a7ce22015-03-03 11:23:17 -080082 mGenerations[i] = 0;
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070083 }
Glenn Kasten214b4062015-03-02 14:15:47 -080084#ifdef FAST_THREAD_STATISTICS
Glenn Kastene4a7ce22015-03-03 11:23:17 -080085 mOldLoad.tv_sec = 0;
86 mOldLoad.tv_nsec = 0;
Glenn Kasten97b5d0d2012-03-23 18:54:19 -070087#endif
Glenn Kasten22340022014-04-07 12:04:41 -070088}
89
90FastMixer::~FastMixer()
91{
92}
93
94FastMixerStateQueue* FastMixer::sq()
95{
96 return &mSQ;
97}
98
99const FastThreadState *FastMixer::poll()
100{
101 return mSQ.poll();
102}
103
Glenn Kasten3ab8d662017-04-03 14:35:09 -0700104void FastMixer::setNBLogWriter(NBLog::Writer *logWriter)
Glenn Kasten22340022014-04-07 12:04:41 -0700105{
Glenn Kasten3ab8d662017-04-03 14:35:09 -0700106 // FIXME If mMixer is set or changed prior to this, we don't inform correctly.
107 // Should cache logWriter and re-apply it at the assignment to mMixer.
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800108 if (mMixer != NULL) {
Glenn Kasten3ab8d662017-04-03 14:35:09 -0700109 mMixer->setNBLogWriter(logWriter);
Glenn Kasten22340022014-04-07 12:04:41 -0700110 }
111}
112
113void FastMixer::onIdle()
114{
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800115 mPreIdle = *(const FastMixerState *)mCurrent;
116 mCurrent = &mPreIdle;
Glenn Kasten22340022014-04-07 12:04:41 -0700117}
118
119void FastMixer::onExit()
120{
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800121 delete mMixer;
Andy Hung1258c1a2014-05-23 21:22:17 -0700122 free(mMixerBuffer);
123 free(mSinkBuffer);
Glenn Kasten22340022014-04-07 12:04:41 -0700124}
125
126bool FastMixer::isSubClassCommand(FastThreadState::Command command)
127{
128 switch ((FastMixerState::Command) command) {
129 case FastMixerState::MIX:
130 case FastMixerState::WRITE:
131 case FastMixerState::MIX_WRITE:
132 return true;
133 default:
134 return false;
135 }
136}
137
138void FastMixer::onStateChange()
139{
Glenn Kasten4dd03b52015-03-03 11:32:04 -0800140 const FastMixerState * const current = (const FastMixerState *) mCurrent;
141 const FastMixerState * const previous = (const FastMixerState *) mPrevious;
142 FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState;
Glenn Kasten22340022014-04-07 12:04:41 -0700143 const size_t frameCount = current->mFrameCount;
144
Andy Hung818e7a32016-02-16 18:08:07 -0800145 // update boottime offset, in case it has changed
146 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
147 mBoottimeOffset.load();
148
Glenn Kasten22340022014-04-07 12:04:41 -0700149 // handle state change here, but since we want to diff the state,
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800150 // we're prepared for previous == &sInitial the first time through
Glenn Kasten22340022014-04-07 12:04:41 -0700151 unsigned previousTrackMask;
152
153 // check for change in output HAL configuration
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800154 NBAIO_Format previousFormat = mFormat;
155 if (current->mOutputSinkGen != mOutputSinkGen) {
156 mOutputSink = current->mOutputSink;
157 mOutputSinkGen = current->mOutputSinkGen;
158 if (mOutputSink == NULL) {
159 mFormat = Format_Invalid;
160 mSampleRate = 0;
Andy Hung9a592762014-07-21 21:56:01 -0700161 mSinkChannelCount = 0;
162 mSinkChannelMask = AUDIO_CHANNEL_NONE;
Glenn Kasten22340022014-04-07 12:04:41 -0700163 } else {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800164 mFormat = mOutputSink->format();
165 mSampleRate = Format_sampleRate(mFormat);
166 mSinkChannelCount = Format_channelCount(mFormat);
Andy Hung9a592762014-07-21 21:56:01 -0700167 LOG_ALWAYS_FATAL_IF(mSinkChannelCount > AudioMixer::MAX_NUM_CHANNELS);
168
169 // TODO: Add channel mask to NBAIO_Format
170 // We assume that the channel mask must be a valid positional channel mask.
171 mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount);
Glenn Kasten22340022014-04-07 12:04:41 -0700172 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800173 dumpState->mSampleRate = mSampleRate;
Glenn Kasten22340022014-04-07 12:04:41 -0700174 }
175
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800176 if ((!Format_isEqual(mFormat, previousFormat)) || (frameCount != previous->mFrameCount)) {
Glenn Kasten22340022014-04-07 12:04:41 -0700177 // FIXME to avoid priority inversion, don't delete here
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800178 delete mMixer;
179 mMixer = NULL;
Andy Hung1258c1a2014-05-23 21:22:17 -0700180 free(mMixerBuffer);
Andy Hung45d68d32014-05-23 21:13:31 -0700181 mMixerBuffer = NULL;
Andy Hung1258c1a2014-05-23 21:22:17 -0700182 free(mSinkBuffer);
183 mSinkBuffer = NULL;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800184 if (frameCount > 0 && mSampleRate > 0) {
Andy Hung60c545d2015-06-19 17:34:53 -0700185 // The mixer produces either 16 bit PCM or float output, select
186 // float output if the HAL supports higher than 16 bit precision.
187 mMixerBufferFormat = mFormat.mFormat == AUDIO_FORMAT_PCM_16_BIT ?
188 AUDIO_FORMAT_PCM_16_BIT : AUDIO_FORMAT_PCM_FLOAT;
Glenn Kasten22340022014-04-07 12:04:41 -0700189 // FIXME new may block for unbounded time at internal mutex of the heap
190 // implementation; it would be better to have normal mixer allocate for us
191 // to avoid blocking here and to prevent possible priority inversion
Andy Hung1bc088a2018-02-09 15:57:31 -0800192 mMixer = new AudioMixer(frameCount, mSampleRate);
Glenn Kasten3ab8d662017-04-03 14:35:09 -0700193 // FIXME See the other FIXME at FastMixer::setNBLogWriter()
Andy Hung9a592762014-07-21 21:56:01 -0700194 const size_t mixerFrameSize = mSinkChannelCount
195 * audio_bytes_per_sample(mMixerBufferFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -0700196 mMixerBufferSize = mixerFrameSize * frameCount;
197 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
Andy Hung9a592762014-07-21 21:56:01 -0700198 const size_t sinkFrameSize = mSinkChannelCount
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800199 * audio_bytes_per_sample(mFormat.mFormat);
Andy Hung1258c1a2014-05-23 21:22:17 -0700200 if (sinkFrameSize > mixerFrameSize) { // need a sink buffer
201 mSinkBufferSize = sinkFrameSize * frameCount;
202 (void)posix_memalign(&mSinkBuffer, 32, mSinkBufferSize);
203 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800204 mPeriodNs = (frameCount * 1000000000LL) / mSampleRate; // 1.00
205 mUnderrunNs = (frameCount * 1750000000LL) / mSampleRate; // 1.75
206 mOverrunNs = (frameCount * 500000000LL) / mSampleRate; // 0.50
207 mForceNs = (frameCount * 950000000LL) / mSampleRate; // 0.95
208 mWarmupNsMin = (frameCount * 750000000LL) / mSampleRate; // 0.75
209 mWarmupNsMax = (frameCount * 1250000000LL) / mSampleRate; // 1.25
Glenn Kasten22340022014-04-07 12:04:41 -0700210 } else {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800211 mPeriodNs = 0;
212 mUnderrunNs = 0;
213 mOverrunNs = 0;
214 mForceNs = 0;
215 mWarmupNsMin = 0;
216 mWarmupNsMax = LONG_MAX;
Glenn Kasten22340022014-04-07 12:04:41 -0700217 }
Andy Hung45d68d32014-05-23 21:13:31 -0700218 mMixerBufferState = UNDEFINED;
Glenn Kasten22340022014-04-07 12:04:41 -0700219#if !LOG_NDEBUG
Glenn Kastendc2c50b2016-04-21 08:13:14 -0700220 for (unsigned i = 0; i < FastMixerState::sMaxFastTracks; ++i) {
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800221 mFastTrackNames[i] = -1;
Glenn Kasten22340022014-04-07 12:04:41 -0700222 }
Glenn Kasten0a14c4c2012-06-13 14:58:49 -0700223#endif
Glenn Kasten22340022014-04-07 12:04:41 -0700224 // we need to reconfigure all active tracks
225 previousTrackMask = 0;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800226 mFastTracksGen = current->mFastTracksGen - 1;
Glenn Kasten22340022014-04-07 12:04:41 -0700227 dumpState->mFrameCount = frameCount;
228 } else {
229 previousTrackMask = previous->mTrackMask;
230 }
Glenn Kasten732845c2013-08-23 09:26:31 -0700231
Glenn Kasten22340022014-04-07 12:04:41 -0700232 // check for change in active track set
233 const unsigned currentTrackMask = current->mTrackMask;
234 dumpState->mTrackMask = currentTrackMask;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800235 if (current->mFastTracksGen != mFastTracksGen) {
Andy Hung45d68d32014-05-23 21:13:31 -0700236 ALOG_ASSERT(mMixerBuffer != NULL);
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700237
Glenn Kasten22340022014-04-07 12:04:41 -0700238 // process removed tracks first to avoid running out of track names
239 unsigned removedTracks = previousTrackMask & ~currentTrackMask;
240 while (removedTracks != 0) {
241 int i = __builtin_ctz(removedTracks);
242 removedTracks &= ~(1 << i);
243 const FastTrack* fastTrack = &current->mFastTracks[i];
244 ALOG_ASSERT(fastTrack->mBufferProvider == NULL);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800245 if (mMixer != NULL) {
Andy Hung1bc088a2018-02-09 15:57:31 -0800246 mMixer->destroy(i);
Glenn Kasten22340022014-04-07 12:04:41 -0700247 }
248#if !LOG_NDEBUG
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800249 mFastTrackNames[i] = -1;
Glenn Kasten22340022014-04-07 12:04:41 -0700250#endif
251 // don't reset track dump state, since other side is ignoring it
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800252 mGenerations[i] = fastTrack->mGeneration;
Glenn Kasten22340022014-04-07 12:04:41 -0700253 }
254
255 // now process added tracks
256 unsigned addedTracks = currentTrackMask & ~previousTrackMask;
257 while (addedTracks != 0) {
258 int i = __builtin_ctz(addedTracks);
259 addedTracks &= ~(1 << i);
260 const FastTrack* fastTrack = &current->mFastTracks[i];
261 AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800262 ALOG_ASSERT(bufferProvider != NULL && mFastTrackNames[i] == -1);
263 if (mMixer != NULL) {
Andy Hung1bc088a2018-02-09 15:57:31 -0800264 const int name = i; // for clarity, choose name as fast track index.
265 status_t status = mMixer->create(
266 name,
267 fastTrack->mChannelMask,
Andy Hunge8a1ced2014-05-09 15:02:21 -0700268 fastTrack->mFormat, AUDIO_SESSION_OUTPUT_MIX);
Andy Hung1bc088a2018-02-09 15:57:31 -0800269 LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
270 "%s: cannot create track name"
271 " %d, mask %#x, format %#x, sessionId %d in AudioMixer",
272 __func__, name,
273 fastTrack->mChannelMask, fastTrack->mFormat, AUDIO_SESSION_OUTPUT_MIX);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800274 mMixer->setBufferProvider(name, bufferProvider);
275 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER,
Andy Hung9a592762014-07-21 21:56:01 -0700276 (void *)mMixerBuffer);
Glenn Kasten22340022014-04-07 12:04:41 -0700277 // newly allocated track names default to full scale volume
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800278 mMixer->setParameter(
Andy Hung1258c1a2014-05-23 21:22:17 -0700279 name,
280 AudioMixer::TRACK,
281 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800282 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::FORMAT,
Andy Hungef7c7fb2014-05-12 16:51:41 -0700283 (void *)(uintptr_t)fastTrack->mFormat);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800284 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
Andy Hung9a592762014-07-21 21:56:01 -0700285 (void *)(uintptr_t)fastTrack->mChannelMask);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800286 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK,
Andy Hung9a592762014-07-21 21:56:01 -0700287 (void *)(uintptr_t)mSinkChannelMask);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800288 mMixer->enable(name);
Glenn Kasten22340022014-04-07 12:04:41 -0700289 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800290 mGenerations[i] = fastTrack->mGeneration;
Glenn Kasten22340022014-04-07 12:04:41 -0700291 }
292
293 // finally process (potentially) modified tracks; these use the same slot
294 // but may have a different buffer provider or volume provider
295 unsigned modifiedTracks = currentTrackMask & previousTrackMask;
296 while (modifiedTracks != 0) {
297 int i = __builtin_ctz(modifiedTracks);
298 modifiedTracks &= ~(1 << i);
299 const FastTrack* fastTrack = &current->mFastTracks[i];
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800300 if (fastTrack->mGeneration != mGenerations[i]) {
Glenn Kasten22340022014-04-07 12:04:41 -0700301 // this track was actually modified
302 AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
303 ALOG_ASSERT(bufferProvider != NULL);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800304 if (mMixer != NULL) {
Andy Hung1bc088a2018-02-09 15:57:31 -0800305 const int name = i;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800306 mMixer->setBufferProvider(name, bufferProvider);
Glenn Kasten22340022014-04-07 12:04:41 -0700307 if (fastTrack->mVolumeProvider == NULL) {
Andy Hung6be49402014-05-30 10:42:03 -0700308 float f = AudioMixer::UNITY_GAIN_FLOAT;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800309 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0, &f);
310 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1, &f);
Glenn Kasten288ed212012-04-25 17:52:27 -0700311 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800312 mMixer->setParameter(name, AudioMixer::RESAMPLE,
Glenn Kasten22340022014-04-07 12:04:41 -0700313 AudioMixer::REMOVE, NULL);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800314 mMixer->setParameter(
Andy Hung1258c1a2014-05-23 21:22:17 -0700315 name,
316 AudioMixer::TRACK,
317 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800318 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::FORMAT,
Andy Hungef7c7fb2014-05-12 16:51:41 -0700319 (void *)(uintptr_t)fastTrack->mFormat);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800320 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
Andy Hung9a592762014-07-21 21:56:01 -0700321 (void *)(uintptr_t)fastTrack->mChannelMask);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800322 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK,
Andy Hung9a592762014-07-21 21:56:01 -0700323 (void *)(uintptr_t)mSinkChannelMask);
Glenn Kasten22340022014-04-07 12:04:41 -0700324 // already enabled
325 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800326 mGenerations[i] = fastTrack->mGeneration;
Glenn Kasten22340022014-04-07 12:04:41 -0700327 }
328 }
329
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800330 mFastTracksGen = current->mFastTracksGen;
Glenn Kasten22340022014-04-07 12:04:41 -0700331
332 dumpState->mNumTracks = popcount(currentTrackMask);
333 }
334}
335
336void FastMixer::onWork()
337{
Sanna Catherine de Treville Wager85768942017-07-26 20:17:30 -0700338 // TODO: pass an ID parameter to indicate which time series we want to write to in NBLog.cpp
339 // Or: pass both of these into a single call with a boolean
340 if (mIsWarm) {
341 LOG_HIST_TS();
342 } else {
343 LOG_AUDIO_STATE();
344 }
Glenn Kasten4dd03b52015-03-03 11:32:04 -0800345 const FastMixerState * const current = (const FastMixerState *) mCurrent;
346 FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState;
347 const FastMixerState::Command command = mCommand;
Glenn Kasten22340022014-04-07 12:04:41 -0700348 const size_t frameCount = current->mFrameCount;
349
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800350 if ((command & FastMixerState::MIX) && (mMixer != NULL) && mIsWarm) {
Andy Hungef7c7fb2014-05-12 16:51:41 -0700351 ALOG_ASSERT(mMixerBuffer != NULL);
Mohan Kumar947ffa32014-12-12 15:16:46 +0530352
353 // AudioMixer::mState.enabledTracks is undefined if mState.hook == process__validate,
354 // so we keep a side copy of enabledTracks
355 bool anyEnabledTracks = false;
356
Glenn Kasten22340022014-04-07 12:04:41 -0700357 // for each track, update volume and check for underrun
358 unsigned currentTrackMask = current->mTrackMask;
359 while (currentTrackMask != 0) {
360 int i = __builtin_ctz(currentTrackMask);
361 currentTrackMask &= ~(1 << i);
362 const FastTrack* fastTrack = &current->mFastTracks[i];
363
Andy Hung818e7a32016-02-16 18:08:07 -0800364 const int64_t trackFramesWrittenButNotPresented =
365 mNativeFramesWrittenButNotPresented;
366 const int64_t trackFramesWritten = fastTrack->mBufferProvider->framesReleased();
367 ExtendedTimestamp perTrackTimestamp(mTimestamp);
368
369 // Can't provide an ExtendedTimestamp before first frame presented.
370 // Also, timestamp may not go to very last frame on stop().
371 if (trackFramesWritten >= trackFramesWrittenButNotPresented &&
372 perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
373 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
374 trackFramesWritten - trackFramesWrittenButNotPresented;
375 } else {
376 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0;
377 perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1;
Glenn Kasten22340022014-04-07 12:04:41 -0700378 }
Andy Hung818e7a32016-02-16 18:08:07 -0800379 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = trackFramesWritten;
380 fastTrack->mBufferProvider->onTimestamp(perTrackTimestamp);
Glenn Kasten22340022014-04-07 12:04:41 -0700381
Andy Hung1bc088a2018-02-09 15:57:31 -0800382 const int name = i;
Glenn Kasten22340022014-04-07 12:04:41 -0700383 if (fastTrack->mVolumeProvider != NULL) {
Glenn Kastenc56f3422014-03-21 17:53:17 -0700384 gain_minifloat_packed_t vlr = fastTrack->mVolumeProvider->getVolumeLR();
Andy Hung6be49402014-05-30 10:42:03 -0700385 float vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
386 float vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
387
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800388 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0, &vlf);
389 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1, &vrf);
Glenn Kasten22340022014-04-07 12:04:41 -0700390 }
391 // FIXME The current implementation of framesReady() for fast tracks
392 // takes a tryLock, which can block
393 // up to 1 ms. If enough active tracks all blocked in sequence, this would result
394 // in the overall fast mix cycle being delayed. Should use a non-blocking FIFO.
395 size_t framesReady = fastTrack->mBufferProvider->framesReady();
396 if (ATRACE_ENABLED()) {
397 // I wish we had formatted trace names
398 char traceName[16];
399 strcpy(traceName, "fRdy");
400 traceName[4] = i + (i < 10 ? '0' : 'A' - 10);
401 traceName[5] = '\0';
402 ATRACE_INT(traceName, framesReady);
403 }
404 FastTrackDump *ftDump = &dumpState->mTracks[i];
405 FastTrackUnderruns underruns = ftDump->mUnderruns;
406 if (framesReady < frameCount) {
407 if (framesReady == 0) {
408 underruns.mBitFields.mEmpty++;
409 underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800410 mMixer->disable(name);
Glenn Kasten09474df2012-05-10 14:48:07 -0700411 } else {
Glenn Kasten22340022014-04-07 12:04:41 -0700412 // allow mixing partial buffer
413 underruns.mBitFields.mPartial++;
414 underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800415 mMixer->enable(name);
Mohan Kumar947ffa32014-12-12 15:16:46 +0530416 anyEnabledTracks = true;
Glenn Kasten288ed212012-04-25 17:52:27 -0700417 }
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700418 } else {
Glenn Kasten22340022014-04-07 12:04:41 -0700419 underruns.mBitFields.mFull++;
420 underruns.mBitFields.mMostRecent = UNDERRUN_FULL;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800421 mMixer->enable(name);
Mohan Kumar947ffa32014-12-12 15:16:46 +0530422 anyEnabledTracks = true;
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700423 }
Glenn Kasten22340022014-04-07 12:04:41 -0700424 ftDump->mUnderruns = underruns;
425 ftDump->mFramesReady = framesReady;
Andy Hungb54c8542016-09-21 12:55:15 -0700426 ftDump->mFramesWritten = trackFramesWritten;
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700427 }
428
Mohan Kumar947ffa32014-12-12 15:16:46 +0530429 if (anyEnabledTracks) {
430 // process() is CPU-bound
431 mMixer->process();
432 mMixerBufferState = MIXED;
433 } else if (mMixerBufferState != ZEROED) {
434 mMixerBufferState = UNDEFINED;
435 }
436
Andy Hung45d68d32014-05-23 21:13:31 -0700437 } else if (mMixerBufferState == MIXED) {
438 mMixerBufferState = UNDEFINED;
Glenn Kasten22340022014-04-07 12:04:41 -0700439 }
440 //bool didFullWrite = false; // dumpsys could display a count of partial writes
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800441 if ((command & FastMixerState::WRITE) && (mOutputSink != NULL) && (mMixerBuffer != NULL)) {
Andy Hung45d68d32014-05-23 21:13:31 -0700442 if (mMixerBufferState == UNDEFINED) {
Andy Hung1258c1a2014-05-23 21:22:17 -0700443 memset(mMixerBuffer, 0, mMixerBufferSize);
Andy Hung45d68d32014-05-23 21:13:31 -0700444 mMixerBufferState = ZEROED;
Glenn Kasten22340022014-04-07 12:04:41 -0700445 }
Andy Hung2ddee192015-12-18 17:34:44 -0800446
447 if (mMasterMono.load()) { // memory_order_seq_cst
Glenn Kastenc42e9b42016-03-21 11:35:03 -0700448 mono_blend(mMixerBuffer, mMixerBufferFormat, Format_channelCount(mFormat), frameCount,
449 true /*limit*/);
Andy Hung2ddee192015-12-18 17:34:44 -0800450 }
Glenn Kastenf59497b2015-01-26 16:35:47 -0800451 // prepare the buffer used to write to sink
Andy Hung1258c1a2014-05-23 21:22:17 -0700452 void *buffer = mSinkBuffer != NULL ? mSinkBuffer : mMixerBuffer;
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800453 if (mFormat.mFormat != mMixerBufferFormat) { // sink format not the same as mixer format
454 memcpy_by_audio_format(buffer, mFormat.mFormat, mMixerBuffer, mMixerBufferFormat,
455 frameCount * Format_channelCount(mFormat));
Andy Hung1258c1a2014-05-23 21:22:17 -0700456 }
Glenn Kasten22340022014-04-07 12:04:41 -0700457 // if non-NULL, then duplicate write() to this non-blocking sink
458 NBAIO_Sink* teeSink;
459 if ((teeSink = current->mTeeSink) != NULL) {
Glenn Kasten329f6512014-08-28 16:23:16 -0700460 (void) teeSink->write(buffer, frameCount);
Glenn Kasten22340022014-04-07 12:04:41 -0700461 }
462 // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink,
463 // but this code should be modified to handle both non-blocking and blocking sinks
464 dumpState->mWriteSequence++;
465 ATRACE_BEGIN("write");
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800466 ssize_t framesWritten = mOutputSink->write(buffer, frameCount);
Glenn Kasten22340022014-04-07 12:04:41 -0700467 ATRACE_END();
468 dumpState->mWriteSequence++;
469 if (framesWritten >= 0) {
470 ALOG_ASSERT((size_t) framesWritten <= frameCount);
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800471 mTotalNativeFramesWritten += framesWritten;
472 dumpState->mFramesWritten = mTotalNativeFramesWritten;
Glenn Kasten22340022014-04-07 12:04:41 -0700473 //if ((size_t) framesWritten == frameCount) {
474 // didFullWrite = true;
475 //}
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700476 } else {
Glenn Kasten22340022014-04-07 12:04:41 -0700477 dumpState->mWriteErrors++;
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700478 }
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800479 mAttemptedWrite = true;
Glenn Kasten22340022014-04-07 12:04:41 -0700480 // FIXME count # of writes blocked excessively, CPU usage, etc. for dump
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700481
Andy Hung818e7a32016-02-16 18:08:07 -0800482 ExtendedTimestamp timestamp; // local
483 status_t status = mOutputSink->getTimestamp(timestamp);
484 if (status == NO_ERROR) {
485 const int64_t totalNativeFramesPresented =
486 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
Glenn Kastene4a7ce22015-03-03 11:23:17 -0800487 if (totalNativeFramesPresented <= mTotalNativeFramesWritten) {
488 mNativeFramesWrittenButNotPresented =
489 mTotalNativeFramesWritten - totalNativeFramesPresented;
Andy Hung818e7a32016-02-16 18:08:07 -0800490 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
491 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
492 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
493 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
Glenn Kasten22340022014-04-07 12:04:41 -0700494 } else {
495 // HAL reported that more frames were presented than were written
Andy Hung818e7a32016-02-16 18:08:07 -0800496 mNativeFramesWrittenButNotPresented = 0;
Andy Hung818e7a32016-02-16 18:08:07 -0800497 status = INVALID_OPERATION;
Glenn Kasten22340022014-04-07 12:04:41 -0700498 }
499 }
Andy Hung818e7a32016-02-16 18:08:07 -0800500 if (status == NO_ERROR) {
501 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] =
502 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
503 } else {
504 // fetch server time if we can't get timestamp
505 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] =
506 systemTime(SYSTEM_TIME_MONOTONIC);
Andy Hung07eee802016-06-21 16:47:16 -0700507 // clear out kernel cached position as this may get rapidly stale
508 // if we never get a new valid timestamp
509 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0;
510 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1;
Andy Hung818e7a32016-02-16 18:08:07 -0800511 }
Glenn Kasten22340022014-04-07 12:04:41 -0700512 }
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700513}
514
Glenn Kasten97b5d0d2012-03-23 18:54:19 -0700515} // namespace android