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 bitstream multiplexer implementation $Revision: 1.1.1.1 $

    23 */

    24 

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

    26   sbr_bitmux.cpp - Bitstream implementations for SBR encoder.

    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 "sbr_bitmux.h"

    35 

    36 #define CODE_BOOK_SCF_LAV10         (60)

    37 #define CODE_BOOK_SCF_LAV11         (31)

    38 #define CODE_BOOK_SCF_LAV_BALANCE11 (12)

    39 #define CODE_BOOK_SCF_LAV_BALANCE10 (24)

    40 

    41 /**

    42  * Writes SBR header data.

    43  */

    44 int16

    45 SBR_WriteHeaderData(SbrHeaderData *h_sbr_header, TBitStream *bs, uint8 writeFlag)

    46 {

    47   int16 bitsWritten;

    48   uint8 headerExtra1, headerExtra2;

    49 

    50   bitsWritten = 1 + 4 + 4 + 3 + 2 + 2;

    51 

    52   if(writeFlag)

    53   {

    54     BsPutBits(bs, 1, h_sbr_header->ampResolution);

    55     BsPutBits(bs, 4, h_sbr_header->startFreq);

    56     BsPutBits(bs, 4, h_sbr_header->stopFreq); 

    57     BsPutBits(bs, 3, h_sbr_header->xover_band);

    58     BsPutBits(bs, 2, 0);

    59   }

    60 

    61   headerExtra1 = 0;

    62   if(h_sbr_header->freqScale   != SBR_FREQ_SCALE_DEF ||

    63      h_sbr_header->alterScale  != SBR_ALTER_SCALE_DEF ||

    64      h_sbr_header->noise_bands != SBR_NOISE_BANDS_DEF)

    65    headerExtra1 = 1;

    66 

    67   headerExtra2 = 0;

    68   if(h_sbr_header->limiterBands    != SBR_LIMITER_BANDS_DEF ||

    69      h_sbr_header->limiterGains    != SBR_LIMITER_GAINS_DEF ||

    70      h_sbr_header->interpolFreq    != SBR_INTERPOL_FREQ_DEF ||

    71      h_sbr_header->smoothingLength != SBR_SMOOTHING_LENGTH_DEF)

    72    headerExtra2 = 1;

    73 

    74   if(writeFlag)

    75   {

    76     BsPutBits(bs, 1, headerExtra1);

    77     BsPutBits(bs, 1, headerExtra2);

    78   }

    79 

    80   if(headerExtra1)

    81   {

    82     bitsWritten += 5;

    83 

    84     if(writeFlag)

    85     {

    86       BsPutBits(bs, 2, h_sbr_header->freqScale);

    87       BsPutBits(bs, 1, h_sbr_header->alterScale);

    88       BsPutBits(bs, 2, h_sbr_header->noise_bands);

    89     }

    90   }

    91 

    92   if(headerExtra2)

    93   {

    94     bitsWritten += 6;

    95 

    96     if(writeFlag)

    97     {

    98       BsPutBits(bs, 2, h_sbr_header->limiterBands);

    99       BsPutBits(bs, 2, h_sbr_header->limiterGains);

   100       BsPutBits(bs, 1, h_sbr_header->interpolFreq);

   101       BsPutBits(bs, 1, h_sbr_header->smoothingLength);

   102     }

   103   }

   104 

   105   return (bitsWritten);

   106 }

   107 

   108 /**

   109  * Writes additional sinusoidal data for SBR.

   110  */

   111 int16

   112 SBR_WriteSinusoidalData(SbrFrameData *hFrameData, TBitStream *bs, int16 nSfb, uint8 writeFlag)

   113 {

   114   int16 bitsWritten;

   115 

   116   bitsWritten = 1;

   117   if(writeFlag)

   118   {

   119     if(hFrameData->isSinesPresent)

   120       BsPutBits(bs, 1, 1);

   121     else

   122       BsPutBits(bs, 1, 0);

   123   }

   124 

   125   if(hFrameData->isSinesPresent)

   126   {

   127     bitsWritten += nSfb;

   128 

   129     if(writeFlag)

   130     {

   131       int16 wSfb;

   132 

   133       wSfb = (nSfb > 32) ? 32 : nSfb;

   134 

   135       BsPutBits(bs, wSfb, hFrameData->addHarmonics[0]);

   136       if(nSfb > 32)

   137       {

   138         wSfb = nSfb - 32;

   139         BsPutBits(bs, wSfb, hFrameData->addHarmonics[1]);

   140       }

   141     }

   142   }

   143 

   144 

   145   return (bitsWritten);

   146 }

   147 

   148 /**

   149  * Writes envelope direction coding data.

   150  */

   151 int16

   152 SBR_WriteDTDFData(SbrFrameData *frameData, TBitStream *bs, uint8 writeFlag)

   153 {

   154   int16 bitsWritten;

   155 

   156   bitsWritten = frameData->frameInfo.nEnvelopes + frameData->frameInfo.nNoiseEnvelopes;

   157 

   158   if(writeFlag)

   159   {

   160     BsPutBits(bs, frameData->frameInfo.nEnvelopes, frameData->domain_vec);

   161     BsPutBits(bs, frameData->frameInfo.nNoiseEnvelopes, frameData->domain_vec_noise);

   162   }

   163 

   164   return (bitsWritten);

   165 }

   166 

   167 /**

   168  * Writes envelope data for SBR.

   169  */

   170 int16

   171 SBR_WriteEnvelopeData(SbrHeaderData *hHeaderData, SbrFrameData *frameData,

   172                       TBitStream *bs, uint8 writeFlag)

   173 {

   174   const uint8 *hCbBits_f, *hCbBits_t;

   175   const int32 *hCb_f = 0, *hCb_t = 0;

   176   const uint16 *hCb_f0 = 0, *hCb_t0 = 0;

   177   uint8 no_band[MAX_ENVELOPES], hCbIndexOffset;

   178   int16 i, j, k, offset, start_bits, bitsWritten, start_bits_balance, ampRes;

   179 

   180   ampRes = hHeaderData->ampResolution;

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

   182     ampRes = SBR_AMP_RES_1_5;

   183 

   184   if(ampRes == SBR_AMP_RES_3_0)

   185   {

   186     start_bits = 6;

   187     start_bits_balance = 5;

   188   }

   189   else

   190   {

   191     start_bits = 7;

   192     start_bits_balance = 6;

   193   }

   194 

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

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

   197   {

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

   199 

   200     no_band[i] = hHeaderData->hFreqBandData->nSfb[resValue];

   201   }

   202 

   203   /*

   204    * Indexing of the codebooks needs some effort in order to same ROM memory...

   205    */

   206   if(frameData->coupling == COUPLING_BAL) 

   207   {

   208     if(ampRes == SBR_AMP_RES_1_5) 

   209     {

   210       hCb_f = bookSbrEnvBalanceC10F;

   211       hCbBits_f = bookSbrEnvBalanceL10F;

   212 

   213       hCb_t = bookSbrEnvBalanceC10T;

   214       hCbBits_t = bookSbrEnvBalanceL10T;

   215 

   216       hCbIndexOffset = CODE_BOOK_SCF_LAV_BALANCE10; 

   217     }

   218     else 

   219     {

   220       hCb_f0 = bookSbrEnvBalanceC11F;

   221       hCbBits_f = bookSbrEnvBalanceL11F;

   222 

   223       hCb_t0 = bookSbrEnvBalanceC11T;

   224       hCbBits_t = bookSbrEnvBalanceL11T;

   225 

   226       hCbIndexOffset = CODE_BOOK_SCF_LAV_BALANCE11;

   227     }

   228   }

   229   else 

   230   {

   231     if(ampRes == SBR_AMP_RES_1_5) 

   232     {

   233       hCb_f = v_Huff_envelopeLevelC10F;

   234       hCbBits_f = v_Huff_envelopeLevelL10F;

   235 

   236       hCb_t = v_Huff_envelopeLevelC10T;

   237       hCbBits_t = v_Huff_envelopeLevelL10T;

   238 

   239       hCbIndexOffset = CODE_BOOK_SCF_LAV10;

   240     }

   241     else 

   242     {

   243       hCb_f = v_Huff_envelopeLevelC11F;

   244       hCbBits_f = v_Huff_envelopeLevelL11F;

   245 

   246       hCb_t = v_Huff_envelopeLevelC11T;

   247       hCbBits_t = v_Huff_envelopeLevelL11T;

   248 

   249       hCbIndexOffset = CODE_BOOK_SCF_LAV11;

   250     }

   251   }

   252 

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

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

   255   {

   256     int16 index;

   257     uint8 codValue;

   258 

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

   260 

   261     if(!codValue) 

   262     {

   263       index = frameData->iEnvelope[offset];

   264       index = MAX(0, index);

   265 

   266       if(frameData->coupling == COUPLING_BAL) 

   267       {

   268         index = MIN(index, (1 << start_bits_balance) - 1);

   269 

   270         bitsWritten += start_bits_balance;

   271         if(writeFlag) BsPutBits(bs, start_bits_balance, index);

   272       }

   273       else 

   274       {

   275         index = MIN(index, (1 << start_bits) - 1);

   276 

   277         bitsWritten += start_bits;

   278         if(writeFlag) BsPutBits(bs, start_bits, index);

   279       }

   280     }

   281 

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

   283     {

   284       uint32 codeWord;

   285 

   286       index  = frameData->iEnvelope[offset + i];

   287       index  = (index < 0) ? MAX(index, -hCbIndexOffset) : MIN(index, hCbIndexOffset);

   288       index += hCbIndexOffset;

   289 

   290       if(!codValue)

   291       {

   292         bitsWritten += hCbBits_f[index];

   293         if(writeFlag) 

   294         {

   295           if(frameData->coupling == COUPLING_BAL && ampRes != SBR_AMP_RES_1_5)

   296             codeWord = hCb_f0[index];

   297           else

   298             codeWord = hCb_f[index];

   299 

   300           BsPutBits(bs, hCbBits_f[index], codeWord);

   301         }

   302       }

   303       else

   304       {

   305         bitsWritten += hCbBits_t[index];

   306         if(writeFlag) 

   307         {

   308           if(frameData->coupling == COUPLING_BAL && ampRes != SBR_AMP_RES_1_5)

   309             codeWord = hCb_t0[index];

   310           else

   311             codeWord = hCb_t[index];

   312 

   313           BsPutBits(bs, hCbBits_t[index], codeWord);

   314         }

   315       }

   316     }

   317 

   318     offset += no_band[j];

   319   }

   320 

   321   return (bitsWritten);

   322 }

   323 

   324 /**

   325  * Writes noise data for SBR.

   326  */

   327 int16

   328 SBR_WriteNoiseData(SbrHeaderData *hHeaderData, SbrFrameData *frameData,

   329                    TBitStream *bs, uint8 writeFlag)

   330 {

   331   uint8 hCbIndexOffset;

   332   const int32 *hCb_f = 0;

   333   const uint16 *hCb_f0 = 0, *hCb_t = 0;

   334   const uint8 *hCbBits_f, *hCbBits_t;

   335   int16 i, k, noNoiseBands, bitsWritten;

   336 

   337   noNoiseBands = hHeaderData->hFreqBandData->nNfb;

   338 

   339   if(frameData->coupling == COUPLING_BAL) 

   340   {

   341     hCb_f0 = bookSbrEnvBalanceC11F;

   342     hCbBits_f = bookSbrEnvBalanceL11F;

   343 

   344     hCb_t = bookSbrNoiseBalanceC11T;

   345     hCbBits_t = bookSbrNoiseBalanceL11T;

   346 

   347     hCbIndexOffset = CODE_BOOK_SCF_LAV_BALANCE11;

   348   }

   349   else 

   350   {

   351     hCb_f = v_Huff_envelopeLevelC11F;

   352     hCbBits_f = v_Huff_envelopeLevelL11F;

   353 

   354     hCb_t = v_Huff_NoiseLevelC11T;

   355     hCbBits_t = v_Huff_NoiseLevelL11T;

   356 

   357     hCbIndexOffset = CODE_BOOK_SCF_LAV11;

   358   }

   359 

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

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

   362   {

   363     int16 j, index;

   364     uint8 codValue;

   365 

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

   367 

   368     if(!codValue) 

   369     {      

   370       bitsWritten += 5;

   371       if(writeFlag) 

   372         BsPutBits(bs, 5, frameData->sbrNoiseFloorLevel[i * noNoiseBands]);

   373 

   374       for(j = 1; j < noNoiseBands; j++) 

   375       {

   376         index  = frameData->sbrNoiseFloorLevel[i * noNoiseBands + j];

   377         index  = (index < 0) ? MAX(index, -hCbIndexOffset) : MIN(index, hCbIndexOffset);

   378         index += hCbIndexOffset;

   379 

   380         bitsWritten += hCbBits_f[index];

   381         if(writeFlag) 

   382         {

   383           uint32 codeWord = (frameData->coupling == COUPLING_BAL) ? hCb_f0[index] : hCb_f[index];

   384           BsPutBits(bs, hCbBits_f[index], codeWord);

   385         }

   386       }

   387     }

   388     else 

   389     {

   390       for(j = 0; j < noNoiseBands; j++) 

   391       {

   392         index  = frameData->sbrNoiseFloorLevel[i * noNoiseBands + j];

   393         index  = (index < 0) ? MAX(index, -hCbIndexOffset) : MIN(index, hCbIndexOffset);

   394         index += hCbIndexOffset;

   395 

   396         bitsWritten += hCbBits_t[index];

   397         if(writeFlag) BsPutBits(bs, hCbBits_t[index], hCb_t[index]);

   398       }

   399     }

   400   }

   401 

   402   return (bitsWritten);

   403 }

   404 

   405 /**

   406  * Writes dummy (=silence) data for parametric stereo part of SBR.

   407  */

   408 int16

   409 SBR_WriteParametricStereoData(TBitStream *bs, uint8 writeFlag)

   410 {

   411   int16 bitsWritten = 0;

   412 

   413   /*-- Write header flag. --*/

   414   bitsWritten += 1;

   415   if(writeFlag) BsPutBits(bs, 1, 1);

   416 

   417   /*-- Write 'enable_iid' element. --*/

   418   bitsWritten += 1;

   419   if(writeFlag) BsPutBits(bs, 1, 0);

   420 

   421   /*-- Write 'enable_icc' element. --*/

   422   bitsWritten += 1;

   423   if(writeFlag) BsPutBits(bs, 1, 0);

   424 

   425   /*-- Write 'enable_ext' element. --*/

   426   bitsWritten += 1;

   427   if(writeFlag) BsPutBits(bs, 1, 0);

   428 

   429   /*-- Write frame class. --*/

   430   bitsWritten += 1;

   431   if(writeFlag) BsPutBits(bs, 1, 0);

   432 

   433   /*-- Write envelope index. --*/

   434   bitsWritten += 2;

   435   if(writeFlag) BsPutBits(bs, 2, 0);

   436 

   437   return (bitsWritten);

   438 }

   439 

   440 /**

   441  * Writes extension data for SBR.

   442  */

   443 int16 

   444 SBR_WritetExtendedData(TBitStream *bs, SbrExtensionData *extData, uint8 writeFlag)

   445 {

   446   uint8 writeExt;

   447   int16 bitsWritten = 0;

   448 

   449   writeExt = (extData->writePsData || extData->extensionDataPresent) ? 1 : 0;

   450 

   451   bitsWritten += 1;

   452   if(writeFlag) BsPutBits(bs, 1, writeExt);

   453 

   454   if(writeExt) 

   455   {

   456     int16 i, nBitsLeft, cnt, byteCount;

   457 

   458     byteCount = (extData->writePsData) ? 2 : extData->byteCount;

   459     cnt = (byteCount >= 15) ? 15 : byteCount;

   460 

   461     bitsWritten += 4;

   462     if(writeFlag) BsPutBits(bs, 4, cnt);

   463 

   464     if(cnt == 15)

   465     {

   466       int16 diff;

   467 

   468       diff = byteCount - 15;

   469 

   470       bitsWritten += 8;

   471       if(writeFlag) BsPutBits(bs, 8, diff);

   472     }

   473 

   474     nBitsLeft = byteCount << 3;

   475 

   476     while(nBitsLeft > 7) 

   477     {

   478       nBitsLeft -= 2;

   479       bitsWritten += 2;

   480       if(writeFlag) BsPutBits(bs, 2, (extData->writePsData) ? 2 : extData->extension_id);

   481 

   482       cnt = nBitsLeft >> 3;

   483       bitsWritten += cnt << 3;

   484       if(writeFlag)

   485       {

   486         if(extData->writePsData)

   487         {

   488           SBR_WriteParametricStereoData(bs, writeFlag);

   489           BsPutBits(bs, 1, 0); /*-- This will byte align the data. --*/

   490         }

   491         else

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

   493             BsPutBits(bs, 8, extData->extensioData[i]);

   494       }

   495 

   496       nBitsLeft -= cnt << 3;

   497     }

   498 

   499     bitsWritten += nBitsLeft;

   500     if(writeFlag) BsPutBits(bs, nBitsLeft, 0);

   501   }

   502 

   503   return (bitsWritten);

   504 }

   505 

   506 /**

   507  * Writes envelope coding grid for SBR.

   508  */

   509 int16

   510 SBR_WriteGridInfo(TBitStream *bs, SbrFrameData *frameData, uint8 writeFlag)

   511 {

   512   FRAME_INFO *frameInfo;

   513   SbrGridInfo *sbrGridInfo;

   514   int16 pointer_bits, nEnv, bitsWritten, k;

   515 

   516   nEnv = 0;

   517   bitsWritten = 0;

   518   frameInfo = &frameData->frameInfo;

   519   sbrGridInfo = &frameData->sbrGridInfo;

   520 

   521   bitsWritten += 2;

   522   if(writeFlag) BsPutBits(bs, 2, frameInfo->frameClass);

   523 

   524   switch(frameInfo->frameClass) 

   525   {

   526     case FIXFIX:

   527       bitsWritten += 2;

   528       if(writeFlag) BsPutBits(bs, 2, sbrGridInfo->bs_num_env);

   529 

   530       bitsWritten += 1;

   531       if(writeFlag) 

   532         BsPutBits(bs, 1, frameInfo->freqRes & 0x1);

   533       break;

   534       

   535     case FIXVAR:

   536     case VARFIX:

   537       bitsWritten += 2;

   538       if(writeFlag) BsPutBits(bs, 2, sbrGridInfo->bs_var_board[0]);

   539 

   540       bitsWritten += 2;

   541       if(writeFlag) BsPutBits(bs, 2, sbrGridInfo->bs_num_env);

   542 

   543       bitsWritten += sbrGridInfo->bs_num_env << 1;

   544       if(writeFlag)

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

   546           BsPutBits(bs, 2, sbrGridInfo->bs_rel_board_0[k]);

   547 

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

   549 

   550       bitsWritten += pointer_bits;

   551       if(writeFlag) BsPutBits(bs, pointer_bits, sbrGridInfo->bs_pointer);

   552 

   553       bitsWritten += sbrGridInfo->bs_num_env + 1;

   554       break;

   555   }

   556 

   557   switch(frameInfo->frameClass) 

   558   {

   559     case FIXVAR:

   560       if(writeFlag)

   561       {

   562         uint8 tmp = 0, tmp2 = frameInfo->freqRes;

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

   564         {

   565           tmp <<= 1;

   566           tmp  |= tmp2 & 0x1;

   567           tmp2 >>= 1;

   568         }

   569         BsPutBits(bs, sbrGridInfo->bs_num_env + 1, tmp);

   570       }

   571       break;

   572 

   573     case VARFIX:

   574       if(writeFlag)

   575         BsPutBits(bs, sbrGridInfo->bs_num_env + 1, frameInfo->freqRes);

   576       break;

   577 

   578     case VARVAR:

   579       bitsWritten += 8;

   580       if(writeFlag)

   581       {

   582         BsPutBits(bs, 2, sbrGridInfo->bs_var_board[0]);

   583         BsPutBits(bs, 2, sbrGridInfo->bs_var_board[1]);

   584         BsPutBits(bs, 2, sbrGridInfo->bs_num_rel[0]);

   585         BsPutBits(bs, 2, sbrGridInfo->bs_num_rel[1]);

   586       }

   587       

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

   589 

   590       bitsWritten += sbrGridInfo->bs_num_rel[0] << 1;

   591       if(writeFlag)

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

   593           BsPutBits(bs, 2, sbrGridInfo->bs_rel_board_0[k]);

   594 

   595       bitsWritten += sbrGridInfo->bs_num_rel[1] << 1;

   596       if(writeFlag)

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

   598           BsPutBits(bs, 2, sbrGridInfo->bs_rel_board_1[k]);

   599 

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

   601 

   602       bitsWritten += pointer_bits;

   603       if(writeFlag) BsPutBits(bs, pointer_bits, sbrGridInfo->bs_pointer);

   604 

   605       bitsWritten += nEnv;

   606       if(writeFlag)

   607         BsPutBits(bs, nEnv, frameInfo->freqRes);

   608       break;

   609   }

   610 

   611   return (bitsWritten);

   612 }

   613 

   614 int16

   615 SBR_WriteSCE(SbrHeaderData *hHeaderData, SbrFrameData  *hFrameData,

   616              SbrExtensionData *sbrExtData, TBitStream *bs,

   617              uint8 isMono, uint8 writeFlag)

   618 {

   619   int16 bitsWritten;

   620 

   621   /*-- No reserved bits. --*/

   622   bitsWritten = 1;

   623   if(writeFlag) BsPutBits(bs, 1, hFrameData->dataPresent);

   624 

   625   bitsWritten += (hFrameData->dataPresent) ? 4 : 0;

   626   if(hFrameData->dataPresent)

   627     if(writeFlag) BsPutBits(bs, 4, 0);

   628 

   629   /*-- Write grid info. --*/

   630   bitsWritten += SBR_WriteGridInfo(bs, hFrameData, writeFlag);

   631 

   632   /*-- Write direction info for the envelope coding. --*/

   633   bitsWritten += SBR_WriteDTDFData(hFrameData, bs, writeFlag);

   634 

   635   /*-- Write inverse filtering modes. --*/

   636   bitsWritten += hHeaderData->hFreqBandData->nInvfBands << 1;

   637   if(writeFlag)

   638     BsPutBits(bs, hHeaderData->hFreqBandData->nInvfBands << 1, hFrameData->sbr_invf_mode);

   639 

   640   /*-- Write envelope values. --*/

   641   bitsWritten += SBR_WriteEnvelopeData(hHeaderData, hFrameData, bs, writeFlag);

   642 

   643   /*-- Write noise floor values. --*/

   644   bitsWritten += SBR_WriteNoiseData(hHeaderData, hFrameData, bs, writeFlag);

   645 

   646   /*-- Write additional sinusoidals, if any. --*/

   647   bitsWritten += SBR_WriteSinusoidalData(hFrameData, bs, hHeaderData->hFreqBandData->nSfb[1], writeFlag);

   648 

   649   /*

   650    * Write extended data info, this is only in case of mono since parameters

   651    * for parametric stereo are decoded via the data extension. In case of stereo

   652    * do nothing.

   653    */

   654   if(!isMono)

   655   {

   656     bitsWritten += 1;

   657     if(writeFlag) BsPutBits(bs, 1, 0);

   658   }

   659   else

   660     bitsWritten += SBR_WritetExtendedData(bs, sbrExtData, writeFlag);

   661 

   662   return (bitsWritten);

   663 }

   664 

   665 int16

   666 SBR_WriteCPE(SbrHeaderData *hHeaderData, SbrFrameData *hFrameDataLeft,

   667              SbrFrameData *hFrameDataRight, SbrExtensionData *sbrExtData,

   668              TBitStream *bs, uint8 writeFlag)

   669 {

   670   int16 bitsWritten;

   671 

   672   /*-- No reserved bits. --*/

   673   bitsWritten = 1;

   674   if(writeFlag) BsPutBits(bs, 1, 0);

   675   bitsWritten += (hFrameDataLeft->dataPresent) ? 8 : 0;

   676   if(hFrameDataLeft->dataPresent)

   677     if(writeFlag) BsPutBits(bs, 8, 0);

   678 

   679   bitsWritten += 1;

   680   if(writeFlag)

   681   {

   682     if(hFrameDataLeft->coupling) 

   683       BsPutBits(bs, 1, 1);

   684     else

   685       BsPutBits(bs, 1, 0);

   686   }

   687 

   688   /*-- Write grid info (left channel). --*/

   689   bitsWritten += SBR_WriteGridInfo(bs, hFrameDataLeft, writeFlag);

   690 

   691   /*-- Write grid info (right channel). --*/

   692   if(!hFrameDataLeft->coupling)

   693     bitsWritten += SBR_WriteGridInfo(bs, hFrameDataRight, writeFlag);

   694 

   695   /*-- Write direction info for the envelope coding (left channel). --*/

   696   bitsWritten += SBR_WriteDTDFData(hFrameDataLeft, bs, writeFlag);

   697 

   698   /*-- Write direction info for the envelope coding (right channel). --*/

   699   bitsWritten += SBR_WriteDTDFData(hFrameDataRight, bs, writeFlag);

   700 

   701   /*-- Write inverse filtering modes. --*/

   702   bitsWritten += hHeaderData->hFreqBandData->nInvfBands << 1;

   703   if(writeFlag)

   704     BsPutBits(bs, hHeaderData->hFreqBandData->nInvfBands << 1, hFrameDataLeft->sbr_invf_mode);

   705 

   706   if(hFrameDataLeft->coupling) 

   707   {

   708     /*-- Write envelope values. --*/

   709     bitsWritten += SBR_WriteEnvelopeData(hHeaderData, hFrameDataLeft, bs, writeFlag);

   710 

   711     /*-- Write noise floor values. --*/

   712     bitsWritten += SBR_WriteNoiseData(hHeaderData, hFrameDataLeft, bs, writeFlag);

   713 

   714     /*-- Write envelope values. --*/

   715     bitsWritten += SBR_WriteEnvelopeData(hHeaderData, hFrameDataRight, bs, writeFlag);

   716   }

   717   else 

   718   {

   719     bitsWritten += hHeaderData->hFreqBandData->nInvfBands << 1;

   720     if(writeFlag)

   721       BsPutBits(bs, hHeaderData->hFreqBandData->nInvfBands << 1, hFrameDataRight->sbr_invf_mode);

   722 

   723     /*-- Write envelope values. --*/

   724     bitsWritten += SBR_WriteEnvelopeData(hHeaderData, hFrameDataLeft, bs, writeFlag);

   725 

   726     /*-- Write envelope values. --*/

   727     bitsWritten += SBR_WriteEnvelopeData(hHeaderData, hFrameDataRight, bs, writeFlag);

   728 

   729     /*-- Write noise floor values. --*/

   730     bitsWritten += SBR_WriteNoiseData(hHeaderData, hFrameDataLeft, bs, writeFlag);

   731   }

   732 

   733   /*-- Write noise floor values. --*/

   734   bitsWritten += SBR_WriteNoiseData(hHeaderData, hFrameDataRight, bs, writeFlag);

   735 

   736   /*-- Write additional sinusoidals, if any. --*/

   737   bitsWritten += SBR_WriteSinusoidalData(hFrameDataLeft, bs, hHeaderData->hFreqBandData->nSfb[1], writeFlag);

   738   bitsWritten += SBR_WriteSinusoidalData(hFrameDataRight, bs, hHeaderData->hFreqBandData->nSfb[1], writeFlag);

   739 

   740   /*-- No extended data. --*/

   741 #if 0

   742   bitsWritten += 1;

   743   if(writeFlag) BsPutBits(bs, 1, 0);

   744 #else

   745   bitsWritten += SBR_WritetExtendedData(bs, sbrExtData, writeFlag);

   746 #endif /*-- 0 --*/

   747 

   748   return (bitsWritten);

   749 }