AudioMixer.cpp revision 4ff14bae91075eb274eb1c2975982358946e7e63 
1/*
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#define LOG_TAG "AudioMixer"
19//#define LOG_NDEBUG 0
20
21#include <assert.h>
22#include <stdint.h>
23#include <string.h>
24#include <stdlib.h>
25#include <sys/types.h>
26
27#include <utils/Errors.h>
28#include <utils/Log.h>
29
30#include <cutils/bitops.h>
31#include <cutils/compiler.h>
32
33#include <system/audio.h>
34
35#include <audio_utils/primitives.h>
36#include <common_time/local_clock.h>
37#include <common_time/cc_helper.h>
38
39#include "AudioMixer.h"
40
41namespace android {
42
43// ----------------------------------------------------------------------------
44
45AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate)
46    :   mTrackNames(0), mSampleRate(sampleRate)
47{
48    // AudioMixer is not yet capable of multi-channel beyond stereo
49    assert(2 == MAX_NUM_CHANNELS);
50
51    LocalClock lc;
52
53    mState.enabledTracks= 0;
54    mState.needsChanged = 0;
55    mState.frameCount   = frameCount;
56    mState.hook         = process__nop;
57    mState.outputTemp   = NULL;
58    mState.resampleTemp = NULL;
59    // mState.reserved
60    track_t* t = mState.tracks;
61    for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
62        t->needs = 0;
63        t->volume[0] = UNITY_GAIN;
64        t->volume[1] = UNITY_GAIN;
65        // no initialization needed
66        // t->prevVolume[0]
67        // t->prevVolume[1]
68        t->volumeInc[0] = 0;
69        t->volumeInc[1] = 0;
70        t->auxLevel = 0;
71        t->auxInc = 0;
72        // no initialization needed
73        // t->prevAuxLevel
74        // t->frameCount
75        t->channelCount = 2;
76        t->enabled = false;
77        t->format = 16;
78        t->channelMask = AUDIO_CHANNEL_OUT_STEREO;
79        t->bufferProvider = NULL;
80        t->buffer.raw = NULL;
81        // t->buffer.frameCount
82        t->hook = NULL;
83        t->in = NULL;
84        t->resampler = NULL;
85        t->sampleRate = mSampleRate;
86        t->mainBuffer = NULL;
87        t->auxBuffer = NULL;
88        t->localTimeFreq = lc.getLocalFreq();
89        t++;
90    }
91}
92
93AudioMixer::~AudioMixer()
94{
95    track_t* t = mState.tracks;
96    for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
97        delete t->resampler;
98        t++;
99    }
100    delete [] mState.outputTemp;
101    delete [] mState.resampleTemp;
102}
103
104int AudioMixer::getTrackName()
105{
106    uint32_t names = ~mTrackNames;
107    if (names != 0) {
108        int n = __builtin_ctz(names);
109        ALOGV("add track (%d)", n);
110        mTrackNames |= 1 << n;
111        return TRACK0 + n;
112    }
113    return -1;
114}
115
116void AudioMixer::invalidateState(uint32_t mask)
117{
118    if (mask) {
119        mState.needsChanged |= mask;
120        mState.hook = process__validate;
121    }
122 }
123
124void AudioMixer::deleteTrackName(int name)
125{
126    name -= TRACK0;
127    assert(uint32_t(name) < MAX_NUM_TRACKS);
128    ALOGV("deleteTrackName(%d)", name);
129    track_t& track(mState.tracks[ name ]);
130    if (track.enabled) {
131        track.enabled = false;
132        invalidateState(1<<name);
133    }
134    if (track.resampler != NULL) {
135        // delete  the resampler
136        delete track.resampler;
137        track.resampler = NULL;
138        track.sampleRate = mSampleRate;
139        invalidateState(1<<name);
140    }
141    track.volumeInc[0] = 0;
142    track.volumeInc[1] = 0;
143    mTrackNames &= ~(1<<name);
144}
145
146void AudioMixer::enable(int name)
147{
148    name -= TRACK0;
149    assert(uint32_t(name) < MAX_NUM_TRACKS);
150    track_t& track = mState.tracks[name];
151
152    if (!track.enabled) {
153        track.enabled = true;
154        ALOGV("enable(%d)", name);
155        invalidateState(1 << name);
156    }
157}
158
159void AudioMixer::disable(int name)
160{
161    name -= TRACK0;
162    assert(uint32_t(name) < MAX_NUM_TRACKS);
163    track_t& track = mState.tracks[name];
164
165    if (track.enabled) {
166        track.enabled = false;
167        ALOGV("disable(%d)", name);
168        invalidateState(1 << name);
169    }
170}
171
172void AudioMixer::setParameter(int name, int target, int param, void *value)
173{
174    name -= TRACK0;
175    assert(uint32_t(name) < MAX_NUM_TRACKS);
176    track_t& track = mState.tracks[name];
177
178    int valueInt = (int)value;
179    int32_t *valueBuf = (int32_t *)value;
180
181    switch (target) {
182
183    case TRACK:
184        switch (param) {
185        case CHANNEL_MASK: {
186            uint32_t mask = (uint32_t)value;
187            if (track.channelMask != mask) {
188                uint8_t channelCount = popcount(mask);
189                assert((channelCount <= MAX_NUM_CHANNELS) && (channelCount));
190                track.channelMask = mask;
191                track.channelCount = channelCount;
192                ALOGV("setParameter(TRACK, CHANNEL_MASK, %x)", mask);
193                invalidateState(1 << name);
194            }
195            } break;
196        case MAIN_BUFFER:
197            if (track.mainBuffer != valueBuf) {
198                track.mainBuffer = valueBuf;
199                ALOGV("setParameter(TRACK, MAIN_BUFFER, %p)", valueBuf);
200                invalidateState(1 << name);
201            }
202            break;
203        case AUX_BUFFER:
204            if (track.auxBuffer != valueBuf) {
205                track.auxBuffer = valueBuf;
206                ALOGV("setParameter(TRACK, AUX_BUFFER, %p)", valueBuf);
207                invalidateState(1 << name);
208            }
209            break;
210        default:
211            // bad param
212            assert(false);
213        }
214        break;
215
216    case RESAMPLE:
217        switch (param) {
218        case SAMPLE_RATE:
219            assert(valueInt > 0);
220            if (track.setResampler(uint32_t(valueInt), mSampleRate)) {
221                ALOGV("setParameter(RESAMPLE, SAMPLE_RATE, %u)",
222                        uint32_t(valueInt));
223                invalidateState(1 << name);
224            }
225            break;
226        case RESET:
227            track.resetResampler();
228            invalidateState(1 << name);
229            break;
230        default:
231            // bad param
232            assert(false);
233        }
234        break;
235
236    case RAMP_VOLUME:
237    case VOLUME:
238        switch (param) {
239        case VOLUME0:
240        case VOLUME1:
241            if (track.volume[param-VOLUME0] != valueInt) {
242                ALOGV("setParameter(VOLUME, VOLUME0/1: %04x)", valueInt);
243                track.prevVolume[param-VOLUME0] = track.volume[param-VOLUME0] << 16;
244                track.volume[param-VOLUME0] = valueInt;
245                if (target == VOLUME) {
246                    track.prevVolume[param-VOLUME0] = valueInt << 16;
247                    track.volumeInc[param-VOLUME0] = 0;
248                } else {
249                    int32_t d = (valueInt<<16) - track.prevVolume[param-VOLUME0];
250                    int32_t volInc = d / int32_t(mState.frameCount);
251                    track.volumeInc[param-VOLUME0] = volInc;
252                    if (volInc == 0) {
253                        track.prevVolume[param-VOLUME0] = valueInt << 16;
254                    }
255                }
256                invalidateState(1 << name);
257            }
258            break;
259        case AUXLEVEL:
260            if (track.auxLevel != valueInt) {
261                ALOGV("setParameter(VOLUME, AUXLEVEL: %04x)", valueInt);
262                track.prevAuxLevel = track.auxLevel << 16;
263                track.auxLevel = valueInt;
264                if (target == VOLUME) {
265                    track.prevAuxLevel = valueInt << 16;
266                    track.auxInc = 0;
267                } else {
268                    int32_t d = (valueInt<<16) - track.prevAuxLevel;
269                    int32_t volInc = d / int32_t(mState.frameCount);
270                    track.auxInc = volInc;
271                    if (volInc == 0) {
272                        track.prevAuxLevel = valueInt << 16;
273                    }
274                }
275                invalidateState(1 << name);
276            }
277            break;
278        default:
279            // bad param
280            assert(false);
281        }
282        break;
283
284    default:
285        // bad target
286        assert(false);
287    }
288}
289
290bool AudioMixer::track_t::setResampler(uint32_t value, uint32_t devSampleRate)
291{
292    if (value!=devSampleRate || resampler) {
293        if (sampleRate != value) {
294            sampleRate = value;
295            if (resampler == NULL) {
296                resampler = AudioResampler::create(
297                        format, channelCount, devSampleRate);
298                resampler->setLocalTimeFreq(localTimeFreq);
299            }
300            return true;
301        }
302    }
303    return false;
304}
305
306inline
307void AudioMixer::track_t::adjustVolumeRamp(bool aux)
308{
309    for (uint32_t i=0 ; i<MAX_NUM_CHANNELS ; i++) {
310        if (((volumeInc[i]>0) && (((prevVolume[i]+volumeInc[i])>>16) >= volume[i])) ||
311            ((volumeInc[i]<0) && (((prevVolume[i]+volumeInc[i])>>16) <= volume[i]))) {
312            volumeInc[i] = 0;
313            prevVolume[i] = volume[i]<<16;
314        }
315    }
316    if (aux) {
317        if (((auxInc>0) && (((prevAuxLevel+auxInc)>>16) >= auxLevel)) ||
318            ((auxInc<0) && (((prevAuxLevel+auxInc)>>16) <= auxLevel))) {
319            auxInc = 0;
320            prevAuxLevel = auxLevel<<16;
321        }
322    }
323}
324
325size_t AudioMixer::getUnreleasedFrames(int name) const
326{
327    name -= TRACK0;
328    if (uint32_t(name) < MAX_NUM_TRACKS) {
329        return mState.tracks[name].getUnreleasedFrames();
330    }
331    return 0;
332}
333
334void AudioMixer::setBufferProvider(int name, AudioBufferProvider* buffer)
335{
336    name -= TRACK0;
337    assert(uint32_t(name) < MAX_NUM_TRACKS);
338    mState.tracks[name].bufferProvider = buffer;
339}
340
341
342
343void AudioMixer::process(int64_t pts)
344{
345    mState.hook(&mState, pts);
346}
347
348
349void AudioMixer::process__validate(state_t* state, int64_t pts)
350{
351    ALOGW_IF(!state->needsChanged,
352        "in process__validate() but nothing's invalid");
353
354    uint32_t changed = state->needsChanged;
355    state->needsChanged = 0; // clear the validation flag
356
357    // recompute which tracks are enabled / disabled
358    uint32_t enabled = 0;
359    uint32_t disabled = 0;
360    while (changed) {
361        const int i = 31 - __builtin_clz(changed);
362        const uint32_t mask = 1<<i;
363        changed &= ~mask;
364        track_t& t = state->tracks[i];
365        (t.enabled ? enabled : disabled) |= mask;
366    }
367    state->enabledTracks &= ~disabled;
368    state->enabledTracks |=  enabled;
369
370    // compute everything we need...
371    int countActiveTracks = 0;
372    bool all16BitsStereoNoResample = true;
373    bool resampling = false;
374    bool volumeRamp = false;
375    uint32_t en = state->enabledTracks;
376    while (en) {
377        const int i = 31 - __builtin_clz(en);
378        en &= ~(1<<i);
379
380        countActiveTracks++;
381        track_t& t = state->tracks[i];
382        uint32_t n = 0;
383        n |= NEEDS_CHANNEL_1 + t.channelCount - 1;
384        n |= NEEDS_FORMAT_16;
385        n |= t.doesResample() ? NEEDS_RESAMPLE_ENABLED : NEEDS_RESAMPLE_DISABLED;
386        if (t.auxLevel != 0 && t.auxBuffer != NULL) {
387            n |= NEEDS_AUX_ENABLED;
388        }
389
390        if (t.volumeInc[0]|t.volumeInc[1]) {
391            volumeRamp = true;
392        } else if (!t.doesResample() && t.volumeRL == 0) {
393            n |= NEEDS_MUTE_ENABLED;
394        }
395        t.needs = n;
396
397        if ((n & NEEDS_MUTE__MASK) == NEEDS_MUTE_ENABLED) {
398            t.hook = track__nop;
399        } else {
400            if ((n & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED) {
401                all16BitsStereoNoResample = false;
402            }
403            if ((n & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) {
404                all16BitsStereoNoResample = false;
405                resampling = true;
406                t.hook = track__genericResample;
407            } else {
408                if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_1){
409                    t.hook = track__16BitsMono;
410                    all16BitsStereoNoResample = false;
411                }
412                if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_2){
413                    t.hook = track__16BitsStereo;
414                }
415            }
416        }
417    }
418
419    // select the processing hooks
420    state->hook = process__nop;
421    if (countActiveTracks) {
422        if (resampling) {
423            if (!state->outputTemp) {
424                state->outputTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
425            }
426            if (!state->resampleTemp) {
427                state->resampleTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
428            }
429            state->hook = process__genericResampling;
430        } else {
431            if (state->outputTemp) {
432                delete [] state->outputTemp;
433                state->outputTemp = NULL;
434            }
435            if (state->resampleTemp) {
436                delete [] state->resampleTemp;
437                state->resampleTemp = NULL;
438            }
439            state->hook = process__genericNoResampling;
440            if (all16BitsStereoNoResample && !volumeRamp) {
441                if (countActiveTracks == 1) {
442                    state->hook = process__OneTrack16BitsStereoNoResampling;
443                }
444            }
445        }
446    }
447
448    ALOGV("mixer configuration change: %d activeTracks (%08x) "
449        "all16BitsStereoNoResample=%d, resampling=%d, volumeRamp=%d",
450        countActiveTracks, state->enabledTracks,
451        all16BitsStereoNoResample, resampling, volumeRamp);
452
453   state->hook(state, pts);
454
455    // Now that the volume ramp has been done, set optimal state and
456    // track hooks for subsequent mixer process
457    if (countActiveTracks) {
458        bool allMuted = true;
459        uint32_t en = state->enabledTracks;
460        while (en) {
461            const int i = 31 - __builtin_clz(en);
462            en &= ~(1<<i);
463            track_t& t = state->tracks[i];
464            if (!t.doesResample() && t.volumeRL == 0)
465            {
466                t.needs |= NEEDS_MUTE_ENABLED;
467                t.hook = track__nop;
468            } else {
469                allMuted = false;
470            }
471        }
472        if (allMuted) {
473            state->hook = process__nop;
474        } else if (all16BitsStereoNoResample) {
475            if (countActiveTracks == 1) {
476                state->hook = process__OneTrack16BitsStereoNoResampling;
477            }
478        }
479    }
480}
481
482
483void AudioMixer::track__genericResample(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux)
484{
485    t->resampler->setSampleRate(t->sampleRate);
486
487    // ramp gain - resample to temp buffer and scale/mix in 2nd step
488    if (aux != NULL) {
489        // always resample with unity gain when sending to auxiliary buffer to be able
490        // to apply send level after resampling
491        // TODO: modify each resampler to support aux channel?
492        t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN);
493        memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t));
494        t->resampler->resample(temp, outFrameCount, t->bufferProvider);
495        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
496            volumeRampStereo(t, out, outFrameCount, temp, aux);
497        } else {
498            volumeStereo(t, out, outFrameCount, temp, aux);
499        }
500    } else {
501        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
502            t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN);
503            memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t));
504            t->resampler->resample(temp, outFrameCount, t->bufferProvider);
505            volumeRampStereo(t, out, outFrameCount, temp, aux);
506        }
507
508        // constant gain
509        else {
510            t->resampler->setVolume(t->volume[0], t->volume[1]);
511            t->resampler->resample(out, outFrameCount, t->bufferProvider);
512        }
513    }
514}
515
516void AudioMixer::track__nop(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux)
517{
518}
519
520void AudioMixer::volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
521{
522    int32_t vl = t->prevVolume[0];
523    int32_t vr = t->prevVolume[1];
524    const int32_t vlInc = t->volumeInc[0];
525    const int32_t vrInc = t->volumeInc[1];
526
527    //ALOGD("[0] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
528    //        t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
529    //       (vl + vlInc*frameCount)/65536.0f, frameCount);
530
531    // ramp volume
532    if (CC_UNLIKELY(aux != NULL)) {
533        int32_t va = t->prevAuxLevel;
534        const int32_t vaInc = t->auxInc;
535        int32_t l;
536        int32_t r;
537
538        do {
539            l = (*temp++ >> 12);
540            r = (*temp++ >> 12);
541            *out++ += (vl >> 16) * l;
542            *out++ += (vr >> 16) * r;
543            *aux++ += (va >> 17) * (l + r);
544            vl += vlInc;
545            vr += vrInc;
546            va += vaInc;
547        } while (--frameCount);
548        t->prevAuxLevel = va;
549    } else {
550        do {
551            *out++ += (vl >> 16) * (*temp++ >> 12);
552            *out++ += (vr >> 16) * (*temp++ >> 12);
553            vl += vlInc;
554            vr += vrInc;
555        } while (--frameCount);
556    }
557    t->prevVolume[0] = vl;
558    t->prevVolume[1] = vr;
559    t->adjustVolumeRamp((aux != NULL));
560}
561
562void AudioMixer::volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
563{
564    const int16_t vl = t->volume[0];
565    const int16_t vr = t->volume[1];
566
567    if (CC_UNLIKELY(aux != NULL)) {
568        const int16_t va = (int16_t)t->auxLevel;
569        do {
570            int16_t l = (int16_t)(*temp++ >> 12);
571            int16_t r = (int16_t)(*temp++ >> 12);
572            out[0] = mulAdd(l, vl, out[0]);
573            int16_t a = (int16_t)(((int32_t)l + r) >> 1);
574            out[1] = mulAdd(r, vr, out[1]);
575            out += 2;
576            aux[0] = mulAdd(a, va, aux[0]);
577            aux++;
578        } while (--frameCount);
579    } else {
580        do {
581            int16_t l = (int16_t)(*temp++ >> 12);
582            int16_t r = (int16_t)(*temp++ >> 12);
583            out[0] = mulAdd(l, vl, out[0]);
584            out[1] = mulAdd(r, vr, out[1]);
585            out += 2;
586        } while (--frameCount);
587    }
588}
589
590void AudioMixer::track__16BitsStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
591{
592    const int16_t *in = static_cast<const int16_t *>(t->in);
593
594    if (CC_UNLIKELY(aux != NULL)) {
595        int32_t l;
596        int32_t r;
597        // ramp gain
598        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
599            int32_t vl = t->prevVolume[0];
600            int32_t vr = t->prevVolume[1];
601            int32_t va = t->prevAuxLevel;
602            const int32_t vlInc = t->volumeInc[0];
603            const int32_t vrInc = t->volumeInc[1];
604            const int32_t vaInc = t->auxInc;
605            // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
606            //        t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
607            //        (vl + vlInc*frameCount)/65536.0f, frameCount);
608
609            do {
610                l = (int32_t)*in++;
611                r = (int32_t)*in++;
612                *out++ += (vl >> 16) * l;
613                *out++ += (vr >> 16) * r;
614                *aux++ += (va >> 17) * (l + r);
615                vl += vlInc;
616                vr += vrInc;
617                va += vaInc;
618            } while (--frameCount);
619
620            t->prevVolume[0] = vl;
621            t->prevVolume[1] = vr;
622            t->prevAuxLevel = va;
623            t->adjustVolumeRamp(true);
624        }
625
626        // constant gain
627        else {
628            const uint32_t vrl = t->volumeRL;
629            const int16_t va = (int16_t)t->auxLevel;
630            do {
631                uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
632                int16_t a = (int16_t)(((int32_t)in[0] + in[1]) >> 1);
633                in += 2;
634                out[0] = mulAddRL(1, rl, vrl, out[0]);
635                out[1] = mulAddRL(0, rl, vrl, out[1]);
636                out += 2;
637                aux[0] = mulAdd(a, va, aux[0]);
638                aux++;
639            } while (--frameCount);
640        }
641    } else {
642        // ramp gain
643        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
644            int32_t vl = t->prevVolume[0];
645            int32_t vr = t->prevVolume[1];
646            const int32_t vlInc = t->volumeInc[0];
647            const int32_t vrInc = t->volumeInc[1];
648
649            // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
650            //        t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
651            //        (vl + vlInc*frameCount)/65536.0f, frameCount);
652
653            do {
654                *out++ += (vl >> 16) * (int32_t) *in++;
655                *out++ += (vr >> 16) * (int32_t) *in++;
656                vl += vlInc;
657                vr += vrInc;
658            } while (--frameCount);
659
660            t->prevVolume[0] = vl;
661            t->prevVolume[1] = vr;
662            t->adjustVolumeRamp(false);
663        }
664
665        // constant gain
666        else {
667            const uint32_t vrl = t->volumeRL;
668            do {
669                uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
670                in += 2;
671                out[0] = mulAddRL(1, rl, vrl, out[0]);
672                out[1] = mulAddRL(0, rl, vrl, out[1]);
673                out += 2;
674            } while (--frameCount);
675        }
676    }
677    t->in = in;
678}
679
680void AudioMixer::track__16BitsMono(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
681{
682    const int16_t *in = static_cast<int16_t const *>(t->in);
683
684    if (CC_UNLIKELY(aux != NULL)) {
685        // ramp gain
686        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
687            int32_t vl = t->prevVolume[0];
688            int32_t vr = t->prevVolume[1];
689            int32_t va = t->prevAuxLevel;
690            const int32_t vlInc = t->volumeInc[0];
691            const int32_t vrInc = t->volumeInc[1];
692            const int32_t vaInc = t->auxInc;
693
694            // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
695            //         t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
696            //         (vl + vlInc*frameCount)/65536.0f, frameCount);
697
698            do {
699                int32_t l = *in++;
700                *out++ += (vl >> 16) * l;
701                *out++ += (vr >> 16) * l;
702                *aux++ += (va >> 16) * l;
703                vl += vlInc;
704                vr += vrInc;
705                va += vaInc;
706            } while (--frameCount);
707
708            t->prevVolume[0] = vl;
709            t->prevVolume[1] = vr;
710            t->prevAuxLevel = va;
711            t->adjustVolumeRamp(true);
712        }
713        // constant gain
714        else {
715            const int16_t vl = t->volume[0];
716            const int16_t vr = t->volume[1];
717            const int16_t va = (int16_t)t->auxLevel;
718            do {
719                int16_t l = *in++;
720                out[0] = mulAdd(l, vl, out[0]);
721                out[1] = mulAdd(l, vr, out[1]);
722                out += 2;
723                aux[0] = mulAdd(l, va, aux[0]);
724                aux++;
725            } while (--frameCount);
726        }
727    } else {
728        // ramp gain
729        if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
730            int32_t vl = t->prevVolume[0];
731            int32_t vr = t->prevVolume[1];
732            const int32_t vlInc = t->volumeInc[0];
733            const int32_t vrInc = t->volumeInc[1];
734
735            // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
736            //         t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
737            //         (vl + vlInc*frameCount)/65536.0f, frameCount);
738
739            do {
740                int32_t l = *in++;
741                *out++ += (vl >> 16) * l;
742                *out++ += (vr >> 16) * l;
743                vl += vlInc;
744                vr += vrInc;
745            } while (--frameCount);
746
747            t->prevVolume[0] = vl;
748            t->prevVolume[1] = vr;
749            t->adjustVolumeRamp(false);
750        }
751        // constant gain
752        else {
753            const int16_t vl = t->volume[0];
754            const int16_t vr = t->volume[1];
755            do {
756                int16_t l = *in++;
757                out[0] = mulAdd(l, vl, out[0]);
758                out[1] = mulAdd(l, vr, out[1]);
759                out += 2;
760            } while (--frameCount);
761        }
762    }
763    t->in = in;
764}
765
766// no-op case
767void AudioMixer::process__nop(state_t* state, int64_t pts)
768{
769    uint32_t e0 = state->enabledTracks;
770    size_t bufSize = state->frameCount * sizeof(int16_t) * MAX_NUM_CHANNELS;
771    while (e0) {
772        // process by group of tracks with same output buffer to
773        // avoid multiple memset() on same buffer
774        uint32_t e1 = e0, e2 = e0;
775        int i = 31 - __builtin_clz(e1);
776        track_t& t1 = state->tracks[i];
777        e2 &= ~(1<<i);
778        while (e2) {
779            i = 31 - __builtin_clz(e2);
780            e2 &= ~(1<<i);
781            track_t& t2 = state->tracks[i];
782            if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
783                e1 &= ~(1<<i);
784            }
785        }
786        e0 &= ~(e1);
787
788        memset(t1.mainBuffer, 0, bufSize);
789
790        while (e1) {
791            i = 31 - __builtin_clz(e1);
792            e1 &= ~(1<<i);
793            t1 = state->tracks[i];
794            size_t outFrames = state->frameCount;
795            while (outFrames) {
796                t1.buffer.frameCount = outFrames;
797                int64_t outputPTS = calculateOutputPTS(
798                    t1, pts, state->frameCount - outFrames);
799                t1.bufferProvider->getNextBuffer(&t1.buffer, outputPTS);
800                if (t1.buffer.raw == NULL) break;
801                outFrames -= t1.buffer.frameCount;
802                t1.bufferProvider->releaseBuffer(&t1.buffer);
803            }
804        }
805    }
806}
807
808// generic code without resampling
809void AudioMixer::process__genericNoResampling(state_t* state, int64_t pts)
810{
811    int32_t outTemp[BLOCKSIZE * MAX_NUM_CHANNELS] __attribute__((aligned(32)));
812
813    // acquire each track's buffer
814    uint32_t enabledTracks = state->enabledTracks;
815    uint32_t e0 = enabledTracks;
816    while (e0) {
817        const int i = 31 - __builtin_clz(e0);
818        e0 &= ~(1<<i);
819        track_t& t = state->tracks[i];
820        t.buffer.frameCount = state->frameCount;
821        t.bufferProvider->getNextBuffer(&t.buffer, pts);
822        t.frameCount = t.buffer.frameCount;
823        t.in = t.buffer.raw;
824        // t.in == NULL can happen if the track was flushed just after having
825        // been enabled for mixing.
826        if (t.in == NULL)
827            enabledTracks &= ~(1<<i);
828    }
829
830    e0 = enabledTracks;
831    while (e0) {
832        // process by group of tracks with same output buffer to
833        // optimize cache use
834        uint32_t e1 = e0, e2 = e0;
835        int j = 31 - __builtin_clz(e1);
836        track_t& t1 = state->tracks[j];
837        e2 &= ~(1<<j);
838        while (e2) {
839            j = 31 - __builtin_clz(e2);
840            e2 &= ~(1<<j);
841            track_t& t2 = state->tracks[j];
842            if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
843                e1 &= ~(1<<j);
844            }
845        }
846        e0 &= ~(e1);
847        // this assumes output 16 bits stereo, no resampling
848        int32_t *out = t1.mainBuffer;
849        size_t numFrames = 0;
850        do {
851            memset(outTemp, 0, sizeof(outTemp));
852            e2 = e1;
853            while (e2) {
854                const int i = 31 - __builtin_clz(e2);
855                e2 &= ~(1<<i);
856                track_t& t = state->tracks[i];
857                size_t outFrames = BLOCKSIZE;
858                int32_t *aux = NULL;
859                if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) {
860                    aux = t.auxBuffer + numFrames;
861                }
862                while (outFrames) {
863                    size_t inFrames = (t.frameCount > outFrames)?outFrames:t.frameCount;
864                    if (inFrames) {
865                        (t.hook)(&t, outTemp + (BLOCKSIZE-outFrames)*MAX_NUM_CHANNELS, inFrames, state->resampleTemp, aux);
866                        t.frameCount -= inFrames;
867                        outFrames -= inFrames;
868                        if (CC_UNLIKELY(aux != NULL)) {
869                            aux += inFrames;
870                        }
871                    }
872                    if (t.frameCount == 0 && outFrames) {
873                        t.bufferProvider->releaseBuffer(&t.buffer);
874                        t.buffer.frameCount = (state->frameCount - numFrames) - (BLOCKSIZE - outFrames);
875                        int64_t outputPTS = calculateOutputPTS(
876                            t, pts, numFrames + (BLOCKSIZE - outFrames));
877                        t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
878                        t.in = t.buffer.raw;
879                        if (t.in == NULL) {
880                            enabledTracks &= ~(1<<i);
881                            e1 &= ~(1<<i);
882                            break;
883                        }
884                        t.frameCount = t.buffer.frameCount;
885                    }
886                }
887            }
888            ditherAndClamp(out, outTemp, BLOCKSIZE);
889            out += BLOCKSIZE;
890            numFrames += BLOCKSIZE;
891        } while (numFrames < state->frameCount);
892    }
893
894    // release each track's buffer
895    e0 = enabledTracks;
896    while (e0) {
897        const int i = 31 - __builtin_clz(e0);
898        e0 &= ~(1<<i);
899        track_t& t = state->tracks[i];
900        t.bufferProvider->releaseBuffer(&t.buffer);
901    }
902}
903
904
905// generic code with resampling
906void AudioMixer::process__genericResampling(state_t* state, int64_t pts)
907{
908    // this const just means that local variable outTemp doesn't change
909    int32_t* const outTemp = state->outputTemp;
910    const size_t size = sizeof(int32_t) * MAX_NUM_CHANNELS * state->frameCount;
911
912    size_t numFrames = state->frameCount;
913
914    uint32_t e0 = state->enabledTracks;
915    while (e0) {
916        // process by group of tracks with same output buffer
917        // to optimize cache use
918        uint32_t e1 = e0, e2 = e0;
919        int j = 31 - __builtin_clz(e1);
920        track_t& t1 = state->tracks[j];
921        e2 &= ~(1<<j);
922        while (e2) {
923            j = 31 - __builtin_clz(e2);
924            e2 &= ~(1<<j);
925            track_t& t2 = state->tracks[j];
926            if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
927                e1 &= ~(1<<j);
928            }
929        }
930        e0 &= ~(e1);
931        int32_t *out = t1.mainBuffer;
932        memset(outTemp, 0, size);
933        while (e1) {
934            const int i = 31 - __builtin_clz(e1);
935            e1 &= ~(1<<i);
936            track_t& t = state->tracks[i];
937            int32_t *aux = NULL;
938            if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) {
939                aux = t.auxBuffer;
940            }
941
942            // this is a little goofy, on the resampling case we don't
943            // acquire/release the buffers because it's done by
944            // the resampler.
945            if ((t.needs & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) {
946                t.resampler->setPTS(pts);
947                (t.hook)(&t, outTemp, numFrames, state->resampleTemp, aux);
948            } else {
949
950                size_t outFrames = 0;
951
952                while (outFrames < numFrames) {
953                    t.buffer.frameCount = numFrames - outFrames;
954                    int64_t outputPTS = calculateOutputPTS(t, pts, outFrames);
955                    t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
956                    t.in = t.buffer.raw;
957                    // t.in == NULL can happen if the track was flushed just after having
958                    // been enabled for mixing.
959                    if (t.in == NULL) break;
960
961                    if (CC_UNLIKELY(aux != NULL)) {
962                        aux += outFrames;
963                    }
964                    (t.hook)(&t, outTemp + outFrames*MAX_NUM_CHANNELS, t.buffer.frameCount, state->resampleTemp, aux);
965                    outFrames += t.buffer.frameCount;
966                    t.bufferProvider->releaseBuffer(&t.buffer);
967                }
968            }
969        }
970        ditherAndClamp(out, outTemp, numFrames);
971    }
972}
973
974// one track, 16 bits stereo without resampling is the most common case
975void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state,
976                                                           int64_t pts)
977{
978    // This method is only called when state->enabledTracks has exactly
979    // one bit set.  The asserts below would verify this, but are commented out
980    // since the whole point of this method is to optimize performance.
981    //assert(0 != state->enabledTracks);
982    const int i = 31 - __builtin_clz(state->enabledTracks);
983    //assert((1 << i) == state->enabledTracks);
984    const track_t& t = state->tracks[i];
985
986    AudioBufferProvider::Buffer& b(t.buffer);
987
988    int32_t* out = t.mainBuffer;
989    size_t numFrames = state->frameCount;
990
991    const int16_t vl = t.volume[0];
992    const int16_t vr = t.volume[1];
993    const uint32_t vrl = t.volumeRL;
994    while (numFrames) {
995        b.frameCount = numFrames;
996        int64_t outputPTS = calculateOutputPTS(t, pts, out - t.mainBuffer);
997        t.bufferProvider->getNextBuffer(&b, outputPTS);
998        const int16_t *in = b.i16;
999
1000        // in == NULL can happen if the track was flushed just after having
1001        // been enabled for mixing.
1002        if (in == NULL || ((unsigned long)in & 3)) {
1003            memset(out, 0, numFrames*MAX_NUM_CHANNELS*sizeof(int16_t));
1004            ALOGE_IF(((unsigned long)in & 3), "process stereo track: input buffer alignment pb: buffer %p track %d, channels %d, needs %08x",
1005                    in, i, t.channelCount, t.needs);
1006            return;
1007        }
1008        size_t outFrames = b.frameCount;
1009
1010        if (CC_UNLIKELY(uint32_t(vl) > UNITY_GAIN || uint32_t(vr) > UNITY_GAIN)) {
1011            // volume is boosted, so we might need to clamp even though
1012            // we process only one track.
1013            do {
1014                uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1015                in += 2;
1016                int32_t l = mulRL(1, rl, vrl) >> 12;
1017                int32_t r = mulRL(0, rl, vrl) >> 12;
1018                // clamping...
1019                l = clamp16(l);
1020                r = clamp16(r);
1021                *out++ = (r<<16) | (l & 0xFFFF);
1022            } while (--outFrames);
1023        } else {
1024            do {
1025                uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1026                in += 2;
1027                int32_t l = mulRL(1, rl, vrl) >> 12;
1028                int32_t r = mulRL(0, rl, vrl) >> 12;
1029                *out++ = (r<<16) | (l & 0xFFFF);
1030            } while (--outFrames);
1031        }
1032        numFrames -= b.frameCount;
1033        t.bufferProvider->releaseBuffer(&b);
1034    }
1035}
1036
1037#if 0
1038// 2 tracks is also a common case
1039// NEVER used in current implementation of process__validate()
1040// only use if the 2 tracks have the same output buffer
1041void AudioMixer::process__TwoTracks16BitsStereoNoResampling(state_t* state,
1042                                                            int64_t pts)
1043{
1044    int i;
1045    uint32_t en = state->enabledTracks;
1046
1047    i = 31 - __builtin_clz(en);
1048    const track_t& t0 = state->tracks[i];
1049    AudioBufferProvider::Buffer& b0(t0.buffer);
1050
1051    en &= ~(1<<i);
1052    i = 31 - __builtin_clz(en);
1053    const track_t& t1 = state->tracks[i];
1054    AudioBufferProvider::Buffer& b1(t1.buffer);
1055
1056    const int16_t *in0;
1057    const int16_t vl0 = t0.volume[0];
1058    const int16_t vr0 = t0.volume[1];
1059    size_t frameCount0 = 0;
1060
1061    const int16_t *in1;
1062    const int16_t vl1 = t1.volume[0];
1063    const int16_t vr1 = t1.volume[1];
1064    size_t frameCount1 = 0;
1065
1066    //FIXME: only works if two tracks use same buffer
1067    int32_t* out = t0.mainBuffer;
1068    size_t numFrames = state->frameCount;
1069    const int16_t *buff = NULL;
1070
1071
1072    while (numFrames) {
1073
1074        if (frameCount0 == 0) {
1075            b0.frameCount = numFrames;
1076            int64_t outputPTS = calculateOutputPTS(t0, pts,
1077                                                   out - t0.mainBuffer);
1078            t0.bufferProvider->getNextBuffer(&b0, outputPTS);
1079            if (b0.i16 == NULL) {
1080                if (buff == NULL) {
1081                    buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
1082                }
1083                in0 = buff;
1084                b0.frameCount = numFrames;
1085            } else {
1086                in0 = b0.i16;
1087            }
1088            frameCount0 = b0.frameCount;
1089        }
1090        if (frameCount1 == 0) {
1091            b1.frameCount = numFrames;
1092            int64_t outputPTS = calculateOutputPTS(t1, pts,
1093                                                   out - t0.mainBuffer);
1094            t1.bufferProvider->getNextBuffer(&b1, outputPTS);
1095            if (b1.i16 == NULL) {
1096                if (buff == NULL) {
1097                    buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
1098                }
1099                in1 = buff;
1100                b1.frameCount = numFrames;
1101            } else {
1102                in1 = b1.i16;
1103            }
1104            frameCount1 = b1.frameCount;
1105        }
1106
1107        size_t outFrames = frameCount0 < frameCount1?frameCount0:frameCount1;
1108
1109        numFrames -= outFrames;
1110        frameCount0 -= outFrames;
1111        frameCount1 -= outFrames;
1112
1113        do {
1114            int32_t l0 = *in0++;
1115            int32_t r0 = *in0++;
1116            l0 = mul(l0, vl0);
1117            r0 = mul(r0, vr0);
1118            int32_t l = *in1++;
1119            int32_t r = *in1++;
1120            l = mulAdd(l, vl1, l0) >> 12;
1121            r = mulAdd(r, vr1, r0) >> 12;
1122            // clamping...
1123            l = clamp16(l);
1124            r = clamp16(r);
1125            *out++ = (r<<16) | (l & 0xFFFF);
1126        } while (--outFrames);
1127
1128        if (frameCount0 == 0) {
1129            t0.bufferProvider->releaseBuffer(&b0);
1130        }
1131        if (frameCount1 == 0) {
1132            t1.bufferProvider->releaseBuffer(&b1);
1133        }
1134    }
1135
1136    delete [] buff;
1137}
1138#endif
1139
1140int64_t AudioMixer::calculateOutputPTS(const track_t& t, int64_t basePTS,
1141                                       int outputFrameIndex)
1142{
1143    if (AudioBufferProvider::kInvalidPTS == basePTS)
1144        return AudioBufferProvider::kInvalidPTS;
1145
1146    return basePTS + ((outputFrameIndex * t.localTimeFreq) / t.sampleRate);
1147}
1148
1149// ----------------------------------------------------------------------------
1150}; // namespace android
1151