path: root/libaudio/AudioHardwareALSA.h

/* AudioHardwareALSA.h
 **
 ** Copyright 2008, Wind River Systems
 **
 ** 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_ALSA_H
#define ANDROID_AUDIO_HARDWARE_ALSA_H

#include <stdint.h>
#include <sys/types.h>
#include <alsa/asoundlib.h>

#include <hardware_legacy/AudioHardwareBase.h>

// sangsu fix : headers for IPC
#include "secril-client.h"

#ifndef ALSA_DEFAULT_SAMPLE_RATE
#define ALSA_DEFAULT_SAMPLE_RATE 44100 // in Hz
#endif

#define DEFAULT_SAMPLE_RATE ALSA_DEFAULT_SAMPLE_RATE

#define PLAYBACK    0
#define PERIOD_SZ_PLAYBACK   1024
#define PERIODS_PLAYBACK     4
#define BUFFER_SZ_PLAYBACK   (PERIODS_PLAYBACK * PERIOD_SZ_PLAYBACK)
#define LATENCY_PLAYBACK_MS  ((BUFFER_SZ_PLAYBACK * 1000 / DEFAULT_SAMPLE_RATE) * 1000)

#define CAPTURE     1
#define PERIOD_SZ_CAPTURE   1024
#define PERIODS_CAPTURE     4
#define BUFFER_SZ_CAPTURE   (PERIODS_CAPTURE * PERIOD_SZ_CAPTURE)
#define LATENCY_CAPTURE_MS  ((BUFFER_SZ_CAPTURE * 1000 / DEFAULT_SAMPLE_RATE) * 1000)

//Recognition param
#define RECOGNITION_OFF	0
#define RECOGNITION_ON	1

namespace android
{

    class AudioHardwareALSA;

    // ----------------------------------------------------------------------------

    class ALSAMixer
    {
        public:
                                    ALSAMixer();
            virtual                ~ALSAMixer();

            bool                    isValid() { return !!mMixer[SND_PCM_STREAM_PLAYBACK]; }
            status_t                setMasterVolume(float volume);
            status_t                setMasterGain(float gain);

            status_t                setVolume(uint32_t device, float volume);
            status_t                setGain(uint32_t device, float gain);

            status_t                setCaptureMuteState(uint32_t device, bool state);
            status_t                getCaptureMuteState(uint32_t device, bool *state);
            status_t                setPlaybackMuteState(uint32_t device, bool state);
            status_t                getPlaybackMuteState(uint32_t device, bool *state);

        private:
            snd_mixer_t            *mMixer[SND_PCM_STREAM_LAST+1];
    };

    class ALSAControl
    {
        public:
                                    ALSAControl(const char *device = "default");
            virtual                ~ALSAControl();

            status_t                get(const char *name, unsigned int &value, int index = 0);
            status_t                set(const char *name, unsigned int value, int index = -1);

        private:
            snd_ctl_t              *mHandle;
    };

    class ALSAStreamOps
    {
     public:
                uint32_t            device() { return mDevice; }
                void                close();

        protected:
            friend class AudioStreamOutALSA;
            friend class AudioStreamInALSA;

            struct StreamDefaults
            {
                const char *        devicePrefix;
                snd_pcm_stream_t    direction;       // playback or capture
                snd_pcm_format_t    format;
                int                 channelCount;
                uint32_t            sampleRate;
                uint32_t            bufferRatio;
                unsigned int        latency;         // Delay in usec
                unsigned int        bufferSize;      // Size of sample buffer
                unsigned int        periodSize;      // Size of sample buffer
            };

                                    ALSAStreamOps();
            virtual                ~ALSAStreamOps();

            status_t                set(int *format,
                                        uint32_t *channels,
                                        uint32_t *rate);
            virtual uint32_t        sampleRate() const;
            status_t                sampleRate(uint32_t rate);
            virtual size_t          bufferSize() const;
            virtual int             format() const;
                    int             getAndroidFormat(snd_pcm_format_t format);

            virtual uint32_t        channels() const;
                    int             channelCount() const;
                    status_t        channelCount(int channelCount);
                    uint32_t        getAndroidChannels(int channelCount) const;

            status_t                open(int mode, uint32_t device);
            status_t                setSoftwareParams();
            status_t                setPCMFormat(snd_pcm_format_t format);
            status_t                setHardwareResample(bool resample);

            const char             *streamName();
            status_t                setDevice(int mode, uint32_t device, uint32_t audio_mode);

            const char             *deviceName(int mode, uint32_t device);

            void                    setStreamDefaults(StreamDefaults *dev) {
                mDefaults = dev;
            }

            Mutex                   mLock;

        private:
            snd_pcm_t              *mHandle;
            snd_pcm_hw_params_t    *mHardwareParams;
            snd_pcm_sw_params_t    *mSoftwareParams;
            uint32_t                mDevice;

            StreamDefaults         *mDefaults;
    };

    // ----------------------------------------------------------------------------

    class AudioStreamOutALSA : public AudioStreamOut, public ALSAStreamOps
    {
        public:
                                    AudioStreamOutALSA(AudioHardwareALSA *parent);
            virtual                ~AudioStreamOutALSA();


            status_t                set(int *format,
                                        uint32_t *channelCount,
                                        uint32_t *sampleRate){
                return ALSAStreamOps::set(format, channelCount, sampleRate);
            }

            virtual uint32_t        sampleRate() const {
                return ALSAStreamOps::sampleRate();
            }

            virtual size_t          bufferSize() const
            {
                return ALSAStreamOps::bufferSize();
            }

            virtual uint32_t        channels() const
            {
                return ALSAStreamOps::channels();
            }

            virtual int             format() const
            {
                return ALSAStreamOps::format();
            }

            virtual uint32_t        latency() const;

            virtual ssize_t         write(const void *buffer, size_t bytes);
            virtual status_t        dump(int fd, const Vector<String16>& args);
                    status_t        setDevice(int mode, uint32_t newDevice, uint32_t audio_mode,
                                              bool force = false);
            virtual status_t        setVolume(float left, float right); //Tushar: New arch

            status_t                setVolume(float volume);

            status_t                standby();

            virtual status_t        setParameters(const String8& keyValuePairs);
            virtual String8         getParameters(const String8& keys);

            virtual status_t        getRenderPosition(uint32_t *dspFrames);
                    bool            isActive() { return mPowerLock; }

        private:
            AudioHardwareALSA      *mParent;
            bool                    mPowerLock;
    };

    class ALSADownsampler;

    class ALSABufferProvider
    {
    public:

        struct Buffer {
            union {
                void*       raw;
                short*      i16;
                int8_t*     i8;
            };
            size_t frameCount;
        };

        virtual ~ALSABufferProvider() {}

        virtual status_t getNextBuffer(Buffer* buffer) = 0;
        virtual void releaseBuffer(Buffer* buffer) = 0;
    };

    class AudioStreamInALSA : public AudioStreamIn, public ALSAStreamOps, public ALSABufferProvider
    {
        public:
                                    AudioStreamInALSA(AudioHardwareALSA *parent);
            virtual                ~AudioStreamInALSA();

            status_t                set(int *format,
                                        uint32_t *channelCount,
                                        uint32_t *sampleRate);

            virtual uint32_t        sampleRate() const {
                return ALSAStreamOps::sampleRate();
            }

            virtual size_t          bufferSize() const
            {
                return ALSAStreamOps::bufferSize();
            }

            virtual uint32_t        channels() const
            {
                return ALSAStreamOps::channels();
            }

            virtual int             format() const
            {
                return ALSAStreamOps::format();
            }

            virtual ssize_t         read(void* buffer, ssize_t bytes);
            virtual status_t        dump(int fd, const Vector<String16>& args);
                    status_t        setDevice(int mode, uint32_t newDevice, uint32_t audio_mode,
                                              bool force = false);

            virtual status_t        setGain(float gain);

            virtual status_t        standby();

            virtual status_t        setParameters(const String8& keyValuePairs);
            virtual String8         getParameters(const String8& keys);

            virtual unsigned int    getInputFramesLost() const { return 0; }

                    bool            isActive() { return mPowerLock; }

            // ALSABufferProvider
            virtual status_t getNextBuffer(ALSABufferProvider::Buffer* buffer);
            virtual void releaseBuffer(ALSABufferProvider::Buffer* buffer);

        private:
            AudioHardwareALSA      *mParent;
            bool                    mPowerLock;
            ALSADownsampler *mDownSampler;
            status_t mReadStatus;
            size_t mInPcmInBuf;
            int16_t *mPcmIn;
    };

    class AudioHardwareALSA : public AudioHardwareBase
    {
        public:
                                    AudioHardwareALSA();
            virtual                ~AudioHardwareALSA();

            /**
             * check to see if the audio hardware interface has been initialized.
             * return status based on values defined in include/utils/Errors.h
             */
            virtual status_t        initCheck();

            /** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
            virtual status_t        setVoiceVolume(float volume);

            virtual status_t        setMode(int mode);

            /**
             * set the audio volume for all audio activities other than voice call.
             * Range between 0.0 and 1.0. If any value other than NO_ERROR is returned,
             * the software mixer will emulate this capability.
             */
            virtual status_t        setMasterVolume(float volume);

            // mic mute
            virtual status_t        setMicMute(bool state);
            virtual status_t        getMicMute(bool* state);
            virtual size_t          getInputBufferSize(uint32_t sampleRate,
                                                       int format,
                                                       int channelCount);

            /** This method creates and opens the audio hardware output stream */
            virtual AudioStreamOut* openOutputStream(uint32_t devices,
                                                     int *format = 0,
                                                     uint32_t *channels = 0,
                                                     uint32_t *sampleRate = 0,
                                                     status_t *status = 0);
            virtual void            closeOutputStream(AudioStreamOut* out);

            /** This method creates and opens the audio hardware input stream */
            virtual AudioStreamIn*  openInputStream(uint32_t devices,
                                                   int *format,
                                                   uint32_t *channels,
                                                   uint32_t *sampleRate,
                                                   status_t *status,
                                                   AudioSystem::audio_in_acoustics acoustics);
            virtual void            closeInputStream(AudioStreamIn* in);

            static uint32_t         checkInputSampleRate(uint32_t sampleRate);
            static const uint32_t   inputSamplingRates[];
            static uint32_t         bufferRatio(uint32_t samplingRate);

                   int              mode() { return mMode; }
                   Mutex&           lock() { return mLock; }

                   int              setVoiceRecordGain(bool enable);
                   int              setVoiceRecordGain_l(bool enable);

            virtual status_t        setParameters(const String8& keyValuePairs);

        protected:
            /**
             * doRouting actually initiates the routing. A call to setRouting
             * or setMode may result in a routing change. The generic logic calls
             * doRouting when required. If the device has any special requirements these
             * methods can be overriden.
             */
                    status_t        doRouting(uint32_t device, bool force = false);
                    status_t        doRouting_l(uint32_t device, bool force = false);

            virtual status_t        dump(int fd, const Vector<String16>& args);

            friend class AudioStreamOutALSA;
            friend class AudioStreamInALSA;

            ALSAMixer              *mMixer;
            AudioStreamOutALSA     *mOutput;
            AudioStreamInALSA      *mInput;

        private:
            Mutex                   mLock;
            void                   *mSecRilLibHandle;
            HRilClient              mRilClient;
            bool                    mVrModeEnabled;
            bool                    mActivatedCP;
            bool                    mBluetoothECOff;

            HRilClient (*openClientRILD)  (void);
            int        (*disconnectRILD)  (HRilClient);
            int        (*closeClientRILD) (HRilClient);
            int        (*isConnectedRILD) (HRilClient);
            int        (*connectRILD)     (HRilClient);
            int        (*setCallVolume)   (HRilClient, SoundType, int);
            int        (*setCallAudioPath)(HRilClient, AudioPath);
            int        (*setCallClockSync)(HRilClient, SoundClockCondition);

            void                    loadRILD(void);
            status_t                connectRILDIfRequired(void);
            void                    setBluetoothNrEcOnOff(bool disable);

    };

    class ALSADownsampler {
    public:
        ALSADownsampler(uint32_t outSampleRate,
                  uint32_t channelCount,
                  uint32_t frameCount,
                  ALSABufferProvider* provider);

        virtual ~ALSADownsampler();

                void reset();
                status_t initCheck() { return mStatus; }
                int resample(int16_t* out, size_t *outFrameCount);

    private:
        status_t    mStatus;
        ALSABufferProvider* mProvider;
        uint32_t mSampleRate;
        uint32_t mChannelCount;
        uint32_t mFrameCount;
        int16_t *mInLeft;
        int16_t *mInRight;
        int16_t *mTmpLeft;
        int16_t *mTmpRight;
        int16_t *mTmp2Left;
        int16_t *mTmp2Right;
        int16_t *mOutLeft;
        int16_t *mOutRight;
        int mInInBuf;
        int mInTmpBuf;
        int mInTmp2Buf;
        int mOutBufPos;
        int mInOutBuf;
    };

};        // namespace android
#endif    // ANDROID_AUDIO_HARDWARE_ALSA_H