AudioMixer.h revision 17a736c3e1d062d7fc916329eb32aef8935614af
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 74 // Allocate a track name. Returns new track name if successful, -1 on failure. 75 int getTrackName(); 76 77 // Free an allocated track by name 78 void deleteTrackName(int name); 79 80 // Enable or disable an allocated track by name 81 void enable(int name); 82 void disable(int name); 83 84 void setParameter(int name, int target, int param, void *value); 85 86 void setBufferProvider(int name, AudioBufferProvider* bufferProvider); 87 void process(int64_t pts); 88 89 uint32_t trackNames() const { return mTrackNames; } 90 91 size_t getUnreleasedFrames(int name) const; 92 93private: 94 95 enum { 96 NEEDS_CHANNEL_COUNT__MASK = 0x00000003, 97 NEEDS_FORMAT__MASK = 0x000000F0, 98 NEEDS_MUTE__MASK = 0x00000100, 99 NEEDS_RESAMPLE__MASK = 0x00001000, 100 NEEDS_AUX__MASK = 0x00010000, 101 }; 102 103 enum { 104 NEEDS_CHANNEL_1 = 0x00000000, 105 NEEDS_CHANNEL_2 = 0x00000001, 106 107 NEEDS_FORMAT_16 = 0x00000010, 108 109 NEEDS_MUTE_DISABLED = 0x00000000, 110 NEEDS_MUTE_ENABLED = 0x00000100, 111 112 NEEDS_RESAMPLE_DISABLED = 0x00000000, 113 NEEDS_RESAMPLE_ENABLED = 0x00001000, 114 115 NEEDS_AUX_DISABLED = 0x00000000, 116 NEEDS_AUX_ENABLED = 0x00010000, 117 }; 118 119 struct state_t; 120 struct track_t; 121 122 typedef void (*hook_t)(track_t* t, int32_t* output, size_t numOutFrames, int32_t* temp, int32_t* aux); 123 static const int BLOCKSIZE = 16; // 4 cache lines 124 125 struct track_t { 126 uint32_t needs; 127 128 union { 129 int16_t volume[MAX_NUM_CHANNELS]; // [0]3.12 fixed point 130 int32_t volumeRL; 131 }; 132 133 int32_t prevVolume[MAX_NUM_CHANNELS]; 134 135 // 16-byte boundary 136 137 int32_t volumeInc[MAX_NUM_CHANNELS]; 138 int32_t auxInc; 139 int32_t prevAuxLevel; 140 141 // 16-byte boundary 142 143 int16_t auxLevel; // 0 <= auxLevel <= MAX_GAIN_INT, but signed for mul performance 144 uint16_t frameCount; 145 146 uint8_t channelCount; // 1 or 2, redundant with (needs & NEEDS_CHANNEL_COUNT__MASK) 147 uint8_t format; // always 16 148 uint16_t enabled; // actually bool 149 uint32_t channelMask; // currently under-used 150 151 AudioBufferProvider* bufferProvider; 152 153 // 16-byte boundary 154 155 mutable AudioBufferProvider::Buffer buffer; // 8 bytes 156 157 hook_t hook; 158 const void* in; // current location in buffer 159 160 // 16-byte boundary 161 162 AudioResampler* resampler; 163 uint32_t sampleRate; 164 int32_t* mainBuffer; 165 int32_t* auxBuffer; 166 167 // 16-byte boundary 168 169 uint64_t localTimeFreq; 170 171 int64_t padding; 172 173 // 16-byte boundary 174 175 bool setResampler(uint32_t sampleRate, uint32_t devSampleRate); 176 bool doesResample() const { return resampler != NULL; } 177 void resetResampler() { if (resampler != NULL) resampler->reset(); } 178 void adjustVolumeRamp(bool aux); 179 size_t getUnreleasedFrames() const { return resampler != NULL ? 180 resampler->getUnreleasedFrames() : 0; }; 181 }; 182 183 // pad to 32-bytes to fill cache line 184 struct state_t { 185 uint32_t enabledTracks; 186 uint32_t needsChanged; 187 size_t frameCount; 188 void (*hook)(state_t* state, int64_t pts); // one of process__*, never NULL 189 int32_t *outputTemp; 190 int32_t *resampleTemp; 191 int32_t reserved[2]; 192 track_t tracks[MAX_NUM_TRACKS]; __attribute__((aligned(32))); 193 }; 194 195 // bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc. 196 uint32_t mTrackNames; 197 const uint32_t mSampleRate; 198 199 state_t mState __attribute__((aligned(32))); 200 201 void invalidateState(uint32_t mask); 202 203 static void track__genericResample(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 204 static void track__nop(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 205 static void track__16BitsStereo(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 206 static void track__16BitsMono(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux); 207 static void volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux); 208 static void volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux); 209 210 static void process__validate(state_t* state, int64_t pts); 211 static void process__nop(state_t* state, int64_t pts); 212 static void process__genericNoResampling(state_t* state, int64_t pts); 213 static void process__genericResampling(state_t* state, int64_t pts); 214 static void process__OneTrack16BitsStereoNoResampling(state_t* state, 215 int64_t pts); 216#if 0 217 static void process__TwoTracks16BitsStereoNoResampling(state_t* state, 218 int64_t pts); 219#endif 220 221 static int64_t calculateOutputPTS(const track_t& t, int64_t basePTS, 222 int outputFrameIndex); 223}; 224 225// ---------------------------------------------------------------------------- 226}; // namespace android 227 228#endif // ANDROID_AUDIO_MIXER_H 229