/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:

*

*/

/*

  \file

  \brief  Frequency scale calculation $Revision: 1.2.4.1 $

*/

/**************************************************************************

  sbr_freq_sca.cpp - SBR frequency scale calculations.

  Author(s): Juha Ojanpera

  Copyright (c) 2004 by Nokia Research Center, Multimedia Technologies.

  *************************************************************************/

/*-- System Headers. --*/

#include <e32math.h>

/*-- Project Headers. --*/

#include "sbr_rom.h"

const int16 MAX_OCTAVE = 29;

const int16 MAX_SECOND_REGION = 50;

const FLOAT WARP_FACTOR = 25200.0f / 32768.0f;

/*!

  \brief   Sorting routine

*/

void 

shellsort(uint8 *in, uint8 n)

{

  int16 i, j, v, w, inc = 1;

  do

  {

    inc = 3 * inc + 1;

  } while (inc <= n);

  do 

  {

    inc = inc / 3;

    for(i = inc; i < n; i++) 

    {

      v = in[i];

      j = i;

      while((w = in[j - inc]) > v) 

      {

        in[j] = w;

        j -= inc;

        if(j < inc)

          break;

      }

      in[j] = v;

    }

  } while(inc > 1);

}

/*!

  \brief     Calculate number of SBR bands between start and stop band

  \return    number of bands

*/

static int16

numberOfBands(FLOAT bpo, int16 start, int16 stop, int16 warpFlag)

{

  int16 num_bands;

  FLOAT num_bands_div2;

  num_bands_div2 = 0.5f * FloatFR_getNumOctaves(start, stop) * bpo;

  if(warpFlag) num_bands_div2 *= WARP_FACTOR;

  num_bands_div2 += 0.5f;

  num_bands = (int16) num_bands_div2;

  num_bands <<= 1;

  return (num_bands);

}

/*!

  \brief     Calculate width of SBR bands

*/

static void

CalcBands(uint8 *diff, uint8 start, uint8 stop, uint8 num_bands)

{

  FLOAT exact, bandfactor;

  int16 i, previous, current;

  previous = start;

  exact = (FLOAT) start;

  Math::Pow(bandfactor, stop * sbr_invIntTable[start], sbr_invIntTable[num_bands]);

  for(i = 1; i <= num_bands; i++)  

  {

    exact *= bandfactor;

    current = (int16) (exact + 0.5f);

    diff[i - 1] = current - previous;

    previous = current;

  }

}

/*!

  \brief     Calculate cumulated sum vector from delta vector

*/

static void

cumSum(uint8 start_value, uint8* diff, uint8 length, uint8 *start_adress)

{

  int16 i;

  start_adress[0] = start_value;

  for(i = 1; i <= length; i++)

    start_adress[i] = start_adress[i - 1] + diff[i - 1];

}

/*!

  \brief     Adapt width of frequency bands in the second region

*/

static int16

modifyBands(uint8 max_band_previous, uint8 * diff, uint8 length)

{

  int16 change = max_band_previous - diff[0];

  if(change > (diff[length - 1] - diff[0]) / 2)

    change = (diff[length - 1] - diff[0]) / 2;

  diff[0] += change;

  diff[length - 1] -= change;

  shellsort(diff, length);

  return (0);

}

/*!

  \brief     Retrieve QMF-band where the SBR range starts

  \return  Number of start band

*/

static int16

getStartBand(int32 fs, uint8 startFreq)

{

  int16 band;

  switch(fs) 

  {

    case 96000:

    case 88200:

      band = sbr_start_freq_88[startFreq];

      break;

    case 64000:

      band = sbr_start_freq_64[startFreq];

      break;

    case 48000:

      band = sbr_start_freq_48[startFreq];

      break;

    case 44100:

      band = sbr_start_freq_44[startFreq];

      break;

    case 32000:

      band = sbr_start_freq_32[startFreq];

      break;

    case 24000:

      band = sbr_start_freq_24[startFreq];

      break;

    case 22050:

      band = sbr_start_freq_22[startFreq];

      break;

    case 16000:

      band = sbr_start_freq_16[startFreq];

      break;

    default:

      band = -1;

      break;

   }

  return (band);

}

/*!

  \brief   Generates master frequency tables

  \return  errorCode, 0 if successful

*/

int16

sbrdecUpdateFreqScale(uint8 * v_k_master, uint8 *numMaster, SbrHeaderData *hHeaderData)

{

  int32 fs;

  FLOAT bpo;

  int16 err, dk, k2_achived, k2_diff, incr;

  uint8 k0, k2, k1, i, num_bands0, num_bands1;

  uint8 diff_tot[MAX_OCTAVE + MAX_SECOND_REGION], *diff0, *diff1;

  diff0 = diff_tot;

  diff1 = diff_tot + MAX_OCTAVE;

  incr = k1 = dk = err = 0;

  fs = hHeaderData->outSampleRate;

  k0 = getStartBand(fs, hHeaderData->startFreq);

  if(hHeaderData->stopFreq < 14) 

  {

    switch(fs) 

    {

      case 48000:

        k1 = 21;

        break;

      case 44100:

        k1 = 23;

        break;

      case 32000:

      case 24000:

        k1 = 32;

        break;

      case 22050:

        k1 = 35;

        break;

      case 16000:

        k1 = 48;

        break;

      default:

        return (1);

    }

    CalcBands(diff0, k1, 64, 13);

    shellsort(diff0, 13);

    cumSum(k1, diff0, 13, diff1);

    k2 = diff1[hHeaderData->stopFreq];

  }

  else 

  {

    if(hHeaderData->stopFreq == 14) 

      k2 = 2 * k0;

    else

      k2 = 3 * k0;

  }

  if(k2 > NO_SYNTHESIS_CHANNELS)

    k2 = NO_SYNTHESIS_CHANNELS;

  if(((k2 - k0) > MAX_FREQ_COEFFS) || (k2 <= k0) ) 

    return (2);

  if(fs == 44100 && ((k2 - k0) > MAX_FREQ_COEFFS_FS44100)) 

    return (3);

  if(fs >= 48000 && ((k2 - k0) > MAX_FREQ_COEFFS_FS48000)) 

    return (4);

  if(hHeaderData->freqScale>0) 

  {

    if(hHeaderData->freqScale == 1)

      bpo = 12.0f;

    else 

    {

      if(hHeaderData->freqScale == 2)

        bpo = 10.0f;

      else

        bpo =  8.0f;

    }

    if(1000 * k2 > 2245 * k0) 

    {

      k1 = 2 * k0;

      num_bands0 = numberOfBands(bpo, k0, k1, 0);

      num_bands1 = numberOfBands(bpo, k1, k2, hHeaderData->alterScale);

      if(num_bands0 < 1)

        return (5);

      if(num_bands1 < 1)

        return (6);

      CalcBands(diff0, k0, k1, num_bands0);

      shellsort(diff0, num_bands0);

      if(diff0[0] == 0) 

        return (7);

      cumSum(k0, diff0, num_bands0, v_k_master);

      CalcBands(diff1, k1, k2, num_bands1);

      shellsort(diff1, num_bands1);

      if(diff0[num_bands0-1] > diff1[0]) 

      {

        err = modifyBands(diff0[num_bands0 - 1], diff1, num_bands1);

        if(err) return (8);

      }

      cumSum(k1, diff1, num_bands1, &v_k_master[num_bands0]);

      *numMaster = num_bands0 + num_bands1;

    }

    else 

    {

      k1 = k2;

      num_bands0 = numberOfBands(bpo, k0, k1, 0);

      if(num_bands0 < 1) 

        return (9);

      CalcBands(diff0, k0, k1, num_bands0);

      shellsort(diff0, num_bands0);

      if(diff0[0] == 0)

        return (10);

      cumSum(k0, diff0, num_bands0, v_k_master);

      *numMaster = num_bands0;

    }

  }

  else 

  {

    if(hHeaderData->alterScale == 0) 

    {

      dk = 1;

      num_bands0 = (k2 - k0) & 254;

    } 

    else 

    {

      dk = 2;

      num_bands0 = (((k2 - k0) >> 1) + 1) & 254;

    }

    if(num_bands0 < 1) 

      return (11);

    k2_achived = k0 + num_bands0 * dk;

    k2_diff = k2 - k2_achived;

    for(i = 0;i < num_bands0; i++)

      diff_tot[i] = dk;

    if(k2_diff < 0) 

    {

      incr = 1;

      i = 0;

    }

    if(k2_diff > 0) 

    {

      incr = -1;

      i = num_bands0 - 1;

    }

    while(k2_diff != 0) 

    {

      diff_tot[i] = diff_tot[i] - incr;

      i = i + incr;

      k2_diff = k2_diff + incr;

    }

    cumSum(k0, diff_tot, num_bands0, v_k_master);

    *numMaster = num_bands0;

  }

  if(*numMaster < 1) 

    return (12);

  return (0);

}

/*!

  \brief   Reset frequency band tables

  \return  error code, 0 on success

*/

int16

resetFreqBandTables(SbrHeaderData *hHeaderData)

{

  uint8 nBandsHi;

  int16 err, k2, kx, intTemp;

  FreqBandData *hFreq = hHeaderData->hFreqBandData;

  err = sbrdecUpdateFreqScale(hFreq->v_k_master, &hFreq->numMaster, hHeaderData);

  if(err) return (err);

  if(hHeaderData->xover_band > hFreq->numMaster)

    return (13);

  nBandsHi = hFreq->numMaster - hHeaderData->xover_band;

  hFreq->nSfb[0] = ((nBandsHi & 1) == 0) ? nBandsHi >> 1 : (nBandsHi + 1) >> 1;

  hFreq->nSfb[1] = nBandsHi;

  k2 = hFreq->v_k_master[nBandsHi - hHeaderData->xover_band];

  kx = hFreq->v_k_master[hHeaderData->xover_band];

  if(hHeaderData->noise_bands == 0)

    hFreq->nNfb = 1;

  else

  {

    FLOAT temp;

    temp = FloatFR_getNumOctaves(kx,k2);

    temp = temp * (FLOAT) hHeaderData->noise_bands;

    intTemp = (int16) (temp + 0.5f);

    if(intTemp == 0)

      intTemp = 1;

    hFreq->nNfb = intTemp;

  }

  hFreq->nInvfBands = hFreq->nNfb;

  if(hFreq->nNfb > MAX_NOISE_COEFFS)

    return (14);

  return (0);

}