FastMixer.cpp revision 4182c4e2a07e2441fcd5c22eaff0ddfe7f826f61
197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten/*
297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * Copyright (C) 2012 The Android Open Source Project
397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten *
497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * Licensed under the Apache License, Version 2.0 (the "License");
597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * you may not use this file except in compliance with the License.
697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * You may obtain a copy of the License at
797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten *
897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten *      http://www.apache.org/licenses/LICENSE-2.0
997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten *
1097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * Unless required by applicable law or agreed to in writing, software
1197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * distributed under the License is distributed on an "AS IS" BASIS,
1297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * See the License for the specific language governing permissions and
1497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten * limitations under the License.
1597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten */
1697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
17a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten// <IMPORTANT_WARNING>
18a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten// Design rules for threadLoop() are given in the comments at section "Fast mixer thread" of
19a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten// StateQueue.h.  In particular, avoid library and system calls except at well-known points.
20a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten// The design rules are only for threadLoop(), and don't apply to FastMixerDumpState methods.
21a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten// </IMPORTANT_WARNING>
22a3d2628a22f2b3d682495044897a40ea1399a662Glenn Kasten
2397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#define LOG_TAG "FastMixer"
247f5d335f7b4caecd0dfb8f1085f352f1d2da5d2eGlenn Kasten//#define LOG_NDEBUG 0
2597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
26b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray#define ATRACE_TAG ATRACE_TAG_AUDIO
27371eb9756c32109ea572b91216b19bb623f6d3fdAlex Ray
28153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#include "Configuration.h"
2997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include <sys/atomics.h>
3097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include <time.h>
3197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include <utils/Log.h>
32d8e6fd35ec2b59ee7d873daf1f1d9d348221c7bcGlenn Kasten#include <utils/Trace.h>
3397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include <system/audio.h>
3497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#ifdef FAST_MIXER_STATISTICS
3597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include <cpustats/CentralTendencyStatistics.h>
360a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
3742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten#include <cpustats/ThreadCpuUsage.h>
3897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
390a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
4097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include "AudioMixer.h"
4197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#include "FastMixer.h"
4297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
4397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#define FAST_HOT_IDLE_NS     1000000L   // 1 ms: time to sleep while hot idling
4497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#define FAST_DEFAULT_NS    999999999L   // ~1 sec: default time to sleep
45eb15716b59020f342df62bce5b293f0603b94861Glenn Kasten#define MIN_WARMUP_CYCLES          2    // minimum number of loop cycles to wait for warmup
46288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten#define MAX_WARMUP_CYCLES         10    // maximum number of loop cycles to wait for warmup
4797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
4897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kastennamespace android {
4997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
5097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten// Fast mixer thread
5197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kastenbool FastMixer::threadLoop()
5297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten{
5397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    static const FastMixerState initial;
5497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    const FastMixerState *previous = &initial, *current = &initial;
5597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    FastMixerState preIdle; // copy of state before we went into idle
5697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    struct timespec oldTs = {0, 0};
5797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    bool oldTsValid = false;
5897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    long slopNs = 0;    // accumulated time we've woken up too early (> 0) or too late (< 0)
5997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    long sleepNs = -1;  // -1: busy wait, 0: sched_yield, > 0: nanosleep
6097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    int fastTrackNames[FastMixerState::kMaxFastTracks]; // handles used by mixer to identify tracks
6197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    int generations[FastMixerState::kMaxFastTracks];    // last observed mFastTracks[i].mGeneration
6297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    unsigned i;
6397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    for (i = 0; i < FastMixerState::kMaxFastTracks; ++i) {
6497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        fastTrackNames[i] = -1;
6597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        generations[i] = 0;
6697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    }
6797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    NBAIO_Sink *outputSink = NULL;
6897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    int outputSinkGen = 0;
6997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    AudioMixer* mixer = NULL;
7097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    short *mixBuffer = NULL;
7197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    enum {UNDEFINED, MIXED, ZEROED} mixBufferState = UNDEFINED;
7297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    NBAIO_Format format = Format_Invalid;
7397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    unsigned sampleRate = 0;
7497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    int fastTracksGen = 0;
7597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    long periodNs = 0;      // expected period; the time required to render one mix buffer
76288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    long underrunNs = 0;    // underrun likely when write cycle is greater than this value
77288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    long overrunNs = 0;     // overrun likely when write cycle is less than this value
78972af221ae7253e406e0e1ea853e56a3010ed6b1Glenn Kasten    long forceNs = 0;       // if overrun detected, force the write cycle to take this much time
79288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    long warmupNs = 0;      // warmup complete when write cycle is greater than to this value
8097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    FastMixerDumpState dummyDumpState, *dumpState = &dummyDumpState;
8197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    bool ignoreNextOverrun = true;  // used to ignore initial overrun and first after an underrun
8297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#ifdef FAST_MIXER_STATISTICS
8342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    struct timespec oldLoad = {0, 0};    // previous value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
8442d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    bool oldLoadValid = false;  // whether oldLoad is valid
8542d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t bounds = 0;
864182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    bool full = false;      // whether we have collected at least mSamplingN samples
870a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
8842d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    ThreadCpuUsage tcu;     // for reading the current CPU clock frequency in kHz
8997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
900a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
9197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    unsigned coldGen = 0;   // last observed mColdGen
92288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    bool isWarm = false;    // true means ready to mix, false means wait for warmup before mixing
93288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    struct timespec measuredWarmupTs = {0, 0};  // how long did it take for warmup to complete
94288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    uint32_t warmupCycles = 0;  // counter of number of loop cycles required to warmup
95fbae5dae5187aca9d974cbe15ec818e9c6f56705Glenn Kasten    NBAIO_Sink* teeSink = NULL; // if non-NULL, then duplicate write() to this non-blocking sink
969e58b552f51b00b3b674102876bd6c77ef3da806Glenn Kasten    NBLog::Writer dummyLogWriter, *logWriter = &dummyLogWriter;
9797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
9897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    for (;;) {
9997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
10097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // either nanosleep, sched_yield, or busy wait
10197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if (sleepNs >= 0) {
10297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (sleepNs > 0) {
10397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                ALOG_ASSERT(sleepNs < 1000000000);
10497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                const struct timespec req = {0, sleepNs};
10597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                nanosleep(&req, NULL);
10697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            } else {
10797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                sched_yield();
10897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
10997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
11097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // default to long sleep for next cycle
11197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        sleepNs = FAST_DEFAULT_NS;
11297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
11397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // poll for state change
11497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        const FastMixerState *next = mSQ.poll();
11597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if (next == NULL) {
11697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // continue to use the default initial state until a real state is available
11797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            ALOG_ASSERT(current == &initial && previous == &initial);
11897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            next = current;
11997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
12097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
12197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        FastMixerState::Command command = next->mCommand;
12297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if (next != current) {
12397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
12497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // As soon as possible of learning of a new dump area, start using it
12597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            dumpState = next->mDumpState != NULL ? next->mDumpState : &dummyDumpState;
126fbae5dae5187aca9d974cbe15ec818e9c6f56705Glenn Kasten            teeSink = next->mTeeSink;
1279e58b552f51b00b3b674102876bd6c77ef3da806Glenn Kasten            logWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &dummyLogWriter;
128ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten            if (mixer != NULL) {
129ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten                mixer->setLog(logWriter);
130ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten            }
13197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
13297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // We want to always have a valid reference to the previous (non-idle) state.
13397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // However, the state queue only guarantees access to current and previous states.
13497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // So when there is a transition from a non-idle state into an idle state, we make a
13597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // copy of the last known non-idle state so it is still available on return from idle.
13697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // The possible transitions are:
13797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            //  non-idle -> non-idle    update previous from current in-place
13897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            //  non-idle -> idle        update previous from copy of current
13997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            //  idle     -> idle        don't update previous
14097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            //  idle     -> non-idle    don't update previous
14197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (!(current->mCommand & FastMixerState::IDLE)) {
14297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (command & FastMixerState::IDLE) {
14397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    preIdle = *current;
14497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    current = &preIdle;
14597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    oldTsValid = false;
146153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#ifdef FAST_MIXER_STATISTICS
14742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                    oldLoadValid = false;
148153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#endif
14997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    ignoreNextOverrun = true;
15097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
15197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                previous = current;
15297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
15397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            current = next;
15497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
15597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#if !LOG_NDEBUG
15697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        next = NULL;    // not referenced again
15797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
15897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
15997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        dumpState->mCommand = command;
16097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
16197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        switch (command) {
16297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::INITIAL:
16397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::HOT_IDLE:
16497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            sleepNs = FAST_HOT_IDLE_NS;
16597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            continue;
16697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::COLD_IDLE:
16797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // only perform a cold idle command once
16821e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten            // FIXME consider checking previous state and only perform if previous != COLD_IDLE
16997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (current->mColdGen != coldGen) {
17097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                int32_t *coldFutexAddr = current->mColdFutexAddr;
17197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                ALOG_ASSERT(coldFutexAddr != NULL);
17297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                int32_t old = android_atomic_dec(coldFutexAddr);
17397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (old <= 0) {
17497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    __futex_syscall4(coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL);
17597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
176a07f17ca46db04c9d5d9e7d6b2878db59ca2b9eaGlenn Kasten                int policy = sched_getscheduler(0);
177a07f17ca46db04c9d5d9e7d6b2878db59ca2b9eaGlenn Kasten                if (!(policy == SCHED_FIFO || policy == SCHED_RR)) {
178a07f17ca46db04c9d5d9e7d6b2878db59ca2b9eaGlenn Kasten                    ALOGE("did not receive expected priority boost");
179a07f17ca46db04c9d5d9e7d6b2878db59ca2b9eaGlenn Kasten                }
180288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // This may be overly conservative; there could be times that the normal mixer
181288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // requests such a brief cold idle that it doesn't require resetting this flag.
182288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                isWarm = false;
183288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                measuredWarmupTs.tv_sec = 0;
184288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                measuredWarmupTs.tv_nsec = 0;
185288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                warmupCycles = 0;
18697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                sleepNs = -1;
18797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                coldGen = current->mColdGen;
188153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#ifdef FAST_MIXER_STATISTICS
18942d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                bounds = 0;
19042d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                full = false;
191153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#endif
19204a4ca4217e9b30342d5865024c340013d7184e8Glenn Kasten                oldTsValid = !clock_gettime(CLOCK_MONOTONIC, &oldTs);
19397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            } else {
19497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                sleepNs = FAST_HOT_IDLE_NS;
19597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
19697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            continue;
19797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::EXIT:
19897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            delete mixer;
19997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            delete[] mixBuffer;
20097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            return false;
20197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::MIX:
20297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::WRITE:
20397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        case FastMixerState::MIX_WRITE:
20497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            break;
20597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        default:
20697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            LOG_FATAL("bad command %d", command);
20797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
20897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
20997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // there is a non-idle state available to us; did the state change?
21097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        size_t frameCount = current->mFrameCount;
21197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if (current != previous) {
21297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
21397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // handle state change here, but since we want to diff the state,
21497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // we're prepared for previous == &initial the first time through
21597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            unsigned previousTrackMask;
21697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
21797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // check for change in output HAL configuration
21897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            NBAIO_Format previousFormat = format;
21997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (current->mOutputSinkGen != outputSinkGen) {
22097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                outputSink = current->mOutputSink;
22197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                outputSinkGen = current->mOutputSinkGen;
22297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (outputSink == NULL) {
22397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    format = Format_Invalid;
22497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    sampleRate = 0;
22597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                } else {
22697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    format = outputSink->format();
22797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    sampleRate = Format_sampleRate(format);
22897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    ALOG_ASSERT(Format_channelCount(format) == 2);
22997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
23021e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                dumpState->mSampleRate = sampleRate;
23197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
23297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
23397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if ((format != previousFormat) || (frameCount != previous->mFrameCount)) {
23497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // FIXME to avoid priority inversion, don't delete here
23597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                delete mixer;
23697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                mixer = NULL;
23797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                delete[] mixBuffer;
23897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                mixBuffer = NULL;
23997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (frameCount > 0 && sampleRate > 0) {
24097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    // FIXME new may block for unbounded time at internal mutex of the heap
24197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    //       implementation; it would be better to have normal mixer allocate for us
24297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    //       to avoid blocking here and to prevent possible priority inversion
24397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    mixer = new AudioMixer(frameCount, sampleRate, FastMixerState::kMaxFastTracks);
24497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    mixBuffer = new short[frameCount * 2];
24597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    periodNs = (frameCount * 1000000000LL) / sampleRate;    // 1.00
24697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    underrunNs = (frameCount * 1750000000LL) / sampleRate;  // 1.75
2470d27c65ddb5c968baa6db0c26e80f5c451bc52bcGlenn Kasten                    overrunNs = (frameCount * 500000000LL) / sampleRate;    // 0.50
2480d27c65ddb5c968baa6db0c26e80f5c451bc52bcGlenn Kasten                    forceNs = (frameCount * 950000000LL) / sampleRate;      // 0.95
249288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    warmupNs = (frameCount * 500000000LL) / sampleRate;     // 0.50
25097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                } else {
25197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    periodNs = 0;
25297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    underrunNs = 0;
25397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    overrunNs = 0;
254972af221ae7253e406e0e1ea853e56a3010ed6b1Glenn Kasten                    forceNs = 0;
255972af221ae7253e406e0e1ea853e56a3010ed6b1Glenn Kasten                    warmupNs = 0;
25697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
25797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                mixBufferState = UNDEFINED;
25897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#if !LOG_NDEBUG
25997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                for (i = 0; i < FastMixerState::kMaxFastTracks; ++i) {
26097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    fastTrackNames[i] = -1;
26197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
26297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
26397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // we need to reconfigure all active tracks
26497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                previousTrackMask = 0;
26597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                fastTracksGen = current->mFastTracksGen - 1;
26621e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                dumpState->mFrameCount = frameCount;
26797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            } else {
26897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                previousTrackMask = previous->mTrackMask;
26997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
27097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
27197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // check for change in active track set
27297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            unsigned currentTrackMask = current->mTrackMask;
2731295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            dumpState->mTrackMask = currentTrackMask;
27497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (current->mFastTracksGen != fastTracksGen) {
27597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                ALOG_ASSERT(mixBuffer != NULL);
27697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                int name;
27797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
27897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // process removed tracks first to avoid running out of track names
27997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                unsigned removedTracks = previousTrackMask & ~currentTrackMask;
28097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                while (removedTracks != 0) {
28197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    i = __builtin_ctz(removedTracks);
28297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    removedTracks &= ~(1 << i);
28397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    const FastTrack* fastTrack = &current->mFastTracks[i];
284288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    ALOG_ASSERT(fastTrack->mBufferProvider == NULL);
28597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    if (mixer != NULL) {
28697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        name = fastTrackNames[i];
28797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        ALOG_ASSERT(name >= 0);
28897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        mixer->deleteTrackName(name);
28997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    }
29097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#if !LOG_NDEBUG
29197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    fastTrackNames[i] = -1;
29297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
293288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    // don't reset track dump state, since other side is ignoring it
29497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    generations[i] = fastTrack->mGeneration;
29597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
29697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
29797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // now process added tracks
29897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                unsigned addedTracks = currentTrackMask & ~previousTrackMask;
29997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                while (addedTracks != 0) {
30097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    i = __builtin_ctz(addedTracks);
30197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    addedTracks &= ~(1 << i);
30297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    const FastTrack* fastTrack = &current->mFastTracks[i];
30397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
30497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    ALOG_ASSERT(bufferProvider != NULL && fastTrackNames[i] == -1);
30597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    if (mixer != NULL) {
306fe3156ec6fd9fa57dde913fd8567530d095a6550Jean-Michel Trivi                        // calling getTrackName with default channel mask and a random invalid
307fe3156ec6fd9fa57dde913fd8567530d095a6550Jean-Michel Trivi                        //   sessionId (no effects here)
308fe3156ec6fd9fa57dde913fd8567530d095a6550Jean-Michel Trivi                        name = mixer->getTrackName(AUDIO_CHANNEL_OUT_STEREO, -555);
30997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        ALOG_ASSERT(name >= 0);
31097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        fastTrackNames[i] = name;
31197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        mixer->setBufferProvider(name, bufferProvider);
31297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER,
31397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                (void *) mixBuffer);
31497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        // newly allocated track names default to full scale volume
31521e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                        if (fastTrack->mSampleRate != 0 && fastTrack->mSampleRate != sampleRate) {
31621e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                            mixer->setParameter(name, AudioMixer::RESAMPLE,
31721e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                    AudioMixer::SAMPLE_RATE, (void*) fastTrack->mSampleRate);
31821e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                        }
31921e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                        mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
32021e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                (void *) fastTrack->mChannelMask);
32197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        mixer->enable(name);
32297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    }
32397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    generations[i] = fastTrack->mGeneration;
32497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
32597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
326ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten                // finally process (potentially) modified tracks; these use the same slot
32797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // but may have a different buffer provider or volume provider
32897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                unsigned modifiedTracks = currentTrackMask & previousTrackMask;
32997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                while (modifiedTracks != 0) {
33097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    i = __builtin_ctz(modifiedTracks);
33197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    modifiedTracks &= ~(1 << i);
33297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    const FastTrack* fastTrack = &current->mFastTracks[i];
33397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    if (fastTrack->mGeneration != generations[i]) {
334ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten                        // this track was actually modified
33597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
33697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        ALOG_ASSERT(bufferProvider != NULL);
33797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        if (mixer != NULL) {
33897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            name = fastTrackNames[i];
33997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            ALOG_ASSERT(name >= 0);
34097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            mixer->setBufferProvider(name, bufferProvider);
34197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            if (fastTrack->mVolumeProvider == NULL) {
34297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
34397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                        (void *)0x1000);
34497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
34597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                        (void *)0x1000);
34697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            }
34721e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                            if (fastTrack->mSampleRate != 0 &&
34821e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                    fastTrack->mSampleRate != sampleRate) {
34921e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                mixer->setParameter(name, AudioMixer::RESAMPLE,
35021e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                        AudioMixer::SAMPLE_RATE, (void*) fastTrack->mSampleRate);
35121e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                            } else {
35221e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                mixer->setParameter(name, AudioMixer::RESAMPLE,
35321e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                        AudioMixer::REMOVE, NULL);
35421e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                            }
35521e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                            mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
35621e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                                    (void *) fastTrack->mChannelMask);
35797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            // already enabled
35897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        }
35997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        generations[i] = fastTrack->mGeneration;
36097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    }
36197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
36297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
36397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                fastTracksGen = current->mFastTracksGen;
36497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
36597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                dumpState->mNumTracks = popcount(currentTrackMask);
36697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
36797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
36897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#if 1   // FIXME shouldn't need this
36997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // only process state change once
37097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            previous = current;
37197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
37297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
37397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
37497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // do work using current state here
375288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten        if ((command & FastMixerState::MIX) && (mixer != NULL) && isWarm) {
37697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            ALOG_ASSERT(mixBuffer != NULL);
377288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten            // for each track, update volume and check for underrun
378288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten            unsigned currentTrackMask = current->mTrackMask;
379288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten            while (currentTrackMask != 0) {
380288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                i = __builtin_ctz(currentTrackMask);
381288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                currentTrackMask &= ~(1 << i);
38297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                const FastTrack* fastTrack = &current->mFastTracks[i];
38397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                int name = fastTrackNames[i];
38497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                ALOG_ASSERT(name >= 0);
38597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (fastTrack->mVolumeProvider != NULL) {
38697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    uint32_t vlr = fastTrack->mVolumeProvider->getVolumeLR();
38797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
38897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            (void *)(vlr & 0xFFFF));
38997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
39097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                            (void *)(vlr >> 16));
39197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
392288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // FIXME The current implementation of framesReady() for fast tracks
393288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // takes a tryLock, which can block
394288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // up to 1 ms.  If enough active tracks all blocked in sequence, this would result
395288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // in the overall fast mix cycle being delayed.  Should use a non-blocking FIFO.
396288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                size_t framesReady = fastTrack->mBufferProvider->framesReady();
397b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray                if (ATRACE_ENABLED()) {
398b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray                    // I wish we had formatted trace names
399b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray                    char traceName[16];
400c9b2e20f7c9a71e07ef398152709c76079decbcdGlenn Kasten                    strcpy(traceName, "fRdy");
401c9b2e20f7c9a71e07ef398152709c76079decbcdGlenn Kasten                    traceName[4] = i + (i < 10 ? '0' : 'A' - 10);
402c9b2e20f7c9a71e07ef398152709c76079decbcdGlenn Kasten                    traceName[5] = '\0';
403b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray                    ATRACE_INT(traceName, framesReady);
404b3a8364eeea621ef63b983e4c1b0771f62069fe0Alex Ray                }
405288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                FastTrackDump *ftDump = &dumpState->mTracks[i];
40609474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                FastTrackUnderruns underruns = ftDump->mUnderruns;
407288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                if (framesReady < frameCount) {
408288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    if (framesReady == 0) {
40909474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                        underruns.mBitFields.mEmpty++;
41009474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                        underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY;
411288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        mixer->disable(name);
412288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    } else {
413288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        // allow mixing partial buffer
41409474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                        underruns.mBitFields.mPartial++;
41509474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                        underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL;
416288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        mixer->enable(name);
417288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    }
41809474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                } else {
41909474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                    underruns.mBitFields.mFull++;
42009474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                    underruns.mBitFields.mMostRecent = UNDERRUN_FULL;
421288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    mixer->enable(name);
422288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                }
42309474df67278c0cd621b57c4aef1deaec4d8447fGlenn Kasten                ftDump->mUnderruns = underruns;
4241295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten                ftDump->mFramesReady = framesReady;
42597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
4262c3b2da3049627264b7c6b449a1622f002210f03John Grossman
4272c3b2da3049627264b7c6b449a1622f002210f03John Grossman            int64_t pts;
4282c3b2da3049627264b7c6b449a1622f002210f03John Grossman            if (outputSink == NULL || (OK != outputSink->getNextWriteTimestamp(&pts)))
4292c3b2da3049627264b7c6b449a1622f002210f03John Grossman                pts = AudioBufferProvider::kInvalidPTS;
4302c3b2da3049627264b7c6b449a1622f002210f03John Grossman
43197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // process() is CPU-bound
4322c3b2da3049627264b7c6b449a1622f002210f03John Grossman            mixer->process(pts);
43397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            mixBufferState = MIXED;
43497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        } else if (mixBufferState == MIXED) {
43597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            mixBufferState = UNDEFINED;
43697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
437288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten        bool attemptedWrite = false;
438288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten        //bool didFullWrite = false;    // dumpsys could display a count of partial writes
43997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if ((command & FastMixerState::WRITE) && (outputSink != NULL) && (mixBuffer != NULL)) {
44097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (mixBufferState == UNDEFINED) {
44197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                memset(mixBuffer, 0, frameCount * 2 * sizeof(short));
44297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                mixBufferState = ZEROED;
44397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
444fbae5dae5187aca9d974cbe15ec818e9c6f56705Glenn Kasten            if (teeSink != NULL) {
445fbae5dae5187aca9d974cbe15ec818e9c6f56705Glenn Kasten                (void) teeSink->write(mixBuffer, frameCount);
446fbae5dae5187aca9d974cbe15ec818e9c6f56705Glenn Kasten            }
44797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink,
44897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            //       but this code should be modified to handle both non-blocking and blocking sinks
44997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            dumpState->mWriteSequence++;
4502d590964aa58e137d17a43e095e6443dd0fe2e98Simon Wilson            ATRACE_BEGIN("write");
45197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            ssize_t framesWritten = outputSink->write(mixBuffer, frameCount);
4522d590964aa58e137d17a43e095e6443dd0fe2e98Simon Wilson            ATRACE_END();
45397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            dumpState->mWriteSequence++;
45497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (framesWritten >= 0) {
455ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten                ALOG_ASSERT((size_t) framesWritten <= frameCount);
45697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                dumpState->mFramesWritten += framesWritten;
457288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                //if ((size_t) framesWritten == frameCount) {
458288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                //    didFullWrite = true;
459288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                //}
46097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            } else {
46197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                dumpState->mWriteErrors++;
46297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
463288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten            attemptedWrite = true;
46497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // FIXME count # of writes blocked excessively, CPU usage, etc. for dump
46597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
46697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
46797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // To be exactly periodic, compute the next sleep time based on current time.
46897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // This code doesn't have long-term stability when the sink is non-blocking.
46997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        // FIXME To avoid drift, use the local audio clock or watch the sink's fill status.
47097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        struct timespec newTs;
47197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
47297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        if (rc == 0) {
473ab7d72f0804fbb7e91ad9d2a16f826d97e20e5d0Glenn Kasten            //logWriter->logTimestamp(newTs);
47497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            if (oldTsValid) {
47597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                time_t sec = newTs.tv_sec - oldTs.tv_sec;
47697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                long nsec = newTs.tv_nsec - oldTs.tv_nsec;
47780b3273cea8660fe8a5868d024d2788a1e083ffcGlenn Kasten                ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0),
47880b3273cea8660fe8a5868d024d2788a1e083ffcGlenn Kasten                        "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld",
47980b3273cea8660fe8a5868d024d2788a1e083ffcGlenn Kasten                        oldTs.tv_sec, oldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec);
48097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                if (nsec < 0) {
48197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    --sec;
48297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    nsec += 1000000000;
48397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
484288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // To avoid an initial underrun on fast tracks after exiting standby,
485288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // do not start pulling data from tracks and mixing until warmup is complete.
486288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // Warmup is considered complete after the earlier of:
487eb15716b59020f342df62bce5b293f0603b94861Glenn Kasten                //      MIN_WARMUP_CYCLES write() attempts and last one blocks for at least warmupNs
488288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                //      MAX_WARMUP_CYCLES write() attempts.
489288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                // This is overly conservative, but to get better accuracy requires a new HAL API.
490288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                if (!isWarm && attemptedWrite) {
491288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    measuredWarmupTs.tv_sec += sec;
492288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    measuredWarmupTs.tv_nsec += nsec;
493288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    if (measuredWarmupTs.tv_nsec >= 1000000000) {
494288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        measuredWarmupTs.tv_sec++;
495288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        measuredWarmupTs.tv_nsec -= 1000000000;
496288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    }
497288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    ++warmupCycles;
498eb15716b59020f342df62bce5b293f0603b94861Glenn Kasten                    if ((nsec > warmupNs && warmupCycles >= MIN_WARMUP_CYCLES) ||
499288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                            (warmupCycles >= MAX_WARMUP_CYCLES)) {
500288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        isWarm = true;
501288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        dumpState->mMeasuredWarmupTs = measuredWarmupTs;
502288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                        dumpState->mWarmupCycles = warmupCycles;
503288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                    }
504288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten                }
505972af221ae7253e406e0e1ea853e56a3010ed6b1Glenn Kasten                sleepNs = -1;
5063d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                if (isWarm) {
5073d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    if (sec > 0 || nsec > underrunNs) {
5083d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        ATRACE_NAME("underrun");
50997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                        // FIXME only log occasionally
5103d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        ALOGV("underrun: time since last cycle %d.%03ld sec",
51197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                                (int) sec, nsec / 1000000L);
5123d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        dumpState->mUnderruns++;
5133d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        ignoreNextOverrun = true;
5143d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    } else if (nsec < overrunNs) {
5153d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        if (ignoreNextOverrun) {
5163d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            ignoreNextOverrun = false;
5173d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        } else {
5183d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            // FIXME only log occasionally
5193d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            ALOGV("overrun: time since last cycle %d.%03ld sec",
5203d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                                    (int) sec, nsec / 1000000L);
5213d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            dumpState->mOverruns++;
5223d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        }
5233d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        // This forces a minimum cycle time. It:
5243d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        //  - compensates for an audio HAL with jitter due to sample rate conversion
5253d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        //  - works with a variable buffer depth audio HAL that never pulls at a
5263d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        //    rate < than overrunNs per buffer.
5273d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        //  - recovers from overrun immediately after underrun
5283d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        // It doesn't work with a non-blocking audio HAL.
5293d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        sleepNs = forceNs - nsec;
5303d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    } else {
5313d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        ignoreNextOverrun = false;
53297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                    }
53397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                }
53497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#ifdef FAST_MIXER_STATISTICS
5353d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                if (isWarm) {
5363d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // advance the FIFO queue bounds
5374182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten                    size_t i = bounds & (dumpState->mSamplingN - 1);
5383d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    bounds = (bounds & 0xFFFF0000) | ((bounds + 1) & 0xFFFF);
5393d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    if (full) {
5403d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        bounds += 0x10000;
5414182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten                    } else if (!(bounds & (dumpState->mSamplingN - 1))) {
5423d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        full = true;
5433d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    }
5443d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // compute the delta value of clock_gettime(CLOCK_MONOTONIC)
5453d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    uint32_t monotonicNs = nsec;
5463d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    if (sec > 0 && sec < 4) {
5473d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        monotonicNs += sec * 1000000000;
5483d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    }
5493d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
5503d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    uint32_t loadNs = 0;
5513d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    struct timespec newLoad;
5523d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad);
5533d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    if (rc == 0) {
5543d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        if (oldLoadValid) {
5553d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            sec = newLoad.tv_sec - oldLoad.tv_sec;
5563d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            nsec = newLoad.tv_nsec - oldLoad.tv_nsec;
5573d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            if (nsec < 0) {
5583d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                                --sec;
5593d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                                nsec += 1000000000;
5603d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            }
5613d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            loadNs = nsec;
5623d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            if (sec > 0 && sec < 4) {
5633d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                                loadNs += sec * 1000000000;
5643d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            }
5653d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        } else {
5663d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            // first time through the loop
5673d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                            oldLoadValid = true;
56842d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                        }
5693d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                        oldLoad = newLoad;
57042d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                    }
5710a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
5723d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // get the absolute value of CPU clock frequency in kHz
5733d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    int cpuNum = sched_getcpu();
5743d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    uint32_t kHz = tcu.getCpukHz(cpuNum);
5753d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    kHz = (kHz << 4) | (cpuNum & 0xF);
5760a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
5773d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // save values in FIFO queues for dumpsys
5783d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // these stores #1, #2, #3 are not atomic with respect to each other,
5793d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // or with respect to store #4 below
5803d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    dumpState->mMonotonicNs[i] = monotonicNs;
5813d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    dumpState->mLoadNs[i] = loadNs;
5820a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
5833d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    dumpState->mCpukHz[i] = kHz;
5840a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
5853d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // this store #4 is not atomic with respect to stores #1, #2, #3 above, but
5863d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    // the newest open & oldest closed halves are atomic with respect to each other
5873d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    dumpState->mBounds = bounds;
5883d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    ATRACE_INT("cycle_ms", monotonicNs / 1000000);
5893d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                    ATRACE_INT("load_us", loadNs / 1000);
5903d1982595cb9cb0856841f1f57fbdb4581189e99Glenn Kasten                }
59197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
59297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            } else {
59397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                // first time through the loop
59497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                oldTsValid = true;
59597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                sleepNs = periodNs;
59697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                ignoreNextOverrun = true;
59797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            }
59897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            oldTs = newTs;
59997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        } else {
60097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            // monotonic clock is broken
60197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            oldTsValid = false;
60297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten            sleepNs = periodNs;
60397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        }
60497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
60542d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten
60697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    }   // for (;;)
60797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
60897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    // never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion
60997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten}
61097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
6114182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn KastenFastMixerDumpState::FastMixerDumpState(
6124182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten#ifdef FAST_MIXER_STATISTICS
6134182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten        uint32_t samplingN
6144182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten#endif
6154182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten        ) :
61697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    mCommand(FastMixerState::INITIAL), mWriteSequence(0), mFramesWritten(0),
61721e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten    mNumTracks(0), mWriteErrors(0), mUnderruns(0), mOverruns(0),
6181295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    mSampleRate(0), mFrameCount(0), /* mMeasuredWarmupTs({0, 0}), */ mWarmupCycles(0),
6191295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    mTrackMask(0)
62097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#ifdef FAST_MIXER_STATISTICS
6214182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    , mSamplingN(0), mBounds(0)
62297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
62397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten{
624288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    mMeasuredWarmupTs.tv_sec = 0;
625288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten    mMeasuredWarmupTs.tv_nsec = 0;
626153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#ifdef FAST_MIXER_STATISTICS
6274182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    increaseSamplingN(samplingN);
6284182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten#endif
6294182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten}
6304182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten
6314182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten#ifdef FAST_MIXER_STATISTICS
6324182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kastenvoid FastMixerDumpState::increaseSamplingN(uint32_t samplingN)
6334182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten{
6344182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    if (samplingN <= mSamplingN || samplingN > kSamplingN || roundup(samplingN) != samplingN) {
6354182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten        return;
6364182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    }
6374182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    uint32_t additional = samplingN - mSamplingN;
63842d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // sample arrays aren't accessed atomically with respect to the bounds,
63942d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // so clearing reduces chance for dumpsys to read random uninitialized samples
6404182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    memset(&mMonotonicNs[mSamplingN], 0, sizeof(mMonotonicNs[0]) * additional);
6414182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    memset(&mLoadNs[mSamplingN], 0, sizeof(mLoadNs[0]) * additional);
6420a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
6434182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    memset(&mCpukHz[mSamplingN], 0, sizeof(mCpukHz[0]) * additional);
644153b9fe667e6e78e0218ff0159353097428c7657Glenn Kasten#endif
6454182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    mSamplingN = samplingN;
64697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten}
6474182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten#endif
64897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
64997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn KastenFastMixerDumpState::~FastMixerDumpState()
65097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten{
65197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten}
65297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
6531ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten// helper function called by qsort()
6541ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kastenstatic int compare_uint32_t(const void *pa, const void *pb)
6551ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten{
6561ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    uint32_t a = *(const uint32_t *)pa;
6571ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    uint32_t b = *(const uint32_t *)pb;
6581ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    if (a < b) {
6591ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        return -1;
6601ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    } else if (a > b) {
6611ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        return 1;
6621ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    } else {
6631ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        return 0;
6641ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    }
6651ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten}
6661ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten
6674182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kastenvoid FastMixerDumpState::dump(int fd) const
66897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten{
669868c0abe9f26852c217bc201b337e72c68f829b8Glenn Kasten    if (mCommand == FastMixerState::INITIAL) {
670868c0abe9f26852c217bc201b337e72c68f829b8Glenn Kasten        fdprintf(fd, "FastMixer not initialized\n");
671868c0abe9f26852c217bc201b337e72c68f829b8Glenn Kasten        return;
672868c0abe9f26852c217bc201b337e72c68f829b8Glenn Kasten    }
67397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#define COMMAND_MAX 32
67497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    char string[COMMAND_MAX];
67597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    switch (mCommand) {
67697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::INITIAL:
67797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "INITIAL");
67897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
67997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::HOT_IDLE:
68097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "HOT_IDLE");
68197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
68297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::COLD_IDLE:
68397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "COLD_IDLE");
68497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
68597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::EXIT:
68697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "EXIT");
68797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
68897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::MIX:
68997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "MIX");
69097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
69197b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::WRITE:
69297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "WRITE");
69397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
69497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    case FastMixerState::MIX_WRITE:
69597b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        strcpy(string, "MIX_WRITE");
69697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
69797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    default:
69897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        snprintf(string, COMMAND_MAX, "%d", mCommand);
69997b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten        break;
70097b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    }
70142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    double measuredWarmupMs = (mMeasuredWarmupTs.tv_sec * 1000.0) +
702288ed2103d96f3aabd7e6bea3c080ab6db164049Glenn Kasten            (mMeasuredWarmupTs.tv_nsec / 1000000.0);
70342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    double mixPeriodSec = (double) mFrameCount / (double) mSampleRate;
70497b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten    fdprintf(fd, "FastMixer command=%s writeSequence=%u framesWritten=%u\n"
70521e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                 "          numTracks=%u writeErrors=%u underruns=%u overruns=%u\n"
70642d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "          sampleRate=%u frameCount=%u measuredWarmup=%.3g ms, warmupCycles=%u\n"
70742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "          mixPeriod=%.2f ms\n",
70897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten                 string, mWriteSequence, mFramesWritten,
70921e8c50bd13ebe44f3088e26c9c6df0e163c469cGlenn Kasten                 mNumTracks, mWriteErrors, mUnderruns, mOverruns,
71042d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 mSampleRate, mFrameCount, measuredWarmupMs, mWarmupCycles,
71142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 mixPeriodSec * 1e3);
71297b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#ifdef FAST_MIXER_STATISTICS
71342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // find the interval of valid samples
71442d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t bounds = mBounds;
71542d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t newestOpen = bounds & 0xFFFF;
71642d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t oldestClosed = bounds >> 16;
71742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t n = (newestOpen - oldestClosed) & 0xFFFF;
7184182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten    if (n > mSamplingN) {
71942d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        ALOGE("too many samples %u", n);
7204182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten        n = mSamplingN;
72142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    }
72242d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // statistics for monotonic (wall clock) time, thread raw CPU load in time, CPU clock frequency,
72342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // and adjusted CPU load in MHz normalized for CPU clock frequency
7240a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten    CentralTendencyStatistics wall, loadNs;
7250a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
7260a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten    CentralTendencyStatistics kHz, loadMHz;
72742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    uint32_t previousCpukHz = 0;
7280a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
7291ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    // Assuming a normal distribution for cycle times, three standard deviations on either side of
7301ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    // the mean account for 99.73% of the population.  So if we take each tail to be 1/1000 of the
7311ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    // sample set, we get 99.8% combined, or close to three standard deviations.
7321ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    static const uint32_t kTailDenominator = 1000;
7331ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    uint32_t *tail = n >= kTailDenominator ? new uint32_t[n] : NULL;
73442d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    // loop over all the samples
7351ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    for (uint32_t j = 0; j < n; ++j) {
7364182c4e2a07e2441fcd5c22eaff0ddfe7f826f61Glenn Kasten        size_t i = oldestClosed++ & (mSamplingN - 1);
73742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        uint32_t wallNs = mMonotonicNs[i];
7381ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        if (tail != NULL) {
7391ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten            tail[j] = wallNs;
7401ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        }
74142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        wall.sample(wallNs);
74242d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        uint32_t sampleLoadNs = mLoadNs[i];
74342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        loadNs.sample(sampleLoadNs);
7440a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
7450a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten        uint32_t sampleCpukHz = mCpukHz[i];
746c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten        // skip bad kHz samples
747c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten        if ((sampleCpukHz & ~0xF) != 0) {
748c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten            kHz.sample(sampleCpukHz >> 4);
749c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten            if (sampleCpukHz == previousCpukHz) {
750c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten                double megacycles = (double) sampleLoadNs * (double) (sampleCpukHz >> 4) * 1e-12;
751c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten                double adjMHz = megacycles / mixPeriodSec;  // _not_ wallNs * 1e9
752c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten                loadMHz.sample(adjMHz);
753c059bd4246c1b3944965be921e5b334d51cd236cGlenn Kasten            }
75442d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        }
75542d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten        previousCpukHz = sampleCpukHz;
7560a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
75742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    }
75842d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    fdprintf(fd, "Simple moving statistics over last %.1f seconds:\n", wall.n() * mixPeriodSec);
75942d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    fdprintf(fd, "  wall clock time in ms per mix cycle:\n"
76042d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "    mean=%.2f min=%.2f max=%.2f stddev=%.2f\n",
76142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 wall.mean()*1e-6, wall.minimum()*1e-6, wall.maximum()*1e-6, wall.stddev()*1e-6);
76242d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    fdprintf(fd, "  raw CPU load in us per mix cycle:\n"
76342d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "    mean=%.0f min=%.0f max=%.0f stddev=%.0f\n",
76442d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 loadNs.mean()*1e-3, loadNs.minimum()*1e-3, loadNs.maximum()*1e-3,
76542d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 loadNs.stddev()*1e-3);
7660a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#ifdef CPU_FREQUENCY_STATISTICS
76742d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    fdprintf(fd, "  CPU clock frequency in MHz:\n"
76842d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "    mean=%.0f min=%.0f max=%.0f stddev=%.0f\n",
76942d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 kHz.mean()*1e-3, kHz.minimum()*1e-3, kHz.maximum()*1e-3, kHz.stddev()*1e-3);
77042d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten    fdprintf(fd, "  adjusted CPU load in MHz (i.e. normalized for CPU clock frequency):\n"
77142d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 "    mean=%.1f min=%.1f max=%.1f stddev=%.1f\n",
77242d45cfd0c3d62357a6549c62f535e4d4fe08d91Glenn Kasten                 loadMHz.mean(), loadMHz.minimum(), loadMHz.maximum(), loadMHz.stddev());
77397b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten#endif
7741ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    if (tail != NULL) {
7751ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        qsort(tail, n, sizeof(uint32_t), compare_uint32_t);
7761ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        // assume same number of tail samples on each side, left and right
7771ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        uint32_t count = n / kTailDenominator;
7781ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        CentralTendencyStatistics left, right;
7791ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        for (uint32_t i = 0; i < count; ++i) {
7801ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten            left.sample(tail[i]);
7811ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten            right.sample(tail[n - (i + 1)]);
7821ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        }
7831ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        fdprintf(fd, "Distribution of mix cycle times in ms for the tails (> ~3 stddev outliers):\n"
7841ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten                     "  left tail: mean=%.2f min=%.2f max=%.2f stddev=%.2f\n"
7851ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten                     "  right tail: mean=%.2f min=%.2f max=%.2f stddev=%.2f\n",
7861ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten                     left.mean()*1e-6, left.minimum()*1e-6, left.maximum()*1e-6, left.stddev()*1e-6,
7871ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten                     right.mean()*1e-6, right.minimum()*1e-6, right.maximum()*1e-6,
7881ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten                     right.stddev()*1e-6);
7891ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten        delete[] tail;
7901ab212cf5cfa5b88c801840e11e3191cd10f48e4Glenn Kasten    }
7910a14c4ce1a41bc09eb7855fa531a3af629a69139Glenn Kasten#endif
7921295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    // The active track mask and track states are updated non-atomically.
7931295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    // So if we relied on isActive to decide whether to display,
7941295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    // then we might display an obsolete track or omit an active track.
7951295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    // Instead we always display all tracks, with an indication
7961295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    // of whether we think the track is active.
7971295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    uint32_t trackMask = mTrackMask;
7981295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    fdprintf(fd, "Fast tracks: kMaxFastTracks=%u activeMask=%#x\n",
7991295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            FastMixerState::kMaxFastTracks, trackMask);
8001295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    fdprintf(fd, "Index Active Full Partial Empty  Recent Ready\n");
8011295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    for (uint32_t i = 0; i < FastMixerState::kMaxFastTracks; ++i, trackMask >>= 1) {
8021295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        bool isActive = trackMask & 1;
8031295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        const FastTrackDump *ftDump = &mTracks[i];
8041295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        const FastTrackUnderruns& underruns = ftDump->mUnderruns;
8051295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        const char *mostRecent;
8061295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        switch (underruns.mBitFields.mMostRecent) {
8071295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        case UNDERRUN_FULL:
8081295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            mostRecent = "full";
8091295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            break;
8101295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        case UNDERRUN_PARTIAL:
8111295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            mostRecent = "partial";
8121295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            break;
8131295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        case UNDERRUN_EMPTY:
8141295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            mostRecent = "empty";
8151295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            break;
8161295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        default:
8171295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            mostRecent = "?";
8181295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten            break;
8191295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        }
8201295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten        fdprintf(fd, "%5u %6s %4u %7u %5u %7s %5u\n", i, isActive ? "yes" : "no",
8211295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten                (underruns.mBitFields.mFull) & UNDERRUN_MASK,
8221295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten                (underruns.mBitFields.mPartial) & UNDERRUN_MASK,
8231295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten                (underruns.mBitFields.mEmpty) & UNDERRUN_MASK,
8241295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten                mostRecent, ftDump->mFramesReady);
8251295bb4dcff7b29c75cd23746816df12a871d72cGlenn Kasten    }
82697b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten}
82797b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten
82897b5d0d5b5ef766eb5dd680d05a5d199662d4ae0Glenn Kasten}   // namespace android
829