| /* ----------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten |
| Forschung e.V. All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software |
| that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding |
| scheme for digital audio. This FDK AAC Codec software is intended to be used on |
| a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient |
| general perceptual audio codecs. AAC-ELD is considered the best-performing |
| full-bandwidth communications codec by independent studies and is widely |
| deployed. AAC has been standardized by ISO and IEC as part of the MPEG |
| specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including |
| those of Fraunhofer) may be obtained through Via Licensing |
| (www.vialicensing.com) or through the respective patent owners individually for |
| the purpose of encoding or decoding bit streams in products that are compliant |
| with the ISO/IEC MPEG audio standards. Please note that most manufacturers of |
| Android devices already license these patent claims through Via Licensing or |
| directly from the patent owners, and therefore FDK AAC Codec software may |
| already be covered under those patent licenses when it is used for those |
| licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions |
| with enhanced sound quality, are also available from Fraunhofer. Users are |
| encouraged to check the Fraunhofer website for additional applications |
| information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted without payment of copyright license fees provided that you |
| satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of |
| the FDK AAC Codec or your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation |
| and/or other materials provided with redistributions of the FDK AAC Codec or |
| your modifications thereto in binary form. You must make available free of |
| charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived |
| from this library without prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute |
| the FDK AAC Codec software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating |
| that you changed the software and the date of any change. For modified versions |
| of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" |
| must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK |
| AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without |
| limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. |
| Fraunhofer provides no warranty of patent non-infringement with respect to this |
| software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for |
| purposes that are authorized by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright |
| holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, |
| including but not limited to the implied warranties of merchantability and |
| fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, |
| or consequential damages, including but not limited to procurement of substitute |
| goods or services; loss of use, data, or profits, or business interruption, |
| however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of |
| this software, even if advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------- */ |
| |
| /************************* MPEG-D DRC decoder library ************************** |
| |
| Author(s): |
| |
| Description: |
| |
| *******************************************************************************/ |
| |
| #include "drcDec_types.h" |
| #include "drcDec_gainDecoder.h" |
| #include "drcGainDec_process.h" |
| |
| #define E_TGAINSTEP 12 |
| |
| static DRC_ERROR _prepareLnbIndex(ACTIVE_DRC* pActiveDrc, |
| const int channelOffset, |
| const int drcChannelOffset, |
| const int numChannelsProcessed, |
| const int lnbPointer) { |
| int g, c; |
| DRC_INSTRUCTIONS_UNI_DRC* pInst = pActiveDrc->pInst; |
| |
| /* channelOffset: start index of physical channels |
| numChannelsProcessed: number of processed channels, physical channels and |
| DRC channels channelOffset + drcChannelOffset: start index of DRC channels, |
| i.e. the channel order referenced in pInst.sequenceIndex */ |
| |
| /* sanity checks */ |
| if ((channelOffset + numChannelsProcessed) > 8) return DE_NOT_OK; |
| |
| if ((channelOffset + drcChannelOffset + numChannelsProcessed) > 8) |
| return DE_NOT_OK; |
| |
| if ((channelOffset + drcChannelOffset) < 0) return DE_NOT_OK; |
| |
| /* prepare lnbIndexForChannel, a map of indices from each channel to its |
| * corresponding linearNodeBuffer instance */ |
| for (c = channelOffset; c < channelOffset + numChannelsProcessed; c++) { |
| if (pInst->drcSetId > 0) { |
| int drcChannel = c + drcChannelOffset; |
| /* fallback for configuration with more physical channels than DRC |
| channels: reuse DRC gain of first channel. This is necessary for HE-AAC |
| mono with stereo output */ |
| if (drcChannel >= pInst->drcChannelCount) drcChannel = 0; |
| g = pActiveDrc->channelGroupForChannel[drcChannel]; |
| if ((g >= 0) && !pActiveDrc->channelGroupIsParametricDrc[g]) { |
| pActiveDrc->lnbIndexForChannel[c][lnbPointer] = |
| pActiveDrc->activeDrcOffset + pActiveDrc->gainElementForGroup[g]; |
| } |
| } |
| } |
| |
| return DE_OK; |
| } |
| |
| static DRC_ERROR _interpolateDrcGain( |
| const GAIN_INTERPOLATION_TYPE gainInterpolationType, |
| const SHORT timePrev, /* time0 */ |
| const SHORT tGainStep, /* time1 - time0 */ |
| const SHORT start, const SHORT stop, const SHORT stepsize, |
| const FIXP_DBL gainLeft, const FIXP_DBL gainRight, const FIXP_DBL slopeLeft, |
| const FIXP_DBL slopeRight, FIXP_DBL* buffer) { |
| int n, n_buf; |
| int start_modulo, start_offset; |
| |
| if (tGainStep < 0) { |
| return DE_NOT_OK; |
| } |
| if (tGainStep == 0) { |
| return DE_OK; |
| } |
| |
| /* get start index offset and buffer index for downsampled interpolation */ |
| /* start_modulo = (start+timePrev)%stepsize; */ /* stepsize is a power of 2 */ |
| start_modulo = (start + timePrev) & (stepsize - 1); |
| start_offset = (start_modulo ? stepsize - start_modulo : 0); |
| /* n_buf = (start + timePrev + start_offset)/stepsize; */ |
| n_buf = (start + timePrev + start_offset) >> (15 - fixnormz_S(stepsize)); |
| |
| { /* gainInterpolationType == GIT_LINEAR */ |
| LONG a; |
| /* runs = ceil((stop - start - start_offset)/stepsize). This works for |
| * stepsize = 2^N only. */ |
| INT runs = (INT)(stop - start - start_offset + stepsize - 1) >> |
| (30 - CountLeadingBits(stepsize)); |
| INT n_min = fMin( |
| fMin(CntLeadingZeros(gainRight), CntLeadingZeros(gainLeft)) - 1, 8); |
| a = (LONG)((gainRight << n_min) - (gainLeft << n_min)) / tGainStep; |
| LONG a_step = a * stepsize; |
| n = start + start_offset; |
| a = a * n + (LONG)(gainLeft << n_min); |
| buffer += n_buf; |
| #if defined(FUNCTION_interpolateDrcGain_func1) |
| interpolateDrcGain_func1(buffer, a, a_step, n_min, runs); |
| #else |
| a -= a_step; |
| n_min = 8 - n_min; |
| for (int i = 0; i < runs; i++) { |
| a += a_step; |
| buffer[i] = fMultDiv2(buffer[i], (FIXP_DBL)a) << n_min; |
| } |
| #endif /* defined(FUNCTION_interpolateDrcGain_func1) */ |
| } |
| return DE_OK; |
| } |
| |
| static DRC_ERROR _processNodeSegments( |
| const int frameSize, const GAIN_INTERPOLATION_TYPE gainInterpolationType, |
| const int nNodes, const NODE_LIN* pNodeLin, const int offset, |
| const SHORT stepsize, |
| const NODE_LIN nodePrevious, /* the last node of the previous frame */ |
| const FIXP_DBL channelGain, FIXP_DBL* buffer) { |
| DRC_ERROR err = DE_OK; |
| SHORT timePrev, duration, start, stop, time; |
| int n; |
| FIXP_DBL gainLin = FL2FXCONST_DBL(1.0f / (float)(1 << 7)), gainLinPrev; |
| FIXP_DBL slopeLin = (FIXP_DBL)0, slopeLinPrev = (FIXP_DBL)0; |
| |
| timePrev = nodePrevious.time + offset; |
| gainLinPrev = nodePrevious.gainLin; |
| for (n = 0; n < nNodes; n++) { |
| time = pNodeLin[n].time + offset; |
| duration = time - timePrev; |
| gainLin = pNodeLin[n].gainLin; |
| if (channelGain != FL2FXCONST_DBL(1.0f / (float)(1 << 8))) |
| gainLin = |
| SATURATE_LEFT_SHIFT(fMultDiv2(gainLin, channelGain), 9, DFRACT_BITS); |
| |
| if ((timePrev >= (frameSize - 1)) || |
| (time < 0)) { /* This segment (between previous and current node) lies |
| outside of this audio frame */ |
| timePrev = time; |
| gainLinPrev = gainLin; |
| slopeLinPrev = slopeLin; |
| continue; |
| } |
| |
| /* start and stop are the boundaries of the region of this segment that lie |
| within this audio frame. Their values are relative to the beginning of |
| this segment. stop is the first sample that isn't processed any more. */ |
| start = fMax(-timePrev, 1); |
| stop = fMin(time, (SHORT)(frameSize - 1)) - timePrev + 1; |
| |
| err = _interpolateDrcGain(gainInterpolationType, timePrev, duration, start, |
| stop, stepsize, gainLinPrev, gainLin, |
| slopeLinPrev, slopeLin, buffer); |
| if (err) return err; |
| |
| timePrev = time; |
| gainLinPrev = gainLin; |
| } |
| return err; |
| } |
| |
| /* process DRC on time-domain signal */ |
| DRC_ERROR |
| processDrcTime(HANDLE_DRC_GAIN_DECODER hGainDec, const int activeDrcIndex, |
| const int delaySamples, const int channelOffset, |
| const int drcChannelOffset, const int numChannelsProcessed, |
| const int timeDataChannelOffset, FIXP_DBL* deinterleavedAudio) { |
| DRC_ERROR err = DE_OK; |
| int c, b, i; |
| ACTIVE_DRC* pActiveDrc = &(hGainDec->activeDrc[activeDrcIndex]); |
| DRC_GAIN_BUFFERS* pDrcGainBuffers = &(hGainDec->drcGainBuffers); |
| int lnbPointer = pDrcGainBuffers->lnbPointer, lnbIx; |
| LINEAR_NODE_BUFFER* pLinearNodeBuffer = pDrcGainBuffers->linearNodeBuffer; |
| LINEAR_NODE_BUFFER* pDummyLnb = &(pDrcGainBuffers->dummyLnb); |
| int offset = 0; |
| |
| if (hGainDec->delayMode == DM_REGULAR_DELAY) { |
| offset = hGainDec->frameSize; |
| } |
| |
| if ((delaySamples + offset) > |
| (NUM_LNB_FRAMES - 2) * |
| hGainDec->frameSize) /* if delaySamples is too big, NUM_LNB_FRAMES |
| should be increased */ |
| return DE_NOT_OK; |
| |
| err = _prepareLnbIndex(pActiveDrc, channelOffset, drcChannelOffset, |
| numChannelsProcessed, lnbPointer); |
| if (err) return err; |
| |
| deinterleavedAudio += |
| channelOffset * timeDataChannelOffset; /* apply channelOffset */ |
| |
| /* signal processing loop */ |
| for (c = channelOffset; c < channelOffset + numChannelsProcessed; c++) { |
| if (activeDrcIndex == hGainDec->channelGainActiveDrcIndex) |
| pDrcGainBuffers->channelGain[c][lnbPointer] = hGainDec->channelGain[c]; |
| |
| b = 0; |
| { |
| LINEAR_NODE_BUFFER *pLnb, *pLnbPrevious; |
| NODE_LIN nodePrevious; |
| int lnbPointerDiff; |
| FIXP_DBL channelGain; |
| /* get pointer to oldest linearNodes */ |
| lnbIx = lnbPointer + 1 - NUM_LNB_FRAMES; |
| while (lnbIx < 0) lnbIx += NUM_LNB_FRAMES; |
| |
| if (activeDrcIndex == hGainDec->channelGainActiveDrcIndex) |
| channelGain = pDrcGainBuffers->channelGain[c][lnbIx]; |
| else |
| channelGain = FL2FXCONST_DBL(1.0f / (float)(1 << 8)); |
| |
| /* Loop over all node buffers in linearNodeBuffer. |
| All nodes which are not relevant for the current frame are sorted out |
| inside _processNodeSegments. */ |
| for (i = 0; i < NUM_LNB_FRAMES - 1; i++) { |
| /* Prepare previous node */ |
| if (pActiveDrc->lnbIndexForChannel[c][lnbIx] >= 0) |
| pLnbPrevious = &( |
| pLinearNodeBuffer[pActiveDrc->lnbIndexForChannel[c][lnbIx] + b]); |
| else |
| pLnbPrevious = pDummyLnb; |
| nodePrevious = |
| pLnbPrevious->linearNode[lnbIx][pLnbPrevious->nNodes[lnbIx] - 1]; |
| nodePrevious.time -= hGainDec->frameSize; |
| if (channelGain != FL2FXCONST_DBL(1.0f / (float)(1 << 8))) |
| nodePrevious.gainLin = SATURATE_LEFT_SHIFT( |
| fMultDiv2(nodePrevious.gainLin, |
| pDrcGainBuffers->channelGain[c][lnbIx]), |
| 9, DFRACT_BITS); |
| |
| /* Prepare current linearNodeBuffer instance */ |
| lnbIx++; |
| if (lnbIx >= NUM_LNB_FRAMES) lnbIx = 0; |
| |
| /* if lnbIndexForChannel changes over time, use the old indices for |
| * smooth transitions */ |
| if (pActiveDrc->lnbIndexForChannel[c][lnbIx] >= 0) |
| pLnb = &( |
| pLinearNodeBuffer[pActiveDrc->lnbIndexForChannel[c][lnbIx] + b]); |
| else /* lnbIndexForChannel = -1 means "no DRC processing", due to |
| drcInstructionsIndex < 0, drcSetId < 0 or channel group < 0 */ |
| pLnb = pDummyLnb; |
| |
| if (activeDrcIndex == hGainDec->channelGainActiveDrcIndex) |
| channelGain = pDrcGainBuffers->channelGain[c][lnbIx]; |
| |
| /* number of frames of offset with respect to lnbPointer */ |
| lnbPointerDiff = i - (NUM_LNB_FRAMES - 2); |
| |
| err = _processNodeSegments( |
| hGainDec->frameSize, pLnb->gainInterpolationType, |
| pLnb->nNodes[lnbIx], pLnb->linearNode[lnbIx], |
| lnbPointerDiff * hGainDec->frameSize + delaySamples + offset, 1, |
| nodePrevious, channelGain, deinterleavedAudio); |
| if (err) return err; |
| } |
| deinterleavedAudio += timeDataChannelOffset; /* proceed to next channel */ |
| } |
| } |
| return DE_OK; |
| } |
| |
| /* process DRC on subband-domain signal */ |
| DRC_ERROR |
| processDrcSubband(HANDLE_DRC_GAIN_DECODER hGainDec, const int activeDrcIndex, |
| const int delaySamples, const int channelOffset, |
| const int drcChannelOffset, const int numChannelsProcessed, |
| const int processSingleTimeslot, |
| FIXP_DBL* deinterleavedAudioReal[], |
| FIXP_DBL* deinterleavedAudioImag[]) { |
| DRC_ERROR err = DE_OK; |
| int b, c, g, m, m_start, m_stop, s, i; |
| FIXP_DBL gainSb; |
| DRC_INSTRUCTIONS_UNI_DRC* pInst = hGainDec->activeDrc[activeDrcIndex].pInst; |
| DRC_GAIN_BUFFERS* pDrcGainBuffers = &(hGainDec->drcGainBuffers); |
| ACTIVE_DRC* pActiveDrc = &(hGainDec->activeDrc[activeDrcIndex]); |
| int activeDrcOffset = pActiveDrc->activeDrcOffset; |
| int lnbPointer = pDrcGainBuffers->lnbPointer, lnbIx; |
| LINEAR_NODE_BUFFER* pLinearNodeBuffer = pDrcGainBuffers->linearNodeBuffer; |
| FIXP_DBL(*subbandGains)[4 * 1024 / 256] = hGainDec->subbandGains; |
| FIXP_DBL* dummySubbandGains = hGainDec->dummySubbandGains; |
| SUBBAND_DOMAIN_MODE subbandDomainMode = hGainDec->subbandDomainSupported; |
| int signalIndex = 0; |
| int frameSizeSb = 0; |
| int nDecoderSubbands; |
| SHORT L = 0; /* L: downsampling factor */ |
| int offset = 0; |
| FIXP_DBL *audioReal = NULL, *audioImag = NULL; |
| |
| if (hGainDec->delayMode == DM_REGULAR_DELAY) { |
| offset = hGainDec->frameSize; |
| } |
| |
| if ((delaySamples + offset) > |
| (NUM_LNB_FRAMES - 2) * |
| hGainDec->frameSize) /* if delaySamples is too big, NUM_LNB_FRAMES |
| should be increased */ |
| return DE_NOT_OK; |
| |
| switch (subbandDomainMode) { |
| #if ((1024 / 256) >= (4096 / SUBBAND_DOWNSAMPLING_FACTOR_QMF64)) |
| case SDM_QMF64: |
| nDecoderSubbands = SUBBAND_NUM_BANDS_QMF64; |
| L = SUBBAND_DOWNSAMPLING_FACTOR_QMF64; |
| /* analysisDelay = SUBBAND_ANALYSIS_DELAY_QMF64; */ |
| break; |
| case SDM_QMF71: |
| nDecoderSubbands = SUBBAND_NUM_BANDS_QMF71; |
| L = SUBBAND_DOWNSAMPLING_FACTOR_QMF71; |
| /* analysisDelay = SUBBAND_ANALYSIS_DELAY_QMF71; */ |
| break; |
| #else |
| case SDM_QMF64: |
| case SDM_QMF71: |
| /* QMF domain processing is not supported. */ |
| return DE_NOT_OK; |
| #endif |
| case SDM_STFT256: |
| nDecoderSubbands = SUBBAND_NUM_BANDS_STFT256; |
| L = SUBBAND_DOWNSAMPLING_FACTOR_STFT256; |
| /* analysisDelay = SUBBAND_ANALYSIS_DELAY_STFT256; */ |
| break; |
| default: |
| return DE_NOT_OK; |
| } |
| |
| /* frameSizeSb = hGainDec->frameSize/L; */ /* L is a power of 2 */ |
| frameSizeSb = |
| hGainDec->frameSize >> (15 - fixnormz_S(L)); /* timeslots per frame */ |
| |
| if ((processSingleTimeslot < 0) || (processSingleTimeslot >= frameSizeSb)) { |
| m_start = 0; |
| m_stop = frameSizeSb; |
| } else { |
| m_start = processSingleTimeslot; |
| m_stop = m_start + 1; |
| } |
| |
| err = _prepareLnbIndex(pActiveDrc, channelOffset, drcChannelOffset, |
| numChannelsProcessed, lnbPointer); |
| if (err) return err; |
| |
| if (!pActiveDrc->subbandGainsReady) /* only for the first time per frame that |
| processDrcSubband is called */ |
| { |
| /* write subbandGains */ |
| for (g = 0; g < pInst->nDrcChannelGroups; g++) { |
| b = 0; |
| { |
| LINEAR_NODE_BUFFER* pLnb = |
| &(pLinearNodeBuffer[activeDrcOffset + |
| pActiveDrc->gainElementForGroup[g] + b]); |
| NODE_LIN nodePrevious; |
| int lnbPointerDiff; |
| |
| for (m = 0; m < frameSizeSb; m++) { |
| subbandGains[activeDrcOffset + g][b * frameSizeSb + m] = |
| FL2FXCONST_DBL(1.0f / (float)(1 << 7)); |
| } |
| |
| lnbIx = lnbPointer - (NUM_LNB_FRAMES - 1); |
| while (lnbIx < 0) lnbIx += NUM_LNB_FRAMES; |
| |
| /* Loop over all node buffers in linearNodeBuffer. |
| All nodes which are not relevant for the current frame are sorted out |
| inside _processNodeSegments. */ |
| for (i = 0; i < NUM_LNB_FRAMES - 1; i++) { |
| /* Prepare previous node */ |
| nodePrevious = pLnb->linearNode[lnbIx][pLnb->nNodes[lnbIx] - 1]; |
| nodePrevious.time -= hGainDec->frameSize; |
| |
| lnbIx++; |
| if (lnbIx >= NUM_LNB_FRAMES) lnbIx = 0; |
| |
| /* number of frames of offset with respect to lnbPointer */ |
| lnbPointerDiff = i - (NUM_LNB_FRAMES - 2); |
| |
| err = _processNodeSegments( |
| hGainDec->frameSize, pLnb->gainInterpolationType, |
| pLnb->nNodes[lnbIx], pLnb->linearNode[lnbIx], |
| lnbPointerDiff * hGainDec->frameSize + delaySamples + offset - |
| (L - 1) / 2, |
| L, nodePrevious, FL2FXCONST_DBL(1.0f / (float)(1 << 8)), |
| &(subbandGains[activeDrcOffset + g][b * frameSizeSb])); |
| if (err) return err; |
| } |
| } |
| } |
| pActiveDrc->subbandGainsReady = 1; |
| } |
| |
| for (c = channelOffset; c < channelOffset + numChannelsProcessed; c++) { |
| FIXP_DBL* thisSubbandGainsBuffer; |
| if (pInst->drcSetId > 0) |
| g = pActiveDrc->channelGroupForChannel[c + drcChannelOffset]; |
| else |
| g = -1; |
| |
| audioReal = deinterleavedAudioReal[signalIndex]; |
| if (subbandDomainMode != SDM_STFT256) { |
| audioImag = deinterleavedAudioImag[signalIndex]; |
| } |
| |
| if ((g >= 0) && !pActiveDrc->channelGroupIsParametricDrc[g]) { |
| thisSubbandGainsBuffer = subbandGains[activeDrcOffset + g]; |
| } else { |
| thisSubbandGainsBuffer = dummySubbandGains; |
| } |
| |
| for (m = m_start; m < m_stop; m++) { |
| INT n_min = 8; |
| { /* single-band DRC */ |
| gainSb = thisSubbandGainsBuffer[m]; |
| if (activeDrcIndex == hGainDec->channelGainActiveDrcIndex) |
| gainSb = SATURATE_LEFT_SHIFT( |
| fMultDiv2(gainSb, hGainDec->channelGain[c]), 9, DFRACT_BITS); |
| /* normalize gainSb for keeping signal precision */ |
| n_min = fMin(CntLeadingZeros(gainSb) - 1, n_min); |
| gainSb <<= n_min; |
| n_min = 8 - n_min; |
| if (subbandDomainMode == |
| SDM_STFT256) { /* For STFT filterbank, real and imaginary parts are |
| interleaved. */ |
| for (s = 0; s < nDecoderSubbands; s++) { |
| *audioReal = fMultDiv2(*audioReal, gainSb) << n_min; |
| audioReal++; |
| *audioReal = fMultDiv2(*audioReal, gainSb) << n_min; |
| audioReal++; |
| } |
| } else { |
| for (s = 0; s < nDecoderSubbands; s++) { |
| *audioReal = fMultDiv2(*audioReal, gainSb) << n_min; |
| audioReal++; |
| *audioImag = fMultDiv2(*audioImag, gainSb) << n_min; |
| audioImag++; |
| } |
| } |
| } |
| } |
| signalIndex++; |
| } |
| return DE_OK; |
| } |
