AudioMixer.h revision 99e53b86eebb605b70dd7591b89bf61a9414ed0e 
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#ifndef ANDROID_AUDIO_MIXER_H
19#define ANDROID_AUDIO_MIXER_H
20
21#include <stdint.h>
22#include <sys/types.h>
23
24#include "AudioBufferProvider.h"
25#include "AudioResampler.h"
26
27namespace android {
28
29// ----------------------------------------------------------------------------
30
31class AudioMixer
32{
33public:
34                            AudioMixer(size_t frameCount, uint32_t sampleRate);
35
36    /*virtual*/             ~AudioMixer();  // non-virtual saves a v-table, restore if sub-classed
37
38    static const uint32_t MAX_NUM_TRACKS = 32;
39    static const uint32_t MAX_NUM_CHANNELS = 2;
40
41    static const uint16_t UNITY_GAIN = 0x1000;
42
43    enum { // names
44
45        // track names (MAX_NUM_TRACKS units)
46        TRACK0          = 0x1000,
47
48        // 0x2000 is unused
49
50        // setParameter targets
51        TRACK           = 0x3000,
52        RESAMPLE        = 0x3001,
53        RAMP_VOLUME     = 0x3002, // ramp to new volume
54        VOLUME          = 0x3003, // don't ramp
55
56        // set Parameter names
57        // for target TRACK
58        CHANNEL_MASK    = 0x4000,
59        FORMAT          = 0x4001,
60        MAIN_BUFFER     = 0x4002,
61        AUX_BUFFER      = 0x4003,
62        // for target RESAMPLE
63        SAMPLE_RATE     = 0x4100,
64        RESET           = 0x4101,
65        // for target RAMP_VOLUME and VOLUME (8 channels max)
66        VOLUME0         = 0x4200,
67        VOLUME1         = 0x4201,
68        AUXLEVEL        = 0x4210,
69    };
70
71
72    // For all APIs with "name": TRACK0 <= name < TRACK0 + MAX_NUM_TRACKS
73    int         getTrackName();
74    void        deleteTrackName(int name);
75
76    void        enable(int name);
77    void        disable(int name);
78
79    void        setParameter(int name, int target, int param, void *value);
80
81    void        setBufferProvider(int name, AudioBufferProvider* bufferProvider);
82    void        process();
83
84    uint32_t    trackNames() const { return mTrackNames; }
85
86    size_t      getUnreleasedFrames(int name) const;
87
88private:
89
90    enum {
91        NEEDS_CHANNEL_COUNT__MASK   = 0x00000003,
92        NEEDS_FORMAT__MASK          = 0x000000F0,
93        NEEDS_MUTE__MASK            = 0x00000100,
94        NEEDS_RESAMPLE__MASK        = 0x00001000,
95        NEEDS_AUX__MASK             = 0x00010000,
96    };
97
98    enum {
99        NEEDS_CHANNEL_1             = 0x00000000,
100        NEEDS_CHANNEL_2             = 0x00000001,
101
102        NEEDS_FORMAT_16             = 0x00000010,
103
104        NEEDS_MUTE_DISABLED         = 0x00000000,
105        NEEDS_MUTE_ENABLED          = 0x00000100,
106
107        NEEDS_RESAMPLE_DISABLED     = 0x00000000,
108        NEEDS_RESAMPLE_ENABLED      = 0x00001000,
109
110        NEEDS_AUX_DISABLED     = 0x00000000,
111        NEEDS_AUX_ENABLED      = 0x00010000,
112    };
113
114    struct state_t;
115    struct track_t;
116
117    typedef void (*mix_t)(state_t* state);
118    typedef void (*hook_t)(track_t* t, int32_t* output, size_t numOutFrames, int32_t* temp, int32_t* aux);
119    static const int BLOCKSIZE = 16; // 4 cache lines
120
121    struct track_t {
122        uint32_t    needs;
123
124        union {
125        int16_t     volume[MAX_NUM_CHANNELS]; // [0]3.12 fixed point
126        int32_t     volumeRL;
127        };
128
129        int32_t     prevVolume[MAX_NUM_CHANNELS];
130
131        int32_t     volumeInc[MAX_NUM_CHANNELS];
132        int32_t     auxLevel;
133        int32_t     auxInc;
134        int32_t     prevAuxLevel;
135
136        uint16_t    frameCount;
137
138        uint8_t     channelCount : 4;
139        uint8_t     enabled      : 1;
140        uint8_t     reserved0    : 3;
141        uint8_t     format;
142        uint32_t    channelMask;
143
144        AudioBufferProvider*                bufferProvider;
145        mutable AudioBufferProvider::Buffer buffer;
146
147        hook_t      hook;
148        const void* in;             // current location in buffer
149
150        AudioResampler*     resampler;
151        uint32_t            sampleRate;
152        int32_t*           mainBuffer;
153        int32_t*           auxBuffer;
154
155        bool        setResampler(uint32_t sampleRate, uint32_t devSampleRate);
156        bool        doesResample() const { return resampler != NULL; }
157        void        resetResampler() { if (resampler != NULL) resampler->reset(); }
158        void        adjustVolumeRamp(bool aux);
159        size_t      getUnreleasedFrames() const { return resampler != NULL ?
160                                                    resampler->getUnreleasedFrames() : 0; };
161    };
162
163    // pad to 32-bytes to fill cache line
164    struct state_t {
165        uint32_t        enabledTracks;
166        uint32_t        needsChanged;
167        size_t          frameCount;
168        mix_t           hook;
169        int32_t         *outputTemp;
170        int32_t         *resampleTemp;
171        int32_t         reserved[2];
172        track_t         tracks[MAX_NUM_TRACKS]; __attribute__((aligned(32)));
173    };
174
175    // bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc.
176    uint32_t        mTrackNames;
177    const uint32_t  mSampleRate;
178
179    state_t         mState __attribute__((aligned(32)));
180
181    void invalidateState(uint32_t mask);
182
183    static void track__genericResample(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
184    static void track__nop(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
185    static void track__16BitsStereo(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
186    static void track__16BitsMono(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
187    static void volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
188    static void volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
189
190    static void process__validate(state_t* state);
191    static void process__nop(state_t* state);
192    static void process__genericNoResampling(state_t* state);
193    static void process__genericResampling(state_t* state);
194    static void process__OneTrack16BitsStereoNoResampling(state_t* state);
195#if 0
196    static void process__TwoTracks16BitsStereoNoResampling(state_t* state);
197#endif
198};
199
200// ----------------------------------------------------------------------------
201}; // namespace android
202
203#endif // ANDROID_AUDIO_MIXER_H
204