1 /* 2 * Copyright (C) 2012 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 //#define LOG_NDEBUG 0 18 #define LOG_TAG "SoftAAC2" 19 #include <utils/Log.h> 20 21 #include "SoftAAC2.h" 22 #include <OMX_AudioExt.h> 23 #include <OMX_IndexExt.h> 24 25 #include <cutils/properties.h> 26 #include <media/stagefright/foundation/ADebug.h> 27 #include <media/stagefright/foundation/hexdump.h> 28 #include <media/stagefright/MediaErrors.h> 29 30 #include <math.h> 31 32 #define FILEREAD_MAX_LAYERS 2 33 34 #define DRC_DEFAULT_MOBILE_REF_LEVEL 64 /* 64*-0.25dB = -16 dB below full scale for mobile conf */ 35 #define DRC_DEFAULT_MOBILE_DRC_CUT 127 /* maximum compression of dynamic range for mobile conf */ 36 #define DRC_DEFAULT_MOBILE_DRC_BOOST 127 /* maximum compression of dynamic range for mobile conf */ 37 #define DRC_DEFAULT_MOBILE_DRC_HEAVY 1 /* switch for heavy compression for mobile conf */ 38 #define DRC_DEFAULT_MOBILE_ENC_LEVEL -1 /* encoder target level; -1 => the value is unknown, otherwise dB step value (e.g. 64 for -16 dB) */ 39 #define MAX_CHANNEL_COUNT 8 /* maximum number of audio channels that can be decoded */ 40 // names of properties that can be used to override the default DRC settings 41 #define PROP_DRC_OVERRIDE_REF_LEVEL "aac_drc_reference_level" 42 #define PROP_DRC_OVERRIDE_CUT "aac_drc_cut" 43 #define PROP_DRC_OVERRIDE_BOOST "aac_drc_boost" 44 #define PROP_DRC_OVERRIDE_HEAVY "aac_drc_heavy" 45 #define PROP_DRC_OVERRIDE_ENC_LEVEL "aac_drc_enc_target_level" 46 47 namespace android { 48 49 template<class T> 50 static void InitOMXParams(T *params) { 51 params->nSize = sizeof(T); 52 params->nVersion.s.nVersionMajor = 1; 53 params->nVersion.s.nVersionMinor = 0; 54 params->nVersion.s.nRevision = 0; 55 params->nVersion.s.nStep = 0; 56 } 57 58 SoftAAC2::SoftAAC2( 59 const char *name, 60 const OMX_CALLBACKTYPE *callbacks, 61 OMX_PTR appData, 62 OMX_COMPONENTTYPE **component) 63 : SimpleSoftOMXComponent(name, callbacks, appData, component), 64 mAACDecoder(NULL), 65 mStreamInfo(NULL), 66 mIsADTS(false), 67 mInputBufferCount(0), 68 mOutputBufferCount(0), 69 mSignalledError(false), 70 mLastInHeader(NULL), 71 mOutputPortSettingsChange(NONE) { 72 initPorts(); 73 CHECK_EQ(initDecoder(), (status_t)OK); 74 } 75 76 SoftAAC2::~SoftAAC2() { 77 aacDecoder_Close(mAACDecoder); 78 delete[] mOutputDelayRingBuffer; 79 } 80 81 void SoftAAC2::initPorts() { 82 OMX_PARAM_PORTDEFINITIONTYPE def; 83 InitOMXParams(&def); 84 85 def.nPortIndex = 0; 86 def.eDir = OMX_DirInput; 87 def.nBufferCountMin = kNumInputBuffers; 88 def.nBufferCountActual = def.nBufferCountMin; 89 def.nBufferSize = 8192; 90 def.bEnabled = OMX_TRUE; 91 def.bPopulated = OMX_FALSE; 92 def.eDomain = OMX_PortDomainAudio; 93 def.bBuffersContiguous = OMX_FALSE; 94 def.nBufferAlignment = 1; 95 96 def.format.audio.cMIMEType = const_cast<char *>("audio/aac"); 97 def.format.audio.pNativeRender = NULL; 98 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 99 def.format.audio.eEncoding = OMX_AUDIO_CodingAAC; 100 101 addPort(def); 102 103 def.nPortIndex = 1; 104 def.eDir = OMX_DirOutput; 105 def.nBufferCountMin = kNumOutputBuffers; 106 def.nBufferCountActual = def.nBufferCountMin; 107 def.nBufferSize = 4096 * MAX_CHANNEL_COUNT; 108 def.bEnabled = OMX_TRUE; 109 def.bPopulated = OMX_FALSE; 110 def.eDomain = OMX_PortDomainAudio; 111 def.bBuffersContiguous = OMX_FALSE; 112 def.nBufferAlignment = 2; 113 114 def.format.audio.cMIMEType = const_cast<char *>("audio/raw"); 115 def.format.audio.pNativeRender = NULL; 116 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 117 def.format.audio.eEncoding = OMX_AUDIO_CodingPCM; 118 119 addPort(def); 120 } 121 122 status_t SoftAAC2::initDecoder() { 123 ALOGV("initDecoder()"); 124 status_t status = UNKNOWN_ERROR; 125 mAACDecoder = aacDecoder_Open(TT_MP4_ADIF, /* num layers */ 1); 126 if (mAACDecoder != NULL) { 127 mStreamInfo = aacDecoder_GetStreamInfo(mAACDecoder); 128 if (mStreamInfo != NULL) { 129 status = OK; 130 } 131 } 132 133 mEndOfInput = false; 134 mEndOfOutput = false; 135 mOutputDelayCompensated = 0; 136 mOutputDelayRingBufferSize = 2048 * MAX_CHANNEL_COUNT * kNumDelayBlocksMax; 137 mOutputDelayRingBuffer = new short[mOutputDelayRingBufferSize]; 138 mOutputDelayRingBufferWritePos = 0; 139 mOutputDelayRingBufferReadPos = 0; 140 mOutputDelayRingBufferFilled = 0; 141 142 if (mAACDecoder == NULL) { 143 ALOGE("AAC decoder is null. TODO: Can not call aacDecoder_SetParam in the following code"); 144 } 145 146 //aacDecoder_SetParam(mAACDecoder, AAC_PCM_LIMITER_ENABLE, 0); 147 148 //init DRC wrapper 149 mDrcWrap.setDecoderHandle(mAACDecoder); 150 mDrcWrap.submitStreamData(mStreamInfo); 151 152 // for streams that contain metadata, use the mobile profile DRC settings unless overridden by platform properties 153 // TODO: change the DRC settings depending on audio output device type (HDMI, loadspeaker, headphone) 154 char value[PROPERTY_VALUE_MAX]; 155 // DRC_PRES_MODE_WRAP_DESIRED_TARGET 156 if (property_get(PROP_DRC_OVERRIDE_REF_LEVEL, value, NULL)) { 157 unsigned refLevel = atoi(value); 158 ALOGV("AAC decoder using desired DRC target reference level of %d instead of %d", refLevel, 159 DRC_DEFAULT_MOBILE_REF_LEVEL); 160 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_TARGET, refLevel); 161 } else { 162 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_TARGET, DRC_DEFAULT_MOBILE_REF_LEVEL); 163 } 164 // DRC_PRES_MODE_WRAP_DESIRED_ATT_FACTOR 165 if (property_get(PROP_DRC_OVERRIDE_CUT, value, NULL)) { 166 unsigned cut = atoi(value); 167 ALOGV("AAC decoder using desired DRC attenuation factor of %d instead of %d", cut, 168 DRC_DEFAULT_MOBILE_DRC_CUT); 169 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_ATT_FACTOR, cut); 170 } else { 171 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_ATT_FACTOR, DRC_DEFAULT_MOBILE_DRC_CUT); 172 } 173 // DRC_PRES_MODE_WRAP_DESIRED_BOOST_FACTOR 174 if (property_get(PROP_DRC_OVERRIDE_BOOST, value, NULL)) { 175 unsigned boost = atoi(value); 176 ALOGV("AAC decoder using desired DRC boost factor of %d instead of %d", boost, 177 DRC_DEFAULT_MOBILE_DRC_BOOST); 178 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_BOOST_FACTOR, boost); 179 } else { 180 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_BOOST_FACTOR, DRC_DEFAULT_MOBILE_DRC_BOOST); 181 } 182 // DRC_PRES_MODE_WRAP_DESIRED_HEAVY 183 if (property_get(PROP_DRC_OVERRIDE_HEAVY, value, NULL)) { 184 unsigned heavy = atoi(value); 185 ALOGV("AAC decoder using desried DRC heavy compression switch of %d instead of %d", heavy, 186 DRC_DEFAULT_MOBILE_DRC_HEAVY); 187 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_HEAVY, heavy); 188 } else { 189 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_HEAVY, DRC_DEFAULT_MOBILE_DRC_HEAVY); 190 } 191 // DRC_PRES_MODE_WRAP_ENCODER_TARGET 192 if (property_get(PROP_DRC_OVERRIDE_ENC_LEVEL, value, NULL)) { 193 unsigned encoderRefLevel = atoi(value); 194 ALOGV("AAC decoder using encoder-side DRC reference level of %d instead of %d", 195 encoderRefLevel, DRC_DEFAULT_MOBILE_ENC_LEVEL); 196 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_ENCODER_TARGET, encoderRefLevel); 197 } else { 198 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_ENCODER_TARGET, DRC_DEFAULT_MOBILE_ENC_LEVEL); 199 } 200 201 return status; 202 } 203 204 OMX_ERRORTYPE SoftAAC2::internalGetParameter( 205 OMX_INDEXTYPE index, OMX_PTR params) { 206 switch (index) { 207 case OMX_IndexParamAudioAac: 208 { 209 OMX_AUDIO_PARAM_AACPROFILETYPE *aacParams = 210 (OMX_AUDIO_PARAM_AACPROFILETYPE *)params; 211 212 if (aacParams->nPortIndex != 0) { 213 return OMX_ErrorUndefined; 214 } 215 216 aacParams->nBitRate = 0; 217 aacParams->nAudioBandWidth = 0; 218 aacParams->nAACtools = 0; 219 aacParams->nAACERtools = 0; 220 aacParams->eAACProfile = OMX_AUDIO_AACObjectMain; 221 222 aacParams->eAACStreamFormat = 223 mIsADTS 224 ? OMX_AUDIO_AACStreamFormatMP4ADTS 225 : OMX_AUDIO_AACStreamFormatMP4FF; 226 227 aacParams->eChannelMode = OMX_AUDIO_ChannelModeStereo; 228 229 if (!isConfigured()) { 230 aacParams->nChannels = 1; 231 aacParams->nSampleRate = 44100; 232 aacParams->nFrameLength = 0; 233 } else { 234 aacParams->nChannels = mStreamInfo->numChannels; 235 aacParams->nSampleRate = mStreamInfo->sampleRate; 236 aacParams->nFrameLength = mStreamInfo->frameSize; 237 } 238 239 return OMX_ErrorNone; 240 } 241 242 case OMX_IndexParamAudioPcm: 243 { 244 OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams = 245 (OMX_AUDIO_PARAM_PCMMODETYPE *)params; 246 247 if (pcmParams->nPortIndex != 1) { 248 return OMX_ErrorUndefined; 249 } 250 251 pcmParams->eNumData = OMX_NumericalDataSigned; 252 pcmParams->eEndian = OMX_EndianBig; 253 pcmParams->bInterleaved = OMX_TRUE; 254 pcmParams->nBitPerSample = 16; 255 pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear; 256 pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF; 257 pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF; 258 pcmParams->eChannelMapping[2] = OMX_AUDIO_ChannelCF; 259 pcmParams->eChannelMapping[3] = OMX_AUDIO_ChannelLFE; 260 pcmParams->eChannelMapping[4] = OMX_AUDIO_ChannelLS; 261 pcmParams->eChannelMapping[5] = OMX_AUDIO_ChannelRS; 262 263 if (!isConfigured()) { 264 pcmParams->nChannels = 1; 265 pcmParams->nSamplingRate = 44100; 266 } else { 267 pcmParams->nChannels = mStreamInfo->numChannels; 268 pcmParams->nSamplingRate = mStreamInfo->sampleRate; 269 } 270 271 return OMX_ErrorNone; 272 } 273 274 default: 275 return SimpleSoftOMXComponent::internalGetParameter(index, params); 276 } 277 } 278 279 OMX_ERRORTYPE SoftAAC2::internalSetParameter( 280 OMX_INDEXTYPE index, const OMX_PTR params) { 281 switch ((int)index) { 282 case OMX_IndexParamStandardComponentRole: 283 { 284 const OMX_PARAM_COMPONENTROLETYPE *roleParams = 285 (const OMX_PARAM_COMPONENTROLETYPE *)params; 286 287 if (strncmp((const char *)roleParams->cRole, 288 "audio_decoder.aac", 289 OMX_MAX_STRINGNAME_SIZE - 1)) { 290 return OMX_ErrorUndefined; 291 } 292 293 return OMX_ErrorNone; 294 } 295 296 case OMX_IndexParamAudioAac: 297 { 298 const OMX_AUDIO_PARAM_AACPROFILETYPE *aacParams = 299 (const OMX_AUDIO_PARAM_AACPROFILETYPE *)params; 300 301 if (aacParams->nPortIndex != 0) { 302 return OMX_ErrorUndefined; 303 } 304 305 if (aacParams->eAACStreamFormat == OMX_AUDIO_AACStreamFormatMP4FF) { 306 mIsADTS = false; 307 } else if (aacParams->eAACStreamFormat 308 == OMX_AUDIO_AACStreamFormatMP4ADTS) { 309 mIsADTS = true; 310 } else { 311 return OMX_ErrorUndefined; 312 } 313 314 return OMX_ErrorNone; 315 } 316 317 case OMX_IndexParamAudioAndroidAacPresentation: 318 { 319 const OMX_AUDIO_PARAM_ANDROID_AACPRESENTATIONTYPE *aacPresParams = 320 (const OMX_AUDIO_PARAM_ANDROID_AACPRESENTATIONTYPE *)params; 321 // for the following parameters of the OMX_AUDIO_PARAM_AACPROFILETYPE structure, 322 // a value of -1 implies the parameter is not set by the application: 323 // nMaxOutputChannels uses default platform properties, see configureDownmix() 324 // nDrcCut uses default platform properties, see initDecoder() 325 // nDrcBoost idem 326 // nHeavyCompression idem 327 // nTargetReferenceLevel idem 328 // nEncodedTargetLevel idem 329 if (aacPresParams->nMaxOutputChannels >= 0) { 330 int max; 331 if (aacPresParams->nMaxOutputChannels >= 8) { max = 8; } 332 else if (aacPresParams->nMaxOutputChannels >= 6) { max = 6; } 333 else if (aacPresParams->nMaxOutputChannels >= 2) { max = 2; } 334 else { 335 // -1 or 0: disable downmix, 1: mono 336 max = aacPresParams->nMaxOutputChannels; 337 } 338 ALOGV("set nMaxOutputChannels=%d", max); 339 aacDecoder_SetParam(mAACDecoder, AAC_PCM_MAX_OUTPUT_CHANNELS, max); 340 } 341 bool updateDrcWrapper = false; 342 if (aacPresParams->nDrcBoost >= 0) { 343 ALOGV("set nDrcBoost=%d", aacPresParams->nDrcBoost); 344 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_BOOST_FACTOR, 345 aacPresParams->nDrcBoost); 346 updateDrcWrapper = true; 347 } 348 if (aacPresParams->nDrcCut >= 0) { 349 ALOGV("set nDrcCut=%d", aacPresParams->nDrcCut); 350 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_ATT_FACTOR, aacPresParams->nDrcCut); 351 updateDrcWrapper = true; 352 } 353 if (aacPresParams->nHeavyCompression >= 0) { 354 ALOGV("set nHeavyCompression=%d", aacPresParams->nHeavyCompression); 355 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_HEAVY, 356 aacPresParams->nHeavyCompression); 357 updateDrcWrapper = true; 358 } 359 if (aacPresParams->nTargetReferenceLevel >= 0) { 360 ALOGV("set nTargetReferenceLevel=%d", aacPresParams->nTargetReferenceLevel); 361 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_DESIRED_TARGET, 362 aacPresParams->nTargetReferenceLevel); 363 updateDrcWrapper = true; 364 } 365 if (aacPresParams->nEncodedTargetLevel >= 0) { 366 ALOGV("set nEncodedTargetLevel=%d", aacPresParams->nEncodedTargetLevel); 367 mDrcWrap.setParam(DRC_PRES_MODE_WRAP_ENCODER_TARGET, 368 aacPresParams->nEncodedTargetLevel); 369 updateDrcWrapper = true; 370 } 371 if (aacPresParams->nPCMLimiterEnable >= 0) { 372 aacDecoder_SetParam(mAACDecoder, AAC_PCM_LIMITER_ENABLE, 373 (aacPresParams->nPCMLimiterEnable != 0)); 374 } 375 if (updateDrcWrapper) { 376 mDrcWrap.update(); 377 } 378 379 return OMX_ErrorNone; 380 } 381 382 case OMX_IndexParamAudioPcm: 383 { 384 const OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams = 385 (OMX_AUDIO_PARAM_PCMMODETYPE *)params; 386 387 if (pcmParams->nPortIndex != 1) { 388 return OMX_ErrorUndefined; 389 } 390 391 return OMX_ErrorNone; 392 } 393 394 default: 395 return SimpleSoftOMXComponent::internalSetParameter(index, params); 396 } 397 } 398 399 bool SoftAAC2::isConfigured() const { 400 return mInputBufferCount > 0; 401 } 402 403 void SoftAAC2::configureDownmix() const { 404 char value[PROPERTY_VALUE_MAX]; 405 if (!(property_get("media.aac_51_output_enabled", value, NULL) 406 && (!strcmp(value, "1") || !strcasecmp(value, "true")))) { 407 ALOGI("limiting to stereo output"); 408 aacDecoder_SetParam(mAACDecoder, AAC_PCM_MAX_OUTPUT_CHANNELS, 2); 409 // By default, the decoder creates a 5.1 channel downmix signal 410 // for seven and eight channel input streams. To enable 6.1 and 7.1 channel output 411 // use aacDecoder_SetParam(mAACDecoder, AAC_PCM_MAX_OUTPUT_CHANNELS, -1) 412 } 413 } 414 415 bool SoftAAC2::outputDelayRingBufferPutSamples(INT_PCM *samples, int32_t numSamples) { 416 if (numSamples == 0) { 417 return true; 418 } 419 if (outputDelayRingBufferSpaceLeft() < numSamples) { 420 ALOGE("RING BUFFER WOULD OVERFLOW"); 421 return false; 422 } 423 if (mOutputDelayRingBufferWritePos + numSamples <= mOutputDelayRingBufferSize 424 && (mOutputDelayRingBufferReadPos <= mOutputDelayRingBufferWritePos 425 || mOutputDelayRingBufferReadPos > mOutputDelayRingBufferWritePos + numSamples)) { 426 // faster memcopy loop without checks, if the preconditions allow this 427 for (int32_t i = 0; i < numSamples; i++) { 428 mOutputDelayRingBuffer[mOutputDelayRingBufferWritePos++] = samples[i]; 429 } 430 431 if (mOutputDelayRingBufferWritePos >= mOutputDelayRingBufferSize) { 432 mOutputDelayRingBufferWritePos -= mOutputDelayRingBufferSize; 433 } 434 } else { 435 ALOGV("slow SoftAAC2::outputDelayRingBufferPutSamples()"); 436 437 for (int32_t i = 0; i < numSamples; i++) { 438 mOutputDelayRingBuffer[mOutputDelayRingBufferWritePos] = samples[i]; 439 mOutputDelayRingBufferWritePos++; 440 if (mOutputDelayRingBufferWritePos >= mOutputDelayRingBufferSize) { 441 mOutputDelayRingBufferWritePos -= mOutputDelayRingBufferSize; 442 } 443 } 444 } 445 mOutputDelayRingBufferFilled += numSamples; 446 return true; 447 } 448 449 int32_t SoftAAC2::outputDelayRingBufferGetSamples(INT_PCM *samples, int32_t numSamples) { 450 451 if (numSamples > mOutputDelayRingBufferFilled) { 452 ALOGE("RING BUFFER WOULD UNDERRUN"); 453 return -1; 454 } 455 456 if (mOutputDelayRingBufferReadPos + numSamples <= mOutputDelayRingBufferSize 457 && (mOutputDelayRingBufferWritePos < mOutputDelayRingBufferReadPos 458 || mOutputDelayRingBufferWritePos >= mOutputDelayRingBufferReadPos + numSamples)) { 459 // faster memcopy loop without checks, if the preconditions allow this 460 if (samples != 0) { 461 for (int32_t i = 0; i < numSamples; i++) { 462 samples[i] = mOutputDelayRingBuffer[mOutputDelayRingBufferReadPos++]; 463 } 464 } else { 465 mOutputDelayRingBufferReadPos += numSamples; 466 } 467 if (mOutputDelayRingBufferReadPos >= mOutputDelayRingBufferSize) { 468 mOutputDelayRingBufferReadPos -= mOutputDelayRingBufferSize; 469 } 470 } else { 471 ALOGV("slow SoftAAC2::outputDelayRingBufferGetSamples()"); 472 473 for (int32_t i = 0; i < numSamples; i++) { 474 if (samples != 0) { 475 samples[i] = mOutputDelayRingBuffer[mOutputDelayRingBufferReadPos]; 476 } 477 mOutputDelayRingBufferReadPos++; 478 if (mOutputDelayRingBufferReadPos >= mOutputDelayRingBufferSize) { 479 mOutputDelayRingBufferReadPos -= mOutputDelayRingBufferSize; 480 } 481 } 482 } 483 mOutputDelayRingBufferFilled -= numSamples; 484 return numSamples; 485 } 486 487 int32_t SoftAAC2::outputDelayRingBufferSamplesAvailable() { 488 return mOutputDelayRingBufferFilled; 489 } 490 491 int32_t SoftAAC2::outputDelayRingBufferSpaceLeft() { 492 return mOutputDelayRingBufferSize - outputDelayRingBufferSamplesAvailable(); 493 } 494 495 496 void SoftAAC2::onQueueFilled(OMX_U32 /* portIndex */) { 497 if (mSignalledError || mOutputPortSettingsChange != NONE) { 498 return; 499 } 500 501 UCHAR* inBuffer[FILEREAD_MAX_LAYERS]; 502 UINT inBufferLength[FILEREAD_MAX_LAYERS] = {0}; 503 UINT bytesValid[FILEREAD_MAX_LAYERS] = {0}; 504 505 List<BufferInfo *> &inQueue = getPortQueue(0); 506 List<BufferInfo *> &outQueue = getPortQueue(1); 507 508 while ((!inQueue.empty() || mEndOfInput) && !outQueue.empty()) { 509 if (!inQueue.empty()) { 510 INT_PCM tmpOutBuffer[2048 * MAX_CHANNEL_COUNT]; 511 BufferInfo *inInfo = *inQueue.begin(); 512 OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader; 513 514 mEndOfInput = (inHeader->nFlags & OMX_BUFFERFLAG_EOS) != 0; 515 516 if (mInputBufferCount == 0 && !(inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) { 517 ALOGE("first buffer should have OMX_BUFFERFLAG_CODECCONFIG set"); 518 inHeader->nFlags |= OMX_BUFFERFLAG_CODECCONFIG; 519 } 520 if ((inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) != 0) { 521 BufferInfo *inInfo = *inQueue.begin(); 522 OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader; 523 524 inBuffer[0] = inHeader->pBuffer + inHeader->nOffset; 525 inBufferLength[0] = inHeader->nFilledLen; 526 527 AAC_DECODER_ERROR decoderErr = 528 aacDecoder_ConfigRaw(mAACDecoder, 529 inBuffer, 530 inBufferLength); 531 532 if (decoderErr != AAC_DEC_OK) { 533 ALOGW("aacDecoder_ConfigRaw decoderErr = 0x%4.4x", decoderErr); 534 mSignalledError = true; 535 notify(OMX_EventError, OMX_ErrorUndefined, decoderErr, NULL); 536 return; 537 } 538 539 mInputBufferCount++; 540 mOutputBufferCount++; // fake increase of outputBufferCount to keep the counters aligned 541 542 inInfo->mOwnedByUs = false; 543 inQueue.erase(inQueue.begin()); 544 mLastInHeader = NULL; 545 inInfo = NULL; 546 notifyEmptyBufferDone(inHeader); 547 inHeader = NULL; 548 549 configureDownmix(); 550 // Only send out port settings changed event if both sample rate 551 // and numChannels are valid. 552 if (mStreamInfo->sampleRate && mStreamInfo->numChannels) { 553 ALOGI("Initially configuring decoder: %d Hz, %d channels", 554 mStreamInfo->sampleRate, 555 mStreamInfo->numChannels); 556 557 notify(OMX_EventPortSettingsChanged, 1, 0, NULL); 558 mOutputPortSettingsChange = AWAITING_DISABLED; 559 } 560 return; 561 } 562 563 if (inHeader->nFilledLen == 0) { 564 inInfo->mOwnedByUs = false; 565 inQueue.erase(inQueue.begin()); 566 mLastInHeader = NULL; 567 inInfo = NULL; 568 notifyEmptyBufferDone(inHeader); 569 inHeader = NULL; 570 continue; 571 } 572 573 if (mIsADTS) { 574 size_t adtsHeaderSize = 0; 575 // skip 30 bits, aac_frame_length follows. 576 // ssssssss ssssiiip ppffffPc ccohCCll llllllll lll????? 577 578 const uint8_t *adtsHeader = inHeader->pBuffer + inHeader->nOffset; 579 580 bool signalError = false; 581 if (inHeader->nFilledLen < 7) { 582 ALOGE("Audio data too short to contain even the ADTS header. " 583 "Got %d bytes.", inHeader->nFilledLen); 584 hexdump(adtsHeader, inHeader->nFilledLen); 585 signalError = true; 586 } else { 587 bool protectionAbsent = (adtsHeader[1] & 1); 588 589 unsigned aac_frame_length = 590 ((adtsHeader[3] & 3) << 11) 591 | (adtsHeader[4] << 3) 592 | (adtsHeader[5] >> 5); 593 594 if (inHeader->nFilledLen < aac_frame_length) { 595 ALOGE("Not enough audio data for the complete frame. " 596 "Got %d bytes, frame size according to the ADTS " 597 "header is %u bytes.", 598 inHeader->nFilledLen, aac_frame_length); 599 hexdump(adtsHeader, inHeader->nFilledLen); 600 signalError = true; 601 } else { 602 adtsHeaderSize = (protectionAbsent ? 7 : 9); 603 604 inBuffer[0] = (UCHAR *)adtsHeader + adtsHeaderSize; 605 inBufferLength[0] = aac_frame_length - adtsHeaderSize; 606 607 inHeader->nOffset += adtsHeaderSize; 608 inHeader->nFilledLen -= adtsHeaderSize; 609 } 610 } 611 612 if (signalError) { 613 mSignalledError = true; 614 notify(OMX_EventError, OMX_ErrorStreamCorrupt, ERROR_MALFORMED, NULL); 615 return; 616 } 617 618 // insert buffer size and time stamp 619 mBufferSizes.add(inBufferLength[0]); 620 if (mLastInHeader != inHeader) { 621 mBufferTimestamps.add(inHeader->nTimeStamp); 622 mLastInHeader = inHeader; 623 } else { 624 int64_t currentTime = mBufferTimestamps.top(); 625 currentTime += mStreamInfo->aacSamplesPerFrame * 626 1000000ll / mStreamInfo->aacSampleRate; 627 mBufferTimestamps.add(currentTime); 628 } 629 } else { 630 inBuffer[0] = inHeader->pBuffer + inHeader->nOffset; 631 inBufferLength[0] = inHeader->nFilledLen; 632 mLastInHeader = inHeader; 633 mBufferTimestamps.add(inHeader->nTimeStamp); 634 mBufferSizes.add(inHeader->nFilledLen); 635 } 636 637 // Fill and decode 638 bytesValid[0] = inBufferLength[0]; 639 640 INT prevSampleRate = mStreamInfo->sampleRate; 641 INT prevNumChannels = mStreamInfo->numChannels; 642 643 aacDecoder_Fill(mAACDecoder, 644 inBuffer, 645 inBufferLength, 646 bytesValid); 647 648 // run DRC check 649 mDrcWrap.submitStreamData(mStreamInfo); 650 mDrcWrap.update(); 651 652 UINT inBufferUsedLength = inBufferLength[0] - bytesValid[0]; 653 inHeader->nFilledLen -= inBufferUsedLength; 654 inHeader->nOffset += inBufferUsedLength; 655 656 AAC_DECODER_ERROR decoderErr; 657 int numLoops = 0; 658 do { 659 if (outputDelayRingBufferSpaceLeft() < 660 (mStreamInfo->frameSize * mStreamInfo->numChannels)) { 661 ALOGV("skipping decode: not enough space left in ringbuffer"); 662 break; 663 } 664 665 int numConsumed = mStreamInfo->numTotalBytes; 666 decoderErr = aacDecoder_DecodeFrame(mAACDecoder, 667 tmpOutBuffer, 668 2048 * MAX_CHANNEL_COUNT, 669 0 /* flags */); 670 671 numConsumed = mStreamInfo->numTotalBytes - numConsumed; 672 numLoops++; 673 674 if (decoderErr == AAC_DEC_NOT_ENOUGH_BITS) { 675 break; 676 } 677 mDecodedSizes.add(numConsumed); 678 679 if (decoderErr != AAC_DEC_OK) { 680 ALOGW("aacDecoder_DecodeFrame decoderErr = 0x%4.4x", decoderErr); 681 } 682 683 if (bytesValid[0] != 0) { 684 ALOGE("bytesValid[0] != 0 should never happen"); 685 mSignalledError = true; 686 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 687 return; 688 } 689 690 size_t numOutBytes = 691 mStreamInfo->frameSize * sizeof(int16_t) * mStreamInfo->numChannels; 692 693 if (decoderErr == AAC_DEC_OK) { 694 if (!outputDelayRingBufferPutSamples(tmpOutBuffer, 695 mStreamInfo->frameSize * mStreamInfo->numChannels)) { 696 mSignalledError = true; 697 notify(OMX_EventError, OMX_ErrorUndefined, decoderErr, NULL); 698 return; 699 } 700 } else { 701 ALOGW("AAC decoder returned error 0x%4.4x, substituting silence", decoderErr); 702 703 memset(tmpOutBuffer, 0, numOutBytes); // TODO: check for overflow 704 705 if (!outputDelayRingBufferPutSamples(tmpOutBuffer, 706 mStreamInfo->frameSize * mStreamInfo->numChannels)) { 707 mSignalledError = true; 708 notify(OMX_EventError, OMX_ErrorUndefined, decoderErr, NULL); 709 return; 710 } 711 712 // Discard input buffer. 713 if (inHeader) { 714 inHeader->nFilledLen = 0; 715 } 716 717 aacDecoder_SetParam(mAACDecoder, AAC_TPDEC_CLEAR_BUFFER, 1); 718 719 // After an error, replace the last entry in mBufferSizes with the sum of the 720 // last <numLoops> entries from mDecodedSizes to resynchronize the in/out lists. 721 mBufferSizes.pop(); 722 int n = 0; 723 for (int i = 0; i < numLoops; i++) { 724 n += mDecodedSizes.itemAt(mDecodedSizes.size() - numLoops + i); 725 } 726 mBufferSizes.add(n); 727 728 // fall through 729 } 730 731 /* 732 * AAC+/eAAC+ streams can be signalled in two ways: either explicitly 733 * or implicitly, according to MPEG4 spec. AAC+/eAAC+ is a dual 734 * rate system and the sampling rate in the final output is actually 735 * doubled compared with the core AAC decoder sampling rate. 736 * 737 * Explicit signalling is done by explicitly defining SBR audio object 738 * type in the bitstream. Implicit signalling is done by embedding 739 * SBR content in AAC extension payload specific to SBR, and hence 740 * requires an AAC decoder to perform pre-checks on actual audio frames. 741 * 742 * Thus, we could not say for sure whether a stream is 743 * AAC+/eAAC+ until the first data frame is decoded. 744 */ 745 if (mInputBufferCount <= 2 || mOutputBufferCount > 1) { // TODO: <= 1 746 if (mStreamInfo->sampleRate != prevSampleRate || 747 mStreamInfo->numChannels != prevNumChannels) { 748 ALOGI("Reconfiguring decoder: %d->%d Hz, %d->%d channels", 749 prevSampleRate, mStreamInfo->sampleRate, 750 prevNumChannels, mStreamInfo->numChannels); 751 752 notify(OMX_EventPortSettingsChanged, 1, 0, NULL); 753 mOutputPortSettingsChange = AWAITING_DISABLED; 754 755 if (inHeader && inHeader->nFilledLen == 0) { 756 inInfo->mOwnedByUs = false; 757 mInputBufferCount++; 758 inQueue.erase(inQueue.begin()); 759 mLastInHeader = NULL; 760 inInfo = NULL; 761 notifyEmptyBufferDone(inHeader); 762 inHeader = NULL; 763 } 764 return; 765 } 766 } else if (!mStreamInfo->sampleRate || !mStreamInfo->numChannels) { 767 ALOGW("Invalid AAC stream"); 768 mSignalledError = true; 769 notify(OMX_EventError, OMX_ErrorUndefined, decoderErr, NULL); 770 return; 771 } 772 if (inHeader && inHeader->nFilledLen == 0) { 773 inInfo->mOwnedByUs = false; 774 mInputBufferCount++; 775 inQueue.erase(inQueue.begin()); 776 mLastInHeader = NULL; 777 inInfo = NULL; 778 notifyEmptyBufferDone(inHeader); 779 inHeader = NULL; 780 } else { 781 ALOGV("inHeader->nFilledLen = %d", inHeader ? inHeader->nFilledLen : 0); 782 } 783 } while (decoderErr == AAC_DEC_OK); 784 } 785 786 int32_t outputDelay = mStreamInfo->outputDelay * mStreamInfo->numChannels; 787 788 if (!mEndOfInput && mOutputDelayCompensated < outputDelay) { 789 // discard outputDelay at the beginning 790 int32_t toCompensate = outputDelay - mOutputDelayCompensated; 791 int32_t discard = outputDelayRingBufferSamplesAvailable(); 792 if (discard > toCompensate) { 793 discard = toCompensate; 794 } 795 int32_t discarded = outputDelayRingBufferGetSamples(0, discard); 796 mOutputDelayCompensated += discarded; 797 continue; 798 } 799 800 if (mEndOfInput) { 801 while (mOutputDelayCompensated > 0) { 802 // a buffer big enough for MAX_CHANNEL_COUNT channels of decoded HE-AAC 803 INT_PCM tmpOutBuffer[2048 * MAX_CHANNEL_COUNT]; 804 805 // run DRC check 806 mDrcWrap.submitStreamData(mStreamInfo); 807 mDrcWrap.update(); 808 809 AAC_DECODER_ERROR decoderErr = 810 aacDecoder_DecodeFrame(mAACDecoder, 811 tmpOutBuffer, 812 2048 * MAX_CHANNEL_COUNT, 813 AACDEC_FLUSH); 814 if (decoderErr != AAC_DEC_OK) { 815 ALOGW("aacDecoder_DecodeFrame decoderErr = 0x%4.4x", decoderErr); 816 } 817 818 int32_t tmpOutBufferSamples = mStreamInfo->frameSize * mStreamInfo->numChannels; 819 if (tmpOutBufferSamples > mOutputDelayCompensated) { 820 tmpOutBufferSamples = mOutputDelayCompensated; 821 } 822 outputDelayRingBufferPutSamples(tmpOutBuffer, tmpOutBufferSamples); 823 mOutputDelayCompensated -= tmpOutBufferSamples; 824 } 825 } 826 827 while (!outQueue.empty() 828 && outputDelayRingBufferSamplesAvailable() 829 >= mStreamInfo->frameSize * mStreamInfo->numChannels) { 830 BufferInfo *outInfo = *outQueue.begin(); 831 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 832 833 if (outHeader->nOffset != 0) { 834 ALOGE("outHeader->nOffset != 0 is not handled"); 835 mSignalledError = true; 836 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 837 return; 838 } 839 840 INT_PCM *outBuffer = 841 reinterpret_cast<INT_PCM *>(outHeader->pBuffer + outHeader->nOffset); 842 int samplesize = mStreamInfo->numChannels * sizeof(int16_t); 843 if (outHeader->nOffset 844 + mStreamInfo->frameSize * samplesize 845 > outHeader->nAllocLen) { 846 ALOGE("buffer overflow"); 847 mSignalledError = true; 848 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 849 return; 850 851 } 852 853 int available = outputDelayRingBufferSamplesAvailable(); 854 int numSamples = outHeader->nAllocLen / sizeof(int16_t); 855 if (numSamples > available) { 856 numSamples = available; 857 } 858 int64_t currentTime = 0; 859 if (available) { 860 861 int numFrames = numSamples / (mStreamInfo->frameSize * mStreamInfo->numChannels); 862 numSamples = numFrames * (mStreamInfo->frameSize * mStreamInfo->numChannels); 863 864 ALOGV("%d samples available (%d), or %d frames", 865 numSamples, available, numFrames); 866 int64_t *nextTimeStamp = &mBufferTimestamps.editItemAt(0); 867 currentTime = *nextTimeStamp; 868 int32_t *currentBufLeft = &mBufferSizes.editItemAt(0); 869 for (int i = 0; i < numFrames; i++) { 870 int32_t decodedSize = mDecodedSizes.itemAt(0); 871 mDecodedSizes.removeAt(0); 872 ALOGV("decoded %d of %d", decodedSize, *currentBufLeft); 873 if (*currentBufLeft > decodedSize) { 874 // adjust/interpolate next time stamp 875 *currentBufLeft -= decodedSize; 876 *nextTimeStamp += mStreamInfo->aacSamplesPerFrame * 877 1000000ll / mStreamInfo->aacSampleRate; 878 ALOGV("adjusted nextTimeStamp/size to %lld/%d", 879 (long long) *nextTimeStamp, *currentBufLeft); 880 } else { 881 // move to next timestamp in list 882 if (mBufferTimestamps.size() > 0) { 883 mBufferTimestamps.removeAt(0); 884 nextTimeStamp = &mBufferTimestamps.editItemAt(0); 885 mBufferSizes.removeAt(0); 886 currentBufLeft = &mBufferSizes.editItemAt(0); 887 ALOGV("moved to next time/size: %lld/%d", 888 (long long) *nextTimeStamp, *currentBufLeft); 889 } 890 // try to limit output buffer size to match input buffers 891 // (e.g when an input buffer contained 4 "sub" frames, output 892 // at most 4 decoded units in the corresponding output buffer) 893 // This is optional. Remove the next three lines to fill the output 894 // buffer with as many units as available. 895 numFrames = i + 1; 896 numSamples = numFrames * mStreamInfo->frameSize * mStreamInfo->numChannels; 897 break; 898 } 899 } 900 901 ALOGV("getting %d from ringbuffer", numSamples); 902 int32_t ns = outputDelayRingBufferGetSamples(outBuffer, numSamples); 903 if (ns != numSamples) { 904 ALOGE("not a complete frame of samples available"); 905 mSignalledError = true; 906 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 907 return; 908 } 909 } 910 911 outHeader->nFilledLen = numSamples * sizeof(int16_t); 912 913 if (mEndOfInput && !outQueue.empty() && outputDelayRingBufferSamplesAvailable() == 0) { 914 outHeader->nFlags = OMX_BUFFERFLAG_EOS; 915 mEndOfOutput = true; 916 } else { 917 outHeader->nFlags = 0; 918 } 919 920 outHeader->nTimeStamp = currentTime; 921 922 mOutputBufferCount++; 923 outInfo->mOwnedByUs = false; 924 outQueue.erase(outQueue.begin()); 925 outInfo = NULL; 926 ALOGV("out timestamp %lld / %d", outHeader->nTimeStamp, outHeader->nFilledLen); 927 notifyFillBufferDone(outHeader); 928 outHeader = NULL; 929 } 930 931 if (mEndOfInput) { 932 int ringBufAvail = outputDelayRingBufferSamplesAvailable(); 933 if (!outQueue.empty() 934 && ringBufAvail < mStreamInfo->frameSize * mStreamInfo->numChannels) { 935 if (!mEndOfOutput) { 936 // send partial or empty block signaling EOS 937 mEndOfOutput = true; 938 BufferInfo *outInfo = *outQueue.begin(); 939 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 940 941 INT_PCM *outBuffer = reinterpret_cast<INT_PCM *>(outHeader->pBuffer 942 + outHeader->nOffset); 943 int32_t ns = outputDelayRingBufferGetSamples(outBuffer, ringBufAvail); 944 if (ns < 0) { 945 ns = 0; 946 } 947 outHeader->nFilledLen = ns; 948 outHeader->nFlags = OMX_BUFFERFLAG_EOS; 949 950 outHeader->nTimeStamp = mBufferTimestamps.itemAt(0); 951 mBufferTimestamps.clear(); 952 mBufferSizes.clear(); 953 mDecodedSizes.clear(); 954 955 mOutputBufferCount++; 956 outInfo->mOwnedByUs = false; 957 outQueue.erase(outQueue.begin()); 958 outInfo = NULL; 959 notifyFillBufferDone(outHeader); 960 outHeader = NULL; 961 } 962 break; // if outQueue not empty but no more output 963 } 964 } 965 } 966 } 967 968 void SoftAAC2::onPortFlushCompleted(OMX_U32 portIndex) { 969 if (portIndex == 0) { 970 // Make sure that the next buffer output does not still 971 // depend on fragments from the last one decoded. 972 // drain all existing data 973 drainDecoder(); 974 mBufferTimestamps.clear(); 975 mBufferSizes.clear(); 976 mDecodedSizes.clear(); 977 mLastInHeader = NULL; 978 mEndOfInput = false; 979 } else { 980 int avail; 981 while ((avail = outputDelayRingBufferSamplesAvailable()) > 0) { 982 if (avail > mStreamInfo->frameSize * mStreamInfo->numChannels) { 983 avail = mStreamInfo->frameSize * mStreamInfo->numChannels; 984 } 985 int32_t ns = outputDelayRingBufferGetSamples(0, avail); 986 if (ns != avail) { 987 ALOGW("not a complete frame of samples available"); 988 break; 989 } 990 mOutputBufferCount++; 991 } 992 mOutputDelayRingBufferReadPos = mOutputDelayRingBufferWritePos; 993 mEndOfOutput = false; 994 } 995 } 996 997 void SoftAAC2::drainDecoder() { 998 // flush decoder until outputDelay is compensated 999 while (mOutputDelayCompensated > 0) { 1000 // a buffer big enough for MAX_CHANNEL_COUNT channels of decoded HE-AAC 1001 INT_PCM tmpOutBuffer[2048 * MAX_CHANNEL_COUNT]; 1002 1003 // run DRC check 1004 mDrcWrap.submitStreamData(mStreamInfo); 1005 mDrcWrap.update(); 1006 1007 AAC_DECODER_ERROR decoderErr = 1008 aacDecoder_DecodeFrame(mAACDecoder, 1009 tmpOutBuffer, 1010 2048 * MAX_CHANNEL_COUNT, 1011 AACDEC_FLUSH); 1012 if (decoderErr != AAC_DEC_OK) { 1013 ALOGW("aacDecoder_DecodeFrame decoderErr = 0x%4.4x", decoderErr); 1014 } 1015 1016 int32_t tmpOutBufferSamples = mStreamInfo->frameSize * mStreamInfo->numChannels; 1017 if (tmpOutBufferSamples > mOutputDelayCompensated) { 1018 tmpOutBufferSamples = mOutputDelayCompensated; 1019 } 1020 outputDelayRingBufferPutSamples(tmpOutBuffer, tmpOutBufferSamples); 1021 1022 mOutputDelayCompensated -= tmpOutBufferSamples; 1023 } 1024 } 1025 1026 void SoftAAC2::onReset() { 1027 drainDecoder(); 1028 // reset the "configured" state 1029 mInputBufferCount = 0; 1030 mOutputBufferCount = 0; 1031 mOutputDelayCompensated = 0; 1032 mOutputDelayRingBufferWritePos = 0; 1033 mOutputDelayRingBufferReadPos = 0; 1034 mOutputDelayRingBufferFilled = 0; 1035 mEndOfInput = false; 1036 mEndOfOutput = false; 1037 mBufferTimestamps.clear(); 1038 mBufferSizes.clear(); 1039 mDecodedSizes.clear(); 1040 mLastInHeader = NULL; 1041 1042 // To make the codec behave the same before and after a reset, we need to invalidate the 1043 // streaminfo struct. This does that: 1044 mStreamInfo->sampleRate = 0; // TODO: mStreamInfo is read only 1045 1046 mSignalledError = false; 1047 mOutputPortSettingsChange = NONE; 1048 } 1049 1050 void SoftAAC2::onPortEnableCompleted(OMX_U32 portIndex, bool enabled) { 1051 if (portIndex != 1) { 1052 return; 1053 } 1054 1055 switch (mOutputPortSettingsChange) { 1056 case NONE: 1057 break; 1058 1059 case AWAITING_DISABLED: 1060 { 1061 CHECK(!enabled); 1062 mOutputPortSettingsChange = AWAITING_ENABLED; 1063 break; 1064 } 1065 1066 default: 1067 { 1068 CHECK_EQ((int)mOutputPortSettingsChange, (int)AWAITING_ENABLED); 1069 CHECK(enabled); 1070 mOutputPortSettingsChange = NONE; 1071 break; 1072 } 1073 } 1074 } 1075 1076 } // namespace android 1077 1078 android::SoftOMXComponent *createSoftOMXComponent( 1079 const char *name, const OMX_CALLBACKTYPE *callbacks, 1080 OMX_PTR appData, OMX_COMPONENTTYPE **component) { 1081 return new android::SoftAAC2(name, callbacks, appData, component); 1082 } 1083