1 /* 2 ** Copyright 2008-2010, The Android Open-Source Project 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 #ifndef ANDROID_AUDIO_HARDWARE_H 18 #define ANDROID_AUDIO_HARDWARE_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include <utils/threads.h> 24 #include <utils/SortedVector.h> 25 26 #include <hardware_legacy/AudioHardwareBase.h> 27 #include "AudioPostProcessor.h" 28 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 29 extern "C" { 30 #include "rate_conv.h" 31 } 32 #endif 33 34 namespace android_audio_legacy { 35 using android::AutoMutex; 36 using android::Mutex; 37 using android::SortedVector; 38 39 #include <linux/cpcap_audio.h> 40 #include <linux/tegra_audio.h> 41 42 #define AUDIO_HW_OUT_SAMPLERATE 44100 43 #define AUDIO_HW_NUM_OUT_BUF 2 44 #define AUDIO_HW_OUT_LATENCY_MS 0 45 46 // FIXME: this is a workaround for issue 3387419 with impact on latency 47 // to be removed when root cause is fixed 48 #define AUDIO_HW_NUM_OUT_BUF_LONG 4 49 50 #define AUDIO_HW_IN_SAMPLERATE 11025 // Default audio input sample rate 51 #define AUDIO_HW_IN_CHANNELS (AudioSystem::CHANNEL_IN_MONO) // Default audio input channel mask 52 #define AUDIO_HW_IN_BUFFERSIZE (4096) // Default audio input buffer size 53 #define AUDIO_HW_IN_FORMAT (AudioSystem::PCM_16_BIT) // Default audio input sample format 54 55 enum { 56 AUDIO_HW_GAIN_SPKR_GAIN = 0, 57 AUDIO_HW_GAIN_MIC_GAIN, 58 AUDIO_HW_GAIN_NUM_DIRECTIONS 59 }; 60 enum { 61 AUDIO_HW_GAIN_USECASE_VOICE= 0, 62 AUDIO_HW_GAIN_USECASE_MM, 63 AUDIO_HW_GAIN_USECASE_VOICE_REC, 64 AUDIO_HW_GAIN_NUM_USECASES 65 }; 66 enum { 67 AUDIO_HW_GAIN_EARPIECE = 0, 68 AUDIO_HW_GAIN_SPEAKERPHONE, 69 AUDIO_HW_GAIN_HEADSET_W_MIC, 70 AUDIO_HW_GAIN_MONO_HEADSET, 71 AUDIO_HW_GAIN_HEADSET_NO_MIC, 72 AUDIO_HW_GAIN_EMU_DEVICE, 73 AUDIO_HW_GAIN_RSVD1, 74 AUDIO_HW_GAIN_RSVD2, 75 AUDIO_HW_GAIN_RSVD3, 76 AUDIO_HW_GAIN_RSVD4, 77 AUDIO_HW_GAIN_RSVD5, 78 AUDIO_HW_GAIN_NUM_PATHS 79 }; 80 81 enum input_state { 82 AUDIO_STREAM_IDLE, 83 AUDIO_STREAM_CONFIG_REQ, 84 AUDIO_STREAM_NEW_RATE_REQ, 85 AUDIO_STREAM_CONFIGURED 86 }; 87 88 class AudioHardware : public AudioHardwareBase 89 { 90 class AudioStreamOutTegra; 91 class AudioStreamInTegra; 92 class AudioStreamSrc; 93 94 public: 95 // AudioHardwareInterface 96 AudioHardware(); 97 virtual ~AudioHardware(); 98 virtual status_t initCheck(); 99 100 virtual status_t setVoiceVolume(float volume); 101 virtual status_t setMasterVolume(float volume); 102 103 virtual status_t setMode(int mode); 104 105 // mic mute 106 virtual status_t setMicMute(bool state); 107 virtual status_t getMicMute(bool* state); 108 109 virtual status_t setParameters(const String8& keyValuePairs); 110 virtual String8 getParameters(const String8& keys); 111 112 // create I/O streams 113 virtual AudioStreamOut* openOutputStream( 114 uint32_t devices, 115 int *format=0, 116 uint32_t *channels=0, 117 uint32_t *sampleRate=0, 118 status_t *status=0); 119 120 virtual AudioStreamIn* openInputStream( 121 122 uint32_t devices, 123 int *format, 124 uint32_t *channels, 125 uint32_t *sampleRate, 126 status_t *status, 127 AudioSystem::audio_in_acoustics acoustics); 128 129 virtual void closeOutputStream(AudioStreamOut* out); 130 virtual void closeInputStream(AudioStreamIn* in); 131 132 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount); 133 // AudioHardwareBase provides default implementation 134 //virtual status_t dumpState(int fd, const Vector<String16>& args); 135 136 // added by AudioHardware 137 status_t init(); 138 139 // voice processing IDs for mEcnsRequested and mEcnsEnabled 140 enum { 141 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 142 PREPROC_AEC = AudioPostProcessor::AEC, // AEC is enabled 143 PREPROC_NS = AudioPostProcessor::NS, // NS is enabled 144 #else 145 PREPROC_AEC = 0x1, // AEC is enabled 146 PREPROC_NS = 0x2, // NS is enabled 147 #endif 148 }; 149 150 void setEcnsRequested_l(int ecns, bool enabled); isEcRequested()151 bool isEcRequested() { return !!(mEcnsRequested & PREPROC_AEC); } 152 protected: 153 // AudioHardwareBase provides default implementation 154 //virtual bool isModeInCall(int mode); 155 //virtual bool isInCall(); 156 157 // AudioHardwareInterface 158 virtual status_t dump(int fd, const Vector<String16>& args); 159 160 // added by AudioHardware 161 int getActiveInputRate(); 162 163 164 private: 165 166 status_t dumpInternals(int fd, const Vector<String16>& args); 167 uint32_t getInputSampleRate(uint32_t sampleRate); 168 status_t doStandby(int stop_fd, bool output, bool enable); 169 status_t doRouting_l(); 170 status_t doRouting(); 171 status_t setVolume_l(float v, int usecase); 172 uint8_t getGain(int direction, int usecase); 173 void readHwGainFile(); 174 175 AudioStreamInTegra* getActiveInput_l(); 176 status_t setMicMute_l(bool state); 177 178 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 179 class AudioStreamSrc { 180 public: 181 AudioStreamSrc(); 182 ~AudioStreamSrc(); inRate()183 inline int inRate() {return mSrcInRate;}; outRate()184 inline int outRate() {return mSrcOutRate;}; initted()185 inline bool initted() {return mSrcInitted;}; 186 void init(int inRate, int outRate); deinit()187 inline void deinit() {mSrcInitted = false;}; 188 SRC_IO_T mIoData; srcConvert()189 inline void srcConvert() { rate_convert(&mIoData, &mSrcObj, 0x0800); }; 190 private: 191 SRC_OBJ_T mSrcObj; 192 char * mSrcBuffer; 193 SRC_INIT_T mSrcInit; 194 int mSrcInRate; 195 int mSrcOutRate; 196 bool mSrcInitted; 197 }; 198 #endif 199 200 class AudioStreamOutTegra : public AudioStreamOut { 201 public: 202 AudioStreamOutTegra(); 203 virtual ~AudioStreamOutTegra(); 204 status_t init(); 205 status_t initCheck(); 206 void setDriver_l(bool speaker, bool bluetooth, bool spdif, int sampleRate); 207 status_t set(AudioHardware* mHardware, 208 uint32_t devices, 209 int *pFormat, 210 uint32_t *pChannels, 211 uint32_t *pRate); sampleRate()212 virtual uint32_t sampleRate() const { return AUDIO_HW_OUT_SAMPLERATE; } 213 // must be 32-bit aligned - driver only seems to like 4800 bufferSize()214 virtual size_t bufferSize() const { return 4096; } channels()215 virtual uint32_t channels() const { return AudioSystem::CHANNEL_OUT_STEREO; } format()216 virtual int format() const { return AudioSystem::PCM_16_BIT; } latency()217 virtual uint32_t latency() const { return (1000*AUDIO_HW_NUM_OUT_BUF_LONG*(bufferSize()/frameSize()))/sampleRate()+AUDIO_HW_OUT_LATENCY_MS; } setVolume(float left,float right)218 virtual status_t setVolume(float left, float right) { return INVALID_OPERATION; } 219 virtual ssize_t write(const void* buffer, size_t bytes); 220 void flush(); 221 void flush_l(); 222 virtual status_t standby(); 223 status_t online_l(); 224 virtual status_t dump(int fd, const Vector<String16>& args); 225 bool getStandby(); 226 virtual status_t setParameters(const String8& keyValuePairs); 227 virtual String8 getParameters(const String8& keys); devices()228 uint32_t devices() { return mDevices; } 229 virtual status_t getRenderPosition(uint32_t *dspFrames); lock()230 void lock() { mSleepReq = true; mLock.lock(); mSleepReq = false; } unlock()231 void unlock() { mLock.unlock(); } isLocked()232 bool isLocked() { return mLocked; } 233 void setNumBufs(int numBufs); lockFd()234 void lockFd() { mFdLock.lock(); } unlockFd()235 void unlockFd() { mFdLock.unlock(); } 236 237 int mBtFdIoCtl; 238 239 private: 240 AudioHardware* mHardware; 241 Mutex mLock; 242 int mFd; 243 int mFdCtl; 244 int mBtFd; 245 int mBtFdCtl; 246 int mSpdifFd; 247 int mSpdifFdCtl; 248 int mStartCount; 249 int mRetryCount; 250 uint32_t mDevices; 251 Mutex mFdLock; 252 bool mIsSpkrEnabled; 253 bool mIsBtEnabled; 254 bool mIsSpdifEnabled; 255 bool mIsSpkrEnabledReq; 256 bool mIsBtEnabledReq; 257 bool mIsSpdifEnabledReq; 258 int16_t mSpareSample; 259 bool mHaveSpareSample; 260 int mState; 261 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 262 AudioStreamSrc mSrc; 263 #endif 264 bool mLocked; // setDriver() doesn't have to lock if true 265 int mDriverRate; 266 bool mInit; 267 bool mSleepReq; 268 }; 269 270 class AudioStreamInTegra : public AudioStreamIn { 271 public: 272 AudioStreamInTegra(); 273 virtual ~AudioStreamInTegra(); 274 status_t set(AudioHardware* mHardware, 275 uint32_t devices, 276 int *pFormat, 277 uint32_t *pChannels, 278 uint32_t *pRate, 279 AudioSystem::audio_in_acoustics acoustics); bufferSize()280 virtual size_t bufferSize() const { return mBufferSize; } channels()281 virtual uint32_t channels() const { return mChannels; } format()282 virtual int format() const { return mFormat; } sampleRate()283 virtual uint32_t sampleRate() const { return mSampleRate; } setGain(float gain)284 virtual status_t setGain(float gain) { return INVALID_OPERATION; } 285 virtual ssize_t read(void* buffer, ssize_t bytes); 286 virtual status_t dump(int fd, const Vector<String16>& args); 287 virtual status_t standby(); 288 virtual status_t online_l(); 289 bool getStandby() const; 290 virtual status_t setParameters(const String8& keyValuePairs); 291 virtual String8 getParameters(const String8& keys); 292 virtual unsigned int getInputFramesLost() const; 293 virtual status_t addAudioEffect(effect_handle_t effect); 294 virtual status_t removeAudioEffect(effect_handle_t effect); 295 devices()296 uint32_t devices() { return mDevices; } 297 void setDriver_l(bool mic, bool bluetooth, int sampleRate); source()298 int source() const { return mSource; } lock()299 void lock() { mSleepReq = true; mLock.lock(); mSleepReq = false; } unlock()300 void unlock() { mLock.unlock(); } isLocked()301 bool isLocked() { return mLocked; } 302 void stop_l(); lockFd()303 void lockFd() { mFdLock.lock(); } unlockFd()304 void unlockFd() { mFdLock.unlock(); } 305 306 private: 307 void reopenReconfigDriver(); 308 void updateEcnsRequested(effect_handle_t effect, bool enabled); 309 310 AudioHardware* mHardware; 311 Mutex mLock; 312 int mFd; 313 int mFdCtl; 314 int mState; 315 int mRetryCount; 316 int mFormat; 317 uint32_t mChannels; 318 uint32_t mSampleRate; 319 size_t mBufferSize; 320 AudioSystem::audio_in_acoustics mAcoustics; 321 uint32_t mDevices; 322 bool mIsMicEnabled; 323 bool mIsBtEnabled; 324 int mSource; 325 // 20 millisecond scratch buffer 326 int16_t mInScratch[48000/50]; 327 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 328 AudioStreamSrc mSrc; 329 #endif 330 bool mLocked; // setDriver() doesn't have to lock if true 331 mutable uint32_t mTotalBuffersRead; 332 mutable nsecs_t mStartTimeNs; 333 int mDriverRate; 334 mutable Mutex mFramesLock; 335 Mutex mFdLock; 336 bool mSleepReq; 337 int mEcnsRequested; // bit field indicating if AEC and/or NS are requested 338 }; 339 340 static const uint32_t inputSamplingRates[]; 341 bool mInit; 342 bool mMicMute; 343 bool mBluetoothNrec; 344 uint32_t mBluetoothId; 345 AudioStreamOutTegra* mOutput; 346 SortedVector <AudioStreamInTegra*> mInputs; 347 348 struct cpcap_audio_stream mCurOutDevice; 349 struct cpcap_audio_stream mCurInDevice; 350 351 friend class AudioStreamInTegra; 352 Mutex mLock; 353 354 int mCpcapCtlFd; 355 int mHwOutRate; 356 int mHwInRate; 357 float mMasterVol; 358 float mVoiceVol; 359 uint8_t mCpcapGain[AUDIO_HW_GAIN_NUM_DIRECTIONS] 360 [AUDIO_HW_GAIN_NUM_USECASES] 361 [AUDIO_HW_GAIN_NUM_PATHS]; 362 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS 363 AudioPostProcessor mAudioPP; 364 #endif 365 int mSpkrVolume; 366 int mMicVolume; 367 368 int mEcnsEnabled; // bit field indicating if AEC and/or NS are enabled 369 int mEcnsRequested; // bit field indicating if AEC and/or NS are requested 370 bool mBtScoOn; 371 }; 372 373 // ---------------------------------------------------------------------------- 374 375 }; // namespace android 376 377 #endif // ANDROID_AUDIO_HARDWARE_H 378