libaudio/AudioHardware.h

/*
** Copyright 2008-2010, 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 <stdint.h>
#include <sys/types.h>

#include <utils/threads.h>
#include <utils/SortedVector.h>

#include <hardware_legacy/AudioHardwareBase.h>
#include <media/mediarecorder.h>
#include "AudioPostProcessor.h"
#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
extern "C" {
#include "rate_conv.h"
}
#endif

namespace android {

#include <linux/cpcap_audio.h>
#include <linux/tegra_audio.h>

#define AUDIO_HW_OUT_SAMPLERATE 44100
#define AUDIO_HW_NUM_OUT_BUF 2
#define AUDIO_HW_OUT_LATENCY_MS 0

// FIXME: this is a workaround for issue 3387419 with impact on latency
// to be removed when root cause is fixed
#define AUDIO_HW_NUM_OUT_BUF_LONG 4

#define AUDIO_HW_IN_SAMPLERATE 11025                  // Default audio input sample rate
#define AUDIO_HW_IN_CHANNELS (AudioSystem::CHANNEL_IN_MONO) // Default audio input channel mask
#define AUDIO_HW_IN_BUFFERSIZE (4096)               // Default audio input buffer size
#define AUDIO_HW_IN_FORMAT (AudioSystem::PCM_16_BIT)  // Default audio input sample format

enum {
    AUDIO_HW_GAIN_SPKR_GAIN = 0,
    AUDIO_HW_GAIN_MIC_GAIN,
    AUDIO_HW_GAIN_NUM_DIRECTIONS
};
enum {
    AUDIO_HW_GAIN_USECASE_VOICE= 0,
    AUDIO_HW_GAIN_USECASE_MM,
    AUDIO_HW_GAIN_USECASE_VOICE_REC,
    AUDIO_HW_GAIN_NUM_USECASES
};
enum {
    AUDIO_HW_GAIN_EARPIECE = 0,
    AUDIO_HW_GAIN_SPEAKERPHONE,
    AUDIO_HW_GAIN_HEADSET_W_MIC,
    AUDIO_HW_GAIN_MONO_HEADSET,
    AUDIO_HW_GAIN_HEADSET_NO_MIC,
    AUDIO_HW_GAIN_EMU_DEVICE,
    AUDIO_HW_GAIN_RSVD1,
    AUDIO_HW_GAIN_RSVD2,
    AUDIO_HW_GAIN_RSVD3,
    AUDIO_HW_GAIN_RSVD4,
    AUDIO_HW_GAIN_RSVD5,
    AUDIO_HW_GAIN_NUM_PATHS
};

enum input_state {
    AUDIO_STREAM_IDLE,
    AUDIO_STREAM_CONFIG_REQ,
    AUDIO_STREAM_NEW_RATE_REQ,
    AUDIO_STREAM_CONFIGURED
};

class AudioHardware : public  AudioHardwareBase
{
    class AudioStreamOutTegra;
    class AudioStreamInTegra;
    class AudioStreamSrc;

public:
    // AudioHardwareInterface
                        AudioHardware();
    virtual             ~AudioHardware();
    virtual status_t    initCheck();

    virtual status_t    setVoiceVolume(float volume);
    virtual status_t    setMasterVolume(float volume);

    virtual status_t    setMode(int mode);

    // mic mute
    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);

    // create I/O streams
    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);
    // AudioHardwareBase provides default implementation
    //virtual  status_t    dumpState(int fd, const Vector<String16>& args);

    // added by AudioHardware
               status_t    init();

protected:
    // AudioHardwareBase provides default implementation
    //virtual  bool        isModeInCall(int mode);
    //virtual  bool        isInCall();

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

    // added by AudioHardware
                int        getActiveInputRate();

private:

    status_t    dumpInternals(int fd, const Vector<String16>& args);
    uint32_t    getInputSampleRate(uint32_t sampleRate);
    status_t    doStandby(int stop_fd, bool output, bool enable);
    status_t    doRouting_l();
    status_t    doRouting();
    status_t    setVolume_l(float v, int usecase);
    uint8_t     getGain(int direction, int usecase);
    void        readHwGainFile();

    AudioStreamInTegra*   getActiveInput_l();
    status_t    setMicMute_l(bool state);

#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
    class AudioStreamSrc {
    public:
                            AudioStreamSrc();
                            ~AudioStreamSrc();
    inline      int         inRate() {return mSrcInRate;};
    inline      int         outRate() {return mSrcOutRate;};
    inline      bool        initted() {return mSrcInitted;};
                void        init(int inRate, int outRate);
    inline      void        deinit() {mSrcInitted = false;};
                SRC_IO_T    mIoData;
    inline      void        srcConvert() { rate_convert(&mIoData, &mSrcObj, 0x0800); };
    private:
                SRC_OBJ_T   mSrcObj;
                char *      mSrcBuffer;
                SRC_INIT_T  mSrcInit;
                int         mSrcInRate;
                int         mSrcOutRate;
                bool        mSrcInitted;
    };
#endif

    class AudioStreamOutTegra : public AudioStreamOut {
    public:
                            AudioStreamOutTegra();
        virtual             ~AudioStreamOutTegra();
                status_t    init();
                status_t    initCheck();
                void        setDriver_l(bool speaker, bool bluetooth, bool spdif, int sampleRate);
                status_t    set(AudioHardware* mHardware,
                                uint32_t devices,
                                int *pFormat,
                                uint32_t *pChannels,
                                uint32_t *pRate);
        virtual uint32_t    sampleRate() const { return AUDIO_HW_OUT_SAMPLERATE; }
        // must be 32-bit aligned - driver only seems to like 4800
        virtual size_t      bufferSize() const { return 4096; }
        virtual uint32_t    channels() const { return AudioSystem::CHANNEL_OUT_STEREO; }
        virtual int         format() const { return AudioSystem::PCM_16_BIT; }
        virtual uint32_t    latency() const { return (1000*AUDIO_HW_NUM_OUT_BUF_LONG*(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);
                void        flush();
                void        flush_l();
        virtual status_t    standby();
                status_t    online_l();
        virtual status_t    dump(int fd, const Vector<String16>& args);
                bool        getStandby();
        virtual status_t    setParameters(const String8& keyValuePairs);
        virtual String8     getParameters(const String8& keys);
                uint32_t    devices() { return mDevices; }
        virtual status_t    getRenderPosition(uint32_t *dspFrames);
                void        lock() { mLock.lock(); }
                void        unlock() { mLock.unlock(); }
                bool        isLocked() { return mLocked; }
                void        setNumBufs(int numBufs);
                void        lockFd() { mFdLock.lock(); }
                void        unlockFd() { mFdLock.unlock(); }

                int         mBtFdIoCtl;

    private:
                AudioHardware* mHardware;
                Mutex       mLock;
                int         mFd;
                int         mFdCtl;
                int         mBtFd;
                int         mBtFdCtl;
                int         mSpdifFd;
                int         mSpdifFdCtl;
                int         mStartCount;
                int         mRetryCount;
                uint32_t    mDevices;
                Mutex       mFdLock;
                bool        mIsSpkrEnabled;
                bool        mIsBtEnabled;
                bool        mIsSpdifEnabled;
                bool        mIsSpkrEnabledReq;
                bool        mIsBtEnabledReq;
                bool        mIsSpdifEnabledReq;
                int16_t     mSpareSample;
                bool        mHaveSpareSample;
                int         mState;
#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
                AudioStreamSrc mSrc;
#endif
                bool        mLocked;        // setDriver() doesn't have to lock if true
                int         mDriverRate;
                bool        mInit;
    };

    class AudioStreamInTegra : public AudioStreamIn {
    public:
                            AudioStreamInTegra();
        virtual             ~AudioStreamInTegra();
                status_t    set(AudioHardware* mHardware,
                                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 mFormat; }
        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<String16>& args);
        virtual status_t    standby();
        virtual status_t    online_l();
                bool        getStandby() const;
        virtual status_t    setParameters(const String8& keyValuePairs);
        virtual String8     getParameters(const String8& keys);
        virtual unsigned int  getInputFramesLost() const;
                uint32_t    devices() { return mDevices; }
                void        setDriver_l(bool mic, bool bluetooth, int sampleRate);
                int         source() const { return mSource; }
                void        lock() { mLock.lock(); }
                void        unlock() { mLock.unlock(); }
                bool        isLocked() { return mLocked; }
                void        stop_l();
                void        lockFd() { mFdLock.lock(); }
                void        unlockFd() { mFdLock.unlock(); }

    private:
                void        reopenReconfigDriver();

                AudioHardware* mHardware;
                Mutex       mLock;
                int         mFd;
                int         mFdCtl;
                int         mState;
                int         mRetryCount;
                int         mFormat;
                uint32_t    mChannels;
                uint32_t    mSampleRate;
                size_t      mBufferSize;
                AudioSystem::audio_in_acoustics mAcoustics;
                uint32_t    mDevices;
                bool        mIsMicEnabled;
                bool        mIsBtEnabled;
                int         mSource;
                // 20 millisecond scratch buffer
                int16_t     mInScratch[48000/50];
#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
                AudioStreamSrc mSrc;
#endif
                bool        mLocked;        // setDriver() doesn't have to lock if true
        mutable uint32_t    mTotalBuffersRead;
        mutable nsecs_t     mStartTimeNs;
                int         mDriverRate;
        mutable Mutex       mFramesLock;
                Mutex       mFdLock;
    };

            static const uint32_t inputSamplingRates[];
            bool        mInit;
            bool        mMicMute;
            bool        mBluetoothNrec;
            uint32_t    mBluetoothId;
            AudioStreamOutTegra*  mOutput;
            SortedVector <AudioStreamInTegra*>   mInputs;

            struct cpcap_audio_stream mCurOutDevice;
            struct cpcap_audio_stream mCurInDevice;

     friend class AudioStreamInTegra;
            Mutex       mLock;

            int mCpcapCtlFd;
            int mHwOutRate;
            int mHwInRate;
            float mMasterVol;
            float mVoiceVol;
            uint8_t mCpcapGain[AUDIO_HW_GAIN_NUM_DIRECTIONS]
                              [AUDIO_HW_GAIN_NUM_USECASES]
                              [AUDIO_HW_GAIN_NUM_PATHS];
#ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
            AudioPostProcessor mAudioPP;
#endif
            int mSpkrVolume;
            int mMicVolume;
            bool mEcnsEnabled;
            bool mBtScoOn;
};

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

}; // namespace android

#endif // ANDROID_AUDIO_HARDWARE_H