Gitiles
Code Review Sign In
review.evervolv.com / android_device_moto_wingray / 2896e59ac088f73318bc010fce3a4a31f0c3ff45 / . / libaudio / AudioHardware.h
blob: 68828325e19ff687ec734bb6adaffba79d84fb65 [file] [log] [blame]
Ying Wang2896e592011-02-18 12:00:38 -0800[diff] [blame^]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 <media/mediarecorder.h>
28#include "AudioPostProcessor.h"
29#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
30extern "C" {
31#include "rate_conv.h"
32}
33#endif
34
35namespace android {
36
37#include <linux/cpcap_audio.h>
38#include <linux/tegra_audio.h>
39
40#define AUDIO_HW_OUT_SAMPLERATE 44100
41#define AUDIO_HW_NUM_OUT_BUF 2
42#define AUDIO_HW_OUT_LATENCY_MS 0
43
44// FIXME: this is a workaround for issue 3387419 with impact on latency
45// to be removed when root cause is fixed
46#define AUDIO_HW_NUM_OUT_BUF_LONG 4
47
48#define AUDIO_HW_IN_SAMPLERATE 11025 // Default audio input sample rate
49#define AUDIO_HW_IN_CHANNELS (AudioSystem::CHANNEL_IN_MONO) // Default audio input channel mask
50#define AUDIO_HW_IN_BUFFERSIZE (4096) // Default audio input buffer size
51#define AUDIO_HW_IN_FORMAT (AudioSystem::PCM_16_BIT) // Default audio input sample format
52
53enum {
54 AUDIO_HW_GAIN_SPKR_GAIN = 0,
55 AUDIO_HW_GAIN_MIC_GAIN,
56 AUDIO_HW_GAIN_NUM_DIRECTIONS
57};
58enum {
59 AUDIO_HW_GAIN_USECASE_VOICE= 0,
60 AUDIO_HW_GAIN_USECASE_MM,
61 AUDIO_HW_GAIN_USECASE_VOICE_REC,
62 AUDIO_HW_GAIN_NUM_USECASES
63};
64enum {
65 AUDIO_HW_GAIN_EARPIECE = 0,
66 AUDIO_HW_GAIN_SPEAKERPHONE,
67 AUDIO_HW_GAIN_HEADSET_W_MIC,
68 AUDIO_HW_GAIN_MONO_HEADSET,
69 AUDIO_HW_GAIN_HEADSET_NO_MIC,
70 AUDIO_HW_GAIN_EMU_DEVICE,
71 AUDIO_HW_GAIN_RSVD1,
72 AUDIO_HW_GAIN_RSVD2,
73 AUDIO_HW_GAIN_RSVD3,
74 AUDIO_HW_GAIN_RSVD4,
75 AUDIO_HW_GAIN_RSVD5,
76 AUDIO_HW_GAIN_NUM_PATHS
77};
78
79enum input_state {
80 AUDIO_STREAM_IDLE,
81 AUDIO_STREAM_CONFIG_REQ,
82 AUDIO_STREAM_NEW_RATE_REQ,
83 AUDIO_STREAM_CONFIGURED
84};
85
86class AudioHardware : public AudioHardwareBase
87{
88 class AudioStreamOutTegra;
89 class AudioStreamInTegra;
90 class AudioStreamSrc;
91
92public:
93 // AudioHardwareInterface
94 AudioHardware();
95 virtual ~AudioHardware();
96 virtual status_t initCheck();
97
98 virtual status_t setVoiceVolume(float volume);
99 virtual status_t setMasterVolume(float volume);
100
101 virtual status_t setMode(int mode);
102
103 // mic mute
104 virtual status_t setMicMute(bool state);
105 virtual status_t getMicMute(bool* state);
106
107 virtual status_t setParameters(const String8& keyValuePairs);
108 virtual String8 getParameters(const String8& keys);
109
110 // create I/O streams
111 virtual AudioStreamOut* openOutputStream(
112 uint32_t devices,
113 int *format=0,
114 uint32_t *channels=0,
115 uint32_t *sampleRate=0,
116 status_t *status=0);
117
118 virtual AudioStreamIn* openInputStream(
119
120 uint32_t devices,
121 int *format,
122 uint32_t *channels,
123 uint32_t *sampleRate,
124 status_t *status,
125 AudioSystem::audio_in_acoustics acoustics);
126
127 virtual void closeOutputStream(AudioStreamOut* out);
128 virtual void closeInputStream(AudioStreamIn* in);
129
130 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
131 // AudioHardwareBase provides default implementation
132 //virtual status_t dumpState(int fd, const Vector<String16>& args);
133
134 // added by AudioHardware
135 status_t init();
136
137protected:
138 // AudioHardwareBase provides default implementation
139 //virtual bool isModeInCall(int mode);
140 //virtual bool isInCall();
141
142 // AudioHardwareInterface
143 virtual status_t dump(int fd, const Vector<String16>& args);
144
145 // added by AudioHardware
146 int getActiveInputRate();
147
148private:
149
150 status_t dumpInternals(int fd, const Vector<String16>& args);
151 uint32_t getInputSampleRate(uint32_t sampleRate);
152 status_t doStandby(int stop_fd, bool output, bool enable);
153 status_t doRouting_l();
154 status_t doRouting();
155 status_t setVolume_l(float v, int usecase);
156 uint8_t getGain(int direction, int usecase);
157 void readHwGainFile();
158
159 AudioStreamInTegra* getActiveInput_l();
160 status_t setMicMute_l(bool state);
161
162#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
163 class AudioStreamSrc {
164 public:
165 AudioStreamSrc();
166 ~AudioStreamSrc();
167 inline int inRate() {return mSrcInRate;};
168 inline int outRate() {return mSrcOutRate;};
169 inline bool initted() {return mSrcInitted;};
170 void init(int inRate, int outRate);
171 inline void deinit() {mSrcInitted = false;};
172 SRC_IO_T mIoData;
173 inline void srcConvert() { rate_convert(&mIoData, &mSrcObj, 0x0800); };
174 private:
175 SRC_OBJ_T mSrcObj;
176 char * mSrcBuffer;
177 SRC_INIT_T mSrcInit;
178 int mSrcInRate;
179 int mSrcOutRate;
180 bool mSrcInitted;
181 };
182#endif
183
184 class AudioStreamOutTegra : public AudioStreamOut {
185 public:
186 AudioStreamOutTegra();
187 virtual ~AudioStreamOutTegra();
188 status_t init();
189 status_t initCheck();
190 void setDriver_l(bool speaker, bool bluetooth, bool spdif, int sampleRate);
191 status_t set(AudioHardware* mHardware,
192 uint32_t devices,
193 int *pFormat,
194 uint32_t *pChannels,
195 uint32_t *pRate);
196 virtual uint32_t sampleRate() const { return AUDIO_HW_OUT_SAMPLERATE; }
197 // must be 32-bit aligned - driver only seems to like 4800
198 virtual size_t bufferSize() const { return 4096; }
199 virtual uint32_t channels() const { return AudioSystem::CHANNEL_OUT_STEREO; }
200 virtual int format() const { return AudioSystem::PCM_16_BIT; }
201 virtual uint32_t latency() const { return (1000*AUDIO_HW_NUM_OUT_BUF*(bufferSize()/frameSize()))/sampleRate()+AUDIO_HW_OUT_LATENCY_MS; }
202 virtual status_t setVolume(float left, float right) { return INVALID_OPERATION; }
203 virtual ssize_t write(const void* buffer, size_t bytes);
204 void flush();
205 virtual status_t standby();
206 status_t online_l();
207 virtual status_t dump(int fd, const Vector<String16>& args);
208 bool getStandby();
209 virtual status_t setParameters(const String8& keyValuePairs);
210 virtual String8 getParameters(const String8& keys);
211 uint32_t devices() { return mDevices; }
212 virtual status_t getRenderPosition(uint32_t *dspFrames);
213 void lock() { mLock.lock(); }
214 void unlock() { mLock.unlock(); }
215 bool isLocked() { return mLocked; }
216 void setNumBufs(int numBufs);
217
218 private:
219 AudioHardware* mHardware;
220 Mutex mLock;
221 int mFd;
222 int mFdCtl;
223 int mBtFd;
224 int mBtFdCtl;
225 int mBtFdIoCtl;
226 int mSpdifFd;
227 int mSpdifFdCtl;
228 int mStartCount;
229 int mRetryCount;
230 uint32_t mDevices;
231 Mutex mFdLock;
232 bool mIsSpkrEnabled;
233 bool mIsBtEnabled;
234 bool mIsSpdifEnabled;
235 bool mIsSpkrEnabledReq;
236 bool mIsBtEnabledReq;
237 bool mIsSpdifEnabledReq;
238 int16_t mSpareSample;
239 bool mHaveSpareSample;
240 int mState;
241#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
242 AudioStreamSrc mSrc;
243#endif
244 bool mLocked; // setDriver() doesn't have to lock if true
245 int mDriverRate;
246 bool mInit;
247 };
248
249 class AudioStreamInTegra : public AudioStreamIn {
250 public:
251 AudioStreamInTegra();
252 virtual ~AudioStreamInTegra();
253 status_t set(AudioHardware* mHardware,
254 uint32_t devices,
255 int *pFormat,
256 uint32_t *pChannels,
257 uint32_t *pRate,
258 AudioSystem::audio_in_acoustics acoustics);
259 virtual size_t bufferSize() const { return mBufferSize; }
260 virtual uint32_t channels() const { return mChannels; }
261 virtual int format() const { return mFormat; }
262 virtual uint32_t sampleRate() const { return mSampleRate; }
263 virtual status_t setGain(float gain) { return INVALID_OPERATION; }
264 virtual ssize_t read(void* buffer, ssize_t bytes);
265 virtual status_t dump(int fd, const Vector<String16>& args);
266 virtual status_t standby();
267 virtual status_t online_l();
268 bool getStandby() const;
269 virtual status_t setParameters(const String8& keyValuePairs);
270 virtual String8 getParameters(const String8& keys);
271 virtual unsigned int getInputFramesLost() const;
272 uint32_t devices() { return mDevices; }
273 void setDriver_l(bool mic, bool bluetooth, int sampleRate);
274 int source() const { return mSource; }
275 void lock() { mLock.lock(); }
276 void unlock() { mLock.unlock(); }
277 bool isLocked() { return mLocked; }
278
279 private:
280 void reopenReconfigDriver();
281
282 AudioHardware* mHardware;
283 mutable Mutex mLock;
284 int mFd;
285 int mFdCtl;
286 int mState;
287 int mRetryCount;
288 int mFormat;
289 uint32_t mChannels;
290 uint32_t mSampleRate;
291 size_t mBufferSize;
292 AudioSystem::audio_in_acoustics mAcoustics;
293 uint32_t mDevices;
294 bool mIsMicEnabled;
295 bool mIsBtEnabled;
296 int mSource;
297 // 20 millisecond scratch buffer
298 int16_t mInScratch[48000/50];
299#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
300 AudioStreamSrc mSrc;
301#endif
302 bool mLocked; // setDriver() doesn't have to lock if true
303 mutable uint32_t mTotalBuffersRead;
304 mutable nsecs_t mStartTimeNs;
305 int mDriverRate;
306 };
307
308 static const uint32_t inputSamplingRates[];
309 bool mInit;
310 bool mMicMute;
311 bool mBluetoothNrec;
312 uint32_t mBluetoothId;
313 AudioStreamOutTegra* mOutput;
314 SortedVector <AudioStreamInTegra*> mInputs;
315
316 struct cpcap_audio_stream mCurOutDevice;
317 struct cpcap_audio_stream mCurInDevice;
318
319 friend class AudioStreamInTegra;
320 Mutex mLock;
321
322 int mCpcapCtlFd;
323 int mHwOutRate;
324 int mHwInRate;
325 float mMasterVol;
326 float mVoiceVol;
327 uint8_t mCpcapGain[AUDIO_HW_GAIN_NUM_DIRECTIONS]
328 [AUDIO_HW_GAIN_NUM_USECASES]
329 [AUDIO_HW_GAIN_NUM_PATHS];
330#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
331 AudioPostProcessor mAudioPP;
332#endif
333 int mSpkrVolume;
334 int mMicVolume;
335};
336
337// ----------------------------------------------------------------------------
338
339}; // namespace android
340
341#endif // ANDROID_AUDIO_HARDWARE_H