AudioRecorder_to_android.cpp revision 9f3ac83aa036a780ca901f9ff75e47a5a7cbba1f
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 18#include "sles_allinclusive.h" 19#include "android_prompts.h" 20 21#include <utils/String16.h> 22 23#include <system/audio.h> 24 25// use this flag to dump all recorded audio into a file 26//#define MONITOR_RECORDING 27#ifdef MONITOR_RECORDING 28#define MONITOR_TARGET "/sdcard/monitor.raw" 29#include <stdio.h> 30static FILE* gMonitorFp = NULL; 31#endif 32 33 34#define KEY_RECORDING_SOURCE_PARAMSIZE sizeof(SLuint32) 35#define KEY_RECORDING_PRESET_PARAMSIZE sizeof(SLuint32) 36 37//----------------------------------------------------------------------------- 38// Internal utility functions 39//---------------------------- 40 41SLresult audioRecorder_setPreset(CAudioRecorder* ar, SLuint32 recordPreset) { 42 SLresult result = SL_RESULT_SUCCESS; 43 44 audio_source_t newRecordSource = AUDIO_SOURCE_DEFAULT; 45 switch (recordPreset) { 46 case SL_ANDROID_RECORDING_PRESET_GENERIC: 47 newRecordSource = AUDIO_SOURCE_DEFAULT; 48 break; 49 case SL_ANDROID_RECORDING_PRESET_CAMCORDER: 50 newRecordSource = AUDIO_SOURCE_CAMCORDER; 51 break; 52 case SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION: 53 newRecordSource = AUDIO_SOURCE_VOICE_RECOGNITION; 54 break; 55 case SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION: 56 newRecordSource = AUDIO_SOURCE_VOICE_COMMUNICATION; 57 break; 58 case SL_ANDROID_RECORDING_PRESET_NONE: 59 // it is an error to set preset "none" 60 default: 61 SL_LOGE(ERROR_RECORDERPRESET_SET_UNKNOWN_PRESET); 62 result = SL_RESULT_PARAMETER_INVALID; 63 } 64 65 // recording preset needs to be set before the object is realized 66 // (ap->mAudioRecord is supposed to be 0 until then) 67 if (SL_OBJECT_STATE_UNREALIZED != ar->mObject.mState) { 68 SL_LOGE(ERROR_RECORDERPRESET_REALIZED); 69 result = SL_RESULT_PRECONDITIONS_VIOLATED; 70 } else { 71 ar->mRecordSource = newRecordSource; 72 } 73 74 return result; 75} 76 77 78SLresult audioRecorder_getPreset(CAudioRecorder* ar, SLuint32* pPreset) { 79 SLresult result = SL_RESULT_SUCCESS; 80 81 switch (ar->mRecordSource) { 82 case AUDIO_SOURCE_DEFAULT: 83 case AUDIO_SOURCE_MIC: 84 *pPreset = SL_ANDROID_RECORDING_PRESET_GENERIC; 85 break; 86 case AUDIO_SOURCE_VOICE_UPLINK: 87 case AUDIO_SOURCE_VOICE_DOWNLINK: 88 case AUDIO_SOURCE_VOICE_CALL: 89 *pPreset = SL_ANDROID_RECORDING_PRESET_NONE; 90 break; 91 case AUDIO_SOURCE_VOICE_RECOGNITION: 92 *pPreset = SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION; 93 break; 94 case AUDIO_SOURCE_CAMCORDER: 95 *pPreset = SL_ANDROID_RECORDING_PRESET_CAMCORDER; 96 break; 97 case AUDIO_SOURCE_VOICE_COMMUNICATION: 98 *pPreset = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION; 99 break; 100 default: 101 *pPreset = SL_ANDROID_RECORDING_PRESET_NONE; 102 result = SL_RESULT_INTERNAL_ERROR; 103 break; 104 } 105 106 return result; 107} 108 109 110void audioRecorder_handleNewPos_lockRecord(CAudioRecorder* ar) { 111 //SL_LOGV("received event EVENT_NEW_POS from AudioRecord"); 112 slRecordCallback callback = NULL; 113 void* callbackPContext = NULL; 114 115 interface_lock_shared(&ar->mRecord); 116 callback = ar->mRecord.mCallback; 117 callbackPContext = ar->mRecord.mContext; 118 interface_unlock_shared(&ar->mRecord); 119 120 if (NULL != callback) { 121 // getting this event implies SL_RECORDEVENT_HEADATNEWPOS was set in the event mask 122 (*callback)(&ar->mRecord.mItf, callbackPContext, SL_RECORDEVENT_HEADATNEWPOS); 123 } 124} 125 126 127void audioRecorder_handleMarker_lockRecord(CAudioRecorder* ar) { 128 //SL_LOGV("received event EVENT_MARKER from AudioRecord"); 129 slRecordCallback callback = NULL; 130 void* callbackPContext = NULL; 131 132 interface_lock_shared(&ar->mRecord); 133 callback = ar->mRecord.mCallback; 134 callbackPContext = ar->mRecord.mContext; 135 interface_unlock_shared(&ar->mRecord); 136 137 if (NULL != callback) { 138 // getting this event implies SL_RECORDEVENT_HEADATMARKER was set in the event mask 139 (*callback)(&ar->mRecord.mItf, callbackPContext, SL_RECORDEVENT_HEADATMARKER); 140 } 141} 142 143 144void audioRecorder_handleOverrun_lockRecord(CAudioRecorder* ar) { 145 //SL_LOGV("received event EVENT_OVERRUN from AudioRecord"); 146 slRecordCallback callback = NULL; 147 void* callbackPContext = NULL; 148 149 interface_lock_shared(&ar->mRecord); 150 if (ar->mRecord.mCallbackEventsMask & SL_RECORDEVENT_HEADSTALLED) { 151 callback = ar->mRecord.mCallback; 152 callbackPContext = ar->mRecord.mContext; 153 } 154 interface_unlock_shared(&ar->mRecord); 155 156 if (NULL != callback) { 157 (*callback)(&ar->mRecord.mItf, callbackPContext, SL_RECORDEVENT_HEADSTALLED); 158 } 159} 160 161//----------------------------------------------------------------------------- 162SLresult android_audioRecorder_checkSourceSinkSupport(CAudioRecorder* ar) { 163 164 const SLDataSource *pAudioSrc = &ar->mDataSource.u.mSource; 165 const SLDataSink *pAudioSnk = &ar->mDataSink.u.mSink; 166 167 // Sink check: 168 // only buffer queue sinks are supported, regardless of the data source 169 if (SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE != *(SLuint32 *)pAudioSnk->pLocator) { 170 SL_LOGE(ERROR_RECORDER_SINK_MUST_BE_ANDROIDSIMPLEBUFFERQUEUE); 171 return SL_RESULT_PARAMETER_INVALID; 172 } else { 173 // only PCM buffer queues are supported 174 SLuint32 formatType = *(SLuint32 *)pAudioSnk->pFormat; 175 if (SL_DATAFORMAT_PCM == formatType) { 176 SLDataFormat_PCM *df_pcm = (SLDataFormat_PCM *)ar->mDataSink.u.mSink.pFormat; 177 ar->mSampleRateMilliHz = df_pcm->samplesPerSec; 178 ar->mNumChannels = df_pcm->numChannels; 179 SL_LOGV("AudioRecorder requested sample rate = %u mHz, %u channel(s)", 180 ar->mSampleRateMilliHz, ar->mNumChannels); 181 } 182 else { 183 SL_LOGE(ERROR_RECORDER_SINK_FORMAT_MUST_BE_PCM); 184 return SL_RESULT_PARAMETER_INVALID; 185 } 186 } 187 188 // Source check: 189 // only input device sources are supported 190 // check it's an IO device 191 if (SL_DATALOCATOR_IODEVICE != *(SLuint32 *)pAudioSrc->pLocator) { 192 SL_LOGE(ERROR_RECORDER_SOURCE_MUST_BE_IODEVICE); 193 return SL_RESULT_PARAMETER_INVALID; 194 } else { 195 196 // check it's an input device 197 SLDataLocator_IODevice *dl_iod = (SLDataLocator_IODevice *) pAudioSrc->pLocator; 198 if (SL_IODEVICE_AUDIOINPUT != dl_iod->deviceType) { 199 SL_LOGE(ERROR_RECORDER_IODEVICE_MUST_BE_AUDIOINPUT); 200 return SL_RESULT_PARAMETER_INVALID; 201 } 202 203 // check it's the default input device, others aren't supported here 204 if (SL_DEFAULTDEVICEID_AUDIOINPUT != dl_iod->deviceID) { 205 SL_LOGE(ERROR_RECORDER_INPUT_ID_MUST_BE_DEFAULT); 206 return SL_RESULT_PARAMETER_INVALID; 207 } 208 } 209 210 return SL_RESULT_SUCCESS; 211} 212//----------------------------------------------------------------------------- 213static void audioRecorder_callback(int event, void* user, void *info) { 214 //SL_LOGV("audioRecorder_callback(%d, %p, %p) entering", event, user, info); 215 216 CAudioRecorder *ar = (CAudioRecorder *)user; 217 218 if (!android::CallbackProtector::enterCbIfOk(ar->mCallbackProtector)) { 219 // it is not safe to enter the callback (the track is about to go away) 220 return; 221 } 222 223 void * callbackPContext = NULL; 224 225 switch(event) { 226 case android::AudioRecord::EVENT_MORE_DATA: { 227 slBufferQueueCallback callback = NULL; 228 android::AudioRecord::Buffer* pBuff = (android::AudioRecord::Buffer*)info; 229 230 // push data to the buffer queue 231 interface_lock_exclusive(&ar->mBufferQueue); 232 233 if (ar->mBufferQueue.mState.count != 0) { 234 assert(ar->mBufferQueue.mFront != ar->mBufferQueue.mRear); 235 236 BufferHeader *oldFront = ar->mBufferQueue.mFront; 237 BufferHeader *newFront = &oldFront[1]; 238 239 // FIXME handle 8bit based on buffer format 240 short *pDest = (short*)((char *)oldFront->mBuffer + ar->mBufferQueue.mSizeConsumed); 241 if (ar->mBufferQueue.mSizeConsumed + pBuff->size < oldFront->mSize) { 242 // can't consume the whole or rest of the buffer in one shot 243 ar->mBufferQueue.mSizeConsumed += pBuff->size; 244 // leave pBuff->size untouched 245 // consume data 246 // FIXME can we avoid holding the lock during the copy? 247 memcpy (pDest, pBuff->i16, pBuff->size); 248#ifdef MONITOR_RECORDING 249 if (NULL != gMonitorFp) { fwrite(pBuff->i16, pBuff->size, 1, gMonitorFp); } 250#endif 251 } else { 252 // finish pushing the buffer or push the buffer in one shot 253 pBuff->size = oldFront->mSize - ar->mBufferQueue.mSizeConsumed; 254 ar->mBufferQueue.mSizeConsumed = 0; 255 if (newFront == &ar->mBufferQueue.mArray[ar->mBufferQueue.mNumBuffers + 1]) { 256 newFront = ar->mBufferQueue.mArray; 257 } 258 ar->mBufferQueue.mFront = newFront; 259 260 ar->mBufferQueue.mState.count--; 261 ar->mBufferQueue.mState.playIndex++; 262 // consume data 263 // FIXME can we avoid holding the lock during the copy? 264 memcpy (pDest, pBuff->i16, pBuff->size); 265#ifdef MONITOR_RECORDING 266 if (NULL != gMonitorFp) { fwrite(pBuff->i16, pBuff->size, 1, gMonitorFp); } 267#endif 268 // data has been copied to the buffer, and the buffer queue state has been updated 269 // we will notify the client if applicable 270 callback = ar->mBufferQueue.mCallback; 271 // save callback data 272 callbackPContext = ar->mBufferQueue.mContext; 273 } 274 } else { 275 // no destination to push the data 276 pBuff->size = 0; 277 } 278 279 interface_unlock_exclusive(&ar->mBufferQueue); 280 // notify client 281 if (NULL != callback) { 282 (*callback)(&ar->mBufferQueue.mItf, callbackPContext); 283 } 284 } 285 break; 286 287 case android::AudioRecord::EVENT_OVERRUN: 288 audioRecorder_handleOverrun_lockRecord(ar); 289 break; 290 291 case android::AudioRecord::EVENT_MARKER: 292 audioRecorder_handleMarker_lockRecord(ar); 293 break; 294 295 case android::AudioRecord::EVENT_NEW_POS: 296 audioRecorder_handleNewPos_lockRecord(ar); 297 break; 298 299 case android::AudioRecord::EVENT_NEW_IAUDIORECORD: 300 // ignore for now 301 break; 302 303 default: 304 SL_LOGE("Encountered unknown AudioRecord event %d for CAudioRecord %p", event, ar); 305 break; 306 } 307 308 ar->mCallbackProtector->exitCb(); 309} 310 311 312//----------------------------------------------------------------------------- 313SLresult android_audioRecorder_create(CAudioRecorder* ar) { 314 SL_LOGV("android_audioRecorder_create(%p) entering", ar); 315 316 const SLDataSource *pAudioSrc = &ar->mDataSource.u.mSource; 317 const SLDataSink *pAudioSnk = &ar->mDataSink.u.mSink; 318 SLresult result = SL_RESULT_SUCCESS; 319 320 const SLuint32 sourceLocatorType = *(SLuint32 *)pAudioSrc->pLocator; 321 const SLuint32 sinkLocatorType = *(SLuint32 *)pAudioSnk->pLocator; 322 323 // the following platform-independent fields have been initialized in CreateAudioRecorder() 324 // ar->mNumChannels 325 // ar->mSampleRateMilliHz 326 327 if ((SL_DATALOCATOR_IODEVICE == sourceLocatorType) && 328 (SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE == sinkLocatorType)) { 329 // microphone to simple buffer queue 330 ar->mAndroidObjType = AUDIORECORDER_FROM_MIC_TO_PCM_BUFFERQUEUE; 331 ar->mAudioRecord.clear(); 332 ar->mCallbackProtector = new android::CallbackProtector(); 333 ar->mRecordSource = AUDIO_SOURCE_DEFAULT; 334 } else { 335 result = SL_RESULT_CONTENT_UNSUPPORTED; 336 } 337 338 return result; 339} 340 341 342//----------------------------------------------------------------------------- 343SLresult android_audioRecorder_setConfig(CAudioRecorder* ar, const SLchar *configKey, 344 const void *pConfigValue, SLuint32 valueSize) { 345 346 SLresult result; 347 348 assert(NULL != ar && NULL != configKey && NULL != pConfigValue); 349 if (strcmp((const char*)configKey, (const char*)SL_ANDROID_KEY_RECORDING_PRESET) == 0) { 350 351 // recording preset 352 if (KEY_RECORDING_PRESET_PARAMSIZE > valueSize) { 353 SL_LOGE(ERROR_CONFIG_VALUESIZE_TOO_LOW); 354 result = SL_RESULT_BUFFER_INSUFFICIENT; 355 } else { 356 result = audioRecorder_setPreset(ar, *(SLuint32*)pConfigValue); 357 } 358 359 } else { 360 SL_LOGE(ERROR_CONFIG_UNKNOWN_KEY); 361 result = SL_RESULT_PARAMETER_INVALID; 362 } 363 364 return result; 365} 366 367 368//----------------------------------------------------------------------------- 369SLresult android_audioRecorder_getConfig(CAudioRecorder* ar, const SLchar *configKey, 370 SLuint32* pValueSize, void *pConfigValue) { 371 372 SLresult result; 373 374 assert(NULL != ar && NULL != configKey && NULL != pValueSize); 375 if (strcmp((const char*)configKey, (const char*)SL_ANDROID_KEY_RECORDING_PRESET) == 0) { 376 377 // recording preset 378 if (NULL == pConfigValue) { 379 result = SL_RESULT_SUCCESS; 380 } else if (KEY_RECORDING_PRESET_PARAMSIZE > *pValueSize) { 381 SL_LOGE(ERROR_CONFIG_VALUESIZE_TOO_LOW); 382 result = SL_RESULT_BUFFER_INSUFFICIENT; 383 } else { 384 result = audioRecorder_getPreset(ar, (SLuint32*)pConfigValue); 385 } 386 *pValueSize = KEY_RECORDING_PRESET_PARAMSIZE; 387 388 } else { 389 SL_LOGE(ERROR_CONFIG_UNKNOWN_KEY); 390 result = SL_RESULT_PARAMETER_INVALID; 391 } 392 393 return result; 394} 395 396 397//----------------------------------------------------------------------------- 398SLresult android_audioRecorder_realize(CAudioRecorder* ar, SLboolean async) { 399 SL_LOGV("android_audioRecorder_realize(%p) entering", ar); 400 401 SLresult result = SL_RESULT_SUCCESS; 402 403 // initialize platform-independent CAudioRecorder fields 404 if (SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE != ar->mDataSink.mLocator.mLocatorType) { 405 SL_LOGE(ERROR_RECORDER_SINK_MUST_BE_ANDROIDSIMPLEBUFFERQUEUE); 406 return SL_RESULT_CONTENT_UNSUPPORTED; 407 } 408 // the following platform-independent fields have been initialized in CreateAudioRecorder() 409 // ar->mNumChannels 410 // ar->mSampleRateMilliHz 411 412 SL_LOGV("new AudioRecord %u channels, %u mHz", ar->mNumChannels, ar->mSampleRateMilliHz); 413 414 // currently nothing analogous to canUseFastTrack() for recording 415 audio_input_flags_t policy = AUDIO_INPUT_FLAG_FAST; 416 417 // initialize platform-specific CAudioRecorder fields 418 ar->mAudioRecord = new android::AudioRecord(android::String16()); 419 android::status_t status = ar->mAudioRecord->set( 420 ar->mRecordSource, // source 421 sles_to_android_sampleRate(ar->mSampleRateMilliHz), // sample rate in Hertz 422 AUDIO_FORMAT_PCM_16_BIT, //FIXME use format from buffer queue sink 423 sles_to_android_channelMaskIn(ar->mNumChannels, 0 /*no channel mask*/), 424 // channel config 425 0, //frameCount min 426 audioRecorder_callback,// callback_t 427 (void*)ar, // user, callback data, here the AudioRecorder 428 0, // notificationFrames 429 false, // threadCanCallJava, note: this will prevent direct Java 430 // callbacks, but we don't want them in the recording loop 431 0, // session ID 432 android::AudioRecord::TRANSFER_CALLBACK, 433 // transfer type 434 policy); // audio_input_flags_t 435 436 if (android::NO_ERROR != status) { 437 SL_LOGE("android_audioRecorder_realize(%p) error creating AudioRecord object; status %d", 438 ar, status); 439 // FIXME should return a more specific result depending on status 440 result = SL_RESULT_CONTENT_UNSUPPORTED; 441 ar->mAudioRecord.clear(); 442 } 443 444#ifdef MONITOR_RECORDING 445 gMonitorFp = fopen(MONITOR_TARGET, "w"); 446 if (NULL == gMonitorFp) { SL_LOGE("error opening %s", MONITOR_TARGET); } 447 else { SL_LOGE("recording to %s", MONITOR_TARGET); } // SL_LOGE so it's always displayed 448#endif 449 450 return result; 451} 452 453 454//----------------------------------------------------------------------------- 455/** 456 * Called with a lock on AudioRecorder, and blocks until safe to destroy 457 */ 458void android_audioRecorder_preDestroy(CAudioRecorder* ar) { 459 object_unlock_exclusive(&ar->mObject); 460 if (ar->mCallbackProtector != 0) { 461 ar->mCallbackProtector->requestCbExitAndWait(); 462 } 463 object_lock_exclusive(&ar->mObject); 464} 465 466 467//----------------------------------------------------------------------------- 468void android_audioRecorder_destroy(CAudioRecorder* ar) { 469 SL_LOGV("android_audioRecorder_destroy(%p) entering", ar); 470 471 if (ar->mAudioRecord != 0) { 472 ar->mAudioRecord->stop(); 473 ar->mAudioRecord.clear(); 474 } 475 // explicit destructor 476 ar->mAudioRecord.~sp(); 477 ar->mCallbackProtector.~sp(); 478 479#ifdef MONITOR_RECORDING 480 if (NULL != gMonitorFp) { 481 fclose(gMonitorFp); 482 gMonitorFp = NULL; 483 } 484#endif 485} 486 487 488//----------------------------------------------------------------------------- 489void android_audioRecorder_setRecordState(CAudioRecorder* ar, SLuint32 state) { 490 SL_LOGV("android_audioRecorder_setRecordState(%p, %u) entering", ar, state); 491 492 if (ar->mAudioRecord == 0) { 493 return; 494 } 495 496 switch (state) { 497 case SL_RECORDSTATE_STOPPED: 498 ar->mAudioRecord->stop(); 499 break; 500 case SL_RECORDSTATE_PAUSED: 501 // Note that pausing is treated like stop as this implementation only records to a buffer 502 // queue, so there is no notion of destination being "opened" or "closed" (See description 503 // of SL_RECORDSTATE in specification) 504 ar->mAudioRecord->stop(); 505 break; 506 case SL_RECORDSTATE_RECORDING: 507 ar->mAudioRecord->start(); 508 break; 509 default: 510 break; 511 } 512 513} 514 515 516//----------------------------------------------------------------------------- 517void android_audioRecorder_useRecordEventMask(CAudioRecorder *ar) { 518 IRecord *pRecordItf = &ar->mRecord; 519 SLuint32 eventFlags = pRecordItf->mCallbackEventsMask; 520 521 if (ar->mAudioRecord == 0) { 522 return; 523 } 524 525 if ((eventFlags & SL_RECORDEVENT_HEADATMARKER) && (pRecordItf->mMarkerPosition != 0)) { 526 ar->mAudioRecord->setMarkerPosition((uint32_t)((((int64_t)pRecordItf->mMarkerPosition 527 * sles_to_android_sampleRate(ar->mSampleRateMilliHz)))/1000)); 528 } else { 529 // clear marker 530 ar->mAudioRecord->setMarkerPosition(0); 531 } 532 533 if (eventFlags & SL_RECORDEVENT_HEADATNEWPOS) { 534 SL_LOGV("pos update period %d", pRecordItf->mPositionUpdatePeriod); 535 ar->mAudioRecord->setPositionUpdatePeriod( 536 (uint32_t)((((int64_t)pRecordItf->mPositionUpdatePeriod 537 * sles_to_android_sampleRate(ar->mSampleRateMilliHz)))/1000)); 538 } else { 539 // clear periodic update 540 ar->mAudioRecord->setPositionUpdatePeriod(0); 541 } 542 543 if (eventFlags & SL_RECORDEVENT_HEADATLIMIT) { 544 // FIXME support SL_RECORDEVENT_HEADATLIMIT 545 SL_LOGD("[ FIXME: IRecord_SetCallbackEventsMask(SL_RECORDEVENT_HEADATLIMIT) on an " 546 "SL_OBJECTID_AUDIORECORDER to be implemented ]"); 547 } 548 549 if (eventFlags & SL_RECORDEVENT_HEADMOVING) { 550 // FIXME support SL_RECORDEVENT_HEADMOVING 551 SL_LOGD("[ FIXME: IRecord_SetCallbackEventsMask(SL_RECORDEVENT_HEADMOVING) on an " 552 "SL_OBJECTID_AUDIORECORDER to be implemented ]"); 553 } 554 555 if (eventFlags & SL_RECORDEVENT_BUFFER_FULL) { 556 // nothing to do for SL_RECORDEVENT_BUFFER_FULL since this will not be encountered on 557 // recording to buffer queues 558 } 559 560 if (eventFlags & SL_RECORDEVENT_HEADSTALLED) { 561 // nothing to do for SL_RECORDEVENT_HEADSTALLED, callback event will be checked against mask 562 // when AudioRecord::EVENT_OVERRUN is encountered 563 564 } 565 566} 567 568 569//----------------------------------------------------------------------------- 570void android_audioRecorder_getPosition(CAudioRecorder *ar, SLmillisecond *pPosMsec) { 571 if ((NULL == ar) || (ar->mAudioRecord == 0)) { 572 *pPosMsec = 0; 573 } else { 574 uint32_t positionInFrames; 575 ar->mAudioRecord->getPosition(&positionInFrames); 576 if (ar->mSampleRateMilliHz == UNKNOWN_SAMPLERATE) { 577 *pPosMsec = 0; 578 } else { 579 *pPosMsec = ((int64_t)positionInFrames * 1000) / 580 sles_to_android_sampleRate(ar->mSampleRateMilliHz); 581 } 582 } 583} 584