AudioMixer.h revision ccf89b54f973f11082150d02ed957f7e967fbc8b 
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                                       uint32_t maxNumTracks = MAX_NUM_TRACKS);
36
37    /*virtual*/             ~AudioMixer();  // non-virtual saves a v-table, restore if sub-classed
38
39    static const uint32_t MAX_NUM_TRACKS = 32;
40    static const uint32_t MAX_NUM_CHANNELS = 2;
41
42    static const uint16_t UNITY_GAIN = 0x1000;
43
44    enum { // names
45
46        // track names (MAX_NUM_TRACKS units)
47        TRACK0          = 0x1000,
48
49        // 0x2000 is unused
50
51        // setParameter targets
52        TRACK           = 0x3000,
53        RESAMPLE        = 0x3001,
54        RAMP_VOLUME     = 0x3002, // ramp to new volume
55        VOLUME          = 0x3003, // don't ramp
56
57        // set Parameter names
58        // for target TRACK
59        CHANNEL_MASK    = 0x4000,
60        FORMAT          = 0x4001,
61        MAIN_BUFFER     = 0x4002,
62        AUX_BUFFER      = 0x4003,
63        // for target RESAMPLE
64        SAMPLE_RATE     = 0x4100,
65        RESET           = 0x4101,
66        // for target RAMP_VOLUME and VOLUME (8 channels max)
67        VOLUME0         = 0x4200,
68        VOLUME1         = 0x4201,
69        AUXLEVEL        = 0x4210,
70    };
71
72
73    // For all APIs with "name": TRACK0 <= name < TRACK0 + MAX_NUM_TRACKS
74
75    // Allocate a track name.  Returns new track name if successful, -1 on failure.
76    int         getTrackName();
77
78    // Free an allocated track by name
79    void        deleteTrackName(int name);
80
81    // Enable or disable an allocated track by name
82    void        enable(int name);
83    void        disable(int name);
84
85    void        setParameter(int name, int target, int param, void *value);
86
87    void        setBufferProvider(int name, AudioBufferProvider* bufferProvider);
88    void        process(int64_t pts);
89
90    uint32_t    trackNames() const { return mTrackNames; }
91
92    size_t      getUnreleasedFrames(int name) const;
93
94private:
95
96    enum {
97        NEEDS_CHANNEL_COUNT__MASK   = 0x00000003,
98        NEEDS_FORMAT__MASK          = 0x000000F0,
99        NEEDS_MUTE__MASK            = 0x00000100,
100        NEEDS_RESAMPLE__MASK        = 0x00001000,
101        NEEDS_AUX__MASK             = 0x00010000,
102    };
103
104    enum {
105        NEEDS_CHANNEL_1             = 0x00000000,
106        NEEDS_CHANNEL_2             = 0x00000001,
107
108        NEEDS_FORMAT_16             = 0x00000010,
109
110        NEEDS_MUTE_DISABLED         = 0x00000000,
111        NEEDS_MUTE_ENABLED          = 0x00000100,
112
113        NEEDS_RESAMPLE_DISABLED     = 0x00000000,
114        NEEDS_RESAMPLE_ENABLED      = 0x00001000,
115
116        NEEDS_AUX_DISABLED     = 0x00000000,
117        NEEDS_AUX_ENABLED      = 0x00010000,
118    };
119
120    struct state_t;
121    struct track_t;
122
123    typedef void (*hook_t)(track_t* t, int32_t* output, size_t numOutFrames, int32_t* temp, int32_t* aux);
124    static const int BLOCKSIZE = 16; // 4 cache lines
125
126    struct track_t {
127        uint32_t    needs;
128
129        union {
130        int16_t     volume[MAX_NUM_CHANNELS]; // [0]3.12 fixed point
131        int32_t     volumeRL;
132        };
133
134        int32_t     prevVolume[MAX_NUM_CHANNELS];
135
136        // 16-byte boundary
137
138        int32_t     volumeInc[MAX_NUM_CHANNELS];
139        int32_t     auxInc;
140        int32_t     prevAuxLevel;
141
142        // 16-byte boundary
143
144        int16_t     auxLevel;       // 0 <= auxLevel <= MAX_GAIN_INT, but signed for mul performance
145        uint16_t    frameCount;
146
147        uint8_t     channelCount;   // 1 or 2, redundant with (needs & NEEDS_CHANNEL_COUNT__MASK)
148        uint8_t     format;         // always 16
149        uint16_t    enabled;        // actually bool
150        uint32_t    channelMask;    // currently under-used
151
152        AudioBufferProvider*                bufferProvider;
153
154        // 16-byte boundary
155
156        mutable AudioBufferProvider::Buffer buffer; // 8 bytes
157
158        hook_t      hook;
159        const void* in;             // current location in buffer
160
161        // 16-byte boundary
162
163        AudioResampler*     resampler;
164        uint32_t            sampleRate;
165        int32_t*           mainBuffer;
166        int32_t*           auxBuffer;
167
168        // 16-byte boundary
169
170        uint64_t    localTimeFreq;
171
172        int64_t     padding;
173
174        // 16-byte boundary
175
176        bool        setResampler(uint32_t sampleRate, uint32_t devSampleRate);
177        bool        doesResample() const { return resampler != NULL; }
178        void        resetResampler() { if (resampler != NULL) resampler->reset(); }
179        void        adjustVolumeRamp(bool aux);
180        size_t      getUnreleasedFrames() const { return resampler != NULL ?
181                                                    resampler->getUnreleasedFrames() : 0; };
182    };
183
184    // pad to 32-bytes to fill cache line
185    struct state_t {
186        uint32_t        enabledTracks;
187        uint32_t        needsChanged;
188        size_t          frameCount;
189        void            (*hook)(state_t* state, int64_t pts);   // one of process__*, never NULL
190        int32_t         *outputTemp;
191        int32_t         *resampleTemp;
192        int32_t         reserved[2];
193        // FIXME allocate dynamically to save some memory when maxNumTracks < MAX_NUM_TRACKS
194        track_t         tracks[MAX_NUM_TRACKS]; __attribute__((aligned(32)));
195    };
196
197    // bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc.
198    uint32_t        mTrackNames;
199
200    // bitmask of configured track names; ~0 if maxNumTracks == MAX_NUM_TRACKS,
201    // but will have fewer bits set if maxNumTracks < MAX_NUM_TRACKS
202    const uint32_t  mConfiguredNames;
203
204    const uint32_t  mSampleRate;
205
206    state_t         mState __attribute__((aligned(32)));
207
208    void invalidateState(uint32_t mask);
209
210    static void track__genericResample(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
211    static void track__nop(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
212    static void track__16BitsStereo(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
213    static void track__16BitsMono(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
214    static void volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
215    static void volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
216
217    static void process__validate(state_t* state, int64_t pts);
218    static void process__nop(state_t* state, int64_t pts);
219    static void process__genericNoResampling(state_t* state, int64_t pts);
220    static void process__genericResampling(state_t* state, int64_t pts);
221    static void process__OneTrack16BitsStereoNoResampling(state_t* state,
222                                                          int64_t pts);
223#if 0
224    static void process__TwoTracks16BitsStereoNoResampling(state_t* state,
225                                                           int64_t pts);
226#endif
227
228    static int64_t calculateOutputPTS(const track_t& t, int64_t basePTS,
229                                      int outputFrameIndex);
230};
231
232// ----------------------------------------------------------------------------
233}; // namespace android
234
235#endif // ANDROID_AUDIO_MIXER_H
236