3 ** Copyright 2007, The Android Open Source Project
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
9 ** http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <sys/types.h>
26 #include <sys/ioctl.h>
28 #define LOG_TAG "AudioHardware"
29 #include <utils/Log.h>
30 #include <utils/String8.h>
32 #include "AudioHardwareGeneric.h"
33 #include <media/AudioRecord.h>
35 #include <hardware_legacy/AudioSystemLegacy.h>
37 namespace android_audio_legacy {
39 // ----------------------------------------------------------------------------
41 static char const * const kAudioDeviceName = "/dev/eac";
43 // ----------------------------------------------------------------------------
45 AudioHardwareGeneric::AudioHardwareGeneric()
46 : mOutput(0), mInput(0), mFd(-1), mMicMute(false)
48 mFd = ::open(kAudioDeviceName, O_RDWR);
51 AudioHardwareGeneric::~AudioHardwareGeneric()
53 if (mFd >= 0) ::close(mFd);
54 closeOutputStream((AudioStreamOut *)mOutput);
55 closeInputStream((AudioStreamIn *)mInput);
58 status_t AudioHardwareGeneric::initCheck()
61 if (::access(kAudioDeviceName, O_RDWR) == NO_ERROR)
67 AudioStreamOut* AudioHardwareGeneric::openOutputStream(
68 uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
70 AutoMutex lock(mLock);
72 // only one output stream allowed
75 *status = INVALID_OPERATION;
80 // create new output stream
81 AudioStreamOutGeneric* out = new AudioStreamOutGeneric();
82 status_t lStatus = out->set(this, mFd, devices, format, channels, sampleRate);
86 if (lStatus == NO_ERROR) {
94 void AudioHardwareGeneric::closeOutputStream(AudioStreamOut* out) {
95 if (mOutput && out == mOutput) {
101 AudioStreamIn* AudioHardwareGeneric::openInputStream(
102 uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate,
103 status_t *status, AudioSystem::audio_in_acoustics acoustics)
105 // check for valid input source
106 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
110 AutoMutex lock(mLock);
112 // only one input stream allowed
115 *status = INVALID_OPERATION;
120 // create new output stream
121 AudioStreamInGeneric* in = new AudioStreamInGeneric();
122 status_t lStatus = in->set(this, mFd, devices, format, channels, sampleRate, acoustics);
126 if (lStatus == NO_ERROR) {
134 void AudioHardwareGeneric::closeInputStream(AudioStreamIn* in) {
135 if (mInput && in == mInput) {
141 status_t AudioHardwareGeneric::setVoiceVolume(float v)
143 // Implement: set voice volume
147 status_t AudioHardwareGeneric::setMasterVolume(float v)
149 // Implement: set master volume
150 // return error - software mixer will handle it
151 return INVALID_OPERATION;
154 status_t AudioHardwareGeneric::setMicMute(bool state)
160 status_t AudioHardwareGeneric::getMicMute(bool* state)
166 status_t AudioHardwareGeneric::dumpInternals(int fd, const Vector<String16>& args)
168 const size_t SIZE = 256;
171 result.append("AudioHardwareGeneric::dumpInternals\n");
172 snprintf(buffer, SIZE, "\tmFd: %d mMicMute: %s\n", mFd, mMicMute? "true": "false");
173 result.append(buffer);
174 ::write(fd, result.string(), result.size());
178 status_t AudioHardwareGeneric::dump(int fd, const Vector<String16>& args)
180 dumpInternals(fd, args);
182 mInput->dump(fd, args);
185 mOutput->dump(fd, args);
190 // ----------------------------------------------------------------------------
192 status_t AudioStreamOutGeneric::set(
193 AudioHardwareGeneric *hw,
200 int lFormat = pFormat ? *pFormat : 0;
201 uint32_t lChannels = pChannels ? *pChannels : 0;
202 uint32_t lRate = pRate ? *pRate : 0;
205 if (lFormat == 0) lFormat = format();
206 if (lChannels == 0) lChannels = channels();
207 if (lRate == 0) lRate = sampleRate();
210 if ((lFormat != format()) ||
211 (lChannels != channels()) ||
212 (lRate != sampleRate())) {
213 if (pFormat) *pFormat = format();
214 if (pChannels) *pChannels = channels();
215 if (pRate) *pRate = sampleRate();
219 if (pFormat) *pFormat = lFormat;
220 if (pChannels) *pChannels = lChannels;
221 if (pRate) *pRate = lRate;
229 AudioStreamOutGeneric::~AudioStreamOutGeneric()
233 ssize_t AudioStreamOutGeneric::write(const void* buffer, size_t bytes)
235 Mutex::Autolock _l(mLock);
236 return ssize_t(::write(mFd, buffer, bytes));
239 status_t AudioStreamOutGeneric::standby()
241 // Implement: audio hardware to standby mode
245 status_t AudioStreamOutGeneric::dump(int fd, const Vector<String16>& args)
247 const size_t SIZE = 256;
250 snprintf(buffer, SIZE, "AudioStreamOutGeneric::dump\n");
251 result.append(buffer);
252 snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
253 result.append(buffer);
254 snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
255 result.append(buffer);
256 snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
257 result.append(buffer);
258 snprintf(buffer, SIZE, "\tformat: %d\n", format());
259 result.append(buffer);
260 snprintf(buffer, SIZE, "\tdevice: %d\n", mDevice);
261 result.append(buffer);
262 snprintf(buffer, SIZE, "\tmAudioHardware: %p\n", mAudioHardware);
263 result.append(buffer);
264 snprintf(buffer, SIZE, "\tmFd: %d\n", mFd);
265 result.append(buffer);
266 ::write(fd, result.string(), result.size());
270 status_t AudioStreamOutGeneric::setParameters(const String8& keyValuePairs)
272 AudioParameter param = AudioParameter(keyValuePairs);
273 String8 key = String8(AudioParameter::keyRouting);
274 status_t status = NO_ERROR;
276 ALOGV("setParameters() %s", keyValuePairs.string());
278 if (param.getInt(key, device) == NO_ERROR) {
289 String8 AudioStreamOutGeneric::getParameters(const String8& keys)
291 AudioParameter param = AudioParameter(keys);
293 String8 key = String8(AudioParameter::keyRouting);
295 if (param.get(key, value) == NO_ERROR) {
296 param.addInt(key, (int)mDevice);
299 ALOGV("getParameters() %s", param.toString().string());
300 return param.toString();
303 status_t AudioStreamOutGeneric::getRenderPosition(uint32_t *dspFrames)
305 return INVALID_OPERATION;
308 // ----------------------------------------------------------------------------
311 status_t AudioStreamInGeneric::set(
312 AudioHardwareGeneric *hw,
318 AudioSystem::audio_in_acoustics acoustics)
320 if (pFormat == 0 || pChannels == 0 || pRate == 0) return BAD_VALUE;
321 ALOGV("AudioStreamInGeneric::set(%p, %d, %d, %d, %u)", hw, fd, *pFormat, *pChannels, *pRate);
323 if ((*pFormat != format()) ||
324 (*pChannels != channels()) ||
325 (*pRate != sampleRate())) {
326 ALOGE("Error opening input channel");
328 *pChannels = channels();
329 *pRate = sampleRate();
339 AudioStreamInGeneric::~AudioStreamInGeneric()
343 ssize_t AudioStreamInGeneric::read(void* buffer, ssize_t bytes)
345 AutoMutex lock(mLock);
347 ALOGE("Attempt to read from unopened device");
350 return ::read(mFd, buffer, bytes);
353 status_t AudioStreamInGeneric::dump(int fd, const Vector<String16>& args)
355 const size_t SIZE = 256;
358 snprintf(buffer, SIZE, "AudioStreamInGeneric::dump\n");
359 result.append(buffer);
360 snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
361 result.append(buffer);
362 snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
363 result.append(buffer);
364 snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
365 result.append(buffer);
366 snprintf(buffer, SIZE, "\tformat: %d\n", format());
367 result.append(buffer);
368 snprintf(buffer, SIZE, "\tdevice: %d\n", mDevice);
369 result.append(buffer);
370 snprintf(buffer, SIZE, "\tmAudioHardware: %p\n", mAudioHardware);
371 result.append(buffer);
372 snprintf(buffer, SIZE, "\tmFd: %d\n", mFd);
373 result.append(buffer);
374 ::write(fd, result.string(), result.size());
378 status_t AudioStreamInGeneric::setParameters(const String8& keyValuePairs)
380 AudioParameter param = AudioParameter(keyValuePairs);
381 String8 key = String8(AudioParameter::keyRouting);
382 status_t status = NO_ERROR;
384 ALOGV("setParameters() %s", keyValuePairs.string());
386 if (param.getInt(key, device) == NO_ERROR) {
397 String8 AudioStreamInGeneric::getParameters(const String8& keys)
399 AudioParameter param = AudioParameter(keys);
401 String8 key = String8(AudioParameter::keyRouting);
403 if (param.get(key, value) == NO_ERROR) {
404 param.addInt(key, (int)mDevice);
407 ALOGV("getParameters() %s", param.toString().string());
408 return param.toString();
411 // ----------------------------------------------------------------------------
413 }; // namespace android