sbr_encoder.cpp revision ef30836651bf059c3120c03dd11e08b6aafdae13 
1
2/* -----------------------------------------------------------------------------------------------------------
3Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5� Copyright  1995 - 2015 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
6  All rights reserved.
7
8 1.    INTRODUCTION
9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
12
13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16of the MPEG specifications.
17
18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20individually for the purpose of encoding or decoding bit streams in products that are compliant with
21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23software may already be covered under those patent licenses when it is used for those licensed purposes only.
24
25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27applications information and documentation.
28
292.    COPYRIGHT LICENSE
30
31Redistribution and use in source and binary forms, with or without modification, are permitted without
32payment of copyright license fees provided that you satisfy the following conditions:
33
34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35your modifications thereto in source code form.
36
37You must retain the complete text of this software license in the documentation and/or other materials
38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40modifications thereto to recipients of copies in binary form.
41
42The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43prior written permission.
44
45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46software or your modifications thereto.
47
48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49and the date of any change. For modified versions of the FDK AAC Codec, the term
50"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
52
533.    NO PATENT LICENSE
54
55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57respect to this software.
58
59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60by appropriate patent licenses.
61
624.    DISCLAIMER
63
64This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69or business interruption, however caused and on any theory of liability, whether in contract, strict
70liability, or tort (including negligence), arising in any way out of the use of this software, even if
71advised of the possibility of such damage.
72
735.    CONTACT INFORMATION
74
75Fraunhofer Institute for Integrated Circuits IIS
76Attention: Audio and Multimedia Departments - FDK AAC LL
77Am Wolfsmantel 33
7891058 Erlangen, Germany
79
80www.iis.fraunhofer.de/amm
81amm-info@iis.fraunhofer.de
82----------------------------------------------------------------------------------------------------------- */
83
84/***************************  Fraunhofer IIS FDK Tools  ***********************
85
86   Author(s): Andreas Ehret, Tobias Chalupka
87   Description: SBR encoder top level processing.
88
89******************************************************************************/
90
91#include "sbr_encoder.h"
92
93#include "sbr_ram.h"
94#include "sbr_rom.h"
95#include "sbrenc_freq_sca.h"
96#include "env_bit.h"
97#include "cmondata.h"
98#include "sbr_misc.h"
99#include "sbr.h"
100#include "qmf.h"
101
102#include "ps_main.h"
103
104#define SBRENCODER_LIB_VL0 3
105#define SBRENCODER_LIB_VL1 3
106#define SBRENCODER_LIB_VL2 6
107
108
109
110/***************************************************************************/
111/*
112 * SBR Delay balancing definitions.
113 */
114
115/*
116      input buffer (1ch)
117
118      |------------ 1537   -------------|-----|---------- 2048 -------------|
119           (core2sbr delay     )          ds     (read, core and ds area)
120*/
121
122#define SFB(dwnsmp)        (32 << (dwnsmp-1))     /* SBR Frequency bands: 64 for dual-rate, 32 for single-rate */
123#define STS(fl)            (((fl)==1024)?32:30)   /* SBR Time Slots: 32 for core frame length 1024, 30 for core frame length 960 */
124
125#define DELAY_QMF_ANA(dwnsmp) ((320<<((dwnsmp)-1)) - (32<<((dwnsmp)-1))) /* Full bandwidth */
126#define DELAY_HYB_ANA         (10*64)       /* + 0.5 */              /*  */
127#define DELAY_HYB_SYN         (6*64 - 32)                            /*  */
128#define DELAY_QMF_POSTPROC(dwnsmp) (32*(dwnsmp))                     /* QMF postprocessing delay */
129#define DELAY_DEC_QMF(dwnsmp) (6 * SFB(dwnsmp) )                     /* Decoder QMF overlap */
130#define DELAY_QMF_SYN         (2)                                    /* NO_POLY/2=2.5, rounded down to 2 */
131#define DELAY_QMF_DS          (32)                                   /* QMF synthesis for downsampled time signal */
132
133/* Delay in QMF paths */
134#define DELAY_SBR(fl,dwnsmp)     (DELAY_QMF_ANA(dwnsmp) + (SFB(dwnsmp)*STS(fl) - 1) + DELAY_QMF_SYN)
135#define DELAY_PS(fl,dwnsmp)      (DELAY_QMF_ANA(dwnsmp) + DELAY_HYB_ANA + DELAY_DEC_QMF(dwnsmp) + (SFB(dwnsmp)*STS(fl)-1) + DELAY_HYB_SYN + DELAY_QMF_SYN)
136#define DELAY_ELDSBR(fl,dwnsmp)  ( ( ((fl)/2)*(dwnsmp) ) - 1 + DELAY_QMF_POSTPROC(dwnsmp) )
137
138/* Delay differences for SBR and SBR+PS */
139#define MAX_DS_FILTER_DELAY (5)                                           /* the additional max downsampler filter delay (source fs) */
140#define DELAY_AAC2SBR(fl,dwnsmp) ((DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + DELAY_QMF_SYN) - DELAY_SBR((fl),(dwnsmp)))
141#define DELAY_ELD2SBR(fl,dwnsmp) ((DELAY_QMF_POSTPROC(dwnsmp)) - DELAY_ELDSBR(fl,dwnsmp))
142#define DELAY_AAC2PS(fl,dwnsmp) ((DELAY_QMF_ANA(dwnsmp) + DELAY_QMF_DS + /*(DELAY_AAC(fl)*2) + */ DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + DELAY_HYB_SYN + DELAY_QMF_SYN) - DELAY_PS(fl,dwnsmp)) /* 2048 - 463*2 */
143
144/* Assumption: The sample delay resulting of of DELAY_AAC2PS is always smaller than the sample delay implied by DELAY_AAC2SBR */
145#define MAX_SAMPLE_DELAY       (DELAY_AAC2SBR(1024,2) + MAX_DS_FILTER_DELAY) /* maximum delay: frame length of 1024 and dual-rate sbr */
146
147/***************************************************************************/
148
149
150
151#define INVALID_TABLE_IDX -1
152
153/***************************************************************************/
154/*!
155
156  \brief  Selects the SBR tuning settings to use dependent on number of
157          channels, bitrate, sample rate and core coder
158
159  \return Index to the appropriate table
160
161****************************************************************************/
162#define DISTANCE_CEIL_VALUE 5000000
163static INT
164getSbrTuningTableIndex(UINT bitrate,    /*! the total bitrate in bits/sec */
165                       UINT numChannels,/*! the number of channels for the core coder */
166                       UINT sampleRate,  /*! the sampling rate of the core coder */
167                       AUDIO_OBJECT_TYPE core,
168                       UINT *pBitRateClosest
169                       )
170{
171  int i, bitRateClosestLowerIndex=-1, bitRateClosestUpperIndex=-1, found = 0;
172  UINT bitRateClosestUpper = 0, bitRateClosestLower=DISTANCE_CEIL_VALUE;
173
174  #define isForThisCore(i) \
175    ( ( sbrTuningTable[i].coreCoder == CODEC_AACLD && core == AOT_ER_AAC_ELD ) || \
176      ( sbrTuningTable[i].coreCoder == CODEC_AAC   && core != AOT_ER_AAC_ELD ) )
177
178  for (i=0; i < sbrTuningTableSize ; i++) {
179    if ( isForThisCore(i) ) /* tuning table is for this core codec */
180    {
181      if ( numChannels == sbrTuningTable [i].numChannels
182        && sampleRate == sbrTuningTable [i].sampleRate )
183      {
184        found = 1;
185        if ((bitrate >= sbrTuningTable [i].bitrateFrom) &&
186            (bitrate < sbrTuningTable [i].bitrateTo)) {
187              bitRateClosestLower = bitrate;
188              bitRateClosestUpper = bitrate;
189              //FDKprintf("entry %d\n", i);
190          return i ;
191        } else {
192          if ( sbrTuningTable [i].bitrateFrom > bitrate ) {
193            if (sbrTuningTable [i].bitrateFrom < bitRateClosestLower) {
194              bitRateClosestLower = sbrTuningTable [i].bitrateFrom;
195              bitRateClosestLowerIndex = i;
196            }
197          }
198          if ( sbrTuningTable [i].bitrateTo <= bitrate ) {
199            if (sbrTuningTable [i].bitrateTo > bitRateClosestUpper) {
200              bitRateClosestUpper = sbrTuningTable [i].bitrateTo-1;
201              bitRateClosestUpperIndex = i;
202            }
203          }
204        }
205      }
206    }
207  }
208
209  if (pBitRateClosest != NULL)
210  {
211    /* If there was at least one matching tuning entry found then pick the least distance bit rate */
212    if (found)
213    {
214      int distanceUpper=DISTANCE_CEIL_VALUE, distanceLower=DISTANCE_CEIL_VALUE;
215      if (bitRateClosestLowerIndex >= 0) {
216        distanceLower = sbrTuningTable [bitRateClosestLowerIndex].bitrateFrom - bitrate;
217      }
218      if (bitRateClosestUpperIndex >= 0) {
219        distanceUpper = bitrate - sbrTuningTable [bitRateClosestUpperIndex].bitrateTo;
220      }
221      if ( distanceUpper < distanceLower )
222      {
223        *pBitRateClosest = bitRateClosestUpper;
224      } else {
225        *pBitRateClosest = bitRateClosestLower;
226      }
227    } else {
228      *pBitRateClosest = 0;
229    }
230  }
231
232  return INVALID_TABLE_IDX;
233}
234
235/***************************************************************************/
236/*!
237
238  \brief  Selects the PS tuning settings to use dependent on bitrate
239  and core coder
240
241  \return Index to the appropriate table
242
243****************************************************************************/
244static INT
245getPsTuningTableIndex(UINT bitrate, UINT *pBitRateClosest){
246
247  INT i, paramSets = sizeof (psTuningTable) / sizeof (psTuningTable [0]);
248  int bitRateClosestLowerIndex=-1, bitRateClosestUpperIndex=-1;
249  UINT bitRateClosestUpper = 0, bitRateClosestLower=DISTANCE_CEIL_VALUE;
250
251  for (i = 0 ; i < paramSets ; i++)  {
252    if ((bitrate >= psTuningTable [i].bitrateFrom) &&
253        (bitrate < psTuningTable [i].bitrateTo)) {
254      return i ;
255    } else {
256      if ( psTuningTable [i].bitrateFrom > bitrate ) {
257        if (psTuningTable [i].bitrateFrom < bitRateClosestLower) {
258          bitRateClosestLower = psTuningTable [i].bitrateFrom;
259          bitRateClosestLowerIndex = i;
260        }
261      }
262      if ( psTuningTable [i].bitrateTo <= bitrate ) {
263        if (psTuningTable [i].bitrateTo > bitRateClosestUpper) {
264          bitRateClosestUpper = psTuningTable [i].bitrateTo-1;
265          bitRateClosestUpperIndex = i;
266        }
267      }
268    }
269  }
270
271  if (pBitRateClosest != NULL)
272  {
273    int distanceUpper=DISTANCE_CEIL_VALUE, distanceLower=DISTANCE_CEIL_VALUE;
274    if (bitRateClosestLowerIndex >= 0) {
275      distanceLower = sbrTuningTable [bitRateClosestLowerIndex].bitrateFrom - bitrate;
276    }
277    if (bitRateClosestUpperIndex >= 0) {
278      distanceUpper = bitrate - sbrTuningTable [bitRateClosestUpperIndex].bitrateTo;
279    }
280    if ( distanceUpper < distanceLower )
281    {
282      *pBitRateClosest = bitRateClosestUpper;
283    } else {
284      *pBitRateClosest = bitRateClosestLower;
285    }
286  }
287
288  return INVALID_TABLE_IDX;
289}
290
291/***************************************************************************/
292/*!
293
294  \brief  In case of downsampled SBR we may need to lower the stop freq
295          of a tuning setting to fit into the lower half of the
296          spectrum ( which is sampleRate/4 )
297
298  \return the adapted stop frequency index (-1 -> error)
299
300  \ingroup SbrEncCfg
301
302****************************************************************************/
303static INT
304FDKsbrEnc_GetDownsampledStopFreq (
305        const INT sampleRateCore,
306        const INT startFreq,
307              INT stopFreq,
308        const INT downSampleFactor
309        )
310{
311  INT maxStopFreqRaw = sampleRateCore / 2;
312  INT startBand, stopBand;
313  HANDLE_ERROR_INFO err;
314
315  while (stopFreq > 0 && FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) > maxStopFreqRaw) {
316    stopFreq--;
317  }
318
319  if (FDKsbrEnc_getSbrStopFreqRAW( stopFreq, sampleRateCore) > maxStopFreqRaw)
320    return -1;
321
322  err = FDKsbrEnc_FindStartAndStopBand (
323                sampleRateCore<<(downSampleFactor-1),
324                sampleRateCore,
325                32<<(downSampleFactor-1),
326                startFreq,
327                stopFreq,
328               &startBand,
329               &stopBand
330                );
331  if (err)
332    return -1;
333
334  return stopFreq;
335}
336
337
338/***************************************************************************/
339/*!
340
341  \brief  tells us, if for the given coreCoder, bitrate, number of channels
342          and input sampling rate an SBR setting is available. If yes, it
343          tells us also the core sampling rate we would need to run with
344
345  \return a flag indicating success: yes (1) or no (0)
346
347****************************************************************************/
348static UINT
349FDKsbrEnc_IsSbrSettingAvail (
350        UINT bitrate,           /*! the total bitrate in bits/sec */
351        UINT vbrMode,           /*! the vbr paramter, 0 means constant bitrate */
352        UINT numOutputChannels, /*! the number of channels for the core coder */
353        UINT sampleRateInput,   /*! the input sample rate [in Hz] */
354        UINT sampleRateCore,    /*! the core's sampling rate */
355        AUDIO_OBJECT_TYPE core
356        )
357{
358  INT idx = INVALID_TABLE_IDX;
359
360  if (sampleRateInput < 16000)
361    return 0;
362
363  if (bitrate==0) {
364    /* map vbr quality to bitrate */
365    if (vbrMode < 30)
366      bitrate = 24000;
367    else if (vbrMode < 40)
368      bitrate = 28000;
369    else if (vbrMode < 60)
370      bitrate = 32000;
371    else if (vbrMode < 75)
372      bitrate = 40000;
373    else
374      bitrate = 48000;
375    bitrate *= numOutputChannels;
376  }
377
378  idx = getSbrTuningTableIndex(bitrate, numOutputChannels, sampleRateCore, core, NULL);
379
380  return (idx == INVALID_TABLE_IDX ? 0 : 1);
381}
382
383
384/***************************************************************************/
385/*!
386
387  \brief  Adjusts the SBR settings according to the chosen core coder
388          settings which are accessible via config->codecSettings
389
390  \return A flag indicating success: yes (1) or no (0)
391
392****************************************************************************/
393static UINT
394FDKsbrEnc_AdjustSbrSettings (const sbrConfigurationPtr config, /*! output, modified */
395                   UINT bitRate,             /*! the total bitrate in bits/sec */
396                   UINT numChannels,         /*! the core coder number of channels */
397                   UINT sampleRateCore,      /*! the core coder sampling rate in Hz */
398                   UINT sampleRateSbr,       /*! the sbr coder sampling rate in Hz */
399                   UINT transFac,            /*! the short block to long block ratio */
400                   UINT standardBitrate,     /*! the standard bitrate per channel in bits/sec */
401                   UINT vbrMode,             /*! the vbr paramter, 0 poor quality .. 100 high quality*/
402                   UINT useSpeechConfig,     /*!< adapt tuning parameters for speech ? */
403                   UINT lcsMode,             /*! the low complexity stereo mode */
404                   UINT bParametricStereo,   /*!< use parametric stereo */
405                   AUDIO_OBJECT_TYPE core)   /* Core audio codec object type */
406{
407  INT idx = INVALID_TABLE_IDX;
408  /* set the core codec settings */
409  config->codecSettings.bitRate         = bitRate;
410  config->codecSettings.nChannels       = numChannels;
411  config->codecSettings.sampleFreq      = sampleRateCore;
412  config->codecSettings.transFac        = transFac;
413  config->codecSettings.standardBitrate = standardBitrate;
414
415  if (bitRate==0) {
416    /* map vbr quality to bitrate */
417    if (vbrMode < 30)
418      bitRate = 24000;
419    else if (vbrMode < 40)
420      bitRate = 28000;
421    else if (vbrMode < 60)
422      bitRate = 32000;
423    else if (vbrMode < 75)
424      bitRate = 40000;
425    else
426      bitRate = 48000;
427    bitRate *= numChannels;
428    /* fix to enable mono vbrMode<40 @ 44.1 of 48kHz */
429    if (numChannels==1) {
430      if (sampleRateSbr==44100 || sampleRateSbr==48000) {
431        if (vbrMode<40) bitRate = 32000;
432      }
433    }
434  }
435
436  idx = getSbrTuningTableIndex(bitRate,numChannels,sampleRateCore, core, NULL);
437
438  if (idx != INVALID_TABLE_IDX) {
439    config->startFreq       = sbrTuningTable[idx].startFreq ;
440    config->stopFreq        = sbrTuningTable[idx].stopFreq ;
441    if (useSpeechConfig) {
442      config->startFreq     = sbrTuningTable[idx].startFreqSpeech;
443      config->stopFreq      = sbrTuningTable[idx].stopFreqSpeech;
444    }
445
446    /* Adapt stop frequency in case of downsampled SBR - only 32 bands then */
447    if (1 == config->downSampleFactor) {
448      INT dsStopFreq = FDKsbrEnc_GetDownsampledStopFreq(
449                               sampleRateCore,
450                               config->startFreq,
451                               config->stopFreq,
452                               config->downSampleFactor
453                               );
454      if (dsStopFreq < 0) {
455        return 0;
456      }
457
458      config->stopFreq = dsStopFreq;
459    }
460
461    config->sbr_noise_bands = sbrTuningTable[idx].numNoiseBands ;
462    if (core == AOT_ER_AAC_ELD)
463      config->init_amp_res_FF = SBR_AMP_RES_1_5;
464    config->noiseFloorOffset= sbrTuningTable[idx].noiseFloorOffset;
465
466    config->ana_max_level   = sbrTuningTable[idx].noiseMaxLevel ;
467    config->stereoMode      = sbrTuningTable[idx].stereoMode ;
468    config->freqScale       = sbrTuningTable[idx].freqScale ;
469
470    /* adjust usage of parametric coding dependent on bitrate and speech config flag */
471    if (useSpeechConfig)
472      config->parametricCoding  = 0;
473
474    if (core == AOT_ER_AAC_ELD) {
475      if (bitRate < 28000)
476        config->init_amp_res_FF = SBR_AMP_RES_3_0;
477      config->SendHeaderDataTime = -1;
478    }
479
480    if (numChannels == 1) {
481      if (bitRate < 16000) {
482        config->parametricCoding  = 0;
483      }
484    }
485    else {
486      if (bitRate < 20000) {
487        config->parametricCoding  = 0;
488      }
489    }
490
491    config->useSpeechConfig = useSpeechConfig;
492
493    /* PS settings */
494    config->bParametricStereo = bParametricStereo;
495
496    return 1 ;
497  }
498  else {
499    return 0 ;
500  }
501}
502
503/*****************************************************************************
504
505 functionname: FDKsbrEnc_InitializeSbrDefaults
506 description:  initializes the SBR confifuration
507 returns:      error status
508 input:        - core codec type,
509               - factor of SBR to core frame length,
510               - core frame length
511 output:       initialized SBR configuration
512
513*****************************************************************************/
514static UINT
515FDKsbrEnc_InitializeSbrDefaults (sbrConfigurationPtr config,
516                                 INT                 downSampleFactor,
517                                 UINT                codecGranuleLen
518                                 )
519{
520    if ( (downSampleFactor < 1 || downSampleFactor > 2) ||
521         (codecGranuleLen*downSampleFactor > QMF_CHANNELS*QMF_MAX_TIME_SLOTS) )
522       return(0); /* error */
523
524    config->SendHeaderDataTime     = 1000;
525    config->useWaveCoding          = 0;
526    config->crcSbr                 = 0;
527    config->dynBwSupported         = 1;
528    config->tran_thr               = 13000;
529    config->parametricCoding       = 1;
530
531    config->sbrFrameSize           = codecGranuleLen * downSampleFactor;
532    config->downSampleFactor       = downSampleFactor;
533
534    /* sbr default parameters */
535    config->sbr_data_extra         = 0;
536    config->amp_res                = SBR_AMP_RES_3_0 ;
537    config->tran_fc                = 0 ;
538    config->tran_det_mode          = 1 ;
539    config->spread                 = 1 ;
540    config->stat                   = 0 ;
541    config->e                      = 1 ;
542    config->deltaTAcrossFrames     = 1 ;
543    config->dF_edge_1stEnv         = FL2FXCONST_DBL(0.3f) ;
544    config->dF_edge_incr           = FL2FXCONST_DBL(0.3f) ;
545
546    config->sbr_invf_mode   = INVF_SWITCHED;
547    config->sbr_xpos_mode   = XPOS_LC;
548    config->sbr_xpos_ctrl   = SBR_XPOS_CTRL_DEFAULT;
549    config->sbr_xpos_level  = 0;
550    config->useSaPan        = 0;
551    config->dynBwEnabled    = 0;
552
553
554    /* the following parameters are overwritten by the FDKsbrEnc_AdjustSbrSettings() function since
555       they are included in the tuning table */
556    config->stereoMode             = SBR_SWITCH_LRC;
557    config->ana_max_level          = 6;
558    config->noiseFloorOffset       = 0;
559    config->startFreq              = 5; /*  5.9 respectively  6.0 kHz at fs = 44.1/48 kHz */
560    config->stopFreq               = 9; /* 16.2 respectively 16.8 kHz at fs = 44.1/48 kHz */
561
562
563    /* header_extra_1 */
564    config->freqScale       = SBR_FREQ_SCALE_DEFAULT;
565    config->alterScale      = SBR_ALTER_SCALE_DEFAULT;
566    config->sbr_noise_bands = SBR_NOISE_BANDS_DEFAULT;
567
568    /* header_extra_2 */
569    config->sbr_limiter_bands    = SBR_LIMITER_BANDS_DEFAULT;
570    config->sbr_limiter_gains    = SBR_LIMITER_GAINS_DEFAULT;
571    config->sbr_interpol_freq    = SBR_INTERPOL_FREQ_DEFAULT;
572    config->sbr_smoothing_length = SBR_SMOOTHING_LENGTH_DEFAULT;
573
574    return 1;
575}
576
577
578/*****************************************************************************
579
580 functionname: DeleteEnvChannel
581 description:  frees memory of one SBR channel
582 returns:      -
583 input:        handle of channel
584 output:       released handle
585
586*****************************************************************************/
587static void
588deleteEnvChannel (HANDLE_ENV_CHANNEL hEnvCut)
589{
590  if (hEnvCut) {
591
592    FDKsbrEnc_DeleteTonCorrParamExtr(&hEnvCut->TonCorr);
593
594    FDKsbrEnc_deleteExtractSbrEnvelope (&hEnvCut->sbrExtractEnvelope);
595  }
596
597}
598
599
600/*****************************************************************************
601
602 functionname: sbrEncoder_ChannelClose
603 description:  close the channel coding handle
604 returns:
605 input:        phSbrChannel
606 output:
607
608*****************************************************************************/
609static void
610sbrEncoder_ChannelClose(HANDLE_SBR_CHANNEL hSbrChannel)
611{
612  if (hSbrChannel != NULL)
613  {
614    deleteEnvChannel (&hSbrChannel->hEnvChannel);
615  }
616}
617
618/*****************************************************************************
619
620 functionname: sbrEncoder_ElementClose
621 description:  close the channel coding handle
622 returns:
623 input:        phSbrChannel
624 output:
625
626*****************************************************************************/
627static void
628sbrEncoder_ElementClose(HANDLE_SBR_ELEMENT *phSbrElement)
629{
630  HANDLE_SBR_ELEMENT hSbrElement = *phSbrElement;
631
632  if (hSbrElement!=NULL) {
633    if (hSbrElement->sbrConfigData.v_k_master)
634      FreeRam_Sbr_v_k_master(&hSbrElement->sbrConfigData.v_k_master);
635    if (hSbrElement->sbrConfigData.freqBandTable[LO])
636      FreeRam_Sbr_freqBandTableLO(&hSbrElement->sbrConfigData.freqBandTable[LO]);
637    if (hSbrElement->sbrConfigData.freqBandTable[HI])
638      FreeRam_Sbr_freqBandTableHI(&hSbrElement->sbrConfigData.freqBandTable[HI]);
639
640    FreeRam_SbrElement(phSbrElement);
641  }
642  return ;
643
644}
645
646
647void sbrEncoder_Close (HANDLE_SBR_ENCODER *phSbrEncoder)
648{
649  HANDLE_SBR_ENCODER hSbrEncoder = *phSbrEncoder;
650
651  if (hSbrEncoder != NULL)
652  {
653    int el, ch;
654
655    for (el=0; el<(8); el++)
656    {
657      if (hSbrEncoder->sbrElement[el]!=NULL) {
658        sbrEncoder_ElementClose(&hSbrEncoder->sbrElement[el]);
659      }
660    }
661
662    /* Close sbr Channels */
663    for (ch=0; ch<(8); ch++)
664    {
665      if (hSbrEncoder->pSbrChannel[ch]) {
666        sbrEncoder_ChannelClose(hSbrEncoder->pSbrChannel[ch]);
667        FreeRam_SbrChannel(&hSbrEncoder->pSbrChannel[ch]);
668      }
669
670      if (hSbrEncoder->QmfAnalysis[ch].FilterStates)
671        FreeRam_Sbr_QmfStatesAnalysis((FIXP_QAS**)&hSbrEncoder->QmfAnalysis[ch].FilterStates);
672
673
674    }
675
676    if (hSbrEncoder->hParametricStereo)
677      PSEnc_Destroy(&hSbrEncoder->hParametricStereo);
678    if (hSbrEncoder->qmfSynthesisPS.FilterStates)
679      FreeRam_PsQmfStatesSynthesis((FIXP_DBL**)&hSbrEncoder->qmfSynthesisPS.FilterStates);
680
681    /* Release Overlay */
682    FreeRam_SbrDynamic_RAM((FIXP_DBL**)&hSbrEncoder->pSBRdynamic_RAM);
683
684
685    FreeRam_SbrEncoder(phSbrEncoder);
686  }
687
688}
689
690/*****************************************************************************
691
692 functionname: updateFreqBandTable
693 description:  updates vk_master
694 returns:      -
695 input:        config handle
696 output:       error info
697
698*****************************************************************************/
699static INT updateFreqBandTable(
700        HANDLE_SBR_CONFIG_DATA  sbrConfigData,
701        HANDLE_SBR_HEADER_DATA  sbrHeaderData,
702        const INT               downSampleFactor
703        )
704{
705  INT k0, k2;
706
707  if( FDKsbrEnc_FindStartAndStopBand (
708              sbrConfigData->sampleFreq,
709              sbrConfigData->sampleFreq >> (downSampleFactor-1),
710              sbrConfigData->noQmfBands,
711              sbrHeaderData->sbr_start_frequency,
712              sbrHeaderData->sbr_stop_frequency,
713             &k0,
714             &k2
715              )
716    )
717    return(1);
718
719
720  if( FDKsbrEnc_UpdateFreqScale(
721              sbrConfigData->v_k_master,
722             &sbrConfigData->num_Master,
723              k0,
724              k2,
725              sbrHeaderData->freqScale,
726              sbrHeaderData->alterScale
727              )
728    )
729    return(1);
730
731
732  sbrHeaderData->sbr_xover_band=0;
733
734
735  if( FDKsbrEnc_UpdateHiRes(
736              sbrConfigData->freqBandTable[HI],
737              &sbrConfigData->nSfb[HI],
738              sbrConfigData->v_k_master,
739              sbrConfigData->num_Master,
740              &sbrHeaderData->sbr_xover_band
741              )
742    )
743    return(1);
744
745
746  FDKsbrEnc_UpdateLoRes(
747          sbrConfigData->freqBandTable[LO],
748          &sbrConfigData->nSfb[LO],
749          sbrConfigData->freqBandTable[HI],
750          sbrConfigData->nSfb[HI]
751          );
752
753
754  sbrConfigData->xOverFreq = (sbrConfigData->freqBandTable[LOW_RES][0] * sbrConfigData->sampleFreq / sbrConfigData->noQmfBands+1)>>1;
755
756  return (0);
757}
758
759
760/*****************************************************************************
761
762 functionname: resetEnvChannel
763 description:  resets parameters and allocates memory
764 returns:      error status
765 input:
766 output:       hEnv
767
768*****************************************************************************/
769static INT resetEnvChannel (HANDLE_SBR_CONFIG_DATA  sbrConfigData,
770                            HANDLE_SBR_HEADER_DATA  sbrHeaderData,
771                            HANDLE_ENV_CHANNEL      hEnv)
772{
773  /* note !!! hEnv->encEnvData.noOfnoisebands will be updated later in function FDKsbrEnc_extractSbrEnvelope !!!*/
774  hEnv->TonCorr.sbrNoiseFloorEstimate.noiseBands =  sbrHeaderData->sbr_noise_bands;
775
776
777  if(FDKsbrEnc_ResetTonCorrParamExtr(&hEnv->TonCorr,
778                           sbrConfigData->xposCtrlSwitch,
779                           sbrConfigData->freqBandTable[HI][0],
780                           sbrConfigData->v_k_master,
781                           sbrConfigData->num_Master,
782                           sbrConfigData->sampleFreq,
783                           sbrConfigData->freqBandTable,
784                           sbrConfigData->nSfb,
785                           sbrConfigData->noQmfBands))
786    return(1);
787
788  hEnv->sbrCodeNoiseFloor.nSfb[LO] = hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
789  hEnv->sbrCodeNoiseFloor.nSfb[HI] = hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
790
791  hEnv->sbrCodeEnvelope.nSfb[LO] = sbrConfigData->nSfb[LO];
792  hEnv->sbrCodeEnvelope.nSfb[HI] = sbrConfigData->nSfb[HI];
793
794  hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];
795
796  hEnv->sbrCodeEnvelope.upDate = 0;
797  hEnv->sbrCodeNoiseFloor.upDate = 0;
798
799  return (0);
800}
801
802/* ****************************** FDKsbrEnc_SbrGetXOverFreq ******************************/
803/**
804 * @fn
805 * @brief       calculates the closest possible crossover frequency
806 * @return      the crossover frequency SBR accepts
807 *
808 */
809static INT
810FDKsbrEnc_SbrGetXOverFreq(HANDLE_SBR_ELEMENT  hEnv,        /*!< handle to SBR encoder instance */
811                          INT                 xoverFreq)   /*!< from core coder suggested crossover frequency */
812{
813  INT band;
814  INT lastDiff, newDiff;
815  INT cutoffSb;
816
817  UCHAR *RESTRICT pVKMaster = hEnv->sbrConfigData.v_k_master;
818
819  /* Check if there is a matching cutoff frequency in the master table */
820  cutoffSb = (4*xoverFreq * hEnv->sbrConfigData.noQmfBands / hEnv->sbrConfigData.sampleFreq + 1)>>1;
821  lastDiff = cutoffSb;
822  for (band = 0; band < hEnv->sbrConfigData.num_Master; band++) {
823
824    newDiff = fixp_abs((INT)pVKMaster[band] - cutoffSb);
825
826    if(newDiff >= lastDiff) {
827      band--;
828      break;
829    }
830
831    lastDiff = newDiff;
832  }
833
834  return ((pVKMaster[band] * hEnv->sbrConfigData.sampleFreq/hEnv->sbrConfigData.noQmfBands+1)>>1);
835}
836
837/*****************************************************************************
838
839 functionname: FDKsbrEnc_EnvEncodeFrame
840 description: performs the sbr envelope calculation for one element
841 returns:
842 input:
843 output:
844
845*****************************************************************************/
846INT
847FDKsbrEnc_EnvEncodeFrame(HANDLE_SBR_ENCODER   hEnvEncoder,
848                         int                  iElement,
849                         INT_PCM             *samples,                 /*!< time samples, always interleaved */
850                         UINT                 timeInStride,            /*!< time buffer channel interleaving stride */
851                         UINT                *sbrDataBits,             /*!< Size of SBR payload  */
852                         UCHAR               *sbrData,                 /*!< SBR payload  */
853                         int                  clearOutput              /*!< Do not consider any input signal */
854                        )
855{
856  HANDLE_SBR_ELEMENT hSbrElement = NULL;
857  FDK_CRCINFO  crcInfo;
858  INT    crcReg;
859  INT    ch;
860  INT    band;
861  INT    cutoffSb;
862  INT    newXOver;
863
864  if (hEnvEncoder == NULL)
865    return -1;
866
867  hSbrElement = hEnvEncoder->sbrElement[iElement];
868
869  if (hSbrElement == NULL)
870    return -1;
871
872
873  /* header bitstream handling */
874  HANDLE_SBR_BITSTREAM_DATA sbrBitstreamData = &hSbrElement->sbrBitstreamData;
875
876  INT psHeaderActive = 0;
877  sbrBitstreamData->HeaderActive = 0;
878
879  /* Anticipate PS header because of internal PS bitstream delay in order to be in sync with SBR header. */
880  if ( sbrBitstreamData->CountSendHeaderData==(sbrBitstreamData->NrSendHeaderData-1) )
881  {
882      psHeaderActive = 1;
883  }
884
885  /* Signal SBR header to be written into bitstream */
886  if ( sbrBitstreamData->CountSendHeaderData==0  )
887  {
888     sbrBitstreamData->HeaderActive = 1;
889  }
890
891  /* Increment header interval counter */
892  if (sbrBitstreamData->NrSendHeaderData == 0) {
893    sbrBitstreamData->CountSendHeaderData = 1;
894  }
895  else {
896    if (sbrBitstreamData->CountSendHeaderData >= 0) {
897      sbrBitstreamData->CountSendHeaderData++;
898      sbrBitstreamData->CountSendHeaderData %= sbrBitstreamData->NrSendHeaderData;
899    }
900  }
901
902  if (hSbrElement->CmonData.dynBwEnabled ) {
903    INT i;
904    for ( i = 4; i > 0; i-- )
905      hSbrElement->dynXOverFreqDelay[i] = hSbrElement->dynXOverFreqDelay[i-1];
906
907    hSbrElement->dynXOverFreqDelay[0] = hSbrElement->CmonData.dynXOverFreqEnc;
908    if (hSbrElement->dynXOverFreqDelay[1] > hSbrElement->dynXOverFreqDelay[2])
909      newXOver = hSbrElement->dynXOverFreqDelay[2];
910    else
911      newXOver = hSbrElement->dynXOverFreqDelay[1];
912
913    /* has the crossover frequency changed? */
914    if ( hSbrElement->sbrConfigData.dynXOverFreq != newXOver ) {
915
916      /* get corresponding master band */
917      cutoffSb = ((4* newXOver * hSbrElement->sbrConfigData.noQmfBands
918                  / hSbrElement->sbrConfigData.sampleFreq)+1)>>1;
919
920      for ( band = 0; band < hSbrElement->sbrConfigData.num_Master; band++ ) {
921        if ( cutoffSb == hSbrElement->sbrConfigData.v_k_master[band] )
922          break;
923      }
924      FDK_ASSERT( band < hSbrElement->sbrConfigData.num_Master );
925
926      hSbrElement->sbrConfigData.dynXOverFreq = newXOver;
927      hSbrElement->sbrHeaderData.sbr_xover_band = band;
928      hSbrElement->sbrBitstreamData.HeaderActive=1;
929      psHeaderActive = 1; /* ps header is one frame delayed */
930
931      /*
932        update vk_master table
933      */
934      if(updateFreqBandTable(&hSbrElement->sbrConfigData,
935                             &hSbrElement->sbrHeaderData,
936                             hEnvEncoder->downSampleFactor
937                             ))
938        return(1);
939
940
941      /* reset SBR channels */
942      INT nEnvCh = hSbrElement->sbrConfigData.nChannels;
943      for ( ch = 0; ch < nEnvCh; ch++ ) {
944        if(resetEnvChannel (&hSbrElement->sbrConfigData,
945                            &hSbrElement->sbrHeaderData,
946                            &hSbrElement->sbrChannel[ch]->hEnvChannel))
947          return(1);
948
949      }
950    }
951  }
952
953  /*
954    allocate space for dummy header and crc
955  */
956  crcReg = FDKsbrEnc_InitSbrBitstream(&hSbrElement->CmonData,
957                                       hSbrElement->payloadDelayLine[hEnvEncoder->nBitstrDelay],
958                                       MAX_PAYLOAD_SIZE*sizeof(UCHAR),
959                                      &crcInfo,
960                                       hSbrElement->sbrConfigData.sbrSyntaxFlags);
961
962  /* Temporal Envelope Data */
963  SBR_FRAME_TEMP_DATA _fData;
964  SBR_FRAME_TEMP_DATA *fData = &_fData;
965  SBR_ENV_TEMP_DATA eData[MAX_NUM_CHANNELS];
966
967  /* Init Temporal Envelope Data */
968  {
969    int i;
970
971    FDKmemclear(&eData[0], sizeof(SBR_ENV_TEMP_DATA));
972    FDKmemclear(&eData[1], sizeof(SBR_ENV_TEMP_DATA));
973    FDKmemclear(fData, sizeof(SBR_FRAME_TEMP_DATA));
974
975    for(i=0; i<MAX_NUM_NOISE_VALUES; i++)
976      fData->res[i] = FREQ_RES_HIGH;
977  }
978
979
980  if (!clearOutput)
981  {
982    /*
983     * Transform audio data into QMF domain
984     */
985    for(ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++)
986    {
987      HANDLE_ENV_CHANNEL h_envChan = &hSbrElement->sbrChannel[ch]->hEnvChannel;
988      HANDLE_SBR_EXTRACT_ENVELOPE sbrExtrEnv = &h_envChan->sbrExtractEnvelope;
989
990      if(hSbrElement->elInfo.fParametricStereo == 0)
991      {
992        QMF_SCALE_FACTOR tmpScale;
993        FIXP_DBL **pQmfReal, **pQmfImag;
994        C_AALLOC_SCRATCH_START(qmfWorkBuffer, FIXP_DBL, QMF_CHANNELS*2)
995
996
997        /* Obtain pointers to QMF buffers. */
998        pQmfReal = sbrExtrEnv->rBuffer;
999        pQmfImag = sbrExtrEnv->iBuffer;
1000
1001        qmfAnalysisFiltering( hSbrElement->hQmfAnalysis[ch],
1002                               pQmfReal,
1003                               pQmfImag,
1004                              &tmpScale,
1005                               samples + hSbrElement->elInfo.ChannelIndex[ch],
1006                               timeInStride,
1007                               qmfWorkBuffer );
1008
1009        h_envChan->qmfScale = tmpScale.lb_scale + 7;
1010
1011
1012        C_AALLOC_SCRATCH_END(qmfWorkBuffer, FIXP_DBL, QMF_CHANNELS*2)
1013
1014      } /* fParametricStereo == 0 */
1015
1016
1017      /*
1018        Parametric Stereo processing
1019      */
1020      if (hSbrElement->elInfo.fParametricStereo)
1021      {
1022        INT error = noError;
1023
1024
1025        /* Limit Parametric Stereo to one instance */
1026        FDK_ASSERT(ch == 0);
1027
1028
1029        if(error == noError){
1030          /* parametric stereo processing:
1031             - input:
1032               o left and right time domain samples
1033             - processing:
1034               o stereo qmf analysis
1035               o stereo hybrid analysis
1036               o ps parameter extraction
1037               o downmix + hybrid synthesis
1038             - output:
1039               o downmixed qmf data is written to sbrExtrEnv->rBuffer and sbrExtrEnv->iBuffer
1040          */
1041          SCHAR qmfScale;
1042          INT_PCM* pSamples[2] = {samples + hSbrElement->elInfo.ChannelIndex[0],samples + hSbrElement->elInfo.ChannelIndex[1]};
1043          error = FDKsbrEnc_PSEnc_ParametricStereoProcessing( hEnvEncoder->hParametricStereo,
1044                                                              pSamples,
1045                                                              timeInStride,
1046                                                              hSbrElement->hQmfAnalysis,
1047                                                              sbrExtrEnv->rBuffer,
1048                                                              sbrExtrEnv->iBuffer,
1049                                                              samples + hSbrElement->elInfo.ChannelIndex[ch],
1050                                                             &hEnvEncoder->qmfSynthesisPS,
1051                                                             &qmfScale,
1052                                                              psHeaderActive );
1053          if (noError != error)
1054          {
1055            error = handBack(error);
1056          }
1057          h_envChan->qmfScale = (int)qmfScale;
1058        }
1059
1060
1061      } /* if (hEnvEncoder->hParametricStereo) */
1062
1063      /*
1064
1065         Extract Envelope relevant things from QMF data
1066
1067      */
1068      FDKsbrEnc_extractSbrEnvelope1(
1069                                &hSbrElement->sbrConfigData,
1070                                &hSbrElement->sbrHeaderData,
1071                                &hSbrElement->sbrBitstreamData,
1072                                 h_envChan,
1073                                &hSbrElement->CmonData,
1074                                &eData[ch],
1075                                 fData
1076                                 );
1077
1078    } /* hEnvEncoder->sbrConfigData.nChannels */
1079 }
1080
1081  /*
1082     Process Envelope relevant things and calculate envelope data and write payload
1083  */
1084  FDKsbrEnc_extractSbrEnvelope2(
1085                                &hSbrElement->sbrConfigData,
1086                                &hSbrElement->sbrHeaderData,
1087                                (hSbrElement->elInfo.fParametricStereo) ? hEnvEncoder->hParametricStereo : NULL,
1088                                &hSbrElement->sbrBitstreamData,
1089                                &hSbrElement->sbrChannel[0]->hEnvChannel,
1090                                &hSbrElement->sbrChannel[1]->hEnvChannel,
1091                                &hSbrElement->CmonData,
1092                                 eData,
1093                                 fData,
1094                                 clearOutput
1095                               );
1096
1097  /*
1098    format payload, calculate crc
1099  */
1100  FDKsbrEnc_AssembleSbrBitstream(&hSbrElement->CmonData, &crcInfo, crcReg, hSbrElement->sbrConfigData.sbrSyntaxFlags);
1101
1102  /*
1103    save new payload, set to zero length if greater than MAX_PAYLOAD_SIZE
1104  */
1105  hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] = FDKgetValidBits(&hSbrElement->CmonData.sbrBitbuf);
1106
1107  if(hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] > (MAX_PAYLOAD_SIZE<<3))
1108    hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay]=0;
1109
1110  /* While filling the Delay lines, sbrData is NULL */
1111  if (sbrData) {
1112    *sbrDataBits = hSbrElement->payloadDelayLineSize[0];
1113    FDKmemcpy(sbrData, hSbrElement->payloadDelayLine[0], (hSbrElement->payloadDelayLineSize[0]+7)>>3);
1114
1115
1116  }
1117
1118
1119/*******************************/
1120
1121  if (hEnvEncoder->fTimeDomainDownsampling)
1122  {
1123    int ch;
1124    int nChannels = hSbrElement->sbrConfigData.nChannels;
1125
1126    for (ch=0; ch < nChannels; ch++)
1127    {
1128      INT nOutSamples;
1129
1130      FDKaacEnc_Downsample(&hSbrElement->sbrChannel[ch]->downSampler,
1131                            samples + hSbrElement->elInfo.ChannelIndex[ch] + hEnvEncoder->bufferOffset,
1132                            hSbrElement->sbrConfigData.frameSize,
1133                            timeInStride,
1134                            samples + hSbrElement->elInfo.ChannelIndex[ch],
1135                           &nOutSamples,
1136                            hEnvEncoder->nChannels);
1137    }
1138  } /* downsample */
1139
1140
1141  return (0);
1142}
1143
1144/*****************************************************************************
1145
1146 functionname: createEnvChannel
1147 description:  initializes parameters and allocates memory
1148 returns:      error status
1149 input:
1150 output:       hEnv
1151
1152*****************************************************************************/
1153
1154static INT
1155createEnvChannel (HANDLE_ENV_CHANNEL     hEnv,
1156                  INT                    channel
1157                 ,UCHAR*                 dynamic_RAM
1158                 )
1159{
1160  FDKmemclear(hEnv,sizeof (struct ENV_CHANNEL));
1161
1162  if ( FDKsbrEnc_CreateTonCorrParamExtr(&hEnv->TonCorr,
1163                                         channel) )
1164  {
1165    return(1);
1166  }
1167
1168  if ( FDKsbrEnc_CreateExtractSbrEnvelope (&hEnv->sbrExtractEnvelope,
1169                               channel
1170                              ,/*chan*/0
1171                              ,dynamic_RAM
1172                              ) )
1173  {
1174    return(1);
1175  }
1176
1177  return 0;
1178}
1179
1180/*****************************************************************************
1181
1182 functionname: initEnvChannel
1183 description:  initializes parameters
1184 returns:      error status
1185 input:
1186 output:
1187
1188*****************************************************************************/
1189static INT
1190initEnvChannel (  HANDLE_SBR_CONFIG_DATA sbrConfigData,
1191                  HANDLE_SBR_HEADER_DATA sbrHeaderData,
1192                  HANDLE_ENV_CHANNEL     hEnv,
1193                  sbrConfigurationPtr    params,
1194                  ULONG                  statesInitFlag
1195                 ,INT                    chanInEl
1196                 ,UCHAR*                 dynamic_RAM
1197                 )
1198{
1199  int frameShift, tran_off=0;
1200  INT e;
1201  INT tran_fc;
1202  INT timeSlots, timeStep, startIndex;
1203  INT noiseBands[2] = { 3, 3 };
1204
1205  e = 1 << params->e;
1206
1207  FDK_ASSERT(params->e >= 0);
1208
1209  hEnv->encEnvData.freq_res_fixfix = 1;
1210  hEnv->fLevelProtect = 0;
1211
1212  hEnv->encEnvData.ldGrid = (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) ? 1 : 0;
1213
1214  hEnv->encEnvData.sbr_xpos_mode = (XPOS_MODE)params->sbr_xpos_mode;
1215
1216  if (hEnv->encEnvData.sbr_xpos_mode == XPOS_SWITCHED) {
1217    /*
1218       no other type than XPOS_MDCT or XPOS_SPEECH allowed,
1219       but enable switching
1220    */
1221    sbrConfigData->switchTransposers = TRUE;
1222    hEnv->encEnvData.sbr_xpos_mode = XPOS_MDCT;
1223  }
1224  else {
1225    sbrConfigData->switchTransposers = FALSE;
1226  }
1227
1228  hEnv->encEnvData.sbr_xpos_ctrl = params->sbr_xpos_ctrl;
1229
1230
1231  /* extended data */
1232  if(params->parametricCoding) {
1233    hEnv->encEnvData.extended_data = 1;
1234  }
1235  else {
1236    hEnv->encEnvData.extended_data = 0;
1237  }
1238
1239  hEnv->encEnvData.extension_size = 0;
1240
1241  startIndex = QMF_FILTER_PROTOTYPE_SIZE - sbrConfigData->noQmfBands;
1242
1243  switch (params->sbrFrameSize) {
1244  case 2304:
1245    timeSlots = 18;
1246    break;
1247  case 2048:
1248  case 1024:
1249  case 512:
1250    timeSlots = 16;
1251    break;
1252  case 1920:
1253  case 960:
1254  case 480:
1255    timeSlots = 15;
1256    break;
1257  case 1152:
1258    timeSlots = 9;
1259    break;
1260  default:
1261    return (1); /* Illegal frame size */
1262  }
1263
1264  timeStep = sbrConfigData->noQmfSlots / timeSlots;
1265
1266  if ( FDKsbrEnc_InitTonCorrParamExtr(params->sbrFrameSize,
1267                                     &hEnv->TonCorr,
1268                                      sbrConfigData,
1269                                      timeSlots,
1270                                      params->sbr_xpos_ctrl,
1271                                      params->ana_max_level,
1272                                      sbrHeaderData->sbr_noise_bands,
1273                                      params->noiseFloorOffset,
1274                                      params->useSpeechConfig) )
1275    return(1);
1276
1277  hEnv->encEnvData.noOfnoisebands = hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
1278
1279  noiseBands[0] = hEnv->encEnvData.noOfnoisebands;
1280  noiseBands[1] = hEnv->encEnvData.noOfnoisebands;
1281
1282  hEnv->encEnvData.sbr_invf_mode = (INVF_MODE)params->sbr_invf_mode;
1283
1284  if (hEnv->encEnvData.sbr_invf_mode == INVF_SWITCHED) {
1285    hEnv->encEnvData.sbr_invf_mode = INVF_MID_LEVEL;
1286    hEnv->TonCorr.switchInverseFilt = TRUE;
1287  }
1288  else {
1289    hEnv->TonCorr.switchInverseFilt = FALSE;
1290  }
1291
1292
1293  tran_fc  = params->tran_fc;
1294
1295  if (tran_fc == 0) {
1296    tran_fc = fixMin (5000, FDKsbrEnc_getSbrStartFreqRAW (sbrHeaderData->sbr_start_frequency,params->codecSettings.sampleFreq));
1297  }
1298
1299  tran_fc = (tran_fc*4*sbrConfigData->noQmfBands/sbrConfigData->sampleFreq + 1)>>1;
1300
1301  if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
1302    frameShift = LD_PRETRAN_OFF;
1303    tran_off = LD_PRETRAN_OFF + FRAME_MIDDLE_SLOT_512LD*timeStep;
1304  } else
1305  {
1306    frameShift = 0;
1307    switch (timeSlots) {
1308      /* The factor of 2 is by definition. */
1309      case NUMBER_TIME_SLOTS_2048: tran_off = 8 + FRAME_MIDDLE_SLOT_2048 * timeStep; break;
1310      case NUMBER_TIME_SLOTS_1920: tran_off = 7 + FRAME_MIDDLE_SLOT_1920 * timeStep; break;
1311      default: return 1;
1312    }
1313  }
1314  if ( FDKsbrEnc_InitExtractSbrEnvelope (&hEnv->sbrExtractEnvelope,
1315                               sbrConfigData->noQmfSlots,
1316                               sbrConfigData->noQmfBands, startIndex,
1317                               timeSlots, timeStep, tran_off,
1318                               statesInitFlag
1319                              ,chanInEl
1320                              ,dynamic_RAM
1321                              ,sbrConfigData->sbrSyntaxFlags
1322                               ) )
1323    return(1);
1324
1325  if(FDKsbrEnc_InitSbrCodeEnvelope (&hEnv->sbrCodeEnvelope,
1326                            sbrConfigData->nSfb,
1327                            params->deltaTAcrossFrames,
1328                            params->dF_edge_1stEnv,
1329                            params->dF_edge_incr))
1330    return(1);
1331
1332  if(FDKsbrEnc_InitSbrCodeEnvelope (&hEnv->sbrCodeNoiseFloor,
1333                            noiseBands,
1334                            params->deltaTAcrossFrames,
1335                            0,0))
1336    return(1);
1337
1338  sbrConfigData->initAmpResFF = params->init_amp_res_FF;
1339
1340  if(FDKsbrEnc_InitSbrHuffmanTables (&hEnv->encEnvData,
1341                           &hEnv->sbrCodeEnvelope,
1342                           &hEnv->sbrCodeNoiseFloor,
1343                           sbrHeaderData->sbr_amp_res))
1344   return(1);
1345
1346  FDKsbrEnc_initFrameInfoGenerator (&hEnv->SbrEnvFrame,
1347                            params->spread,
1348                            e,
1349                            params->stat,
1350                            timeSlots,
1351                            hEnv->encEnvData.freq_res_fixfix
1352                            ,hEnv->encEnvData.ldGrid
1353                            );
1354
1355  if(FDKsbrEnc_InitSbrTransientDetector (&hEnv->sbrTransientDetector,
1356                                          sbrConfigData->frameSize,
1357                                          sbrConfigData->sampleFreq,
1358                                          params,
1359                                          tran_fc,
1360                                          sbrConfigData->noQmfSlots,
1361                                          sbrConfigData->noQmfBands,
1362                                          hEnv->sbrExtractEnvelope.YBufferWriteOffset,
1363                                          hEnv->sbrExtractEnvelope.YBufferSzShift,
1364                                          frameShift,
1365                                          tran_off
1366                                          ))
1367  return(1);
1368
1369
1370  sbrConfigData->xposCtrlSwitch = params->sbr_xpos_ctrl;
1371
1372  hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];
1373  hEnv->encEnvData.addHarmonicFlag = 0;
1374
1375  return (0);
1376}
1377
1378INT sbrEncoder_Open(
1379        HANDLE_SBR_ENCODER  *phSbrEncoder,
1380        INT                  nElements,
1381        INT                  nChannels,
1382        INT                  supportPS
1383        )
1384{
1385  INT i;
1386  INT errorStatus = 1;
1387  HANDLE_SBR_ENCODER hSbrEncoder = NULL;
1388
1389  if (phSbrEncoder==NULL
1390     )
1391  {
1392    goto bail;
1393  }
1394
1395  hSbrEncoder = GetRam_SbrEncoder();
1396  if (hSbrEncoder==NULL) {
1397    goto bail;
1398  }
1399  FDKmemclear(hSbrEncoder, sizeof(SBR_ENCODER));
1400
1401      hSbrEncoder->pSBRdynamic_RAM = (UCHAR*)GetRam_SbrDynamic_RAM();
1402      hSbrEncoder->dynamicRam = hSbrEncoder->pSBRdynamic_RAM;
1403
1404  for (i=0; i<nElements; i++) {
1405    hSbrEncoder->sbrElement[i] = GetRam_SbrElement(i);
1406    if (hSbrEncoder->sbrElement[i]==NULL) {
1407        goto bail;
1408    }
1409    FDKmemclear(hSbrEncoder->sbrElement[i], sizeof(SBR_ELEMENT));
1410    hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] =  GetRam_Sbr_freqBandTableLO(i);
1411    hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] =  GetRam_Sbr_freqBandTableHI(i);
1412    hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master        =  GetRam_Sbr_v_k_master(i);
1413    if ( (hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO]==NULL) ||
1414         (hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI]==NULL) ||
1415         (hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master==NULL) )
1416    {
1417        goto bail;
1418    }
1419  }
1420
1421  for (i=0; i<nChannels; i++) {
1422    hSbrEncoder->pSbrChannel[i] = GetRam_SbrChannel(i);
1423    if (hSbrEncoder->pSbrChannel[i]==NULL) {
1424        goto bail;
1425    }
1426
1427    if ( createEnvChannel(&hSbrEncoder->pSbrChannel[i]->hEnvChannel,
1428                           i
1429                          ,hSbrEncoder->dynamicRam
1430                           ) )
1431    {
1432        goto bail;
1433    }
1434
1435  }
1436
1437  for (i=0; i<fixMax(nChannels,(supportPS)?2:0); i++) {
1438    hSbrEncoder->QmfAnalysis[i].FilterStates = GetRam_Sbr_QmfStatesAnalysis(i);
1439    if (hSbrEncoder->QmfAnalysis[i].FilterStates==NULL) {
1440        goto bail;
1441    }
1442  }
1443
1444  if (supportPS) {
1445    if (PSEnc_Create(&hSbrEncoder->hParametricStereo))
1446    {
1447      goto bail;
1448    }
1449
1450    hSbrEncoder->qmfSynthesisPS.FilterStates = GetRam_PsQmfStatesSynthesis();
1451    if (hSbrEncoder->qmfSynthesisPS.FilterStates==NULL) {
1452      goto bail;
1453    }
1454  }  /* supportPS */
1455
1456  *phSbrEncoder = hSbrEncoder;
1457
1458  errorStatus = 0;
1459  return errorStatus;
1460
1461bail:
1462  /* Close SBR encoder instance */
1463  sbrEncoder_Close(&hSbrEncoder);
1464  return errorStatus;
1465}
1466
1467static
1468INT FDKsbrEnc_Reallocate(
1469                    HANDLE_SBR_ENCODER   hSbrEncoder,
1470                    SBR_ELEMENT_INFO     elInfo[(8)],
1471                    const INT            noElements)
1472{
1473  INT totalCh = 0;
1474  INT totalQmf = 0;
1475  INT coreEl;
1476  INT el=-1;
1477
1478  hSbrEncoder->lfeChIdx = -1; /* default value, until lfe found */
1479
1480  for (coreEl=0; coreEl<noElements; coreEl++)
1481  {
1482    /* SBR only handles SCE and CPE's */
1483    if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
1484      el++;
1485    } else {
1486      if (elInfo[coreEl].elType == ID_LFE) {
1487          hSbrEncoder->lfeChIdx = elInfo[coreEl].ChannelIndex[0];
1488      }
1489      continue;
1490    }
1491
1492    SBR_ELEMENT_INFO    *pelInfo = &elInfo[coreEl];
1493    HANDLE_SBR_ELEMENT  hSbrElement = hSbrEncoder->sbrElement[el];
1494
1495    int ch;
1496    for ( ch = 0; ch < pelInfo->nChannelsInEl; ch++ ) {
1497      hSbrElement->sbrChannel[ch] = hSbrEncoder->pSbrChannel[totalCh];
1498      totalCh++;
1499    }
1500    /* analysis QMF */
1501    for ( ch = 0; ch < ((pelInfo->fParametricStereo)?2:pelInfo->nChannelsInEl); ch++ ) {
1502      hSbrElement->elInfo.ChannelIndex[ch] = pelInfo->ChannelIndex[ch];
1503      hSbrElement->hQmfAnalysis[ch] = &hSbrEncoder->QmfAnalysis[totalQmf++];
1504    }
1505
1506    /* Copy Element info */
1507    hSbrElement->elInfo.elType            = pelInfo->elType;
1508    hSbrElement->elInfo.instanceTag       = pelInfo->instanceTag;
1509    hSbrElement->elInfo.nChannelsInEl     = pelInfo->nChannelsInEl;
1510    hSbrElement->elInfo.fParametricStereo = pelInfo->fParametricStereo;
1511  } /* coreEl */
1512
1513  return 0;
1514}
1515
1516
1517
1518/*****************************************************************************
1519
1520 functionname: FDKsbrEnc_EnvInit
1521 description:  initializes parameters
1522 returns:      error status
1523 input:
1524 output:       hEnv
1525
1526*****************************************************************************/
1527static
1528INT FDKsbrEnc_EnvInit (
1529                       HANDLE_SBR_ELEMENT   hSbrElement,
1530                       sbrConfigurationPtr params,
1531                       INT      *coreBandWith,
1532                       AUDIO_OBJECT_TYPE aot,
1533                       int       nBitstrDelay,
1534                       int       nElement,
1535                       const int headerPeriod,
1536                       ULONG     statesInitFlag,
1537                       int       fTimeDomainDownsampling
1538                      ,UCHAR    *dynamic_RAM
1539                      )
1540{
1541  UCHAR    *bitstreamBuffer;
1542  int ch, i;
1543
1544  if ((params->codecSettings.nChannels < 1) || (params->codecSettings.nChannels > MAX_NUM_CHANNELS)){
1545    return(1);
1546  }
1547
1548  /* initialize the encoder handle  and structs*/
1549  bitstreamBuffer = hSbrElement->payloadDelayLine[nBitstrDelay];
1550
1551  /* init and set syntax flags */
1552  hSbrElement->sbrConfigData.sbrSyntaxFlags = 0;
1553
1554  switch (aot) {
1555  case AOT_DRM_MPEG_PS:
1556  case AOT_DRM_SBR:
1557    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_SCALABLE;
1558    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_DRM_CRC;
1559    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_CRC;
1560    break;
1561  case AOT_ER_AAC_ELD:
1562    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_LOW_DELAY;
1563    break;
1564  default:
1565    break;
1566  }
1567  if (params->crcSbr) {
1568    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_CRC;
1569  }
1570
1571  hSbrElement->sbrConfigData.noQmfBands = QMF_CHANNELS>>(2-params->downSampleFactor);
1572  switch (hSbrElement->sbrConfigData.noQmfBands)
1573  {
1574    case 64: hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize>>6;
1575             break;
1576    case 32: hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize>>5;
1577             break;
1578    default: hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize>>6;
1579             return(2);
1580  }
1581
1582  FDKinitBitStream(&hSbrElement->CmonData.sbrBitbuf, bitstreamBuffer, MAX_PAYLOAD_SIZE*sizeof(UCHAR), 0, BS_WRITER);
1583
1584  /*
1585    now initialize sbrConfigData, sbrHeaderData and sbrBitstreamData,
1586  */
1587  hSbrElement->sbrConfigData.nChannels = params->codecSettings.nChannels;
1588
1589  if(params->codecSettings.nChannels == 2)
1590     hSbrElement->sbrConfigData.stereoMode = params->stereoMode;
1591  else
1592     hSbrElement->sbrConfigData.stereoMode = SBR_MONO;
1593
1594  hSbrElement->sbrConfigData.frameSize   = params->sbrFrameSize;
1595
1596  hSbrElement->sbrConfigData.sampleFreq = params->downSampleFactor * params->codecSettings.sampleFreq;
1597
1598  hSbrElement->sbrBitstreamData.CountSendHeaderData = 0;
1599  if (params->SendHeaderDataTime > 0 ) {
1600
1601    if (headerPeriod==-1) {
1602
1603      hSbrElement->sbrBitstreamData.NrSendHeaderData = (INT)(params->SendHeaderDataTime * hSbrElement->sbrConfigData.sampleFreq
1604                                               / (1000 * hSbrElement->sbrConfigData.frameSize));
1605      hSbrElement->sbrBitstreamData.NrSendHeaderData = fixMax(hSbrElement->sbrBitstreamData.NrSendHeaderData,1);
1606    }
1607    else {
1608      /* assure header period at least once per second */
1609      hSbrElement->sbrBitstreamData.NrSendHeaderData = fixMin(fixMax(headerPeriod,1),(hSbrElement->sbrConfigData.sampleFreq/hSbrElement->sbrConfigData.frameSize));
1610    }
1611  }
1612  else {
1613   hSbrElement->sbrBitstreamData.NrSendHeaderData = 0;
1614  }
1615
1616  hSbrElement->sbrHeaderData.sbr_data_extra = params->sbr_data_extra;
1617  hSbrElement->sbrBitstreamData.HeaderActive = 0;
1618  hSbrElement->sbrHeaderData.sbr_start_frequency = params->startFreq;
1619  hSbrElement->sbrHeaderData.sbr_stop_frequency  = params->stopFreq;
1620  hSbrElement->sbrHeaderData.sbr_xover_band = 0;
1621  hSbrElement->sbrHeaderData.sbr_lc_stereo_mode = 0;
1622
1623  /* data_extra */
1624  if (params->sbr_xpos_ctrl!= SBR_XPOS_CTRL_DEFAULT)
1625     hSbrElement->sbrHeaderData.sbr_data_extra = 1;
1626
1627  hSbrElement->sbrHeaderData.sbr_amp_res = (AMP_RES)params->amp_res;
1628
1629  /* header_extra_1 */
1630  hSbrElement->sbrHeaderData.freqScale  = params->freqScale;
1631  hSbrElement->sbrHeaderData.alterScale = params->alterScale;
1632  hSbrElement->sbrHeaderData.sbr_noise_bands = params->sbr_noise_bands;
1633  hSbrElement->sbrHeaderData.header_extra_1 = 0;
1634
1635  if ((params->freqScale != SBR_FREQ_SCALE_DEFAULT) ||
1636      (params->alterScale != SBR_ALTER_SCALE_DEFAULT) ||
1637      (params->sbr_noise_bands != SBR_NOISE_BANDS_DEFAULT))
1638  {
1639   hSbrElement->sbrHeaderData.header_extra_1 = 1;
1640  }
1641
1642  /* header_extra_2 */
1643  hSbrElement->sbrHeaderData.sbr_limiter_bands = params->sbr_limiter_bands;
1644  hSbrElement->sbrHeaderData.sbr_limiter_gains = params->sbr_limiter_gains;
1645
1646  if ((hSbrElement->sbrConfigData.sampleFreq > 48000) &&
1647      (hSbrElement->sbrHeaderData.sbr_start_frequency >= 9))
1648  {
1649    hSbrElement->sbrHeaderData.sbr_limiter_gains = SBR_LIMITER_GAINS_INFINITE;
1650  }
1651
1652  hSbrElement->sbrHeaderData.sbr_interpol_freq = params->sbr_interpol_freq;
1653  hSbrElement->sbrHeaderData.sbr_smoothing_length = params->sbr_smoothing_length;
1654  hSbrElement->sbrHeaderData.header_extra_2 = 0;
1655
1656  if ((params->sbr_limiter_bands != SBR_LIMITER_BANDS_DEFAULT) ||
1657      (params->sbr_limiter_gains != SBR_LIMITER_GAINS_DEFAULT) ||
1658      (params->sbr_interpol_freq != SBR_INTERPOL_FREQ_DEFAULT) ||
1659      (params->sbr_smoothing_length != SBR_SMOOTHING_LENGTH_DEFAULT))
1660  {
1661     hSbrElement->sbrHeaderData.header_extra_2 = 1;
1662  }
1663
1664   /* other switches */
1665  hSbrElement->sbrConfigData.useWaveCoding             = params->useWaveCoding;
1666  hSbrElement->sbrConfigData.useParametricCoding       = params->parametricCoding;
1667
1668  /* init freq band table */
1669  if(updateFreqBandTable(&hSbrElement->sbrConfigData,
1670                         &hSbrElement->sbrHeaderData,
1671                         params->downSampleFactor
1672                         ))
1673  {
1674    return(1);
1675  }
1676
1677  /* now create envelope ext and QMF for each available channel */
1678  for ( ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++ ) {
1679
1680     if ( initEnvChannel(&hSbrElement->sbrConfigData,
1681                         &hSbrElement->sbrHeaderData,
1682                         &hSbrElement->sbrChannel[ch]->hEnvChannel,
1683                          params,
1684                          statesInitFlag
1685                        ,ch
1686                        ,dynamic_RAM
1687                         ) )
1688     {
1689       return(1);
1690     }
1691
1692
1693  } /* nChannels */
1694
1695  /* reset and intialize analysis qmf */
1696  for ( ch = 0; ch < ((hSbrElement->elInfo.fParametricStereo)?2:hSbrElement->sbrConfigData.nChannels); ch++ )
1697  {
1698    int err;
1699    UINT qmfFlags = (hSbrElement->sbrConfigData.sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) ? QMF_FLAG_CLDFB : 0;
1700    if (statesInitFlag)
1701      qmfFlags &= ~QMF_FLAG_KEEP_STATES;
1702    else
1703      qmfFlags |=  QMF_FLAG_KEEP_STATES;
1704
1705    err = qmfInitAnalysisFilterBank( hSbrElement->hQmfAnalysis[ch],
1706                                     (FIXP_QAS*)hSbrElement->hQmfAnalysis[ch]->FilterStates,
1707                                     hSbrElement->sbrConfigData.noQmfSlots,
1708                                     hSbrElement->sbrConfigData.noQmfBands,
1709                                     hSbrElement->sbrConfigData.noQmfBands,
1710                                     hSbrElement->sbrConfigData.noQmfBands,
1711                                     qmfFlags );
1712    if (0!=err) {
1713      return err;
1714    }
1715  }
1716
1717  /*  */
1718  hSbrElement->CmonData.xOverFreq = hSbrElement->sbrConfigData.xOverFreq;
1719  hSbrElement->CmonData.dynBwEnabled = (params->dynBwSupported && params->dynBwEnabled);
1720  hSbrElement->CmonData.dynXOverFreqEnc = FDKsbrEnc_SbrGetXOverFreq( hSbrElement, hSbrElement->CmonData.xOverFreq);
1721  for ( i = 0; i < 5; i++ )
1722      hSbrElement->dynXOverFreqDelay[i] = hSbrElement->CmonData.dynXOverFreqEnc;
1723  hSbrElement->CmonData.sbrNumChannels  = hSbrElement->sbrConfigData.nChannels;
1724  hSbrElement->sbrConfigData.dynXOverFreq = hSbrElement->CmonData.xOverFreq;
1725
1726  /* Update Bandwith to be passed to the core encoder */
1727  *coreBandWith = hSbrElement->CmonData.xOverFreq;
1728
1729  return(0);
1730 }
1731
1732INT sbrEncoder_GetInBufferSize(int noChannels)
1733{
1734  INT temp;
1735
1736  temp = (2048);
1737  temp += 1024 + MAX_SAMPLE_DELAY;
1738  temp *= noChannels;
1739  temp *= sizeof(INT_PCM);
1740  return temp;
1741}
1742
1743/*
1744 * Encode Dummy SBR payload frames to fill the delay lines.
1745 */
1746static
1747INT FDKsbrEnc_DelayCompensation (
1748                                  HANDLE_SBR_ENCODER hEnvEnc,
1749                                  INT_PCM *timeBuffer
1750                                 )
1751{
1752    int n, el;
1753
1754    for (n=hEnvEnc->nBitstrDelay; n>0; n--)
1755    {
1756      for (el=0; el<hEnvEnc->noElements; el++)
1757      {
1758        if (FDKsbrEnc_EnvEncodeFrame(
1759                                     hEnvEnc,
1760                                     el,
1761                                     timeBuffer + hEnvEnc->downsampledOffset,
1762                                     hEnvEnc->sbrElement[el]->sbrConfigData.nChannels,
1763                                     NULL,
1764                                     NULL,
1765                                     1
1766                                    ))
1767          return -1;
1768      }
1769      sbrEncoder_UpdateBuffers(hEnvEnc, timeBuffer);
1770    }
1771	  return 0;
1772}
1773
1774UINT sbrEncoder_LimitBitRate(UINT bitRate, UINT numChannels, UINT coreSampleRate, AUDIO_OBJECT_TYPE aot)
1775{
1776  UINT newBitRate;
1777  INT index;
1778
1779  FDK_ASSERT(numChannels > 0 && numChannels <= 2);
1780  if (aot == AOT_PS) {
1781    if (numChannels == 2) {
1782      index = getPsTuningTableIndex(bitRate, &newBitRate);
1783      if (index == INVALID_TABLE_IDX) {
1784        bitRate = newBitRate;
1785      }
1786      /* Set numChannels to 1 because for PS we need a SBR SCE (mono) element. */
1787      numChannels = 1;
1788    } else {
1789      return 0;
1790    }
1791  }
1792  index = getSbrTuningTableIndex(bitRate, numChannels, coreSampleRate, aot, &newBitRate);
1793  if (index != INVALID_TABLE_IDX) {
1794    newBitRate = bitRate;
1795  }
1796
1797  return newBitRate;
1798}
1799
1800UINT sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot)
1801{
1802  UINT isPossible=(AOT_PS==aot)?0:1;
1803  return isPossible;
1804}
1805
1806INT sbrEncoder_Init(
1807        HANDLE_SBR_ENCODER   hSbrEncoder,
1808        SBR_ELEMENT_INFO     elInfo[(8)],
1809        int                  noElements,
1810        INT_PCM             *inputBuffer,
1811        INT                 *coreBandwidth,
1812        INT                 *inputBufferOffset,
1813        INT                 *numChannels,
1814        INT                 *coreSampleRate,
1815        UINT                *downSampleFactor,
1816        INT                 *frameLength,
1817        AUDIO_OBJECT_TYPE    aot,
1818        int                 *delay,
1819        int                  transformFactor,
1820        const int            headerPeriod,
1821        ULONG                statesInitFlag
1822        )
1823{
1824    HANDLE_ERROR_INFO errorInfo = noError;
1825    sbrConfiguration sbrConfig[(8)];
1826    INT error = 0;
1827    INT lowestBandwidth;
1828    /* Save input parameters */
1829    INT inputSampleRate = *coreSampleRate;
1830    int coreFrameLength = *frameLength;
1831    int inputBandWidth = *coreBandwidth;
1832    int inputChannels = *numChannels;
1833
1834    int downsampledOffset = 0;
1835    int sbrOffset = 0;
1836    int downsamplerDelay = 0;
1837    int timeDomainDownsample = 0;
1838    int nBitstrDelay = 0;
1839    int highestSbrStartFreq, highestSbrStopFreq;
1840    int lowDelay = 0;
1841    int usePs = 0;
1842
1843    /* check whether SBR setting is available for the current encoder configuration (bitrate, samplerate) */
1844    if (!sbrEncoder_IsSingleRatePossible(aot)) {
1845      *downSampleFactor = 2;
1846    }
1847
1848
1849
1850    if ( (aot==AOT_PS) || (aot==AOT_MP2_PS) || (aot==AOT_DABPLUS_PS) || (aot==AOT_DRM_MPEG_PS) ) {
1851        usePs = 1;
1852    }
1853    if ( (aot==AOT_ER_AAC_ELD) ) {
1854        lowDelay = 1;
1855    }
1856    else if ( (aot==AOT_ER_AAC_LD) ) {
1857        error = 1;
1858        goto bail;
1859    }
1860
1861    /* Parametric Stereo */
1862    if ( usePs ) {
1863      if ( *numChannels == 2 && noElements == 1) {
1864        /* Override Element type in case of Parametric stereo */
1865        elInfo[0].elType = ID_SCE;
1866        elInfo[0].fParametricStereo = 1;
1867        elInfo[0].nChannelsInEl = 1;
1868        /* core encoder gets downmixed mono signal */
1869        *numChannels  = 1;
1870      } else {
1871        error = 1;
1872        goto bail;
1873      }
1874    } /* usePs */
1875
1876    /* set the core's sample rate */
1877    switch (*downSampleFactor) {
1878    case 1:
1879      *coreSampleRate = inputSampleRate;
1880      break;
1881    case 2:
1882      *coreSampleRate = inputSampleRate>>1;
1883      break;
1884    default:
1885      *coreSampleRate = inputSampleRate>>1;
1886      return 0; /* return error */
1887    }
1888
1889    /* check whether SBR setting is available for the current encoder configuration (bitrate, coreSampleRate) */
1890    {
1891      int delayDiff = 0;
1892      int el, coreEl;
1893
1894      /* Check if every element config is feasible */
1895      for (coreEl=0; coreEl<noElements; coreEl++)
1896      {
1897        /* SBR only handles SCE and CPE's */
1898        if (elInfo[coreEl].elType != ID_SCE && elInfo[coreEl].elType != ID_CPE) {
1899          continue;
1900        }
1901        /* check if desired configuration is available */
1902        if ( !FDKsbrEnc_IsSbrSettingAvail (elInfo[coreEl].bitRate, 0, elInfo[coreEl].nChannelsInEl, inputSampleRate, *coreSampleRate, aot) )
1903        {
1904            error = 1;
1905            goto bail;
1906        }
1907      }
1908
1909      /* Determine Delay balancing and new encoder delay */
1910      if (lowDelay) {
1911        {
1912        delayDiff = (*delay * *downSampleFactor) + DELAY_ELD2SBR(coreFrameLength,*downSampleFactor);
1913        *delay = DELAY_ELDSBR(coreFrameLength,*downSampleFactor);
1914        }
1915      }
1916      else if (usePs) {
1917        delayDiff = (*delay * *downSampleFactor) + DELAY_AAC2PS(coreFrameLength,*downSampleFactor);
1918        *delay = DELAY_PS(coreFrameLength,*downSampleFactor);
1919      }
1920      else {
1921        delayDiff = DELAY_AAC2SBR(coreFrameLength,*downSampleFactor);
1922        delayDiff += (*delay * *downSampleFactor);
1923        *delay = DELAY_SBR(coreFrameLength,*downSampleFactor);
1924      }
1925
1926      if (!usePs) {
1927          timeDomainDownsample = *downSampleFactor-1;  /* activate time domain downsampler when downSampleFactor is != 1 */
1928      }
1929
1930
1931      /* Take care about downsampled data bound to the SBR path */
1932      if (!timeDomainDownsample && delayDiff > 0) {
1933        /*
1934         * We must tweak the balancing into a situation where the downsampled path
1935         * is the one to be delayed, because delaying the QMF domain input, also delays
1936         * the downsampled audio, counteracting to the purpose of delay balancing.
1937         */
1938        while ( delayDiff > 0 )
1939        {
1940          /* Encoder delay increases */
1941          {
1942            *delay += coreFrameLength * *downSampleFactor;
1943            /* Add one frame delay to SBR path */
1944            delayDiff -= coreFrameLength * *downSampleFactor;
1945          }
1946          nBitstrDelay += 1;
1947        }
1948      } else
1949      {
1950        *delay += fixp_abs(delayDiff);
1951      }
1952
1953      if (delayDiff < 0) {
1954        /* Delay AAC data */
1955        delayDiff = -delayDiff;
1956        /* Multiply downsampled offset by AAC core channels. Divide by 2 because of half samplerate of downsampled data. */
1957        FDK_ASSERT(*downSampleFactor>0 && *downSampleFactor<=2);
1958        downsampledOffset = (delayDiff*(*numChannels))>>(*downSampleFactor-1);
1959        sbrOffset = 0;
1960      } else {
1961        /* Delay SBR input */
1962        if ( delayDiff > (int)coreFrameLength * (int)*downSampleFactor )
1963        {
1964          /* Do bitstream frame-wise delay balancing if we have more than SBR framelength samples delay difference */
1965          delayDiff -= coreFrameLength * *downSampleFactor;
1966          nBitstrDelay = 1;
1967        }
1968        /* Multiply input offset by input channels */
1969        sbrOffset = delayDiff*(*numChannels);
1970        downsampledOffset = 0;
1971      }
1972      hSbrEncoder->nBitstrDelay            = nBitstrDelay;
1973      hSbrEncoder->nChannels               = *numChannels;
1974      hSbrEncoder->frameSize               = coreFrameLength * *downSampleFactor;
1975      hSbrEncoder->fTimeDomainDownsampling = timeDomainDownsample;
1976      hSbrEncoder->downSampleFactor        = *downSampleFactor;
1977      hSbrEncoder->estimateBitrate         = 0;
1978      hSbrEncoder->inputDataDelay          = 0;
1979
1980
1981      /* Open SBR elements */
1982      el = -1;
1983      highestSbrStartFreq = highestSbrStopFreq = 0;
1984      lowestBandwidth = 99999;
1985
1986      /* Loop through each core encoder element and get a matching SBR element config */
1987      for (coreEl=0; coreEl<noElements; coreEl++)
1988      {
1989        /* SBR only handles SCE and CPE's */
1990        if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
1991          el++;
1992        } else {
1993          continue;
1994        }
1995
1996        /* Set parametric Stereo Flag. */
1997        if (usePs) {
1998          elInfo[coreEl].fParametricStereo = 1;
1999        } else {
2000          elInfo[coreEl].fParametricStereo = 0;
2001        }
2002
2003        /*
2004         * Init sbrConfig structure
2005         */
2006        if ( ! FDKsbrEnc_InitializeSbrDefaults ( &sbrConfig[el],
2007                                                 *downSampleFactor,
2008                                                  coreFrameLength
2009                                                  ) )
2010        {
2011          error = 1;
2012          goto bail;
2013        }
2014
2015        /*
2016         * Modify sbrConfig structure according to Element parameters
2017         */
2018        if ( ! FDKsbrEnc_AdjustSbrSettings (&sbrConfig[el],
2019                                             elInfo[coreEl].bitRate,
2020                                             elInfo[coreEl].nChannelsInEl,
2021                                            *coreSampleRate,
2022                                             inputSampleRate,
2023                                             transformFactor,
2024                                             24000,
2025                                             0,
2026                                             0,     /* useSpeechConfig */
2027                                             0,     /* lcsMode */
2028                                             usePs, /* bParametricStereo */
2029                                             aot) )
2030        {
2031          error = 1;
2032          goto bail;
2033        }
2034
2035        /* Find common frequency border for all SBR elements */
2036        highestSbrStartFreq = fixMax(highestSbrStartFreq, sbrConfig[el].startFreq);
2037        highestSbrStopFreq = fixMax(highestSbrStopFreq, sbrConfig[el].stopFreq);
2038
2039      } /* first element loop */
2040
2041      /* Set element count (can be less than core encoder element count) */
2042      hSbrEncoder->noElements = el+1;
2043
2044      FDKsbrEnc_Reallocate(hSbrEncoder,
2045                           elInfo,
2046                           noElements);
2047
2048      for (el=0; el<hSbrEncoder->noElements; el++) {
2049
2050        int bandwidth = *coreBandwidth;
2051
2052        /* Use lowest common bandwidth */
2053        sbrConfig[el].startFreq = highestSbrStartFreq;
2054        sbrConfig[el].stopFreq = highestSbrStopFreq;
2055
2056        /* initialize SBR element, and get core bandwidth */
2057        error = FDKsbrEnc_EnvInit(hSbrEncoder->sbrElement[el],
2058                                  &sbrConfig[el],
2059                                  &bandwidth,
2060                                   aot,
2061                                   nBitstrDelay,
2062                                   el,
2063                                   headerPeriod,
2064                                   statesInitFlag,
2065                                   hSbrEncoder->fTimeDomainDownsampling
2066                                  ,hSbrEncoder->dynamicRam
2067                                  );
2068
2069        if (error != 0) {
2070          error = 2;
2071          goto bail;
2072        }
2073
2074        /* Get lowest core encoder bandwidth to be returned later. */
2075        lowestBandwidth = fixMin(lowestBandwidth, bandwidth);
2076
2077      } /* second element loop */
2078
2079      /* Initialize a downsampler for each channel in each SBR element */
2080      if (hSbrEncoder->fTimeDomainDownsampling)
2081      {
2082        for (el=0; el<hSbrEncoder->noElements; el++)
2083        {
2084          HANDLE_SBR_ELEMENT hSbrEl = hSbrEncoder->sbrElement[el];
2085          INT Wc, ch;
2086
2087          /* Calculated required normalized cutoff frequency (Wc = 1.0 -> lowestBandwidth = inputSampleRate/2) */
2088          Wc = (2*lowestBandwidth)*1000 / inputSampleRate;
2089
2090          for (ch=0; ch<hSbrEl->elInfo.nChannelsInEl; ch++)
2091          {
2092            FDKaacEnc_InitDownsampler (&hSbrEl->sbrChannel[ch]->downSampler, Wc, *downSampleFactor);
2093            FDK_ASSERT (hSbrEl->sbrChannel[ch]->downSampler.delay <=MAX_DS_FILTER_DELAY);
2094          }
2095
2096          downsamplerDelay = hSbrEl->sbrChannel[0]->downSampler.delay;
2097        } /* third element loop */
2098
2099        /* lfe */
2100        FDKaacEnc_InitDownsampler (&hSbrEncoder->lfeDownSampler, 0, *downSampleFactor);
2101
2102        /* Add the resampler additional delay to get the final delay and buffer offset values. */
2103        if (sbrOffset > 0 || downsampledOffset <= ((downsamplerDelay * (*numChannels))>>(*downSampleFactor-1))) {
2104          sbrOffset += (downsamplerDelay - downsampledOffset) * (*numChannels) ;
2105          *delay += downsamplerDelay - downsampledOffset;
2106          downsampledOffset = 0;
2107        } else {
2108          downsampledOffset -= (downsamplerDelay * (*numChannels))>>(*downSampleFactor-1);
2109          sbrOffset = 0;
2110        }
2111
2112        hSbrEncoder->inputDataDelay = downsamplerDelay;
2113      }
2114
2115      /* Assign core encoder Bandwidth */
2116      *coreBandwidth = lowestBandwidth;
2117
2118      /* Estimate sbr bitrate, 2.5 kBit/s per sbr channel */
2119      hSbrEncoder->estimateBitrate += 2500 * (*numChannels);
2120
2121      /* initialize parametric stereo */
2122      if (usePs)
2123      {
2124        PSENC_CONFIG psEncConfig;
2125        FDK_ASSERT(hSbrEncoder->noElements == 1);
2126        INT psTuningTableIdx = getPsTuningTableIndex(elInfo[0].bitRate, NULL);
2127
2128        psEncConfig.frameSize           = coreFrameLength; //sbrConfig.sbrFrameSize;
2129        psEncConfig.qmfFilterMode       = 0;
2130        psEncConfig.sbrPsDelay          = 0;
2131
2132        /* tuning parameters */
2133        if (psTuningTableIdx  != INVALID_TABLE_IDX) {
2134          psEncConfig.nStereoBands           = psTuningTable[psTuningTableIdx].nStereoBands;
2135          psEncConfig.maxEnvelopes           = psTuningTable[psTuningTableIdx].nEnvelopes;
2136          psEncConfig.iidQuantErrorThreshold = (FIXP_DBL)psTuningTable[psTuningTableIdx].iidQuantErrorThreshold;
2137
2138          /* calculation is not quite linear, increased number of envelopes causes more bits */
2139          /* assume avg. 50 bits per frame for 10 stereo bands / 1 envelope configuration */
2140          hSbrEncoder->estimateBitrate += ( (((*coreSampleRate) * 5 * psEncConfig.nStereoBands * psEncConfig.maxEnvelopes) / hSbrEncoder->frameSize));
2141
2142        } else {
2143          error = ERROR(CDI, "Invalid ps tuning table index.");
2144          goto bail;
2145        }
2146
2147        qmfInitSynthesisFilterBank(&hSbrEncoder->qmfSynthesisPS,
2148                                    (FIXP_DBL*)hSbrEncoder->qmfSynthesisPS.FilterStates,
2149                                    hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
2150                                    hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands>>1,
2151                                    hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands>>1,
2152                                    hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands>>1,
2153                                    (statesInitFlag) ? 0 : QMF_FLAG_KEEP_STATES);
2154
2155        if(errorInfo == noError){
2156          /* update delay */
2157          psEncConfig.sbrPsDelay = FDKsbrEnc_GetEnvEstDelay(&hSbrEncoder->sbrElement[0]->sbrChannel[0]->hEnvChannel.sbrExtractEnvelope);
2158
2159          if(noError != (errorInfo = PSEnc_Init( hSbrEncoder->hParametricStereo,
2160                                                &psEncConfig,
2161                                                 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
2162                                                 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands
2163                                                ,hSbrEncoder->dynamicRam
2164                                                 )))
2165          {
2166            errorInfo = handBack(errorInfo);
2167          }
2168        }
2169
2170        /* QMF analysis + Hybrid analysis + Hybrid synthesis + QMF synthesis + downsampled input buffer delay */
2171        hSbrEncoder->inputDataDelay = (64*10/2) + (6*64) +  (0) + (64*10/2-64+1) + ((*downSampleFactor)*downsampledOffset);
2172      }
2173
2174      hSbrEncoder->downsampledOffset = downsampledOffset;
2175      {
2176        hSbrEncoder->downmixSize = coreFrameLength*(*numChannels);
2177      }
2178
2179      hSbrEncoder->bufferOffset = sbrOffset;
2180      /* Delay Compensation: fill bitstream delay buffer with zero input signal */
2181      if ( hSbrEncoder->nBitstrDelay > 0 )
2182      {
2183        error = FDKsbrEnc_DelayCompensation (hSbrEncoder, inputBuffer);
2184        if (error != 0)
2185          goto bail;
2186      }
2187
2188      /* Set Output frame length */
2189      *frameLength = coreFrameLength * *downSampleFactor;
2190      /* Input buffer offset */
2191      *inputBufferOffset = fixMax(sbrOffset, downsampledOffset);
2192
2193
2194    }
2195
2196    return error;
2197
2198bail:
2199    /* Restore input settings */
2200    *coreSampleRate = inputSampleRate;
2201    *frameLength = coreFrameLength;
2202    *numChannels = inputChannels;
2203    *coreBandwidth = inputBandWidth;
2204
2205    return error;
2206 }
2207
2208
2209INT
2210sbrEncoder_EncodeFrame(  HANDLE_SBR_ENCODER   hSbrEncoder,
2211                         INT_PCM             *samples,
2212                         UINT                 timeInStride,
2213                         UINT                 sbrDataBits[(8)],
2214                         UCHAR                sbrData[(8)][MAX_PAYLOAD_SIZE]
2215                        )
2216{
2217  INT error;
2218  int el;
2219
2220  for (el=0; el<hSbrEncoder->noElements; el++)
2221  {
2222    if (hSbrEncoder->sbrElement[el] != NULL)
2223    {
2224      error = FDKsbrEnc_EnvEncodeFrame(
2225                                        hSbrEncoder,
2226                                        el,
2227                                        samples + hSbrEncoder->downsampledOffset,
2228                                        timeInStride,
2229                                       &sbrDataBits[el],
2230                                        sbrData[el],
2231                                        0
2232                                       );
2233      if (error)
2234        return error;
2235    }
2236  }
2237
2238  if ( ( hSbrEncoder->lfeChIdx!=-1) && (hSbrEncoder->downSampleFactor > 1) )
2239  {   /* lfe downsampler */
2240      INT nOutSamples;
2241
2242      FDKaacEnc_Downsample(&hSbrEncoder->lfeDownSampler,
2243                            samples + hSbrEncoder->downsampledOffset + hSbrEncoder->bufferOffset + hSbrEncoder->lfeChIdx,
2244                            hSbrEncoder->frameSize,
2245                            timeInStride,
2246                            samples + hSbrEncoder->downsampledOffset + hSbrEncoder->lfeChIdx,
2247                           &nOutSamples,
2248                            hSbrEncoder->nChannels);
2249
2250
2251  }
2252
2253  return 0;
2254}
2255
2256
2257INT sbrEncoder_UpdateBuffers(
2258                            HANDLE_SBR_ENCODER hSbrEncoder,
2259                            INT_PCM *timeBuffer
2260                            )
2261 {
2262    if ( hSbrEncoder->downsampledOffset > 0 ) {
2263      /* Move delayed downsampled data */
2264      FDKmemcpy ( timeBuffer,
2265                  timeBuffer + hSbrEncoder->downmixSize,
2266                  sizeof(INT_PCM) * (hSbrEncoder->downsampledOffset) );
2267    } else {
2268      /* Move delayed input data */
2269      FDKmemcpy ( timeBuffer,
2270        timeBuffer + hSbrEncoder->nChannels * hSbrEncoder->frameSize,
2271                  sizeof(INT_PCM) * hSbrEncoder->bufferOffset );
2272    }
2273    if ( hSbrEncoder->nBitstrDelay > 0  )
2274    {
2275      int el;
2276
2277      for (el=0; el<hSbrEncoder->noElements; el++)
2278      {
2279        FDKmemmove ( hSbrEncoder->sbrElement[el]->payloadDelayLine[0],
2280                     hSbrEncoder->sbrElement[el]->payloadDelayLine[1],
2281                     sizeof(UCHAR) * (hSbrEncoder->nBitstrDelay*MAX_PAYLOAD_SIZE) );
2282
2283        FDKmemmove( &hSbrEncoder->sbrElement[el]->payloadDelayLineSize[0],
2284                    &hSbrEncoder->sbrElement[el]->payloadDelayLineSize[1],
2285                    sizeof(UINT) * (hSbrEncoder->nBitstrDelay) );
2286      }
2287    }
2288    return 0;
2289 }
2290
2291
2292INT sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder)
2293{
2294  INT estimateBitrate = 0;
2295
2296  if(hSbrEncoder) {
2297    estimateBitrate += hSbrEncoder->estimateBitrate;
2298  }
2299
2300  return estimateBitrate;
2301}
2302
2303INT sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder)
2304{
2305  INT delay = -1;
2306
2307  if(hSbrEncoder) {
2308    delay = hSbrEncoder->inputDataDelay;
2309  }
2310  return delay;
2311}
2312
2313
2314INT sbrEncoder_GetLibInfo( LIB_INFO *info )
2315{
2316  int i;
2317
2318  if (info == NULL) {
2319    return -1;
2320  }
2321  /* search for next free tab */
2322  for (i = 0; i < FDK_MODULE_LAST; i++) {
2323    if (info[i].module_id == FDK_NONE) break;
2324  }
2325  if (i == FDK_MODULE_LAST) {
2326    return -1;
2327  }
2328  info += i;
2329
2330  info->module_id = FDK_SBRENC;
2331  info->version = LIB_VERSION(SBRENCODER_LIB_VL0, SBRENCODER_LIB_VL1, SBRENCODER_LIB_VL2);
2332  LIB_VERSION_STRING(info);
2333#ifdef __ANDROID__
2334  info->build_date = "";
2335  info->build_time = "";
2336#else
2337  info->build_date = __DATE__;
2338  info->build_time = __TIME__;
2339#endif
2340  info->title = "SBR Encoder";
2341
2342  /* Set flags */
2343  info->flags = 0
2344    | CAPF_SBR_HQ
2345    | CAPF_SBR_PS_MPEG
2346    ;
2347  /* End of flags */
2348
2349  return 0;
2350}
2351