1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:

    16 *

    17 */

    18 

    19 

    20 /*

    21   \file

    22   \brief SBR codec implementation $Revision: 1.1.1.1.4.1 $

    23 */

    24 

    25 /**************************************************************************

    26   sbr_demux.cpp - SBR bitstream demultiplexer implementations.

    27  

    28   Author(s): Juha Ojanpera

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

    30   *************************************************************************/

    31 

    32 /*-- Project Headers. --*/

    33 #include "sbr_rom.h"

    34 #include "env_extr.h"

    35 

    36 typedef const int8 (*Huffman)[2];

    37 

    38 /*

    39   \brief   Decodes Huffman codeword from TBitStream

    40 

    41   \return  Decoded Huffman value.

    42 */

    43 int16

    44 DecodeHuffmanCW(Huffman h, TBitStream *bs)

    45 {

    46   int16 value, bit, index = 0;

    47 

    48   while(index >= 0) 

    49   {

    50     bit = (int16) BsGetBits(bs, 1);

    51     index = h[index][bit];

    52   }

    53 

    54   value = index + 64;

    55 

    56   return (value);

    57 }

    58 

    59 /*

    60   \brief   Reads direction control data from TBitStream

    61 */

    62 void

    63 sbrGetDTDFData(SbrFrameData *frameData, TBitStream *bs)

    64 {

    65   frameData->domain_vec = (uint8) BsGetBits(bs, frameData->frameInfo.nEnvelopes);

    66   frameData->domain_vec_noise = (uint8) BsGetBits(bs, frameData->frameInfo.nNoiseEnvelopes);

    67 }

    68 

    69 /*

    70   \brief   Reads noise-floor-level data from TBitStream

    71 */

    72 void

    73 sbrGetNoiseFloorData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)

    74 {

    75   int16 i, j, k, noNoiseBands;

    76   Huffman hcb_noiseF, hcb_noise;

    77 

    78   noNoiseBands = headerData->hFreqBandData->nNfb;

    79 

    80   if(frameData->coupling == COUPLING_BAL) 

    81   {

    82     hcb_noise = (Huffman) &sbr_huffBook_NoiseBalance11T;

    83     hcb_noiseF = (Huffman) &sbr_huffBook_EnvBalance11F;

    84   }

    85   else 

    86   {

    87     hcb_noise = (Huffman) &sbr_huffBook_NoiseLevel11T;

    88     hcb_noiseF = (Huffman) &sbr_huffBook_EnvLevel11F;

    89   }

    90 

    91   k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nNoiseEnvelopes;

    92   for(i = 0; i < frameData->frameInfo.nNoiseEnvelopes; i++, k++) 

    93   {

    94     uint8 codValue;

    95     int16 index = i * noNoiseBands;

    96 

    97     codValue = frameData->domain_vec_noise & bitArray[k];

    98 

    99     if(!codValue) 

   100     {

   101       frameData->sbrNoiseFloorLevel[index++] = (int16) BsGetBits(bs, 5);

   102 

   103       for(j = 1; j < noNoiseBands; j++, index++) 

   104         frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noiseF, bs);

   105     }

   106     else 

   107     {

   108       for(j = 0; j < noNoiseBands; j++, index++)

   109         frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noise, bs);

   110     }

   111   }

   112 }

   113 

   114 /*

   115   \brief   Reads envelope data from TBitStream

   116 

   117   \return  One on success.

   118 */

   119 int16

   120 sbrGetEnvelope(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs, int16 decVal)

   121 {

   122   Huffman hcb_t, hcb_f;

   123   uint8 no_band[MAX_ENVELOPES];

   124   int16 i, j, k, delta, offset, ampRes;

   125   int16 start_bits, start_bits_balance;

   126 

   127   ampRes = headerData->ampResolution;

   128   if(frameData->frameInfo.frameClass == FIXFIX && frameData->frameInfo.nEnvelopes == 1)

   129     ampRes = SBR_AMP_RES_1_5;

   130 

   131   if(ampRes == SBR_AMP_RES_3_0)

   132   {

   133     start_bits = 6;

   134     start_bits_balance = 5;

   135   }

   136   else

   137   {

   138     start_bits = 7;

   139     start_bits_balance = 6;

   140   }

   141 

   142   k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;

   143   for(i = 0; i < frameData->frameInfo.nEnvelopes; i++, k++) 

   144   {

   145     uint8 resValue = (frameData->frameInfo.freqRes & bitArray[k]) ? 1 : 0;

   146 

   147     no_band[i] = headerData->hFreqBandData->nSfb[resValue];

   148   }

   149 

   150   if(frameData->coupling == COUPLING_BAL) 

   151   {

   152     if(ampRes == SBR_AMP_RES_1_5) 

   153     {

   154       hcb_t = (Huffman) &sbr_huffBook_EnvBalance10T;

   155       hcb_f = (Huffman) &sbr_huffBook_EnvBalance10F;

   156     }

   157     else 

   158     {

   159       hcb_t = (Huffman) &sbr_huffBook_EnvBalance11T;

   160       hcb_f = (Huffman) &sbr_huffBook_EnvBalance11F;

   161     }

   162   }

   163   else 

   164   {

   165     if(ampRes == SBR_AMP_RES_1_5) 

   166     {

   167       hcb_t = (Huffman) &sbr_huffBook_EnvLevel10T;

   168       hcb_f = (Huffman) &sbr_huffBook_EnvLevel10F;

   169     }

   170     else 

   171     {

   172       hcb_t = (Huffman) &sbr_huffBook_EnvLevel11T;

   173       hcb_f = (Huffman) &sbr_huffBook_EnvLevel11F;

   174     }

   175   }

   176 

   177   decVal = (ampRes) ? decVal : decVal << 1;

   178 

   179   k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;

   180   for(j = 0, offset = 0; j < frameData->frameInfo.nEnvelopes; j++, k++) 

   181   {

   182     uint8 codValue = frameData->domain_vec & bitArray[k];

   183 

   184     if(!codValue) 

   185     {

   186       if(frameData->coupling == COUPLING_BAL)

   187         frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits_balance);

   188       else 

   189       {

   190         frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits);

   191         

   192         frameData->iEnvelope[offset] -= decVal;

   193         if(frameData->iEnvelope[offset] < 0)

   194           frameData->iEnvelope[offset] = 0;          

   195       }

   196     }

   197 

   198     for(i = (1 - ((codValue) ? 1 : 0)); i < no_band[j]; i++) 

   199     {

   200       if(!codValue) 

   201         delta = DecodeHuffmanCW(hcb_f, bs);

   202       else 

   203       {

   204         delta = DecodeHuffmanCW(hcb_t, bs);

   205 

   206         if(i == 0)

   207           delta -= decVal;

   208       }

   209 

   210       frameData->iEnvelope[offset + i] = delta;

   211     }

   212 

   213     offset += no_band[j];

   214   }

   215 

   216   return (1);

   217 }

   218 

   219 /*

   220   \brief   Extracts the frame information from the TBitStream

   221 

   222   \return  One on success

   223 */

   224 int16

   225 sbrReadGridInfo(TBitStream *bs, SbrHeaderData *headerData, SbrFrameData *frameData)

   226 {

   227   uint8 tmp;

   228   FRAME_INFO *frameInfo;

   229   SbrGridInfo *sbrGridInfo;

   230   int16 pointer_bits, nEnv, k, staticFreqRes;

   231 

   232   nEnv = 0;

   233   frameInfo = &frameData->frameInfo;

   234   sbrGridInfo = &frameData->sbrGridInfo;

   235 

   236   frameInfo->frameClass = (uint8) BsGetBits(bs, 2);

   237 

   238   switch(frameInfo->frameClass) 

   239   {

   240     case FIXFIX:

   241       sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);

   242       staticFreqRes = (int16) BsGetBits(bs, 1);

   243       nEnv = (int16) (1 << sbrGridInfo->bs_num_env);

   244 

   245       if(sbrGridInfo->bs_num_env < 3 && headerData->numberTimeSlots == 16)

   246         COPY_MEMORY(frameInfo, &(sbr_staticFrameInfo[sbrGridInfo->bs_num_env]), sizeof(FRAME_INFO));

   247 

   248       if(!staticFreqRes)

   249         frameInfo->freqRes = 0;

   250       break;

   251       

   252     case FIXVAR:

   253     case VARFIX:

   254       sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);

   255       sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);

   256       nEnv = sbrGridInfo->bs_num_env + 1;

   257 

   258       for(k = 0; k < sbrGridInfo->bs_num_env; k++) 

   259         sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);

   260 

   261       pointer_bits = (int16) (FloatFR_logDualis(sbrGridInfo->bs_num_env + 2) + 0.992188f);

   262       sbrGridInfo->bs_pointer = (uint8) BsGetBits(bs, pointer_bits);

   263       break;

   264   }

   265 

   266   switch(frameInfo->frameClass) 

   267   {

   268     case FIXVAR:

   269       frameInfo->freqRes = 0;

   270       tmp = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);

   271       for(k = sbrGridInfo->bs_num_env; k >= 0; k--)

   272       {

   273         frameInfo->freqRes <<= 1;

   274         frameInfo->freqRes  |= tmp & 0x1;

   275         tmp >>= 1;

   276       }

   277       break;

   278 

   279     case VARFIX:

   280       frameInfo->freqRes = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);

   281       break;

   282 

   283     case VARVAR:

   284       sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);

   285       sbrGridInfo->bs_var_board[1] = (uint8) BsGetBits(bs, 2);

   286       sbrGridInfo->bs_num_rel[0] = (uint8) BsGetBits(bs, 2);

   287       sbrGridInfo->bs_num_rel[1] = (uint8) BsGetBits(bs, 2);

   288       

   289       nEnv = sbrGridInfo->bs_num_rel[0] + sbrGridInfo->bs_num_rel[1] + 1;

   290 

   291       for(k = 0; k < sbrGridInfo->bs_num_rel[0]; k++)

   292         sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);

   293 

   294       for(k = 0; k < sbrGridInfo->bs_num_rel[1]; k++) 

   295         sbrGridInfo->bs_rel_board_1[k] = (uint8) BsGetBits(bs, 2);

   296 

   297       pointer_bits = (int16) (FloatFR_logDualis(nEnv + 1) + 0.992188f);

   298       sbrGridInfo->bs_pointer = (int16) BsGetBits(bs, pointer_bits);

   299 

   300       frameInfo->freqRes = (uint8) BsGetBits(bs, nEnv);

   301       break;

   302   }

   303 

   304   frameInfo->nEnvelopes = (uint8) nEnv;

   305   frameInfo->nNoiseEnvelopes = (nEnv == 1) ? 1 : 2;

   306 

   307   return (1);

   308 }

   309 

   310 /*

   311   \brief     Initializes SBR header data

   312 */

   313 void

   314 initHeaderData(SbrHeaderData *headerData, FreqBandData *freqBandData,

   315                int32 sampleRate, int16 samplesPerFrame)

   316 {

   317   FreqBandData *hFreq = freqBandData;

   318 

   319   COPY_MEMORY(headerData, &sbr_defaultHeader, sizeof(SbrHeaderData));

   320 

   321   headerData->hFreqBandData = hFreq;

   322   headerData->codecFrameSize = samplesPerFrame;

   323   headerData->outSampleRate = SBR_UPSAMPLE_FAC * sampleRate;

   324   headerData->numberTimeSlots = samplesPerFrame >> (4 + headerData->timeStep);

   325 }

   326 

   327 /*

   328   \brief   Reads header data from TBitStream

   329 

   330   \return  Processing status - HEADER_RESET or HEADER_OK

   331 */

   332 SBR_HEADER_STATUS

   333 sbrGetHeaderData(SbrHeaderData *h_sbr_header, TBitStream *bs)

   334 {

   335   SbrHeaderData lastHeader;

   336   uint8 headerExtra1, headerExtra2;

   337 

   338   COPY_MEMORY(&lastHeader, h_sbr_header, sizeof(SbrHeaderData));

   339 

   340   h_sbr_header->ampResolution = (uint8) BsGetBits(bs, 1);

   341   h_sbr_header->startFreq = (uint8) BsGetBits(bs, 4);

   342   h_sbr_header->stopFreq = (uint8) BsGetBits(bs, 4);

   343   h_sbr_header->xover_band = (uint8) BsGetBits(bs, 3);

   344 

   345   BsGetBits(bs, 2);

   346 

   347   headerExtra1 = (uint8) BsGetBits(bs, 1);

   348   headerExtra2 = (uint8) BsGetBits(bs, 1);

   349 

   350   if(headerExtra1) 

   351   {

   352     h_sbr_header->freqScale = (uint8) BsGetBits(bs, 2);

   353     h_sbr_header->alterScale = (uint8) BsGetBits(bs, 1);

   354     h_sbr_header->noise_bands = (uint8) BsGetBits(bs, 2);

   355   }

   356   else 

   357   {

   358     h_sbr_header->freqScale   = SBR_FREQ_SCALE_DEF;

   359     h_sbr_header->alterScale  = SBR_ALTER_SCALE_DEF;

   360     h_sbr_header->noise_bands = SBR_NOISE_BANDS_DEF;

   361   }

   362 

   363   if(headerExtra2) 

   364   {

   365     h_sbr_header->limiterBands = (uint8) BsGetBits(bs, 2);

   366     h_sbr_header->limiterGains = (uint8) BsGetBits(bs, 2);

   367     h_sbr_header->interpolFreq = (uint8) BsGetBits(bs, 1);

   368     h_sbr_header->smoothingLength = (uint8) BsGetBits(bs, 1);

   369   }

   370   else 

   371   {

   372     h_sbr_header->limiterBands    = SBR_LIMITER_BANDS_DEF;

   373     h_sbr_header->limiterGains    = SBR_LIMITER_GAINS_DEF;

   374     h_sbr_header->interpolFreq    = SBR_INTERPOL_FREQ_DEF;

   375     h_sbr_header->smoothingLength = SBR_SMOOTHING_LENGTH_DEF;

   376   }

   377 

   378   if(h_sbr_header->syncState != SBR_ACTIVE                ||

   379      lastHeader.startFreq    != h_sbr_header->startFreq   ||

   380      lastHeader.stopFreq     != h_sbr_header->stopFreq    ||

   381      lastHeader.xover_band   != h_sbr_header->xover_band  ||

   382      lastHeader.freqScale    != h_sbr_header->freqScale   ||

   383      lastHeader.alterScale   != h_sbr_header->alterScale  ||

   384      lastHeader.noise_bands  != h_sbr_header->noise_bands) 

   385     return (HEADER_RESET); /*-- New settings --*/

   386 

   387   return (HEADER_OK);

   388 }

   389 

   390 /*

   391   \brief   Reads additional harmonics parameters

   392 

   393   \return  Number of bits read

   394 */

   395 static int16

   396 sbrGetSineData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)

   397 {

   398   int16 bitsRead;

   399 

   400   bitsRead = 1;

   401   frameData->isSinesPresent = (uint8) BsGetBits(bs, 1);

   402 

   403   if(frameData->isSinesPresent)

   404   {

   405     int16 rSfb;

   406 

   407     bitsRead += headerData->hFreqBandData->nSfb[1];

   408 

   409     rSfb = (headerData->hFreqBandData->nSfb[1] > 32) ? 32 : headerData->hFreqBandData->nSfb[1];

   410 

   411     frameData->addHarmonics[0] = (uint8) BsGetBits(bs, rSfb);

   412 

   413     if(headerData->hFreqBandData->nSfb[1] > 32)

   414     {

   415       rSfb = headerData->hFreqBandData->nSfb[1] - 32;

   416       frameData->addHarmonics[1] = (uint8) BsGetBits(bs, rSfb);

   417     }

   418   }

   419 

   420   return (bitsRead);

   421 }

   422 

   423 /*

   424   \brief      Reads extension data from the TBitStream

   425 */

   426 static void 

   427 sbrReadExtensionData(TBitStream *bs, SbrExtensionData *sbrExtData, uint8 isMono)

   428 {

   429   sbrExtData->writePsData = 0;

   430   sbrExtData->extensionDataPresent = (uint8) BsGetBits(bs, 1);

   431 

   432   if(sbrExtData->extensionDataPresent) 

   433   {

   434     int16 i, nBitsLeft, cnt;

   435 

   436     cnt = (int16) BsGetBits(bs, 4);

   437     if(cnt == 15)

   438       cnt += (int16) BsGetBits(bs, 8);

   439 

   440     sbrExtData->byteCount = MIN(cnt, sbrExtData->extDataBufLen);

   441 

   442     nBitsLeft = cnt << 3;

   443 

   444     while(nBitsLeft > 7) 

   445     {

   446       sbrExtData->extension_id = (uint8) BsGetBits(bs, 2);

   447 

   448       if(!(sbrExtData->extension_id == SBR_PARAMETRIC_STEREO_ID && isMono))

   449         sbrExtData->extension_id = 0;

   450       else

   451         sbrExtData->writePsData = 1;

   452 

   453       nBitsLeft -= 2;

   454 

   455       cnt = (int16) ((uint16) nBitsLeft >> 3);

   456 

   457       if(sbrExtData->extDataBufLen)

   458       {

   459         for(i = 0; i < MIN(cnt, sbrExtData->extDataBufLen); i++)

   460           sbrExtData->extensioData[i] = (uint8) BsGetBits(bs, 8);

   461 

   462         for( ; i < cnt; i++)

   463           BsGetBits(bs, 8);

   464       }

   465       else

   466         for(i = 0; i < cnt; i++)

   467           BsGetBits(bs, 8);

   468 

   469       nBitsLeft -= cnt << 3;

   470     }

   471 

   472     BsGetBits(bs, nBitsLeft);

   473   }

   474 }

   475 

   476 /*

   477   \brief   Reads TBitStream elements of one channel

   478 

   479   \return  One on success

   480 */

   481 int16

   482 sbrGetSCE(SbrHeaderData *headerData, SbrFrameData *frameData,

   483           SbrExtensionData *sbrExtData, TBitStream *bs, 

   484           int16 decVal, uint8 isMono)

   485 {

   486   frameData->coupling = COUPLING_OFF;

   487 

   488   /*-- Data present. --*/

   489   frameData->dataPresent = (int16) BsGetBits(bs, 1);

   490   if(frameData->dataPresent) BsGetBits(bs, 4);

   491 

   492   /*-- Read grid info. --*/

   493   sbrReadGridInfo(bs, headerData, frameData);

   494 

   495   /*-- Read direction info for envelope decoding. --*/

   496   sbrGetDTDFData(frameData, bs);

   497 

   498   /*-- Read inverse filtering modes. --*/

   499   frameData->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);

   500 

   501   /*-- Read Huffman coded envelope values. --*/

   502   sbrGetEnvelope(headerData, frameData, bs, decVal);

   503 

   504   /*-- Read noise data. --*/

   505   sbrGetNoiseFloorData(headerData, frameData, bs);

   506 

   507   /*-- Read sine data, if any. --*/

   508   sbrGetSineData(headerData, frameData, bs);

   509 

   510   /*-- Read extension data, if any. --*/

   511   sbrReadExtensionData(bs, sbrExtData, isMono);

   512 

   513   return (1);

   514 }

   515 

   516 /*

   517   \brief      Reads TBitStream elements of a channel pair

   518 

   519   \return     One on success

   520 */

   521 int16

   522 sbrGetCPE(SbrHeaderData *headerData, SbrFrameData *frameDataLeft,

   523           SbrFrameData *frameDataRight, SbrExtensionData *sbrExtData,

   524           TBitStream *bs, int16 decVal)

   525 {

   526   /*-- Data present. -*/

   527   frameDataLeft->dataPresent = (uint8) BsGetBits(bs, 1);

   528   if(frameDataLeft->dataPresent)

   529     BsGetBits(bs, 8);

   530 

   531   /*-- Coupling mode. --*/

   532   if(BsGetBits(bs, 1)) 

   533   {

   534     frameDataLeft->coupling = COUPLING_LEVEL;

   535     frameDataRight->coupling = COUPLING_BAL;

   536   }

   537   else 

   538   {

   539     frameDataLeft->coupling = COUPLING_OFF;

   540     frameDataRight->coupling = COUPLING_OFF;

   541   }

   542 

   543   /*-- Read grid info (left channel). --*/

   544   sbrReadGridInfo(bs, headerData, frameDataLeft);

   545 

   546   /*-- Read grid info (right channel). --*/

   547   if(frameDataLeft->coupling) 

   548     COPY_MEMORY(&frameDataRight->frameInfo, &frameDataLeft->frameInfo, sizeof(FRAME_INFO));

   549   else 

   550     sbrReadGridInfo(bs, headerData, frameDataRight);

   551 

   552   /*-- Read direction info for envelope decoding. --*/

   553   sbrGetDTDFData(frameDataLeft, bs);

   554   sbrGetDTDFData(frameDataRight, bs);

   555 

   556   /*-- Read inverse filtering modes for left channel. --*/

   557   frameDataLeft->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);

   558 

   559   if(frameDataLeft->coupling) 

   560   {

   561     frameDataRight->sbr_invf_mode = frameDataLeft->sbr_invf_mode;

   562 

   563     /*-- Read Huffman coded envelope + noise values for left channel. --*/

   564     sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);

   565     sbrGetNoiseFloorData(headerData, frameDataLeft, bs);

   566 

   567     /*-- Read Huffman coded envelope for right channel. --*/

   568     sbrGetEnvelope(headerData, frameDataRight, bs, decVal);

   569   }

   570   else 

   571   {

   572     /*-- Read inverse filtering modes for right channel. --*/

   573     frameDataRight->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);

   574  

   575     /*-- Read Huffman coded envelope values. --*/

   576     sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);

   577     sbrGetEnvelope(headerData, frameDataRight, bs, decVal);

   578 

   579     /*-- Read noise data for left channel. --*/

   580     sbrGetNoiseFloorData(headerData, frameDataLeft, bs);

   581   }

   582 

   583   /*-- Read noise data for right channel. --*/

   584   sbrGetNoiseFloorData(headerData, frameDataRight, bs);

   585 

   586   /*-- Read additional sines, if any. --*/

   587   sbrGetSineData(headerData, frameDataLeft, bs);

   588   sbrGetSineData(headerData, frameDataRight, bs);

   589 

   590   /*-- Read extension data, if any. --*/

   591   sbrReadExtensionData(bs, sbrExtData, 0);

   592 

   593   return (1);

   594 }