/* ** Copyright 2008, The Android Open-Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #ifndef ANDROID_AUDIO_HARDWARE_H #define ANDROID_AUDIO_HARDWARE_H #include #include #include #include #include #include #include "secril-client.h" #include #include extern "C" { struct pcm; struct mixer; struct mixer_ctl; }; namespace android_audio_legacy { using android::AutoMutex; using android::Mutex; using android::RefBase; using android::SortedVector; using android::sp; using android::String16; using android::Vector; // TODO: determine actual audio DSP and hardware latency // Additional latency introduced by audio DSP and hardware in ms #define AUDIO_HW_OUT_LATENCY_MS 0 // Default audio output sample rate #define AUDIO_HW_OUT_SAMPLERATE 44100 // Default audio output channel mask #define AUDIO_HW_OUT_CHANNELS (AudioSystem::CHANNEL_OUT_STEREO) // Default audio output sample format #define AUDIO_HW_OUT_FORMAT (AudioSystem::PCM_16_BIT) // Kernel pcm out buffer size in frames at 44.1kHz #define AUDIO_HW_OUT_PERIOD_SZ 880 #define AUDIO_HW_OUT_PERIOD_CNT 2 // Default audio output buffer size in bytes #define AUDIO_HW_OUT_PERIOD_BYTES (AUDIO_HW_OUT_PERIOD_SZ * 2 * sizeof(int16_t)) // Default audio input sample rate #define AUDIO_HW_IN_SAMPLERATE 44100 // Default audio input channel mask #define AUDIO_HW_IN_CHANNELS (AudioSystem::CHANNEL_IN_MONO) // Default audio input sample format #define AUDIO_HW_IN_FORMAT (AudioSystem::PCM_16_BIT) // Kernel pcm in buffer size in frames at 44.1kHz (before resampling) #define AUDIO_HW_IN_PERIOD_SZ 1024 #define AUDIO_HW_IN_PERIOD_CNT 4 // Default audio input buffer size in bytes (8kHz mono) #define AUDIO_HW_IN_PERIOD_BYTES ((AUDIO_HW_IN_PERIOD_SZ*sizeof(int16_t))/8) class AudioHardware : public AudioHardwareBase { class AudioStreamOutALSA; class AudioStreamInALSA; public: // input path names used to translate from input sources to driver paths static const char *inputPathNameDefault; static const char *inputPathNameCamcorder; static const char *inputPathNameVoiceRecognition; static const char *inputPathNameVoiceCommunication; AudioHardware(); virtual ~AudioHardware(); virtual status_t initCheck(); virtual status_t setVoiceVolume(float volume); virtual status_t setMasterVolume(float volume); #ifdef HAVE_FM_RADIO virtual status_t setFmVolume(float volume); #endif virtual status_t setMode(int mode); virtual status_t setMicMute(bool state); virtual status_t getMicMute(bool* state); virtual status_t setParameters(const String8& keyValuePairs); virtual String8 getParameters(const String8& keys); virtual AudioStreamOut* openOutputStream( uint32_t devices, int *format=0, uint32_t *channels=0, uint32_t *sampleRate=0, status_t *status=0); virtual AudioStreamIn* openInputStream( uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status, AudioSystem::audio_in_acoustics acoustics); virtual void closeOutputStream(AudioStreamOut* out); virtual void closeInputStream(AudioStreamIn* in); virtual size_t getInputBufferSize( uint32_t sampleRate, int format, int channelCount); int mode() { return mMode; } const char *getOutputRouteFromDevice(uint32_t device); const char *getInputRouteFromDevice(uint32_t device); const char *getVoiceRouteFromDevice(uint32_t device); status_t setIncallPath_l(uint32_t device); #ifdef HAVE_FM_RADIO void enableFMRadio(); void disableFMRadio(); status_t setFMRadioPath_l(uint32_t device); #endif status_t setInputSource_l(audio_source source); void setVoiceVolume_l(float volume); static uint32_t getInputSampleRate(uint32_t sampleRate); sp getActiveInput_l(); Mutex& lock() { return mLock; } struct pcm *openPcmOut_l(); void closePcmOut_l(); struct mixer *openMixer_l(); void closeMixer_l(); sp output() { return mOutput; } struct echo_reference_itfe *getEchoReference(audio_format_t format, uint32_t channelCount, uint32_t samplingRate); void releaseEchoReference(struct echo_reference_itfe *reference); protected: virtual status_t dump(int fd, const Vector& args); private: enum tty_modes { TTY_MODE_OFF, TTY_MODE_VCO, TTY_MODE_HCO, TTY_MODE_FULL }; bool mInit; bool mMicMute; sp mOutput; SortedVector < sp > mInputs; Mutex mLock; struct pcm* mPcm; struct mixer* mMixer; uint32_t mPcmOpenCnt; uint32_t mMixerOpenCnt; bool mInCallAudioMode; float mVoiceVol; audio_source mInputSource; bool mBluetoothNrec; int mTTYMode; void* mSecRilLibHandle; HRilClient mRilClient; bool mActivatedCP; HRilClient (*openClientRILD) (void); int (*disconnectRILD) (HRilClient); int (*closeClientRILD) (HRilClient); int (*isConnectedRILD) (HRilClient); int (*connectRILD) (HRilClient); #ifdef USES_FROYO_RILCLIENT int (*invokeOemRequestHookRaw) (HRilClient, char *, size_t); int (convertSoundType) (SoundType); int (convertAudioPath) (AudioPath); int (setCallVolume) (HRilClient, SoundType, int); int (setCallAudioPath) (HRilClient, AudioPath); int (setCallClockSync) (HRilClient, SoundClockCondition); #else int (*setCallVolume) (HRilClient, SoundType, int); int (*setCallAudioPath)(HRilClient, AudioPath); int (*setCallClockSync)(HRilClient, SoundClockCondition); #endif void loadRILD(void); status_t connectRILDIfRequired(void); struct echo_reference_itfe *mEchoReference; #ifdef HAVE_FM_RADIO int mFmFd; float mFmVolume; bool mFmResumeAfterCall; #endif // trace driver operations for dump int mDriverOp; static uint32_t checkInputSampleRate(uint32_t sampleRate); // column index in inputConfigTable[][] enum { INPUT_CONFIG_SAMPLE_RATE, INPUT_CONFIG_BUFFER_RATIO, INPUT_CONFIG_CNT }; // contains the list of valid sampling rates for input streams as well as the ratio // between the kernel buffer size and audio hal buffer size for each sampling rate static const uint32_t inputConfigTable[][INPUT_CONFIG_CNT]; class AudioStreamOutALSA : public AudioStreamOut, public RefBase { public: AudioStreamOutALSA(); virtual ~AudioStreamOutALSA(); status_t set(AudioHardware* mHardware, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate); virtual uint32_t sampleRate() const { return mSampleRate; } virtual size_t bufferSize() const { return mBufferSize; } virtual uint32_t channels() const { return mChannels; } virtual int format() const { return AUDIO_HW_OUT_FORMAT; } virtual uint32_t latency() const { return (1000 * AUDIO_HW_OUT_PERIOD_CNT * (bufferSize()/frameSize()))/sampleRate() + AUDIO_HW_OUT_LATENCY_MS; } virtual status_t setVolume(float left, float right) { return INVALID_OPERATION; } virtual ssize_t write(const void* buffer, size_t bytes); virtual status_t standby(); bool checkStandby(); virtual status_t dump(int fd, const Vector& args); virtual status_t setParameters(const String8& keyValuePairs); virtual String8 getParameters(const String8& keys); uint32_t device() { return mDevices; } virtual status_t getRenderPosition(uint32_t *dspFrames); void doStandby_l(); void close_l(); status_t open_l(); int standbyCnt() { return mStandbyCnt; } int prepareLock(); void lock(); void unlock(); void addEchoReference(struct echo_reference_itfe *reference); void removeEchoReference(struct echo_reference_itfe *reference); private: int computeEchoReferenceDelay(size_t frames, struct timespec *echoRefRenderTime); int getPlaybackDelay(size_t frames, struct echo_reference_buffer *buffer); Mutex mLock; AudioHardware* mHardware; struct pcm *mPcm; struct mixer *mMixer; struct mixer_ctl *mRouteCtl; const char *next_route; bool mStandby; uint32_t mDevices; uint32_t mChannels; uint32_t mSampleRate; size_t mBufferSize; // trace driver operations for dump int mDriverOp; int mStandbyCnt; bool mSleepReq; struct echo_reference_itfe *mEchoReference; }; class AudioStreamInALSA : public AudioStreamIn, public RefBase { public: AudioStreamInALSA(); virtual ~AudioStreamInALSA(); status_t set(AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate, AudioSystem::audio_in_acoustics acoustics); virtual size_t bufferSize() const { return mBufferSize; } virtual uint32_t channels() const { return mChannels; } virtual int format() const { return AUDIO_HW_IN_FORMAT; } virtual uint32_t sampleRate() const { return mSampleRate; } virtual status_t setGain(float gain) { return INVALID_OPERATION; } virtual ssize_t read(void* buffer, ssize_t bytes); virtual status_t dump(int fd, const Vector& args); virtual status_t standby(); bool checkStandby(); virtual status_t setParameters(const String8& keyValuePairs); virtual String8 getParameters(const String8& keys); virtual unsigned int getInputFramesLost() const { return 0; } virtual status_t addAudioEffect(effect_handle_t effect); virtual status_t removeAudioEffect(effect_handle_t effect); uint32_t device() { return mDevices; } void doStandby_l(); void close_l(); status_t open_l(); int standbyCnt() { return mStandbyCnt; } static size_t getBufferSize(uint32_t sampleRate, int channelCount); // resampler_buffer_provider static int getNextBufferStatic(struct resampler_buffer_provider *provider, struct resampler_buffer* buffer); static void releaseBufferStatic(struct resampler_buffer_provider *provider, struct resampler_buffer* buffer); int prepareLock(); void lock(); void unlock(); private: struct ResamplerBufferProvider { struct resampler_buffer_provider mProvider; AudioStreamInALSA *mInputStream; }; ssize_t readFrames(void* buffer, ssize_t frames); ssize_t processFrames(void* buffer, ssize_t frames); int32_t updateEchoReference(size_t frames); void pushEchoReference(size_t frames); void updateEchoDelay(size_t frames, struct timespec *echoRefRenderTime); void getCaptureDelay(size_t frames, struct echo_reference_buffer *buffer); status_t setPreProcessorEchoDelay(effect_handle_t handle, int32_t delayUs); status_t setPreprocessorParam(effect_handle_t handle, effect_param_t *param); // BufferProvider status_t getNextBuffer(struct resampler_buffer* buffer); void releaseBuffer(struct resampler_buffer* buffer); Mutex mLock; AudioHardware* mHardware; struct pcm *mPcm; struct mixer *mMixer; struct mixer_ctl *mRouteCtl; const char *next_route; bool mStandby; uint32_t mDevices; uint32_t mChannels; uint32_t mChannelCount; uint32_t mSampleRate; size_t mBufferSize; struct resampler_itfe *mDownSampler; struct ResamplerBufferProvider mBufferProvider; status_t mReadStatus; size_t mInputFramesIn; int16_t *mInputBuf; // trace driver operations for dump int mDriverOp; int mStandbyCnt; bool mSleepReq; SortedVector mPreprocessors; int16_t *mProcBuf; size_t mProcBufSize; size_t mProcFramesIn; int16_t *mRefBuf; size_t mRefBufSize; size_t mRefFramesIn; struct echo_reference_itfe *mEchoReference; bool mNeedEchoReference; }; }; }; // namespace android #endif