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