AudioHardwareGeneric.h revision f01215993dda68b6b52111d754bd0c7c2d5bcfa3 
1/*
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef ANDROID_AUDIO_HARDWARE_GENERIC_H
19#define ANDROID_AUDIO_HARDWARE_GENERIC_H
20
21#include <stdint.h>
22#include <sys/types.h>
23
24#include <utils/threads.h>
25
26#include <hardware_legacy/AudioHardwareBase.h>
27
28namespace android {
29
30// ----------------------------------------------------------------------------
31
32class AudioHardwareGeneric;
33
34class AudioStreamOutGeneric : public AudioStreamOut {
35public:
36                        AudioStreamOutGeneric() : mAudioHardware(0), mFd(-1) {}
37    virtual             ~AudioStreamOutGeneric();
38
39    virtual status_t    set(
40            AudioHardwareGeneric *hw,
41            int mFd,
42            uint32_t devices,
43            int *pFormat,
44            uint32_t *pChannels,
45            uint32_t *pRate);
46
47    virtual uint32_t    sampleRate() const { return 44100; }
48    virtual size_t      bufferSize() const { return 4096; }
49    virtual uint32_t    channels() const { return AudioSystem::CHANNEL_OUT_STEREO; }
50    virtual int         format() const { return AudioSystem::PCM_16_BIT; }
51    virtual uint32_t    latency() const { return 20; }
52    virtual status_t    setVolume(float left, float right) { return INVALID_OPERATION; }
53    virtual ssize_t     write(const void* buffer, size_t bytes);
54    virtual status_t    standby();
55    virtual status_t    dump(int fd, const Vector<String16>& args);
56    virtual status_t    setParameters(const String8& keyValuePairs);
57    virtual String8     getParameters(const String8& keys);
58    virtual status_t    getRenderPosition(uint32_t *dspFrames);
59
60private:
61    AudioHardwareGeneric *mAudioHardware;
62    Mutex   mLock;
63    int     mFd;
64    uint32_t mDevice;
65};
66
67class AudioStreamInGeneric : public AudioStreamIn {
68public:
69                        AudioStreamInGeneric() : mAudioHardware(0), mFd(-1) {}
70    virtual             ~AudioStreamInGeneric();
71
72    virtual status_t    set(
73            AudioHardwareGeneric *hw,
74            int mFd,
75            uint32_t devices,
76            int *pFormat,
77            uint32_t *pChannels,
78            uint32_t *pRate,
79            AudioSystem::audio_in_acoustics acoustics);
80
81    virtual uint32_t    sampleRate() const { return 8000; }
82    virtual size_t      bufferSize() const { return 320; }
83    virtual uint32_t    channels() const { return AudioSystem::CHANNEL_IN_MONO; }
84    virtual int         format() const { return AudioSystem::PCM_16_BIT; }
85    virtual status_t    setGain(float gain) { return INVALID_OPERATION; }
86    virtual ssize_t     read(void* buffer, ssize_t bytes);
87    virtual status_t    dump(int fd, const Vector<String16>& args);
88    virtual status_t    standby() { return NO_ERROR; }
89    virtual status_t    setParameters(const String8& keyValuePairs);
90    virtual String8     getParameters(const String8& keys);
91    virtual unsigned int  getInputFramesLost() const { return 0; }
92
93private:
94    AudioHardwareGeneric *mAudioHardware;
95    Mutex   mLock;
96    int     mFd;
97    uint32_t mDevice;
98};
99
100
101class AudioHardwareGeneric : public AudioHardwareBase
102{
103public:
104                        AudioHardwareGeneric();
105    virtual             ~AudioHardwareGeneric();
106    virtual status_t    initCheck();
107    virtual status_t    setVoiceVolume(float volume);
108    virtual status_t    setMasterVolume(float volume);
109
110    // mic mute
111    virtual status_t    setMicMute(bool state);
112    virtual status_t    getMicMute(bool* state);
113
114    // create I/O streams
115    virtual AudioStreamOut* openOutputStream(
116            uint32_t devices,
117            int *format=0,
118            uint32_t *channels=0,
119            uint32_t *sampleRate=0,
120            status_t *status=0);
121    virtual    void        closeOutputStream(AudioStreamOut* out);
122
123    virtual AudioStreamIn* openInputStream(
124            uint32_t devices,
125            int *format,
126            uint32_t *channels,
127            uint32_t *sampleRate,
128            status_t *status,
129            AudioSystem::audio_in_acoustics acoustics);
130    virtual    void        closeInputStream(AudioStreamIn* in);
131
132            void            closeOutputStream(AudioStreamOutGeneric* out);
133            void            closeInputStream(AudioStreamInGeneric* in);
134protected:
135    virtual status_t        dump(int fd, const Vector<String16>& args);
136
137private:
138    status_t                dumpInternals(int fd, const Vector<String16>& args);
139
140    Mutex                   mLock;
141    AudioStreamOutGeneric   *mOutput;
142    AudioStreamInGeneric    *mInput;
143    int                     mFd;
144    bool                    mMicMute;
145};
146
147// ----------------------------------------------------------------------------
148
149}; // namespace android
150
151#endif // ANDROID_AUDIO_HARDWARE_GENERIC_H
152