1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/*
* Copyright (C) 2007 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_INTERFACE_H
#define ANDROID_AUDIO_HARDWARE_INTERFACE_H
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/Vector.h>
#include <utils/String16.h>
#include <media/IAudioFlinger.h>
#include "media/AudioSystem.h"
namespace android {
// ----------------------------------------------------------------------------
/**
* This is the abstraction interface for the audio output hardware. It provides
* information about various properties of the audio output hardware driver.
*/
class AudioStreamOut {
public:
virtual ~AudioStreamOut() = 0;
/** return audio sampling rate in hz - eg. 44100 */
virtual uint32_t sampleRate() const = 0;
/** returns size of output buffer - eg. 4800 */
virtual size_t bufferSize() const = 0;
/**
* return number of output audio channels.
* Acceptable values are 1 (mono) or 2 (stereo)
*/
virtual int channelCount() const = 0;
/**
* return audio format in 8bit or 16bit PCM format -
* eg. AudioSystem:PCM_16_BIT
*/
virtual int format() const = 0;
/**
* This method can be used in situations where audio mixing is done in the
* hardware. It is a direct interface to the hardware to set the volume as
* as opposed to controlling this via the framework. It could be multiple
* PCM outputs or hardware accelerated codecs such as MP3 or AAC
*/
virtual status_t setVolume(float volume) = 0;
/** write audio buffer to driver. Returns number of bytes written */
virtual ssize_t write(const void* buffer, size_t bytes) = 0;
/** dump the state of the audio output device */
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
};
/**
* This is the abstraction interface for the audio input hardware. It defines
* the various properties of the audio hardware input driver.
*/
class AudioStreamIn {
public:
virtual ~AudioStreamIn() = 0;
/** return the input buffer size allowed by audio driver */
virtual size_t bufferSize() const = 0;
/** return the number of audio input channels */
virtual int channelCount() const = 0;
/**
* return audio format in 8bit or 16bit PCM format -
* eg. AudioSystem:PCM_16_BIT
*/
virtual int format() const = 0;
/** set the input gain for the audio driver. This method is for
* for future use */
virtual status_t setGain(float gain) = 0;
/** read audio buffer in from audio driver */
virtual ssize_t read(void* buffer, ssize_t bytes) = 0;
/** dump the state of the audio input device */
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
};
/**
* This defines the interface to the audio hardware abstraction layer. It
* supports setting and getting parameters, selecting audio routing paths and
* defining input and output streams.
*
* AudioFlinger initializes the audio hardware and immediately opens an output
* stream. Audio routing can be set to output to handset, speaker, bluetooth or
* headset.
*
* The audio input stream is initialized when AudioFlinger is called to carry
* out a record operation.
*/
class AudioHardwareInterface
{
public:
AudioHardwareInterface();
virtual ~AudioHardwareInterface() { }
/**
* 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() = 0;
/**
* put the audio hardware into standby mode to conserve power. Returns
* status based on include/utils/Errors.h
*/
virtual status_t standby() = 0;
/** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
virtual status_t setVoiceVolume(float volume) = 0;
/**
* 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) = 0;
/**
* Audio routing methods. Routes defined in include/hardware/AudioSystem.h.
* Audio routes can be (ROUTE_EARPIECE | ROUTE_SPEAKER | ROUTE_BLUETOOTH
* | ROUTE_HEADSET)
*
* setRouting sets the routes for a mode. This is called at startup. It is
* also called when a new device is connected, such as a wired headset is
* plugged in or a Bluetooth headset is paired
*/
virtual status_t setRouting(int mode, uint32_t routes);
virtual status_t getRouting(int mode, uint32_t* routes);
/**
* setMode is called when the audio mode changes. NORMAL mode is for
* standard audio playback, RINGTONE when a ringtone is playing and IN_CALL
* when a call is in progress.
*/
virtual status_t setMode(int mode);
virtual status_t getMode(int* mode);
// mic mute
virtual status_t setMicMute(bool state) = 0;
virtual status_t getMicMute(bool* state) = 0;
// Temporary interface, do not use
// TODO: Replace with a more generic key:value get/set mechanism
virtual status_t setParameter(const char* key, const char* value);
/** This method creates and opens the audio hardware output stream */
virtual AudioStreamOut* openOutputStream(
int format=0,
int channelCount=0,
uint32_t sampleRate=0) = 0;
/** This method creates and opens the audio hardware input stream */
virtual AudioStreamIn* openInputStream(
int format,
int channelCount,
uint32_t sampleRate) = 0;
/**This method dumps the state of the audio hardware */
virtual status_t dumpState(int fd, const Vector<String16>& args);
static AudioHardwareInterface* create();
protected:
/**
* doRouting actually initiates the routing to occur. A call to setRouting
* or setMode may result in a routing change. The generic logic will call
* doRouting when required. If the device has any special requirements these
* methods can be overriden.
*/
virtual status_t doRouting() = 0;
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
int mMode;
uint32_t mRoutes[AudioSystem::NUM_MODES];
};
// ----------------------------------------------------------------------------
extern "C" AudioHardwareInterface* createAudioHardware(void);
}; // namespace android
#endif // ANDROID_AUDIO_HARDWARE_INTERFACE_H
|
