/* ----------------------------------------------------------------------------------------------------------- Software License for The Fraunhofer FDK AAC Codec Library for Android © Copyright 1995 - 2015 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 ----------------------------------------------------------------------------------------------------------- */ #include "fram_gen.h" #include "sbr_misc.h" #include "genericStds.h" static const SBR_FRAME_INFO frameInfo1_2048 = { 1, { 0, 16}, {FREQ_RES_HIGH}, 0, 1, {0, 16} }; static const SBR_FRAME_INFO frameInfo2_2048 = { 2, { 0, 8, 16}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 8, 16} }; static const SBR_FRAME_INFO frameInfo4_2048 = { 4, { 0, 4, 8, 12, 16}, {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 8, 16} }; static const SBR_FRAME_INFO frameInfo1_2304 = { 1, { 0, 18}, {FREQ_RES_HIGH}, 0, 1, { 0, 18} }; static const SBR_FRAME_INFO frameInfo2_2304 = { 2, { 0, 9, 18}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 9, 18} }; static const SBR_FRAME_INFO frameInfo4_2304 = { 4, { 0, 5, 9, 14, 18}, {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 9, 18} }; static const SBR_FRAME_INFO frameInfo1_1920 = { 1, { 0, 15}, {FREQ_RES_HIGH}, 0, 1, { 0, 15} }; static const SBR_FRAME_INFO frameInfo2_1920 = { 2, { 0, 8, 15}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 8, 15} }; static const SBR_FRAME_INFO frameInfo4_1920 = { 4, { 0, 4, 8, 12, 15}, {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 8, 15} }; static const SBR_FRAME_INFO frameInfo1_1152 = { 1, { 0, 9}, {FREQ_RES_HIGH}, 0, 1, { 0, 9} }; static const SBR_FRAME_INFO frameInfo2_1152 = { 2, { 0, 5, 9}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 5, 9} }; static const SBR_FRAME_INFO frameInfo4_1152 = { 4, { 0, 2, 5, 7, 9}, {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, { 0, 5, 9} }; /* AACLD frame info */ static const SBR_FRAME_INFO frameInfo1_512LD = { 1, {0, 8}, {FREQ_RES_HIGH}, 0, 1, {0, 8}}; static const SBR_FRAME_INFO frameInfo2_512LD = { 2, {0, 4, 8}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 4, 8}}; static const SBR_FRAME_INFO frameInfo4_512LD = { 4, {0, 2, 4, 6, 8}, {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 4, 8}}; static int calcFillLengthMax (int tranPos, /*!< input : transient position (ref: tran det) */ int numberTimeSlots /*!< input : number of timeslots */ ); static void fillFrameTran (const int *v_tuningSegm, /*!< tuning: desired segment lengths */ const int *v_tuningFreq, /*!< tuning: desired frequency resolutions */ int tran, /*!< input : position of transient */ int *v_bord, /*!< memNew: borders */ int *length_v_bord, /*!< memNew: # borders */ int *v_freq, /*!< memNew: frequency resolutions */ int *length_v_freq, /*!< memNew: # frequency resolutions */ int *bmin, /*!< hlpNew: first mandatory border */ int *bmax /*!< hlpNew: last mandatory border */ ); static void fillFramePre (INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT bmin, INT rest); static void fillFramePost (INT *parts, INT *d, INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT bmax, INT bufferFrameStart, INT numberTimeSlots, INT fmax); static void fillFrameInter (INT *nL, const int *v_tuningSegm, INT *v_bord, INT *length_v_bord, INT bmin, INT *v_freq, INT *length_v_freq, INT *v_bordFollow, INT *length_v_bordFollow, INT *v_freqFollow, INT *length_v_freqFollow, INT i_fillFollow, INT dmin, INT dmax, INT numberTimeSlots); static void calcFrameClass (FRAME_CLASS *frameClass, FRAME_CLASS *frameClassOld, INT tranFlag, INT *spreadFlag); static void specialCase (INT *spreadFlag, INT allowSpread, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT *parts, INT d); static void calcCmonBorder (INT *i_cmon, INT *i_tran, INT *v_bord, INT *length_v_bord, INT tran, INT bufferFrameStart, INT numberTimeSlots); static void keepForFollowUp (INT *v_bordFollow, INT *length_v_bordFollow, INT *v_freqFollow, INT *length_v_freqFollow, INT *i_tranFollow, INT *i_fillFollow, INT *v_bord, INT *length_v_bord, INT *v_freq, INT i_cmon, INT i_tran, INT parts, INT numberTimeSlots); static void calcCtrlSignal (HANDLE_SBR_GRID hSbrGrid, FRAME_CLASS frameClass, INT *v_bord, INT length_v_bord, INT *v_freq, INT length_v_freq, INT i_cmon, INT i_tran, INT spreadFlag, INT nL); static void ctrlSignal2FrameInfo (HANDLE_SBR_GRID hSbrGrid, HANDLE_SBR_FRAME_INFO hFrameInfo, FREQ_RES *freq_res_fixfix); /* table for 8 time slot index */ static const int envelopeTable_8 [8][5] = { /* transientIndex nEnv, tranIdx, shortEnv, border1, border2, ... */ /* borders from left to right side; -1 = not in use */ /*[|T-|------]*/ { 2, 0, 0, 1, -1 }, /*[|-T-|-----]*/ { 2, 0, 0, 2, -1 }, /*[--|T-|----]*/ { 3, 1, 1, 2, 4 }, /*[---|T-|---]*/ { 3, 1, 1, 3, 5 }, /*[----|T-|--]*/ { 3, 1, 1, 4, 6 }, /*[-----|T--|]*/ { 2, 1, 1, 5, -1 }, /*[------|T-|]*/ { 2, 1, 1, 6, -1 }, /*[-------|T|]*/ { 2, 1, 1, 7, -1 }, }; /* table for 16 time slot index */ static const int envelopeTable_16 [16][6] = { /* transientIndex nEnv, tranIdx, shortEnv, border1, border2, ... */ /* length from left to right side; -1 = not in use */ /*[|T---|------------|]*/ { 2, 0, 0, 4, -1, -1}, /*[|-T---|-----------|]*/ { 2, 0, 0, 5, -1, -1}, /*[|--|T---|----------]*/ { 3, 1, 1, 2, 6, -1}, /*[|---|T---|---------]*/ { 3, 1, 1, 3, 7, -1}, /*[|----|T---|--------]*/ { 3, 1, 1, 4, 8, -1}, /*[|-----|T---|-------]*/ { 3, 1, 1, 5, 9, -1}, /*[|------|T---|------]*/ { 3, 1, 1, 6, 10, -1}, /*[|-------|T---|-----]*/ { 3, 1, 1, 7, 11, -1}, /*[|--------|T---|----]*/ { 3, 1, 1, 8, 12, -1}, /*[|---------|T---|---]*/ { 3, 1, 1, 9, 13, -1}, /*[|----------|T---|--]*/ { 3, 1, 1,10, 14, -1}, /*[|-----------|T----|]*/ { 2, 1, 1,11, -1, -1}, /*[|------------|T---|]*/ { 2, 1, 1,12, -1, -1}, /*[|-------------|T--|]*/ { 2, 1, 1,13, -1, -1}, /*[|--------------|T-|]*/ { 2, 1, 1,14, -1, -1}, /*[|---------------|T|]*/ { 2, 1, 1,15, -1, -1}, }; /* table for 15 time slot index */ static const int envelopeTable_15 [15][6] = { /* transientIndex nEnv, tranIdx, shortEnv, border1, border2, ... */ /* length from left to right side; -1 = not in use */ /*[|T---|------------]*/ { 2, 0, 0, 4, -1, -1}, /*[|-T---|-----------]*/ { 2, 0, 0, 5, -1, -1}, /*[|--|T---|---------]*/ { 3, 1, 1, 2, 6, -1}, /*[|---|T---|--------]*/ { 3, 1, 1, 3, 7, -1}, /*[|----|T---|-------]*/ { 3, 1, 1, 4, 8, -1}, /*[|-----|T---|------]*/ { 3, 1, 1, 5, 9, -1}, /*[|------|T---|-----]*/ { 3, 1, 1, 6, 10, -1}, /*[|-------|T---|----]*/ { 3, 1, 1, 7, 11, -1}, /*[|--------|T---|---]*/ { 3, 1, 1, 8, 12, -1}, /*[|---------|T---|--]*/ { 3, 1, 1, 9, 13, -1}, /*[|----------|T----|]*/ { 2, 1, 1,10, -1, -1}, /*[|-----------|T---|]*/ { 2, 1, 1,11, -1, -1}, /*[|------------|T--|]*/ { 2, 1, 1,12, -1, -1}, /*[|-------------|T-|]*/ { 2, 1, 1,13, -1, -1}, /*[|--------------|T|]*/ { 2, 1, 1,14, -1, -1}, }; static const int minFrameTranDistance = 4; static const FREQ_RES freqRes_table_8[] = {FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH}; static const FREQ_RES freqRes_table_16[16] = { /* size of envelope */ /* 0-4 */ FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, FREQ_RES_LOW, /* 5-9 */ FREQ_RES_LOW, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, /* 10-16 */ FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH }; static void generateFixFixOnly ( HANDLE_SBR_FRAME_INFO hSbrFrameInfo, HANDLE_SBR_GRID hSbrGrid, int tranPosInternal, int numberTimeSlots, UCHAR fResTransIsLow ); /*! Functionname: FDKsbrEnc_frameInfoGenerator Description: produces the FRAME_INFO struct for the current frame Arguments: hSbrEnvFrame - pointer to sbr envelope handle v_pre_transient_info - pointer to transient info vector v_transient_info - pointer to previous transient info vector v_tuning - pointer to tuning vector Return: frame_info - pointer to SBR_FRAME_INFO struct *******************************************************************************/ HANDLE_SBR_FRAME_INFO FDKsbrEnc_frameInfoGenerator (HANDLE_SBR_ENVELOPE_FRAME hSbrEnvFrame, UCHAR *v_transient_info, UCHAR *v_transient_info_pre, int ldGrid, const int *v_tuning) { INT numEnv, tranPosInternal=0, bmin=0, bmax=0, parts, d, i_cmon=0, i_tran=0, nL; INT fmax = 0; INT *v_bord = hSbrEnvFrame->v_bord; INT *v_freq = hSbrEnvFrame->v_freq; INT *v_bordFollow = hSbrEnvFrame->v_bordFollow; INT *v_freqFollow = hSbrEnvFrame->v_freqFollow; INT *length_v_bordFollow = &hSbrEnvFrame->length_v_bordFollow; INT *length_v_freqFollow = &hSbrEnvFrame->length_v_freqFollow; INT *length_v_bord = &hSbrEnvFrame->length_v_bord; INT *length_v_freq = &hSbrEnvFrame->length_v_freq; INT *spreadFlag = &hSbrEnvFrame->spreadFlag; INT *i_tranFollow = &hSbrEnvFrame->i_tranFollow; INT *i_fillFollow = &hSbrEnvFrame->i_fillFollow; FRAME_CLASS *frameClassOld = &hSbrEnvFrame->frameClassOld; FRAME_CLASS frameClass = FIXFIX; INT allowSpread = hSbrEnvFrame->allowSpread; INT numEnvStatic = hSbrEnvFrame->numEnvStatic; INT staticFraming = hSbrEnvFrame->staticFraming; INT dmin = hSbrEnvFrame->dmin; INT dmax = hSbrEnvFrame->dmax; INT bufferFrameStart = hSbrEnvFrame->SbrGrid.bufferFrameStart; INT numberTimeSlots = hSbrEnvFrame->SbrGrid.numberTimeSlots; INT frameMiddleSlot = hSbrEnvFrame->frameMiddleSlot; INT tranPos = v_transient_info[0]; INT tranFlag = v_transient_info[1]; const int *v_tuningSegm = v_tuning; const int *v_tuningFreq = v_tuning + 3; hSbrEnvFrame->v_tuningSegm = v_tuningSegm; if (ldGrid) { /* in case there was a transient at the very end of the previous frame, start with a transient envelope */ if ( !tranFlag && v_transient_info_pre[1] && (numberTimeSlots - v_transient_info_pre[0] < minFrameTranDistance) ){ tranFlag = 1; tranPos = 0; } } /* * Synopsis: * * The frame generator creates the time-/frequency-grid for one SBR frame. * Input signals are provided by the transient detector and the frame * splitter (transientDetectNew() & FrameSplitter() in tran_det.c). The * framing is controlled by adjusting tuning parameters stored in * FRAME_GEN_TUNING. The parameter values are dependent on frame lengths * and bitrates, and may in the future be signal dependent. * * The envelope borders are stored for frame generator internal use in * aBorders. The contents of aBorders represent positions along the time * axis given in the figures in fram_gen.h (the "frame-generator" rows). * The unit is "time slot". The figures in fram_gen.h also define the * detection ranges for the transient detector. For every border in * aBorders, there is a corresponding entry in aFreqRes, which defines the * frequency resolution of the envelope following (delimited by) the * border. * * When no transients are present, FIXFIX class frames are used. The * frame splitter decides whether to use one or two envelopes in the * FIXFIX frame. "Sparse transients" (separated by a few frames without * transients) are handeled by [FIXVAR, VARFIX] pairs or (depending on * tuning and transient position relative the nominal frame boundaries) * by [FIXVAR, VARVAR, VARFIX] triples. "Tight transients" (in * consecutive frames) are handeled by [..., VARVAR, VARVAR, ...] * sequences. * * The generator assumes that transients are "sparse", and designs * borders for [FIXVAR, VARFIX] pairs right away, where the first frame * corresponds to the present frame. At the next call of the generator * it is known whether the transient actually is "sparse" or not. If * 'yes', the already calculated VARFIX borders are used. If 'no', new * borders, meeting the requirements of the "tight" transient, are * calculated. * * The generator produces two outputs: A "clear-text bitstream" stored in * SBR_GRID, and a straight-forward representation of the grid stored in * SBR_FRAME_INFO. The former is subsequently converted to the actual * bitstream sbr_grid() (encodeSbrGrid() in bit_sbr.c). The latter is * used by other encoder functions, such as the envelope estimator * (calculateSbrEnvelope() in env_est.c) and the noise floor and missing * harmonics detector (TonCorrParamExtr() in nf_est.c). */ if (staticFraming) { /*-------------------------------------------------------------------------- Ignore transient detector ---------------------------------------------------------------------------*/ frameClass = FIXFIX; numEnv = numEnvStatic; /* {1,2,4,8} */ *frameClassOld = FIXFIX; /* for change to dyn */ hSbrEnvFrame->SbrGrid.bs_num_env = numEnv; hSbrEnvFrame->SbrGrid.frameClass = frameClass; } else { /*-------------------------------------------------------------------------- Calculate frame class to use ---------------------------------------------------------------------------*/ calcFrameClass (&frameClass, frameClassOld, tranFlag, spreadFlag); /* patch for new frame class FIXFIXonly for AAC LD */ if (tranFlag && ldGrid) { frameClass = FIXFIXonly; *frameClassOld = FIXFIX; } /* * every transient is processed below by inserting * * - one border at the onset of the transient * - one or more "decay borders" (after the onset of the transient) * - optionally one "attack border" (before the onset of the transient) * * those borders are referred to as "mandatory borders" and are * defined by the 'segmentLength' array in FRAME_GEN_TUNING * * the frequency resolutions of the corresponding envelopes are * defined by the 'segmentRes' array in FRAME_GEN_TUNING */ /*-------------------------------------------------------------------------- Design frame (or follow-up old design) ---------------------------------------------------------------------------*/ if (tranFlag) { /* Always for FixVar, often but not always for VarVar */ /*-------------------------------------------------------------------------- Design part of T/F-grid around the new transient ---------------------------------------------------------------------------*/ tranPosInternal = frameMiddleSlot + tranPos + bufferFrameStart ; /* FH 00-06-26 */ /* add mandatory borders around transient */ fillFrameTran ( v_tuningSegm, v_tuningFreq, tranPosInternal, v_bord, length_v_bord, v_freq, length_v_freq, &bmin, &bmax ); /* make sure we stay within the maximum SBR frame overlap */ fmax = calcFillLengthMax(tranPos, numberTimeSlots); } switch (frameClass) { case FIXFIXonly: FDK_ASSERT(ldGrid); tranPosInternal = tranPos; generateFixFixOnly ( &(hSbrEnvFrame->SbrFrameInfo), &(hSbrEnvFrame->SbrGrid), tranPosInternal, numberTimeSlots, hSbrEnvFrame->fResTransIsLow ); return &(hSbrEnvFrame->SbrFrameInfo); case FIXVAR: /*-------------------------------------------------------------------------- Design remaining parts of T/F-grid (assuming next frame is VarFix) ---------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------- Fill region before new transient: ---------------------------------------------------------------------------*/ fillFramePre (dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin, bmin - bufferFrameStart); /* FH 00-06-26 */ /*-------------------------------------------------------------------------- Fill region after new transient: ---------------------------------------------------------------------------*/ fillFramePost (&parts, &d, dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmax, bufferFrameStart, numberTimeSlots, fmax); /*-------------------------------------------------------------------------- Take care of special case: ---------------------------------------------------------------------------*/ if (parts == 1 && d < dmin) /* no fill, short last envelope */ specialCase (spreadFlag, allowSpread, v_bord, length_v_bord, v_freq, length_v_freq, &parts, d); /*-------------------------------------------------------------------------- Calculate common border (split-point) ---------------------------------------------------------------------------*/ calcCmonBorder (&i_cmon, &i_tran, v_bord, length_v_bord, tranPosInternal, bufferFrameStart, numberTimeSlots); /* FH 00-06-26 */ /*-------------------------------------------------------------------------- Extract data for proper follow-up in next frame ---------------------------------------------------------------------------*/ keepForFollowUp (v_bordFollow, length_v_bordFollow, v_freqFollow, length_v_freqFollow, i_tranFollow, i_fillFollow, v_bord, length_v_bord, v_freq, i_cmon, i_tran, parts, numberTimeSlots); /* FH 00-06-26 */ /*-------------------------------------------------------------------------- Calculate control signal ---------------------------------------------------------------------------*/ calcCtrlSignal (&hSbrEnvFrame->SbrGrid, frameClass, v_bord, *length_v_bord, v_freq, *length_v_freq, i_cmon, i_tran, *spreadFlag, DC); break; case VARFIX: /*-------------------------------------------------------------------------- Follow-up old transient - calculate control signal ---------------------------------------------------------------------------*/ calcCtrlSignal (&hSbrEnvFrame->SbrGrid, frameClass, v_bordFollow, *length_v_bordFollow, v_freqFollow, *length_v_freqFollow, DC, *i_tranFollow, *spreadFlag, DC); break; case VARVAR: if (*spreadFlag) { /* spread across three frames */ /*-------------------------------------------------------------------------- Follow-up old transient - calculate control signal ---------------------------------------------------------------------------*/ calcCtrlSignal (&hSbrEnvFrame->SbrGrid, frameClass, v_bordFollow, *length_v_bordFollow, v_freqFollow, *length_v_freqFollow, DC, *i_tranFollow, *spreadFlag, DC); *spreadFlag = 0; /*-------------------------------------------------------------------------- Extract data for proper follow-up in next frame ---------------------------------------------------------------------------*/ v_bordFollow[0] = hSbrEnvFrame->SbrGrid.bs_abs_bord_1 - numberTimeSlots; /* FH 00-06-26 */ v_freqFollow[0] = 1; *length_v_bordFollow = 1; *length_v_freqFollow = 1; *i_tranFollow = -DC; *i_fillFollow = -DC; } else { /*-------------------------------------------------------------------------- Design remaining parts of T/F-grid (assuming next frame is VarFix) adapt or fill region before new transient: ---------------------------------------------------------------------------*/ fillFrameInter (&nL, v_tuningSegm, v_bord, length_v_bord, bmin, v_freq, length_v_freq, v_bordFollow, length_v_bordFollow, v_freqFollow, length_v_freqFollow, *i_fillFollow, dmin, dmax, numberTimeSlots); /*-------------------------------------------------------------------------- Fill after transient: ---------------------------------------------------------------------------*/ fillFramePost (&parts, &d, dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmax, bufferFrameStart, numberTimeSlots, fmax); /*-------------------------------------------------------------------------- Take care of special case: ---------------------------------------------------------------------------*/ if (parts == 1 && d < dmin) /*% no fill, short last envelope */ specialCase (spreadFlag, allowSpread, v_bord, length_v_bord, v_freq, length_v_freq, &parts, d); /*-------------------------------------------------------------------------- Calculate common border (split-point) ---------------------------------------------------------------------------*/ calcCmonBorder (&i_cmon, &i_tran, v_bord, length_v_bord, tranPosInternal, bufferFrameStart, numberTimeSlots); /*-------------------------------------------------------------------------- Extract data for proper follow-up in next frame ---------------------------------------------------------------------------*/ keepForFollowUp (v_bordFollow, length_v_bordFollow, v_freqFollow, length_v_freqFollow, i_tranFollow, i_fillFollow, v_bord, length_v_bord, v_freq, i_cmon, i_tran, parts, numberTimeSlots); /*-------------------------------------------------------------------------- Calculate control signal ---------------------------------------------------------------------------*/ calcCtrlSignal (&hSbrEnvFrame->SbrGrid, frameClass, v_bord, *length_v_bord, v_freq, *length_v_freq, i_cmon, i_tran, 0, nL); } break; case FIXFIX: if (tranPos == 0) numEnv = 1; else numEnv = 2; hSbrEnvFrame->SbrGrid.bs_num_env = numEnv; hSbrEnvFrame->SbrGrid.frameClass = frameClass; break; default: FDK_ASSERT(0); } } /*------------------------------------------------------------------------- Convert control signal to frame info struct ---------------------------------------------------------------------------*/ ctrlSignal2FrameInfo (&hSbrEnvFrame->SbrGrid, &hSbrEnvFrame->SbrFrameInfo, hSbrEnvFrame->freq_res_fixfix); return &hSbrEnvFrame->SbrFrameInfo; } /***************************************************************************/ /*! \brief Gnerates frame info for FIXFIXonly frame class used for low delay version \return nothing ****************************************************************************/ static void generateFixFixOnly ( HANDLE_SBR_FRAME_INFO hSbrFrameInfo, HANDLE_SBR_GRID hSbrGrid, int tranPosInternal, int numberTimeSlots, UCHAR fResTransIsLow ) { int nEnv, i, k=0, tranIdx; const int *pTable = NULL; const FREQ_RES *freqResTable = NULL; switch (numberTimeSlots) { case 8: pTable = envelopeTable_8[tranPosInternal]; freqResTable = freqRes_table_8; break; case 15: pTable = envelopeTable_15[tranPosInternal]; freqResTable = freqRes_table_16; break; case 16: pTable = envelopeTable_16[tranPosInternal]; freqResTable = freqRes_table_16; break; } /* look number of envolpes in table */ nEnv = pTable[0]; /* look up envolpe distribution in table */ for (i=1; iborders[i] = pTable[i+2]; /* open and close frame border */ hSbrFrameInfo->borders[0] = 0; hSbrFrameInfo->borders[nEnv] = numberTimeSlots; /* adjust segment-frequency-resolution according to the segment-length */ for (i=0; iborders[i+1] - hSbrFrameInfo->borders[i]; if (!fResTransIsLow) hSbrFrameInfo->freqRes[i] = freqResTable[k]; else hSbrFrameInfo->freqRes[i] = FREQ_RES_LOW; hSbrGrid->v_f[i] = hSbrFrameInfo->freqRes[i]; } hSbrFrameInfo->nEnvelopes = nEnv; hSbrFrameInfo->shortEnv = pTable[2]; /* transient idx */ tranIdx = pTable[1]; /* add noise floors */ hSbrFrameInfo->bordersNoise[0] = 0; hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[tranIdx?tranIdx:1]; hSbrFrameInfo->bordersNoise[2] = numberTimeSlots; hSbrFrameInfo->nNoiseEnvelopes = 2; hSbrGrid->frameClass = FIXFIXonly; hSbrGrid->bs_abs_bord = tranPosInternal; hSbrGrid->bs_num_env = nEnv; } /******************************************************************************* Functionname: FDKsbrEnc_initFrameInfoGenerator ******************************************************************************* Description: Arguments: hSbrEnvFrame - pointer to sbr envelope handle allowSpread - commandline parameter numEnvStatic - commandline parameter staticFraming - commandline parameter Return: none *******************************************************************************/ void FDKsbrEnc_initFrameInfoGenerator ( HANDLE_SBR_ENVELOPE_FRAME hSbrEnvFrame, INT allowSpread, INT numEnvStatic, INT staticFraming, INT timeSlots, const FREQ_RES* freq_res_fixfix ,UCHAR fResTransIsLow, INT ldGrid ) { /* FH 00-06-26 */ FDKmemclear(hSbrEnvFrame,sizeof(SBR_ENVELOPE_FRAME )); /* Initialisation */ hSbrEnvFrame->frameClassOld = FIXFIX; hSbrEnvFrame->spreadFlag = 0; hSbrEnvFrame->allowSpread = allowSpread; hSbrEnvFrame->numEnvStatic = numEnvStatic; hSbrEnvFrame->staticFraming = staticFraming; hSbrEnvFrame->freq_res_fixfix[0] = freq_res_fixfix[0]; hSbrEnvFrame->freq_res_fixfix[1] = freq_res_fixfix[1]; hSbrEnvFrame->fResTransIsLow = fResTransIsLow; hSbrEnvFrame->length_v_bord = 0; hSbrEnvFrame->length_v_bordFollow = 0; hSbrEnvFrame->length_v_freq = 0; hSbrEnvFrame->length_v_freqFollow = 0; hSbrEnvFrame->i_tranFollow = 0; hSbrEnvFrame->i_fillFollow = 0; hSbrEnvFrame->SbrGrid.numberTimeSlots = timeSlots; if (ldGrid) { /*case CODEC_AACLD:*/ hSbrEnvFrame->dmin = 2; hSbrEnvFrame->dmax = 16; hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_512LD; hSbrEnvFrame->SbrGrid.bufferFrameStart = 0; } else switch(timeSlots){ case NUMBER_TIME_SLOTS_1920: hSbrEnvFrame->dmin = 4; hSbrEnvFrame->dmax = 12; hSbrEnvFrame->SbrGrid.bufferFrameStart = 0; hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_1920; break; case NUMBER_TIME_SLOTS_2048: hSbrEnvFrame->dmin = 4; hSbrEnvFrame->dmax = 12; hSbrEnvFrame->SbrGrid.bufferFrameStart = 0; hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_2048; break; case NUMBER_TIME_SLOTS_1152: hSbrEnvFrame->dmin = 2; hSbrEnvFrame->dmax = 8; hSbrEnvFrame->SbrGrid.bufferFrameStart = 0; hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_1152; break; case NUMBER_TIME_SLOTS_2304: hSbrEnvFrame->dmin = 4; hSbrEnvFrame->dmax = 15; hSbrEnvFrame->SbrGrid.bufferFrameStart = 0; hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_2304; break; default: FDK_ASSERT(0); } } /******************************************************************************* Functionname: fillFrameTran ******************************************************************************* Description: Add mandatory borders, as described by the tuning vector and the current transient position Arguments: modified: v_bord - int pointer to v_bord vector length_v_bord - length of v_bord vector v_freq - int pointer to v_freq vector length_v_freq - length of v_freq vector bmin - int pointer to bmin (call by reference) bmax - int pointer to bmax (call by reference) not modified: tran - position of transient v_tuningSegm - int pointer to v_tuningSegm vector v_tuningFreq - int pointer to v_tuningFreq vector Return: none *******************************************************************************/ static void fillFrameTran (const int *v_tuningSegm, /*!< tuning: desired segment lengths */ const int *v_tuningFreq, /*!< tuning: desired frequency resolutions */ int tran, /*!< input : position of transient */ int *v_bord, /*!< memNew: borders */ int *length_v_bord, /*!< memNew: # borders */ int *v_freq, /*!< memNew: frequency resolutions */ int *length_v_freq, /*!< memNew: # frequency resolutions */ int *bmin, /*!< hlpNew: first mandatory border */ int *bmax /*!< hlpNew: last mandatory border */ ) { int bord, i; *length_v_bord = 0; *length_v_freq = 0; /* add attack env leading border (optional) */ if (v_tuningSegm[0]) { /* v_bord = [(Ba)] start of attack env */ FDKsbrEnc_AddRight (v_bord, length_v_bord, (tran - v_tuningSegm[0])); /* v_freq = [(Fa)] res of attack env */ FDKsbrEnc_AddRight (v_freq, length_v_freq, v_tuningFreq[0]); } /* add attack env trailing border/first decay env leading border */ bord = tran; FDKsbrEnc_AddRight (v_bord, length_v_bord, tran); /* v_bord = [(Ba),Bd1] */ /* add first decay env trailing border/2:nd decay env leading border */ if (v_tuningSegm[1]) { bord += v_tuningSegm[1]; /* v_bord = [(Ba),Bd1,Bd2] */ FDKsbrEnc_AddRight (v_bord, length_v_bord, bord); /* v_freq = [(Fa),Fd1] */ FDKsbrEnc_AddRight (v_freq, length_v_freq, v_tuningFreq[1]); } /* add 2:nd decay env trailing border (optional) */ if (v_tuningSegm[2] != 0) { bord += v_tuningSegm[2]; /* v_bord = [(Ba),Bd1, Bd2,(Bd3)] */ FDKsbrEnc_AddRight (v_bord, length_v_bord, bord); /* v_freq = [(Fa),Fd1,(Fd2)] */ FDKsbrEnc_AddRight (v_freq, length_v_freq, v_tuningFreq[2]); } /* v_freq = [(Fa),Fd1,(Fd2),1] */ FDKsbrEnc_AddRight (v_freq, length_v_freq, 1); /* calc min and max values of mandatory borders */ *bmin = v_bord[0]; for (i = 0; i < *length_v_bord; i++) if (v_bord[i] < *bmin) *bmin = v_bord[i]; *bmax = v_bord[0]; for (i = 0; i < *length_v_bord; i++) if (v_bord[i] > *bmax) *bmax = v_bord[i]; } /******************************************************************************* Functionname: fillFramePre ******************************************************************************* Description: Add borders before mandatory borders, if needed Arguments: modified: v_bord - int pointer to v_bord vector length_v_bord - length of v_bord vector v_freq - int pointer to v_freq vector length_v_freq - length of v_freq vector not modified: dmax - int value bmin - int value rest - int value Return: none *******************************************************************************/ static void fillFramePre (INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT bmin, INT rest) { /* input state: v_bord = [(Ba),Bd1, Bd2 ,(Bd3)] v_freq = [(Fa),Fd1,(Fd2),1 ] */ INT parts, d, j, S, s = 0, segm, bord; /* start with one envelope */ parts = 1; d = rest; /* calc # of additional envelopes and corresponding lengths */ while (d > dmax) { parts++; segm = rest / parts; S = (segm - 2)>>1; s = fixMin (8, 2 * S + 2); d = rest - (parts - 1) * s; } /* add borders before mandatory borders */ bord = bmin; for (j = 0; j <= parts - 2; j++) { bord = bord - s; /* v_bord = [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3)] */ FDKsbrEnc_AddLeft (v_bord, length_v_bord, bord); /* v_freq = [...,(1 ),(Fa),Fd1,(Fd2), 1 ] */ FDKsbrEnc_AddLeft (v_freq, length_v_freq, 1); } } /***************************************************************************/ /*! \brief Overlap control Calculate max length of trailing fill segments, such that we always get a border within the frame overlap region \return void ****************************************************************************/ static int calcFillLengthMax (int tranPos, /*!< input : transient position (ref: tran det) */ int numberTimeSlots /*!< input : number of timeslots */ ) { int fmax; /* calculate transient position within envelope buffer */ switch (numberTimeSlots) { case NUMBER_TIME_SLOTS_2048: if (tranPos < 4) fmax = 6; else if (tranPos == 4 || tranPos == 5) fmax = 4; else fmax = 8; break; case NUMBER_TIME_SLOTS_1920: if (tranPos < 4) fmax = 5; else if (tranPos == 4 || tranPos == 5) fmax = 3; else fmax = 7; break; default: fmax = 8; break; } return fmax; } /******************************************************************************* Functionname: fillFramePost ******************************************************************************* Description: -Add borders after mandatory borders, if needed Make a preliminary design of next frame, assuming no transient is present there Arguments: modified: parts - int pointer to parts (call by reference) d - int pointer to d (call by reference) v_bord - int pointer to v_bord vector length_v_bord - length of v_bord vector v_freq - int pointer to v_freq vector length_v_freq - length of v_freq vector not modified: bmax - int value dmax - int value Return: none *******************************************************************************/ static void fillFramePost (INT *parts, INT *d, INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT bmax, INT bufferFrameStart, INT numberTimeSlots, INT fmax) { INT j, rest, segm, S, s = 0, bord; /* input state: v_bord = [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3)] v_freq = [...,(1 ),(Fa),Fd1,(Fd2),1 ] */ rest = bufferFrameStart + 2 * numberTimeSlots - bmax; *d = rest; if (*d > 0) { *parts = 1; /* start with one envelope */ /* calc # of additional envelopes and corresponding lengths */ while (*d > dmax) { *parts = *parts + 1; segm = rest / (*parts); S = (segm - 2)>>1; s = fixMin (fmax, 2 * S + 2); *d = rest - (*parts - 1) * s; } /* add borders after mandatory borders */ bord = bmax; for (j = 0; j <= *parts - 2; j++) { bord += s; /* v_bord = [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3),(Bf)] */ FDKsbrEnc_AddRight (v_bord, length_v_bord, bord); /* v_freq = [...,(1 ),(Fa),Fd1,(Fd2), 1 , 1! ,1] */ FDKsbrEnc_AddRight (v_freq, length_v_freq, 1); } } else { *parts = 1; /* remove last element from v_bord and v_freq */ *length_v_bord = *length_v_bord - 1; *length_v_freq = *length_v_freq - 1; } } /******************************************************************************* Functionname: fillFrameInter ******************************************************************************* Description: Arguments: nL - v_tuningSegm - v_bord - length_v_bord - bmin - v_freq - length_v_freq - v_bordFollow - length_v_bordFollow - v_freqFollow - length_v_freqFollow - i_fillFollow - dmin - dmax - Return: none *******************************************************************************/ static void fillFrameInter (INT *nL, const int *v_tuningSegm, INT *v_bord, INT *length_v_bord, INT bmin, INT *v_freq, INT *length_v_freq, INT *v_bordFollow, INT *length_v_bordFollow, INT *v_freqFollow, INT *length_v_freqFollow, INT i_fillFollow, INT dmin, INT dmax, INT numberTimeSlots) { INT middle, b_new, numBordFollow, bordMaxFollow, i; if (numberTimeSlots != NUMBER_TIME_SLOTS_1152) { /* % remove fill borders: */ if (i_fillFollow >= 1) { *length_v_bordFollow = i_fillFollow; *length_v_freqFollow = i_fillFollow; } numBordFollow = *length_v_bordFollow; bordMaxFollow = v_bordFollow[numBordFollow - 1]; /* remove even more borders if needed */ middle = bmin - bordMaxFollow; while (middle < 0) { numBordFollow--; bordMaxFollow = v_bordFollow[numBordFollow - 1]; middle = bmin - bordMaxFollow; } *length_v_bordFollow = numBordFollow; *length_v_freqFollow = numBordFollow; *nL = numBordFollow - 1; b_new = *length_v_bord; if (middle <= dmax) { if (middle >= dmin) { /* concatenate */ FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } else { if (v_tuningSegm[0] != 0) { /* remove one new border and concatenate */ *length_v_bord = b_new - 1; FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); *length_v_freq = b_new - 1; FDKsbrEnc_AddVecLeft (v_freq + 1, length_v_freq, v_freqFollow, *length_v_freqFollow); } else { if (*length_v_bordFollow > 1) { /* remove one old border and concatenate */ FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow - 1); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_bordFollow - 1); *nL = *nL - 1; } else { /* remove new "transient" border and concatenate */ for (i = 0; i < *length_v_bord - 1; i++) v_bord[i] = v_bord[i + 1]; for (i = 0; i < *length_v_freq - 1; i++) v_freq[i] = v_freq[i + 1]; *length_v_bord = b_new - 1; *length_v_freq = b_new - 1; FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } } } } else { /* middle > dmax */ fillFramePre (dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin, middle); FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } } else { /* numberTimeSlots==NUMBER_TIME_SLOTS_1152 */ INT l,m; /*------------------------------------------------------------------------ remove fill borders ------------------------------------------------------------------------*/ if (i_fillFollow >= 1) { *length_v_bordFollow = i_fillFollow; *length_v_freqFollow = i_fillFollow; } numBordFollow = *length_v_bordFollow; bordMaxFollow = v_bordFollow[numBordFollow - 1]; /*------------------------------------------------------------------------ remove more borders if necessary to eliminate overlap ------------------------------------------------------------------------*/ /* check for overlap */ middle = bmin - bordMaxFollow; /* intervals: i) middle < 0 : overlap, must remove borders ii) 0 <= middle < dmin : no overlap but too tight, must remove borders iii) dmin <= middle <= dmax : ok, just concatenate iv) dmax <= middle : too wide, must add borders */ /* first remove old non-fill-borders... */ while (middle < 0) { /* ...but don't remove all of them */ if (numBordFollow == 1) break; numBordFollow--; bordMaxFollow = v_bordFollow[numBordFollow - 1]; middle = bmin - bordMaxFollow; } /* if this isn't enough, remove new non-fill borders */ if (middle < 0) { for (l = 0, m = 0 ; l < *length_v_bord ; l++) { if(v_bord[l]> bordMaxFollow) { v_bord[m] = v_bord[l]; v_freq[m] = v_freq[l]; m++; } } *length_v_bord = l; *length_v_freq = l; bmin = v_bord[0]; } /*------------------------------------------------------------------------ update modified follow-up data ------------------------------------------------------------------------*/ *length_v_bordFollow = numBordFollow; *length_v_freqFollow = numBordFollow; /* left relative borders correspond to follow-up */ *nL = numBordFollow - 1; /*------------------------------------------------------------------------ take care of intervals ii through iv ------------------------------------------------------------------------*/ /* now middle should be >= 0 */ middle = bmin - bordMaxFollow; if (middle <= dmin) /* (ii) */ { b_new = *length_v_bord; if (v_tuningSegm[0] != 0) { /* remove new "luxury" border and concatenate */ *length_v_bord = b_new - 1; FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); *length_v_freq = b_new - 1; FDKsbrEnc_AddVecLeft (v_freq + 1, length_v_freq, v_freqFollow, *length_v_freqFollow); } else if (*length_v_bordFollow > 1) { /* remove old border and concatenate */ FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow - 1); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_bordFollow - 1); *nL = *nL - 1; } else { /* remove new border and concatenate */ for (i = 0; i < *length_v_bord - 1; i++) v_bord[i] = v_bord[i + 1]; for (i = 0; i < *length_v_freq - 1; i++) v_freq[i] = v_freq[i + 1]; *length_v_bord = b_new - 1; *length_v_freq = b_new - 1; FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } } else if ((middle >= dmin) && (middle <= dmax)) /* (iii) */ { /* concatenate */ FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } else /* (iv) */ { fillFramePre (dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin, middle); FDKsbrEnc_AddVecLeft (v_bord, length_v_bord, v_bordFollow, *length_v_bordFollow); FDKsbrEnc_AddVecLeft (v_freq, length_v_freq, v_freqFollow, *length_v_freqFollow); } } } /******************************************************************************* Functionname: calcFrameClass ******************************************************************************* Description: Arguments: INT* frameClass, INT* frameClassOld, INT tranFlag, INT* spreadFlag) Return: none *******************************************************************************/ static void calcFrameClass (FRAME_CLASS *frameClass, FRAME_CLASS *frameClassOld, INT tranFlag, INT *spreadFlag) { switch (*frameClassOld) { case FIXFIXonly: case FIXFIX: if (tranFlag) *frameClass = FIXVAR; else *frameClass = FIXFIX; break; case FIXVAR: if (tranFlag) { *frameClass = VARVAR; *spreadFlag = 0; } else { if (*spreadFlag) *frameClass = VARVAR; else *frameClass = VARFIX; } break; case VARFIX: if (tranFlag) *frameClass = FIXVAR; else *frameClass = FIXFIX; break; case VARVAR: if (tranFlag) { *frameClass = VARVAR; *spreadFlag = 0; } else { if (*spreadFlag) *frameClass = VARVAR; else *frameClass = VARFIX; } break; }; *frameClassOld = *frameClass; } /******************************************************************************* Functionname: specialCase ******************************************************************************* Description: Arguments: spreadFlag allowSpread v_bord length_v_bord v_freq length_v_freq parts d Return: none *******************************************************************************/ static void specialCase (INT *spreadFlag, INT allowSpread, INT *v_bord, INT *length_v_bord, INT *v_freq, INT *length_v_freq, INT *parts, INT d) { INT L; L = *length_v_bord; if (allowSpread) { /* add one "step 8" */ *spreadFlag = 1; FDKsbrEnc_AddRight (v_bord, length_v_bord, v_bord[L - 1] + 8); FDKsbrEnc_AddRight (v_freq, length_v_freq, 1); (*parts)++; } else { if (d == 1) { /* stretch one slot */ *length_v_bord = L - 1; *length_v_freq = L - 1; } else { if ((v_bord[L - 1] - v_bord[L - 2]) > 2) { /* compress one quant step */ v_bord[L - 1] = v_bord[L - 1] - 2; v_freq[*length_v_freq - 1] = 0; /* use low res for short segment */ } } } } /******************************************************************************* Functionname: calcCmonBorder ******************************************************************************* Description: Arguments: i_cmon i_tran v_bord length_v_bord tran Return: none *******************************************************************************/ static void calcCmonBorder (INT *i_cmon, INT *i_tran, INT *v_bord, INT *length_v_bord, INT tran, INT bufferFrameStart, INT numberTimeSlots) { /* FH 00-06-26 */ INT i; for (i = 0; i < *length_v_bord; i++) if (v_bord[i] >= bufferFrameStart + numberTimeSlots) { /* FH 00-06-26 */ *i_cmon = i; break; } /* keep track of transient: */ for (i = 0; i < *length_v_bord; i++) if (v_bord[i] >= tran) { *i_tran = i; break; } else *i_tran = EMPTY; } /******************************************************************************* Functionname: keepForFollowUp ******************************************************************************* Description: Arguments: v_bordFollow length_v_bordFollow v_freqFollow length_v_freqFollow i_tranFollow i_fillFollow v_bord length_v_bord v_freq i_cmon i_tran parts) Return: none *******************************************************************************/ static void keepForFollowUp (INT *v_bordFollow, INT *length_v_bordFollow, INT *v_freqFollow, INT *length_v_freqFollow, INT *i_tranFollow, INT *i_fillFollow, INT *v_bord, INT *length_v_bord, INT *v_freq, INT i_cmon, INT i_tran, INT parts, INT numberTimeSlots) { /* FH 00-06-26 */ INT L, i, j; L = *length_v_bord; (*length_v_bordFollow) = 0; (*length_v_freqFollow) = 0; for (j = 0, i = i_cmon; i < L; i++, j++) { v_bordFollow[j] = v_bord[i] - numberTimeSlots; /* FH 00-06-26 */ v_freqFollow[j] = v_freq[i]; (*length_v_bordFollow)++; (*length_v_freqFollow)++; } if (i_tran != EMPTY) *i_tranFollow = i_tran - i_cmon; else *i_tranFollow = EMPTY; *i_fillFollow = L - (parts - 1) - i_cmon; } /******************************************************************************* Functionname: calcCtrlSignal ******************************************************************************* Description: Arguments: hSbrGrid frameClass v_bord length_v_bord v_freq length_v_freq i_cmon i_tran spreadFlag nL Return: none *******************************************************************************/ static void calcCtrlSignal (HANDLE_SBR_GRID hSbrGrid, FRAME_CLASS frameClass, INT *v_bord, INT length_v_bord, INT *v_freq, INT length_v_freq, INT i_cmon, INT i_tran, INT spreadFlag, INT nL) { INT i, r, a, n, p, b, aL, aR, ntot, nmax, nR; INT *v_f = hSbrGrid->v_f; INT *v_fLR = hSbrGrid->v_fLR; INT *v_r = hSbrGrid->bs_rel_bord; INT *v_rL = hSbrGrid->bs_rel_bord_0; INT *v_rR = hSbrGrid->bs_rel_bord_1; INT length_v_r = 0; INT length_v_rR = 0; INT length_v_rL = 0; switch (frameClass) { case FIXVAR: /* absolute border: */ a = v_bord[i_cmon]; /* relative borders: */ length_v_r = 0; i = i_cmon; while (i >= 1) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_r, &length_v_r, r); i--; } /* number of relative borders: */ n = length_v_r; /* freq res: */ for (i = 0; i < i_cmon; i++) v_f[i] = v_freq[i_cmon - 1 - i]; v_f[i_cmon] = 1; /* pointer: */ p = (i_cmon >= i_tran && i_tran != EMPTY) ? (i_cmon - i_tran + 1) : (0) ; hSbrGrid->frameClass = frameClass; hSbrGrid->bs_abs_bord = a; hSbrGrid->n = n; hSbrGrid->p = p; break; case VARFIX: /* absolute border: */ a = v_bord[0]; /* relative borders: */ length_v_r = 0; for (i = 1; i < length_v_bord; i++) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_r, &length_v_r, r); } /* number of relative borders: */ n = length_v_r; /* freq res: */ FDKmemcpy (v_f, v_freq, length_v_freq * sizeof (INT)); /* pointer: */ p = (i_tran >= 0 && i_tran != EMPTY) ? (i_tran + 1) : (0) ; hSbrGrid->frameClass = frameClass; hSbrGrid->bs_abs_bord = a; hSbrGrid->n = n; hSbrGrid->p = p; break; case VARVAR: if (spreadFlag) { /* absolute borders: */ b = length_v_bord; aL = v_bord[0]; aR = v_bord[b - 1]; /* number of relative borders: */ ntot = b - 2; nmax = 2; /* n: {0,1,2} */ if (ntot > nmax) { nL = nmax; nR = ntot - nmax; } else { nL = ntot; nR = 0; } /* relative borders: */ length_v_rL = 0; for (i = 1; i <= nL; i++) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_rL, &length_v_rL, r); } length_v_rR = 0; i = b - 1; while (i >= b - nR) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_rR, &length_v_rR, r); i--; } /* pointer (only one due to constraint in frame info): */ p = (i_tran > 0 && i_tran != EMPTY) ? (b - i_tran) : (0) ; /* freq res: */ for (i = 0; i < b - 1; i++) v_fLR[i] = v_freq[i]; } else { length_v_bord = i_cmon + 1; length_v_freq = i_cmon + 1; /* absolute borders: */ b = length_v_bord; aL = v_bord[0]; aR = v_bord[b - 1]; /* number of relative borders: */ ntot = b - 2; nR = ntot - nL; /* relative borders: */ length_v_rL = 0; for (i = 1; i <= nL; i++) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_rL, &length_v_rL, r); } length_v_rR = 0; i = b - 1; while (i >= b - nR) { r = v_bord[i] - v_bord[i - 1]; FDKsbrEnc_AddRight (v_rR, &length_v_rR, r); i--; } /* pointer (only one due to constraint in frame info): */ p = (i_cmon >= i_tran && i_tran != EMPTY) ? (i_cmon - i_tran + 1) : (0) ; /* freq res: */ for (i = 0; i < b - 1; i++) v_fLR[i] = v_freq[i]; } hSbrGrid->frameClass = frameClass; hSbrGrid->bs_abs_bord_0 = aL; hSbrGrid->bs_abs_bord_1 = aR; hSbrGrid->bs_num_rel_0 = nL; hSbrGrid->bs_num_rel_1 = nR; hSbrGrid->p = p; break; default: /* do nothing */ break; } } /******************************************************************************* Functionname: createDefFrameInfo ******************************************************************************* Description: Copies the default (static) frameInfo structs to the frameInfo passed by reference; only used for FIXFIX frames Arguments: hFrameInfo - HANLDE_SBR_FRAME_INFO nEnv - INT nTimeSlots - INT Return: none; hSbrFrameInfo contains a copy of the default frameInfo Written: Andreas Schneider Revised: *******************************************************************************/ static void createDefFrameInfo(HANDLE_SBR_FRAME_INFO hSbrFrameInfo, INT nEnv, INT nTimeSlots) { switch (nEnv) { case 1: switch (nTimeSlots) { case NUMBER_TIME_SLOTS_1920: FDKmemcpy (hSbrFrameInfo, &frameInfo1_1920, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2048: FDKmemcpy (hSbrFrameInfo, &frameInfo1_2048, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_1152: FDKmemcpy (hSbrFrameInfo, &frameInfo1_1152, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2304: FDKmemcpy (hSbrFrameInfo, &frameInfo1_2304, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_512LD: FDKmemcpy (hSbrFrameInfo, &frameInfo1_512LD, sizeof (SBR_FRAME_INFO)); break; default: FDK_ASSERT(0); } break; case 2: switch (nTimeSlots) { case NUMBER_TIME_SLOTS_1920: FDKmemcpy (hSbrFrameInfo, &frameInfo2_1920, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2048: FDKmemcpy (hSbrFrameInfo, &frameInfo2_2048, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_1152: FDKmemcpy (hSbrFrameInfo, &frameInfo2_1152, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2304: FDKmemcpy (hSbrFrameInfo, &frameInfo2_2304, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_512LD: FDKmemcpy (hSbrFrameInfo, &frameInfo2_512LD, sizeof (SBR_FRAME_INFO)); break; default: FDK_ASSERT(0); } break; case 4: switch (nTimeSlots) { case NUMBER_TIME_SLOTS_1920: FDKmemcpy (hSbrFrameInfo, &frameInfo4_1920, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2048: FDKmemcpy (hSbrFrameInfo, &frameInfo4_2048, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_1152: FDKmemcpy (hSbrFrameInfo, &frameInfo4_1152, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_2304: FDKmemcpy (hSbrFrameInfo, &frameInfo4_2304, sizeof (SBR_FRAME_INFO)); break; case NUMBER_TIME_SLOTS_512LD: FDKmemcpy (hSbrFrameInfo, &frameInfo4_512LD, sizeof (SBR_FRAME_INFO)); break; default: FDK_ASSERT(0); } break; default: FDK_ASSERT(0); } } /******************************************************************************* Functionname: ctrlSignal2FrameInfo ******************************************************************************* Description: Convert "clear-text" sbr_grid() to "frame info" used by the envelope and noise floor estimators. This is basically (except for "low level" calculations) the bitstream decoder defined in the MPEG-4 standard, sub clause 4.6.18.3.3, Time / Frequency Grid. See inline comments for explanation of the shorten and noise border algorithms. Arguments: hSbrGrid - source hSbrFrameInfo - destination freq_res_fixfix - frequency resolution for FIXFIX frames Return: void; hSbrFrameInfo contains the updated FRAME_INFO struct *******************************************************************************/ static void ctrlSignal2FrameInfo ( HANDLE_SBR_GRID hSbrGrid, /* input : the grid handle */ HANDLE_SBR_FRAME_INFO hSbrFrameInfo, /* output: the frame info handle */ FREQ_RES *freq_res_fixfix /* in/out: frequency resolution for FIXFIX frames */ ) { INT frameSplit = 0; INT nEnv = 0, border = 0, i, k, p /*?*/; INT *v_r = hSbrGrid->bs_rel_bord; INT *v_f = hSbrGrid->v_f; FRAME_CLASS frameClass = hSbrGrid->frameClass; INT bufferFrameStart = hSbrGrid->bufferFrameStart; INT numberTimeSlots = hSbrGrid->numberTimeSlots; switch (frameClass) { case FIXFIX: createDefFrameInfo(hSbrFrameInfo, hSbrGrid->bs_num_env, numberTimeSlots); frameSplit = (hSbrFrameInfo->nEnvelopes > 1); for (i = 0; i < hSbrFrameInfo->nEnvelopes; i++) { hSbrGrid->v_f[i] = hSbrFrameInfo->freqRes[i] = freq_res_fixfix[frameSplit]; } break; case FIXVAR: case VARFIX: nEnv = hSbrGrid->n + 1; /* read n [SBR_NUM_BITS bits] */ /*? snd*/ FDK_ASSERT(nEnv <= MAX_ENVELOPES_FIXVAR_VARFIX); hSbrFrameInfo->nEnvelopes = nEnv; border = hSbrGrid->bs_abs_bord; /* read the absolute border */ if (nEnv == 1) hSbrFrameInfo->nNoiseEnvelopes = 1; else hSbrFrameInfo->nNoiseEnvelopes = 2; break; default: /* do nothing */ break; } switch (frameClass) { case FIXVAR: hSbrFrameInfo->borders[0] = bufferFrameStart; /* start-position of 1st envelope */ hSbrFrameInfo->borders[nEnv] = border; for (k = 0, i = nEnv - 1; k < nEnv - 1; k++, i--) { border -= v_r[k]; hSbrFrameInfo->borders[i] = border; } /* make either envelope nr. nEnv + 1 - p short; or don't shorten if p == 0 */ p = hSbrGrid->p; if (p == 0) { hSbrFrameInfo->shortEnv = 0; } else { hSbrFrameInfo->shortEnv = nEnv + 1 - p; } for (k = 0, i = nEnv - 1; k < nEnv; k++, i--) { hSbrFrameInfo->freqRes[i] = (FREQ_RES)v_f[k]; } /* if either there is no short envelope or the last envelope is short... */ if (p == 0 || p == 1) { hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1]; } else { hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv]; } break; case VARFIX: /* in this case 'border' indicates the start of the 1st envelope */ hSbrFrameInfo->borders[0] = border; for (k = 0; k < nEnv - 1; k++) { border += v_r[k]; hSbrFrameInfo->borders[k + 1] = border; } hSbrFrameInfo->borders[nEnv] = bufferFrameStart + numberTimeSlots; p = hSbrGrid->p; if (p == 0 || p == 1) { hSbrFrameInfo->shortEnv = 0; } else { hSbrFrameInfo->shortEnv = p - 1; } for (k = 0; k < nEnv; k++) { hSbrFrameInfo->freqRes[k] = (FREQ_RES)v_f[k]; } switch (p) { case 0: hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[1]; break; case 1: hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1]; break; default: hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv]; break; } break; case VARVAR: nEnv = hSbrGrid->bs_num_rel_0 + hSbrGrid->bs_num_rel_1 + 1; FDK_ASSERT(nEnv <= MAX_ENVELOPES_VARVAR); /* just to be sure */ hSbrFrameInfo->nEnvelopes = nEnv; hSbrFrameInfo->borders[0] = border = hSbrGrid->bs_abs_bord_0; for (k = 0, i = 1; k < hSbrGrid->bs_num_rel_0; k++, i++) { border += hSbrGrid->bs_rel_bord_0[k]; hSbrFrameInfo->borders[i] = border; } border = hSbrGrid->bs_abs_bord_1; hSbrFrameInfo->borders[nEnv] = border; for (k = 0, i = nEnv - 1; k < hSbrGrid->bs_num_rel_1; k++, i--) { border -= hSbrGrid->bs_rel_bord_1[k]; hSbrFrameInfo->borders[i] = border; } p = hSbrGrid->p; if (p == 0) { hSbrFrameInfo->shortEnv = 0; } else { hSbrFrameInfo->shortEnv = nEnv + 1 - p; } for (k = 0; k < nEnv; k++) { hSbrFrameInfo->freqRes[k] = (FREQ_RES)hSbrGrid->v_fLR[k]; } if (nEnv == 1) { hSbrFrameInfo->nNoiseEnvelopes = 1; hSbrFrameInfo->bordersNoise[0] = hSbrGrid->bs_abs_bord_0; hSbrFrameInfo->bordersNoise[1] = hSbrGrid->bs_abs_bord_1; } else { hSbrFrameInfo->nNoiseEnvelopes = 2; hSbrFrameInfo->bordersNoise[0] = hSbrGrid->bs_abs_bord_0; if (p == 0 || p == 1) { hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1]; } else { hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv]; } hSbrFrameInfo->bordersNoise[2] = hSbrGrid->bs_abs_bord_1; } break; default: /* do nothing */ break; } if (frameClass == VARFIX || frameClass == FIXVAR) { hSbrFrameInfo->bordersNoise[0] = hSbrFrameInfo->borders[0]; if (nEnv == 1) { hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv]; } else { hSbrFrameInfo->bordersNoise[2] = hSbrFrameInfo->borders[nEnv]; } } }