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 #include <stdint.h> 19 #include <sys/types.h> 20 21 #include <stdlib.h> 22 #include <stdio.h> 23 #include <unistd.h> 24 #include <sched.h> 25 #include <fcntl.h> 26 #include <sys/ioctl.h> 27 28 #define LOG_TAG "AudioHardware" 29 #include <utils/Log.h> 30 #include <utils/String8.h> 31 32 #include "AudioHardwareGeneric.h" 33 #include <media/AudioRecord.h> 34 35 #include <hardware_legacy/AudioSystemLegacy.h> 36 37 namespace android_audio_legacy { 38 39 // ---------------------------------------------------------------------------- 40 41 static char const * const kAudioDeviceName = "/dev/eac"; 42 43 // ---------------------------------------------------------------------------- 44 45 AudioHardwareGeneric::AudioHardwareGeneric() 46 : mOutput(0), mInput(0), mFd(-1), mMicMute(false) 47 { 48 mFd = ::open(kAudioDeviceName, O_RDWR); 49 } 50 51 AudioHardwareGeneric::~AudioHardwareGeneric() 52 { 53 if (mFd >= 0) ::close(mFd); 54 closeOutputStream((AudioStreamOut *)mOutput); 55 closeInputStream((AudioStreamIn *)mInput); 56 } 57 58 status_t AudioHardwareGeneric::initCheck() 59 { 60 if (mFd >= 0) { 61 if (::access(kAudioDeviceName, O_RDWR) == NO_ERROR) 62 return NO_ERROR; 63 } 64 return NO_INIT; 65 } 66 67 AudioStreamOut* AudioHardwareGeneric::openOutputStream( 68 uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status) 69 { 70 AutoMutex lock(mLock); 71 72 // only one output stream allowed 73 if (mOutput) { 74 if (status) { 75 *status = INVALID_OPERATION; 76 } 77 return 0; 78 } 79 80 // create new output stream 81 AudioStreamOutGeneric* out = new AudioStreamOutGeneric(); 82 status_t lStatus = out->set(this, mFd, devices, format, channels, sampleRate); 83 if (status) { 84 *status = lStatus; 85 } 86 if (lStatus == NO_ERROR) { 87 mOutput = out; 88 } else { 89 delete out; 90 } 91 return mOutput; 92 } 93 94 void AudioHardwareGeneric::closeOutputStream(AudioStreamOut* out) { 95 if (mOutput && out == mOutput) { 96 delete mOutput; 97 mOutput = 0; 98 } 99 } 100 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) 104 { 105 // check for valid input source 106 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) { 107 return 0; 108 } 109 110 AutoMutex lock(mLock); 111 112 // only one input stream allowed 113 if (mInput) { 114 if (status) { 115 *status = INVALID_OPERATION; 116 } 117 return 0; 118 } 119 120 // create new output stream 121 AudioStreamInGeneric* in = new AudioStreamInGeneric(); 122 status_t lStatus = in->set(this, mFd, devices, format, channels, sampleRate, acoustics); 123 if (status) { 124 *status = lStatus; 125 } 126 if (lStatus == NO_ERROR) { 127 mInput = in; 128 } else { 129 delete in; 130 } 131 return mInput; 132 } 133 134 void AudioHardwareGeneric::closeInputStream(AudioStreamIn* in) { 135 if (mInput && in == mInput) { 136 delete mInput; 137 mInput = 0; 138 } 139 } 140 141 status_t AudioHardwareGeneric::setVoiceVolume(float v) 142 { 143 // Implement: set voice volume 144 return NO_ERROR; 145 } 146 147 status_t AudioHardwareGeneric::setMasterVolume(float v) 148 { 149 // Implement: set master volume 150 // return error - software mixer will handle it 151 return INVALID_OPERATION; 152 } 153 154 status_t AudioHardwareGeneric::setMicMute(bool state) 155 { 156 mMicMute = state; 157 return NO_ERROR; 158 } 159 160 status_t AudioHardwareGeneric::getMicMute(bool* state) 161 { 162 *state = mMicMute; 163 return NO_ERROR; 164 } 165 166 status_t AudioHardwareGeneric::dumpInternals(int fd, const Vector<String16>& args) 167 { 168 const size_t SIZE = 256; 169 char buffer[SIZE]; 170 String8 result; 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()); 175 return NO_ERROR; 176 } 177 178 status_t AudioHardwareGeneric::dump(int fd, const Vector<String16>& args) 179 { 180 dumpInternals(fd, args); 181 if (mInput) { 182 mInput->dump(fd, args); 183 } 184 if (mOutput) { 185 mOutput->dump(fd, args); 186 } 187 return NO_ERROR; 188 } 189 190 // ---------------------------------------------------------------------------- 191 192 status_t AudioStreamOutGeneric::set( 193 AudioHardwareGeneric *hw, 194 int fd, 195 uint32_t devices, 196 int *pFormat, 197 uint32_t *pChannels, 198 uint32_t *pRate) 199 { 200 int lFormat = pFormat ? *pFormat : 0; 201 uint32_t lChannels = pChannels ? *pChannels : 0; 202 uint32_t lRate = pRate ? *pRate : 0; 203 204 // fix up defaults 205 if (lFormat == 0) lFormat = format(); 206 if (lChannels == 0) lChannels = channels(); 207 if (lRate == 0) lRate = sampleRate(); 208 209 // check values 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(); 216 return BAD_VALUE; 217 } 218 219 if (pFormat) *pFormat = lFormat; 220 if (pChannels) *pChannels = lChannels; 221 if (pRate) *pRate = lRate; 222 223 mAudioHardware = hw; 224 mFd = fd; 225 mDevice = devices; 226 return NO_ERROR; 227 } 228 229 AudioStreamOutGeneric::~AudioStreamOutGeneric() 230 { 231 } 232 233 ssize_t AudioStreamOutGeneric::write(const void* buffer, size_t bytes) 234 { 235 Mutex::Autolock _l(mLock); 236 return ssize_t(::write(mFd, buffer, bytes)); 237 } 238 239 status_t AudioStreamOutGeneric::standby() 240 { 241 // Implement: audio hardware to standby mode 242 return NO_ERROR; 243 } 244 245 status_t AudioStreamOutGeneric::dump(int fd, const Vector<String16>& args) 246 { 247 const size_t SIZE = 256; 248 char buffer[SIZE]; 249 String8 result; 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()); 267 return NO_ERROR; 268 } 269 270 status_t AudioStreamOutGeneric::setParameters(const String8& keyValuePairs) 271 { 272 AudioParameter param = AudioParameter(keyValuePairs); 273 String8 key = String8(AudioParameter::keyRouting); 274 status_t status = NO_ERROR; 275 int device; 276 ALOGV("setParameters() %s", keyValuePairs.string()); 277 278 if (param.getInt(key, device) == NO_ERROR) { 279 mDevice = device; 280 param.remove(key); 281 } 282 283 if (param.size()) { 284 status = BAD_VALUE; 285 } 286 return status; 287 } 288 289 String8 AudioStreamOutGeneric::getParameters(const String8& keys) 290 { 291 AudioParameter param = AudioParameter(keys); 292 String8 value; 293 String8 key = String8(AudioParameter::keyRouting); 294 295 if (param.get(key, value) == NO_ERROR) { 296 param.addInt(key, (int)mDevice); 297 } 298 299 ALOGV("getParameters() %s", param.toString().string()); 300 return param.toString(); 301 } 302 303 status_t AudioStreamOutGeneric::getRenderPosition(uint32_t *dspFrames) 304 { 305 return INVALID_OPERATION; 306 } 307 308 // ---------------------------------------------------------------------------- 309 310 // record functions 311 status_t AudioStreamInGeneric::set( 312 AudioHardwareGeneric *hw, 313 int fd, 314 uint32_t devices, 315 int *pFormat, 316 uint32_t *pChannels, 317 uint32_t *pRate, 318 AudioSystem::audio_in_acoustics acoustics) 319 { 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); 322 // check values 323 if ((*pFormat != format()) || 324 (*pChannels != channels()) || 325 (*pRate != sampleRate())) { 326 ALOGE("Error opening input channel"); 327 *pFormat = format(); 328 *pChannels = channels(); 329 *pRate = sampleRate(); 330 return BAD_VALUE; 331 } 332 333 mAudioHardware = hw; 334 mFd = fd; 335 mDevice = devices; 336 return NO_ERROR; 337 } 338 339 AudioStreamInGeneric::~AudioStreamInGeneric() 340 { 341 } 342 343 ssize_t AudioStreamInGeneric::read(void* buffer, ssize_t bytes) 344 { 345 AutoMutex lock(mLock); 346 if (mFd < 0) { 347 ALOGE("Attempt to read from unopened device"); 348 return NO_INIT; 349 } 350 return ::read(mFd, buffer, bytes); 351 } 352 353 status_t AudioStreamInGeneric::dump(int fd, const Vector<String16>& args) 354 { 355 const size_t SIZE = 256; 356 char buffer[SIZE]; 357 String8 result; 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()); 375 return NO_ERROR; 376 } 377 378 status_t AudioStreamInGeneric::setParameters(const String8& keyValuePairs) 379 { 380 AudioParameter param = AudioParameter(keyValuePairs); 381 String8 key = String8(AudioParameter::keyRouting); 382 status_t status = NO_ERROR; 383 int device; 384 ALOGV("setParameters() %s", keyValuePairs.string()); 385 386 if (param.getInt(key, device) == NO_ERROR) { 387 mDevice = device; 388 param.remove(key); 389 } 390 391 if (param.size()) { 392 status = BAD_VALUE; 393 } 394 return status; 395 } 396 397 String8 AudioStreamInGeneric::getParameters(const String8& keys) 398 { 399 AudioParameter param = AudioParameter(keys); 400 String8 value; 401 String8 key = String8(AudioParameter::keyRouting); 402 403 if (param.get(key, value) == NO_ERROR) { 404 param.addInt(key, (int)mDevice); 405 } 406 407 ALOGV("getParameters() %s", param.toString().string()); 408 return param.toString(); 409 } 410 411 // ---------------------------------------------------------------------------- 412 413 }; // namespace android 414
