AudioMixer.h revision 3b81acab52b7140c1b8b20be2d67be3e221637e7
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(int64_t pts); 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 (*hook_t)(track_t* t, int32_t* output, size_t numOutFrames, int32_t* temp, int32_t* aux); 118 static const int BLOCKSIZE = 16; // 4 cache lines 119 120 struct track_t { 121 uint32_t needs; 122 123 union { 124 int16_t volume[MAX_NUM_CHANNELS]; // [0]3.12 fixed point 125 int32_t volumeRL; 126 }; 127 128 int32_t prevVolume[MAX_NUM_CHANNELS]; 129 130 // 16-byte boundary 131 132 int32_t volumeInc[MAX_NUM_CHANNELS]; 133 int32_t auxInc; 134 int32_t prevAuxLevel; 135 136 // 16-byte boundary 137 138 int16_t auxLevel; // 0 <= auxLevel <= MAX_GAIN_INT, but signed for mul performance 139 uint16_t frameCount; 140 141 uint8_t channelCount; // 1 or 2, redundant with (needs & NEEDS_CHANNEL_COUNT__MASK) 142 uint8_t format; // always 16 143 uint16_t enabled; // actually bool 144 uint32_t channelMask; // currently under-used 145 146 AudioBufferProvider* bufferProvider; 147 148 // 16-byte boundary 149 150 mutable AudioBufferProvider::Buffer buffer; // 8 bytes 151 152 hook_t hook; 153 const void* in; // current location in buffer 154 155 // 16-byte boundary 156 157 AudioResampler* resampler; 158 uint32_t sampleRate; 159 int32_t* mainBuffer; 160 int32_t* auxBuffer; 161 162 // 16-byte boundary 163 164 uint64_t localTimeFreq; 165 166 int64_t padding; 167 168 // 16-byte boundary 169 170 bool setResampler(uint32_t sampleRate, uint32_t devSampleRate); 171 bool doesResample() const { return resampler != NULL; } 172 void resetResampler() { if (resampler != NULL) resampler->reset(); } 173 void adjustVolumeRamp(bool aux); 174 size_t getUnreleasedFrames() const { return resampler != NULL ? 175 resampler->getUnreleasedFrames() : 0; }; 176 }; 177 178 // pad to 32-bytes to fill cache line 179 struct state_t { 180 uint32_t enabledTracks; 181 uint32_t needsChanged; 182 size_t frameCount; 183 void (*hook)(state_t* state, int64_t pts); // one of process__*, never NULL 184 int32_t *outputTemp; 185 int32_t *resampleTemp; 186 int32_t reserved[2]; 187 track_t tracks[MAX_NUM_TRACKS]; __attribute__((aligned(32))); 188 }; 189 190 // bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc. 191 uint32_t mTrackNames; 192 const uint32_t mSampleRate; 193 194 state_t mState __attribute__((aligned(32))); 195 196 void invalidateState(uint32_t mask); 197 198 static void track__genericResample(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 199 static void track__nop(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 200 static void track__16BitsStereo(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 201 static void track__16BitsMono(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 202 static void volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux); 203 static void volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux); 204 205 static void process__validate(state_t* state, int64_t pts); 206 static void process__nop(state_t* state, int64_t pts); 207 static void process__genericNoResampling(state_t* state, int64_t pts); 208 static void process__genericResampling(state_t* state, int64_t pts); 209 static void process__OneTrack16BitsStereoNoResampling(state_t* state, 210 int64_t pts); 211#if 0 212 static void process__TwoTracks16BitsStereoNoResampling(state_t* state, 213 int64_t pts); 214#endif 215 216 static int64_t calculateOutputPTS(const track_t& t, int64_t basePTS, 217 int outputFrameIndex); 218}; 219 220// ---------------------------------------------------------------------------- 221}; // namespace android 222 223#endif // ANDROID_AUDIO_MIXER_H 224