libSBRenc/src/bit_sbr.cpp

   1
   2 /* -----------------------------------------------------------------------------------------------------------
   3 Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5 © Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
   6   All rights reserved.
   7
   8  1.    INTRODUCTION
   9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
  10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
  11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
  12
  13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
  14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
  15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
  16 of the MPEG specifications.
  17
  18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
  19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
  20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
  21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
  22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
  23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
  24
  25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
  26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
  27 applications information and documentation.
  28
  29 2.    COPYRIGHT LICENSE
  30
  31 Redistribution and use in source and binary forms, with or without modification, are permitted without
  32 payment of copyright license fees provided that you satisfy the following conditions:
  33
  34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
  35 your modifications thereto in source code form.
  36
  37 You must retain the complete text of this software license in the documentation and/or other materials
  38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
  39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
  40 modifications thereto to recipients of copies in binary form.
  41
  42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
  43 prior written permission.
  44
  45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
  46 software or your modifications thereto.
  47
  48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
  49 and 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
  53 3.    NO PATENT LICENSE
  54
  55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
  56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
  57 respect to this software.
  58
  59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
  60 by appropriate patent licenses.
  61
  62 4.    DISCLAIMER
  63
  64 This 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
  66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
  68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
  69 or business interruption, however caused and on any theory of liability, whether in contract, strict
  70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
  71 advised of the possibility of such damage.
  72
  73 5.    CONTACT INFORMATION
  74
  75 Fraunhofer Institute for Integrated Circuits IIS
  76 Attention: Audio and Multimedia Departments - FDK AAC LL
  77 Am Wolfsmantel 33
  78 91058 Erlangen, Germany
  79
  80 www.iis.fraunhofer.de/amm
  81 amm-info@iis.fraunhofer.de
  82 ----------------------------------------------------------------------------------------------------------- */
  83
  84 /*!
  85   \file
  86   \brief  SBR bit writing routines
  87 */
  88
  89
  90 #include "bit_sbr.h"
  91
  92 #include "code_env.h"
  93 #include "cmondata.h"
  94 #include "sbr.h"
  95
  96 #include "ps_main.h"
  97
  98 typedef enum {
  99   SBR_ID_SCE = 1,
 100   SBR_ID_CPE
 101 } SBR_ELEMENT_TYPE;
 102
 103
 104 static INT encodeSbrData (HANDLE_SBR_ENV_DATA       sbrEnvDataLeft,
 105                           HANDLE_SBR_ENV_DATA       sbrEnvDataRight,
 106                           HANDLE_PARAMETRIC_STEREO  hParametricStereo,
 107                           HANDLE_COMMON_DATA        cmonData,
 108                           SBR_ELEMENT_TYPE          sbrElem,
 109                           INT                       coupling,
 110                           UINT                      sbrSyntaxFlags);
 111
 112 static INT encodeSbrHeader (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
 113                             HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
 114                             HANDLE_COMMON_DATA         cmonData);
 115
 116
 117 static INT encodeSbrHeaderData (HANDLE_SBR_HEADER_DATA sbrHeaderData,
 118                                 HANDLE_FDK_BITSTREAM   hBitStream);
 119
 120 static INT encodeSbrSingleChannelElement (HANDLE_SBR_ENV_DATA      sbrEnvData,
 121                                           HANDLE_FDK_BITSTREAM     hBitStream
 122                                           ,HANDLE_PARAMETRIC_STEREO hParametricStereo
 123                                           ,UINT  sbrSyntaxFlags
 124                                           );
 125
 126
 127
 128 static INT encodeSbrChannelPairElement (HANDLE_SBR_ENV_DATA      sbrEnvDataLeft,
 129                                         HANDLE_SBR_ENV_DATA      sbrEnvDataRight,
 130                                         HANDLE_PARAMETRIC_STEREO hParametricStereo,
 131                                         HANDLE_FDK_BITSTREAM     hBitStream,
 132                                         INT                      coupling);
 133
 134
 135 static INT encodeSbrGrid (HANDLE_SBR_ENV_DATA   sbrEnvData,
 136                           HANDLE_FDK_BITSTREAM  hBitStream);
 137
 138 static int encodeLowDelaySbrGrid ( HANDLE_SBR_ENV_DATA sbrEnvData,
 139                                    HANDLE_FDK_BITSTREAM hBitStream,
 140                                    int transmitFreqs);
 141
 142 static INT encodeSbrDtdf (HANDLE_SBR_ENV_DATA   sbrEnvData,
 143                           HANDLE_FDK_BITSTREAM  hBitStream);
 144
 145 static INT writeNoiseLevelData (HANDLE_SBR_ENV_DATA   sbrEnvData,
 146                                 HANDLE_FDK_BITSTREAM  hBitStream,
 147                                 INT                   coupling);
 148
 149 static INT writeEnvelopeData (HANDLE_SBR_ENV_DATA    sbrEnvData,
 150                               HANDLE_FDK_BITSTREAM   hBitStream,
 151                               INT                    coupling);
 152
 153 static INT writeSyntheticCodingData (HANDLE_SBR_ENV_DATA  sbrEnvData,
 154                                      HANDLE_FDK_BITSTREAM hBitStream);
 155
 156
 157 static INT encodeExtendedData (HANDLE_PARAMETRIC_STEREO hParametricStereo,
 158                                HANDLE_FDK_BITSTREAM     hBitStream);
 159
 160
 161
 162 static INT getSbrExtendedDataSize (HANDLE_PARAMETRIC_STEREO  hParametricStereo);
 163
 164 /*****************************************************************************
 165
 166     functionname: FDKsbrEnc_WriteEnvSingleChannelElement
 167     description:  writes pure SBR single channel data element
 168     returns:      number of bits written
 169     input:
 170     output:
 171
 172 *****************************************************************************/
 173 INT
 174 FDKsbrEnc_WriteEnvSingleChannelElement(
 175                                        HANDLE_SBR_HEADER_DATA sbrHeaderData,
 176                                        HANDLE_PARAMETRIC_STEREO         hParametricStereo,
 177                                        HANDLE_SBR_BITSTREAM_DATA        sbrBitstreamData,
 178                                        HANDLE_SBR_ENV_DATA              sbrEnvData,
 179                                        HANDLE_COMMON_DATA               cmonData,
 180                                        UINT                             sbrSyntaxFlags
 181                                       )
 182
 183 {
 184   INT payloadBits = 0;
 185
 186   cmonData->sbrHdrBits  = 0;
 187   cmonData->sbrDataBits = 0;
 188
 189   /* write pure sbr data */
 190   if (sbrEnvData != NULL) {
 191
 192     /* write header */
 193     payloadBits += encodeSbrHeader (sbrHeaderData,
 194                                     sbrBitstreamData,
 195                                     cmonData);
 196
 197
 198     /* write data */
 199     payloadBits += encodeSbrData (sbrEnvData,
 200                                   NULL,
 201                                   hParametricStereo,
 202                                   cmonData,
 203                                   SBR_ID_SCE,
 204                                   0,
 205                                   sbrSyntaxFlags);
 206
 207   }
 208   return payloadBits;
 209 }
 210
 211 /*****************************************************************************
 212
 213     functionname: FDKsbrEnc_WriteEnvChannelPairElement
 214     description:  writes pure SBR channel pair data element
 215     returns:      number of bits written
 216     input:
 217     output:
 218
 219 *****************************************************************************/
 220 INT
 221 FDKsbrEnc_WriteEnvChannelPairElement (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
 222                                       HANDLE_PARAMETRIC_STEREO   hParametricStereo,
 223                                       HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
 224                                       HANDLE_SBR_ENV_DATA        sbrEnvDataLeft,
 225                                       HANDLE_SBR_ENV_DATA        sbrEnvDataRight,
 226                                       HANDLE_COMMON_DATA         cmonData,
 227                                       UINT                       sbrSyntaxFlags)
 228
 229 {
 230   INT payloadBits = 0;
 231   cmonData->sbrHdrBits  = 0;
 232   cmonData->sbrDataBits = 0;
 233
 234   /* write pure sbr data */
 235   if ((sbrEnvDataLeft != NULL) && (sbrEnvDataRight != NULL)) {
 236
 237     /* write header */
 238     payloadBits += encodeSbrHeader (sbrHeaderData,
 239                                     sbrBitstreamData,
 240                                     cmonData);
 241
 242     /* write data */
 243     payloadBits += encodeSbrData (sbrEnvDataLeft,
 244                                   sbrEnvDataRight,
 245                                   hParametricStereo,
 246                                   cmonData,
 247                                   SBR_ID_CPE,
 248                                   sbrHeaderData->coupling,
 249                                   sbrSyntaxFlags);
 250
 251   }
 252   return payloadBits;
 253 }
 254
 255 INT
 256 FDKsbrEnc_CountSbrChannelPairElement (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
 257                                       HANDLE_PARAMETRIC_STEREO   hParametricStereo,
 258                                       HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
 259                                       HANDLE_SBR_ENV_DATA        sbrEnvDataLeft,
 260                                       HANDLE_SBR_ENV_DATA        sbrEnvDataRight,
 261                                       HANDLE_COMMON_DATA         cmonData,
 262                                       UINT                       sbrSyntaxFlags)
 263 {
 264   INT payloadBits;
 265   INT bitPos = FDKgetValidBits(&cmonData->sbrBitbuf);
 266
 267   payloadBits = FDKsbrEnc_WriteEnvChannelPairElement(sbrHeaderData,
 268                                            hParametricStereo,
 269                                            sbrBitstreamData,
 270                                            sbrEnvDataLeft,
 271                                            sbrEnvDataRight,
 272                                            cmonData,
 273                                            sbrSyntaxFlags);
 274
 275   FDKpushBack(&cmonData->sbrBitbuf, (FDKgetValidBits(&cmonData->sbrBitbuf) - bitPos) );
 276
 277   return payloadBits;
 278 }
 279
 280
 281 void sbrEncoder_GetHeader(SBR_ENCODER   *sbrEncoder,
 282                           HANDLE_FDK_BITSTREAM hBs,
 283                           INT            element_index,
 284                           int            fSendHeaders)
 285 {
 286   int bits;
 287
 288   bits = encodeSbrHeaderData (&sbrEncoder->sbrElement[element_index]->sbrHeaderData, hBs);
 289
 290   if (fSendHeaders == 0) {
 291     /* Prevent header being embedded into the SBR payload. */
 292     sbrEncoder->sbrElement[element_index]->sbrBitstreamData.NrSendHeaderData = -1;
 293     sbrEncoder->sbrElement[element_index]->sbrBitstreamData.HeaderActive = 0;
 294     sbrEncoder->sbrElement[element_index]->sbrBitstreamData.CountSendHeaderData = -1;
 295   }
 296 }
 297
 298
 299 /*****************************************************************************
 300
 301     functionname: encodeSbrHeader
 302     description:  encodes SBR Header information
 303     returns:      number of bits written
 304     input:
 305     output:
 306
 307 *****************************************************************************/
 308 static INT
 309 encodeSbrHeader (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
 310                  HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
 311                  HANDLE_COMMON_DATA         cmonData)
 312 {
 313   INT payloadBits = 0;
 314
 315   if (sbrBitstreamData->HeaderActive) {
 316     payloadBits += FDKwriteBits (&cmonData->sbrBitbuf, 1, 1);
 317     payloadBits += encodeSbrHeaderData (sbrHeaderData,
 318                                         &cmonData->sbrBitbuf);
 319   }
 320   else {
 321     payloadBits += FDKwriteBits (&cmonData->sbrBitbuf, 0, 1);
 322   }
 323
 324   cmonData->sbrHdrBits = payloadBits;
 325
 326   return payloadBits;
 327 }
 328
 329
 330
 331 /*****************************************************************************
 332
 333     functionname: encodeSbrHeaderData
 334     description:  writes sbr_header()
 335                   bs_protocol_version through bs_header_extra_2
 336     returns:      number of bits written
 337     input:
 338     output:
 339
 340 *****************************************************************************/
 341 static INT
 342 encodeSbrHeaderData (HANDLE_SBR_HEADER_DATA sbrHeaderData,
 343                      HANDLE_FDK_BITSTREAM hBitStream)
 344
 345 {
 346   INT payloadBits = 0;
 347   if (sbrHeaderData != NULL) {
 348     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_amp_res,
 349                               SI_SBR_AMP_RES_BITS);
 350     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_start_frequency,
 351                               SI_SBR_START_FREQ_BITS);
 352     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_stop_frequency,
 353                               SI_SBR_STOP_FREQ_BITS);
 354     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_xover_band,
 355                               SI_SBR_XOVER_BAND_BITS);
 356
 357     payloadBits += FDKwriteBits (hBitStream, 0,
 358                               SI_SBR_RESERVED_BITS);
 359
 360     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->header_extra_1,
 361                               SI_SBR_HEADER_EXTRA_1_BITS);
 362     payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->header_extra_2,
 363                               SI_SBR_HEADER_EXTRA_2_BITS);
 364
 365
 366     if (sbrHeaderData->header_extra_1) {
 367       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->freqScale,
 368                                 SI_SBR_FREQ_SCALE_BITS);
 369       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->alterScale,
 370                                 SI_SBR_ALTER_SCALE_BITS);
 371       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_noise_bands,
 372                                 SI_SBR_NOISE_BANDS_BITS);
 373     } /* sbrHeaderData->header_extra_1 */
 374
 375     if (sbrHeaderData->header_extra_2) {
 376       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_limiter_bands,
 377                                 SI_SBR_LIMITER_BANDS_BITS);
 378       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_limiter_gains,
 379                                 SI_SBR_LIMITER_GAINS_BITS);
 380       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_interpol_freq,
 381                                 SI_SBR_INTERPOL_FREQ_BITS);
 382       payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_smoothing_length,
 383                                 SI_SBR_SMOOTHING_LENGTH_BITS);
 384
 385     } /* sbrHeaderData->header_extra_2 */
 386   } /* sbrHeaderData != NULL */
 387
 388   return payloadBits;
 389 }
 390
 391
 392 /*****************************************************************************
 393
 394     functionname: encodeSbrData
 395     description:  encodes sbr Data information
 396     returns:      number of bits written
 397     input:
 398     output:
 399
 400 *****************************************************************************/
 401 static INT
 402 encodeSbrData (HANDLE_SBR_ENV_DATA   sbrEnvDataLeft,
 403                HANDLE_SBR_ENV_DATA   sbrEnvDataRight,
 404                HANDLE_PARAMETRIC_STEREO   hParametricStereo,
 405                HANDLE_COMMON_DATA    cmonData,
 406                SBR_ELEMENT_TYPE      sbrElem,
 407                INT                   coupling,
 408                UINT                  sbrSyntaxFlags)
 409 {
 410   INT payloadBits = 0;
 411
 412   switch (sbrElem) {
 413   case SBR_ID_SCE:
 414     payloadBits += encodeSbrSingleChannelElement (sbrEnvDataLeft, &cmonData->sbrBitbuf, hParametricStereo, sbrSyntaxFlags);
 415     break;
 416   case SBR_ID_CPE:
 417     payloadBits += encodeSbrChannelPairElement (sbrEnvDataLeft, sbrEnvDataRight, hParametricStereo, &cmonData->sbrBitbuf, coupling);
 418     break;
 419   default:
 420     /* we never should apply SBR to any other element type */
 421     FDK_ASSERT (0);
 422   }
 423
 424   cmonData->sbrDataBits = payloadBits;
 425
 426   return payloadBits;
 427 }
 428
 429 #define MODE_FREQ_TANS                          1
 430 #define MODE_NO_FREQ_TRAN                       0
 431 #define LD_TRANSMISSION                         MODE_FREQ_TANS
 432 static int encodeFreqs (int mode) {
 433     return ((mode & MODE_FREQ_TANS) ? 1 : 0);
 434 }
 435
 436
 437 /*****************************************************************************
 438
 439     functionname: encodeSbrSingleChannelElement
 440     description:  encodes sbr SCE information
 441     returns:      number of bits written
 442     input:
 443     output:
 444
 445 *****************************************************************************/
 446 static INT
 447 encodeSbrSingleChannelElement (HANDLE_SBR_ENV_DATA   sbrEnvData,
 448                                HANDLE_FDK_BITSTREAM  hBitStream
 449                                ,HANDLE_PARAMETRIC_STEREO hParametricStereo
 450                                ,UINT  sbrSyntaxFlags
 451                                )
 452 {
 453   INT i, payloadBits = 0;
 454
 455   payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_DATA_EXTRA_BITS); /* no reserved bits */
 456
 457   if (sbrEnvData->ldGrid) {
 458       if ( sbrEnvData->hSbrBSGrid->frameClass != FIXFIXonly ) {
 459         /* encode normal SbrGrid */
 460         payloadBits += encodeSbrGrid (sbrEnvData, hBitStream);
 461       } else {
 462         /* use FIXFIXonly frame Grid */
 463         payloadBits += encodeLowDelaySbrGrid ( sbrEnvData, hBitStream, encodeFreqs(LD_TRANSMISSION));
 464       }
 465   }
 466   else
 467   {
 468     if (sbrSyntaxFlags & SBR_SYNTAX_SCALABLE) {
 469       payloadBits += FDKwriteBits (hBitStream, 1, SI_SBR_COUPLING_BITS);
 470     }
 471     payloadBits += encodeSbrGrid (sbrEnvData, hBitStream);
 472   }
 473
 474   payloadBits += encodeSbrDtdf (sbrEnvData, hBitStream);
 475
 476   for (i = 0; i < sbrEnvData->noOfnoisebands; i++) {
 477     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
 478   }
 479
 480   payloadBits += writeEnvelopeData (sbrEnvData, hBitStream, 0);
 481   payloadBits += writeNoiseLevelData (sbrEnvData, hBitStream, 0);
 482
 483   payloadBits += writeSyntheticCodingData (sbrEnvData,hBitStream);
 484
 485   payloadBits += encodeExtendedData(hParametricStereo, hBitStream);
 486
 487   return payloadBits;
 488 }
 489
 490
 491 /*****************************************************************************
 492
 493     functionname: encodeSbrChannelPairElement
 494     description:  encodes sbr CPE information
 495     returns:
 496     input:
 497     output:
 498
 499 *****************************************************************************/
 500 static INT
 501 encodeSbrChannelPairElement (HANDLE_SBR_ENV_DATA   sbrEnvDataLeft,
 502                              HANDLE_SBR_ENV_DATA   sbrEnvDataRight,
 503                              HANDLE_PARAMETRIC_STEREO   hParametricStereo,
 504                              HANDLE_FDK_BITSTREAM  hBitStream,
 505                              INT                   coupling)
 506 {
 507   INT payloadBits = 0;
 508   INT i = 0;
 509
 510   payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_DATA_EXTRA_BITS); /* no reserved bits */
 511
 512   payloadBits += FDKwriteBits (hBitStream, coupling, SI_SBR_COUPLING_BITS);
 513
 514   if (coupling) {
 515     if (sbrEnvDataLeft->ldGrid) {
 516           if ( sbrEnvDataLeft->hSbrBSGrid->frameClass != FIXFIXonly ) {
 517             /* normal SbrGrid */
 518             payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
 519
 520           } else {
 521               /* FIXFIXonly frame Grid */
 522               payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataLeft, hBitStream, encodeFreqs(LD_TRANSMISSION));
 523           }
 524     } else
 525         payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
 526
 527     payloadBits += encodeSbrDtdf (sbrEnvDataLeft, hBitStream);
 528     payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
 529
 530     for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
 531       payloadBits += FDKwriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
 532     }
 533
 534     payloadBits += writeEnvelopeData  (sbrEnvDataLeft,  hBitStream,1);
 535     payloadBits += writeNoiseLevelData (sbrEnvDataLeft,  hBitStream,1);
 536     payloadBits += writeEnvelopeData  (sbrEnvDataRight, hBitStream,1);
 537     payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,1);
 538
 539     payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
 540     payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
 541
 542   } else { /* no coupling */
 543     FDK_ASSERT(sbrEnvDataLeft->ldGrid == sbrEnvDataRight->ldGrid);
 544
 545     if (sbrEnvDataLeft->ldGrid || sbrEnvDataRight->ldGrid) {
 546     /* sbrEnvDataLeft (left channel) */
 547       if ( sbrEnvDataLeft->hSbrBSGrid->frameClass != FIXFIXonly) {
 548         /* no FIXFIXonly Frame so we dont need encodeLowDelaySbrGrid */
 549         /* normal SbrGrid */
 550         payloadBits += encodeSbrGrid (sbrEnvDataLeft,  hBitStream);
 551
 552       } else {
 553         /* FIXFIXonly frame Grid */
 554           payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataLeft, hBitStream, encodeFreqs(LD_TRANSMISSION));
 555       }
 556
 557       /* sbrEnvDataRight (right channel) */
 558       if ( sbrEnvDataRight->hSbrBSGrid->frameClass != FIXFIXonly) {
 559         /* no FIXFIXonly Frame so we dont need encodeLowDelaySbrGrid */
 560         /* normal SbrGrid */
 561         payloadBits += encodeSbrGrid (sbrEnvDataRight, hBitStream);
 562
 563       } else {
 564         /* FIXFIXonly frame Grid */
 565           payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataRight, hBitStream, encodeFreqs(LD_TRANSMISSION));
 566       }
 567     } else
 568     {
 569         payloadBits += encodeSbrGrid (sbrEnvDataLeft,  hBitStream);
 570         payloadBits += encodeSbrGrid (sbrEnvDataRight, hBitStream);
 571     }
 572     payloadBits += encodeSbrDtdf (sbrEnvDataLeft,  hBitStream);
 573     payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
 574
 575     for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
 576       payloadBits += FDKwriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i],
 577                                 SI_SBR_INVF_MODE_BITS);
 578     }
 579     for (i = 0; i < sbrEnvDataRight->noOfnoisebands; i++) {
 580       payloadBits += FDKwriteBits (hBitStream, sbrEnvDataRight->sbr_invf_mode_vec[i],
 581                                 SI_SBR_INVF_MODE_BITS);
 582     }
 583
 584     payloadBits += writeEnvelopeData  (sbrEnvDataLeft,  hBitStream,0);
 585     payloadBits += writeEnvelopeData  (sbrEnvDataRight, hBitStream,0);
 586     payloadBits += writeNoiseLevelData (sbrEnvDataLeft,  hBitStream,0);
 587     payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,0);
 588
 589     payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
 590     payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
 591
 592   } /* coupling */
 593
 594   payloadBits += encodeExtendedData(hParametricStereo, hBitStream);
 595
 596   return payloadBits;
 597 }
 598
 599 static INT ceil_ln2(INT x)
 600 {
 601   INT tmp=-1;
 602   while((1<<++tmp) < x);
 603   return(tmp);
 604 }
 605
 606
 607 /*****************************************************************************
 608
 609     functionname: encodeSbrGrid
 610     description:  if hBitStream != NULL writes bits that describes the
 611                   time/frequency grouping of a frame; else counts them only
 612     returns:      number of bits written or counted
 613     input:
 614     output:
 615
 616 *****************************************************************************/
 617 static INT
 618 encodeSbrGrid (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream)
 619 {
 620   INT payloadBits = 0;
 621   INT i, temp;
 622   INT bufferFrameStart = sbrEnvData->hSbrBSGrid->bufferFrameStart;
 623   INT numberTimeSlots  = sbrEnvData->hSbrBSGrid->numberTimeSlots;
 624
 625   if (sbrEnvData->ldGrid)
 626     payloadBits += FDKwriteBits (hBitStream,
 627                                  sbrEnvData->hSbrBSGrid->frameClass,
 628                                  SBR_CLA_BITS_LD);
 629   else
 630     payloadBits += FDKwriteBits (hBitStream,
 631                                  sbrEnvData->hSbrBSGrid->frameClass,
 632                                  SBR_CLA_BITS);
 633
 634   switch (sbrEnvData->hSbrBSGrid->frameClass) {
 635   case FIXFIXonly:
 636     FDK_ASSERT(0 /* Fatal error in encodeSbrGrid! */);
 637     break;
 638   case FIXFIX:
 639     temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_env);
 640     payloadBits += FDKwriteBits (hBitStream, temp, SBR_ENV_BITS);
 641     if ((sbrEnvData->ldGrid) && (sbrEnvData->hSbrBSGrid->bs_num_env==1))
 642       payloadBits += FDKwriteBits(hBitStream, sbrEnvData->currentAmpResFF, SI_SBR_AMP_RES_BITS);
 643     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[0], SBR_RES_BITS);
 644
 645     break;
 646
 647   case FIXVAR:
 648   case VARFIX:
 649     if (sbrEnvData->hSbrBSGrid->frameClass == FIXVAR)
 650       temp = sbrEnvData->hSbrBSGrid->bs_abs_bord - (bufferFrameStart + numberTimeSlots);
 651     else
 652       temp = sbrEnvData->hSbrBSGrid->bs_abs_bord - bufferFrameStart;
 653
 654     payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
 655     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->n, SBR_NUM_BITS);
 656
 657     for (i = 0; i < sbrEnvData->hSbrBSGrid->n; i++) {
 658       temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord[i] - 2) >> 1;
 659       payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
 660     }
 661
 662     temp = ceil_ln2(sbrEnvData->hSbrBSGrid->n + 2);
 663     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
 664
 665     for (i = 0; i < sbrEnvData->hSbrBSGrid->n + 1; i++) {
 666       payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[i],
 667                                 SBR_RES_BITS);
 668     }
 669     break;
 670
 671   case VARVAR:
 672     temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_0 - bufferFrameStart;
 673     payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
 674     temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_1 - (bufferFrameStart + numberTimeSlots);
 675     payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
 676
 677     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_0, SBR_NUM_BITS);
 678     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_1, SBR_NUM_BITS);
 679
 680     for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_0; i++) {
 681       temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_0[i] - 2) >> 1;
 682       payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
 683     }
 684
 685     for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_1; i++) {
 686       temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_1[i] - 2) >> 1;
 687       payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
 688     }
 689
 690     temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
 691                              sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 2);
 692     payloadBits +=  FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
 693
 694     temp = sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
 695            sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 1;
 696
 697     for (i = 0; i < temp; i++) {
 698       payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_fLR[i],
 699                                 SBR_RES_BITS);
 700     }
 701     break;
 702   }
 703
 704   return payloadBits;
 705 }
 706
 707 #define SBR_CLA_BITS_LD 1
 708 /*****************************************************************************
 709
 710     functionname: encodeLowDelaySbrGrid
 711     description:  if hBitStream != NULL writes bits that describes the
 712                   time/frequency grouping of a frame;
 713                   else counts them only
 714                   (this function only write the FIXFIXonly Bitstream data)
 715     returns:      number of bits written or counted
 716     input:
 717     output:
 718
 719 *****************************************************************************/
 720 static int
 721 encodeLowDelaySbrGrid (  HANDLE_SBR_ENV_DATA sbrEnvData,
 722                          HANDLE_FDK_BITSTREAM hBitStream,
 723                          int transmitFreqs
 724                        )
 725 {
 726   int payloadBits = 0;
 727   int i;
 728
 729   /* write FIXFIXonly Grid */
 730   /* write frameClass [1 bit] for FIXFIXonly Grid */
 731   payloadBits += FDKwriteBits(hBitStream, 1, SBR_CLA_BITS_LD);
 732
 733   /* absolute Borders are fix: 0,X,X,X,nTimeSlots; so we dont have to transmit them */
 734   /* only transmit the transient position! */
 735   /* with this info (b1) we can reconstruct the Frame on Decoder side : */
 736   /* border[0] = 0; border[1] = b1; border[2]=b1+2; border[3] = nrTimeSlots */
 737
 738   /* use 3 or 4bits for transient border (border) */
 739   if (sbrEnvData->hSbrBSGrid->numberTimeSlots == 8)
 740     payloadBits += FDKwriteBits ( hBitStream, sbrEnvData->hSbrBSGrid->bs_abs_bord, 3);
 741   else
 742     payloadBits += FDKwriteBits ( hBitStream, sbrEnvData->hSbrBSGrid->bs_abs_bord, 4);
 743
 744   if (transmitFreqs) {
 745     /* write FreqRes grid */
 746     for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_env; i++) {
 747       payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[i], SBR_RES_BITS);
 748     }
 749   }
 750
 751   return payloadBits;
 752 }
 753
 754 /*****************************************************************************
 755
 756     functionname: encodeSbrDtdf
 757     description:  writes bits that describes the direction of the envelopes of a frame
 758     returns:      number of bits written
 759     input:
 760     output:
 761
 762 *****************************************************************************/
 763 static INT
 764 encodeSbrDtdf (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream)
 765 {
 766   INT i, payloadBits = 0, noOfNoiseEnvelopes;
 767
 768   noOfNoiseEnvelopes = sbrEnvData->noOfEnvelopes > 1 ? 2 : 1;
 769
 770   for (i = 0; i < sbrEnvData->noOfEnvelopes; ++i) {
 771     payloadBits += FDKwriteBits (hBitStream, sbrEnvData->domain_vec[i], SBR_DIR_BITS);
 772   }
 773   for (i = 0; i < noOfNoiseEnvelopes; ++i) {
 774     payloadBits +=  FDKwriteBits (hBitStream, sbrEnvData->domain_vec_noise[i], SBR_DIR_BITS);
 775   }
 776
 777   return payloadBits;
 778 }
 779
 780
 781 /*****************************************************************************
 782
 783     functionname: writeNoiseLevelData
 784     description:  writes bits corresponding to the noise-floor-level
 785     returns:      number of bits written
 786     input:
 787     output:
 788
 789 *****************************************************************************/
 790 static INT
 791 writeNoiseLevelData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream, INT coupling)
 792 {
 793   INT j, i, payloadBits = 0;
 794   INT nNoiseEnvelopes = sbrEnvData->noOfEnvelopes > 1 ? 2 : 1;
 795
 796   for (i = 0; i < nNoiseEnvelopes; i++) {
 797     switch (sbrEnvData->domain_vec_noise[i]) {
 798     case FREQ:
 799       if (coupling && sbrEnvData->balance) {
 800         payloadBits += FDKwriteBits (hBitStream,
 801                                   sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
 802                                   sbrEnvData->si_sbr_start_noise_bits_balance);
 803       } else {
 804         payloadBits += FDKwriteBits (hBitStream,
 805                                   sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
 806                                   sbrEnvData->si_sbr_start_noise_bits);
 807       }
 808
 809       for (j = 1 + i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
 810         if (coupling) {
 811           if (sbrEnvData->balance) {
 812             /* coupling && balance */
 813             payloadBits += FDKwriteBits (hBitStream,
 814                                       sbrEnvData->hufftableNoiseBalanceFreqC[sbrEnvData->sbr_noise_levels[j] +
 815                                                                             CODE_BOOK_SCF_LAV_BALANCE11],
 816                                       sbrEnvData->hufftableNoiseBalanceFreqL[sbrEnvData->sbr_noise_levels[j] +
 817                                                                             CODE_BOOK_SCF_LAV_BALANCE11]);
 818           } else {
 819             /* coupling && !balance */
 820             payloadBits += FDKwriteBits (hBitStream,
 821                                       sbrEnvData->hufftableNoiseLevelFreqC[sbrEnvData->sbr_noise_levels[j] +
 822                                                                           CODE_BOOK_SCF_LAV11],
 823                                       sbrEnvData->hufftableNoiseLevelFreqL[sbrEnvData->sbr_noise_levels[j] +
 824                                                                           CODE_BOOK_SCF_LAV11]);
 825           }
 826         } else {
 827           /* !coupling */
 828           payloadBits += FDKwriteBits (hBitStream,
 829                                     sbrEnvData->hufftableNoiseFreqC[sbrEnvData->sbr_noise_levels[j] +
 830                                                                    CODE_BOOK_SCF_LAV11],
 831                                     sbrEnvData->hufftableNoiseFreqL[sbrEnvData->sbr_noise_levels[j] +
 832                                                                    CODE_BOOK_SCF_LAV11]);
 833         }
 834       }
 835       break;
 836
 837     case TIME:
 838       for (j = i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
 839         if (coupling) {
 840           if (sbrEnvData->balance) {
 841             /* coupling && balance */
 842             payloadBits += FDKwriteBits (hBitStream,
 843                                       sbrEnvData->hufftableNoiseBalanceTimeC[sbrEnvData->sbr_noise_levels[j] +
 844                                                                             CODE_BOOK_SCF_LAV_BALANCE11],
 845                                       sbrEnvData->hufftableNoiseBalanceTimeL[sbrEnvData->sbr_noise_levels[j] +
 846                                                                             CODE_BOOK_SCF_LAV_BALANCE11]);
 847           } else {
 848             /* coupling && !balance */
 849             payloadBits += FDKwriteBits (hBitStream,
 850                                       sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
 851                                                                           CODE_BOOK_SCF_LAV11],
 852                                       sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
 853                                                                           CODE_BOOK_SCF_LAV11]);
 854           }
 855         } else {
 856           /* !coupling */
 857           payloadBits += FDKwriteBits (hBitStream,
 858                                     sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
 859                                                                         CODE_BOOK_SCF_LAV11],
 860                                     sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
 861                                                                         CODE_BOOK_SCF_LAV11]);
 862         }
 863       }
 864       break;
 865     }
 866   }
 867   return payloadBits;
 868 }
 869
 870
 871 /*****************************************************************************
 872
 873     functionname: writeEnvelopeData
 874     description:  writes bits corresponding to the envelope
 875     returns:      number of bits written
 876     input:
 877     output:
 878
 879 *****************************************************************************/
 880 static INT
 881 writeEnvelopeData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream, INT coupling)
 882 {
 883   INT payloadBits = 0, j, i, delta;
 884
 885   for (j = 0; j < sbrEnvData->noOfEnvelopes; j++) { /* loop over all envelopes */
 886     if (sbrEnvData->domain_vec[j] == FREQ) {
 887       if (coupling && sbrEnvData->balance) {
 888         payloadBits += FDKwriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits_balance);
 889       } else {
 890         payloadBits += FDKwriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits);
 891       }
 892     }
 893
 894     for (i = 1 - sbrEnvData->domain_vec[j]; i < sbrEnvData->noScfBands[j]; i++) {
 895       delta = sbrEnvData->ienvelope[j][i];
 896       if (coupling && sbrEnvData->balance) {
 897         FDK_ASSERT (fixp_abs (delta) <= sbrEnvData->codeBookScfLavBalance);
 898       } else {
 899         FDK_ASSERT (fixp_abs (delta) <= sbrEnvData->codeBookScfLav);
 900       }
 901       if (coupling) {
 902         if (sbrEnvData->balance) {
 903           if (sbrEnvData->domain_vec[j]) {
 904             /* coupling && balance && TIME */
 905             payloadBits += FDKwriteBits (hBitStream,
 906                                       sbrEnvData->hufftableBalanceTimeC[delta + sbrEnvData->codeBookScfLavBalance],
 907                                       sbrEnvData->hufftableBalanceTimeL[delta + sbrEnvData->codeBookScfLavBalance]);
 908           } else {
 909             /* coupling && balance && FREQ */
 910             payloadBits += FDKwriteBits (hBitStream,
 911                                       sbrEnvData->hufftableBalanceFreqC[delta + sbrEnvData->codeBookScfLavBalance],
 912                                       sbrEnvData->hufftableBalanceFreqL[delta + sbrEnvData->codeBookScfLavBalance]);
 913           }
 914         } else {
 915           if (sbrEnvData->domain_vec[j]) {
 916             /* coupling && !balance && TIME */
 917             payloadBits += FDKwriteBits (hBitStream,
 918                                       sbrEnvData->hufftableLevelTimeC[delta + sbrEnvData->codeBookScfLav],
 919                                       sbrEnvData->hufftableLevelTimeL[delta + sbrEnvData->codeBookScfLav]);
 920           } else {
 921             /* coupling && !balance && FREQ */
 922             payloadBits += FDKwriteBits (hBitStream,
 923                                       sbrEnvData->hufftableLevelFreqC[delta + sbrEnvData->codeBookScfLav],
 924                                       sbrEnvData->hufftableLevelFreqL[delta + sbrEnvData->codeBookScfLav]);
 925           }
 926         }
 927       } else {
 928         if (sbrEnvData->domain_vec[j]) {
 929           /* !coupling && TIME */
 930           payloadBits += FDKwriteBits (hBitStream,
 931                                     sbrEnvData->hufftableTimeC[delta + sbrEnvData->codeBookScfLav],
 932                                     sbrEnvData->hufftableTimeL[delta + sbrEnvData->codeBookScfLav]);
 933         } else {
 934           /* !coupling && FREQ */
 935           payloadBits += FDKwriteBits (hBitStream,
 936                                     sbrEnvData->hufftableFreqC[delta + sbrEnvData->codeBookScfLav],
 937                                     sbrEnvData->hufftableFreqL[delta + sbrEnvData->codeBookScfLav]);
 938         }
 939       }
 940     }
 941   }
 942   return payloadBits;
 943 }
 944
 945
 946 /*****************************************************************************
 947
 948     functionname: encodeExtendedData
 949     description:  writes bits corresponding to the extended data
 950     returns:      number of bits written
 951     input:
 952     output:
 953
 954 *****************************************************************************/
 955 static INT encodeExtendedData (HANDLE_PARAMETRIC_STEREO  hParametricStereo,
 956                                HANDLE_FDK_BITSTREAM hBitStream)
 957 {
 958   INT extDataSize;
 959   INT payloadBits = 0;
 960
 961   extDataSize = getSbrExtendedDataSize(hParametricStereo);
 962
 963
 964   if (extDataSize != 0) {
 965     INT maxExtSize = (1<<SI_SBR_EXTENSION_SIZE_BITS) - 1;
 966     INT writtenNoBits = 0; /* needed to byte align the extended data */
 967
 968     payloadBits += FDKwriteBits (hBitStream, 1, SI_SBR_EXTENDED_DATA_BITS);
 969     FDK_ASSERT(extDataSize <= SBR_EXTENDED_DATA_MAX_CNT);
 970
 971     if (extDataSize < maxExtSize) {
 972       payloadBits += FDKwriteBits (hBitStream, extDataSize, SI_SBR_EXTENSION_SIZE_BITS);
 973     } else {
 974       payloadBits += FDKwriteBits (hBitStream, maxExtSize, SI_SBR_EXTENSION_SIZE_BITS);
 975       payloadBits += FDKwriteBits (hBitStream, extDataSize - maxExtSize, SI_SBR_EXTENSION_ESC_COUNT_BITS);
 976     }
 977
 978     /* parametric coding signalled here? */
 979     if(hParametricStereo){
 980       writtenNoBits += FDKwriteBits (hBitStream, EXTENSION_ID_PS_CODING, SI_SBR_EXTENSION_ID_BITS);
 981       writtenNoBits += FDKsbrEnc_PSEnc_WritePSData(hParametricStereo, hBitStream);
 982     }
 983
 984     payloadBits += writtenNoBits;
 985
 986     /* byte alignment */
 987     writtenNoBits = writtenNoBits%8;
 988     if(writtenNoBits)
 989       payloadBits += FDKwriteBits(hBitStream, 0, (8 - writtenNoBits));
 990   } else {
 991     payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_EXTENDED_DATA_BITS);
 992   }
 993
 994   return payloadBits;
 995 }
 996
 997
 998 /*****************************************************************************
 999
1000     functionname: writeSyntheticCodingData
1001     description:  writes bits corresponding to the "synthetic-coding"-extension
1002     returns:      number of bits written
1003     input:
1004     output:
1005
1006 *****************************************************************************/
1007 static INT writeSyntheticCodingData (HANDLE_SBR_ENV_DATA  sbrEnvData,
1008                                      HANDLE_FDK_BITSTREAM hBitStream)
1009
1010 {
1011   INT i;
1012   INT payloadBits = 0;
1013
1014   payloadBits += FDKwriteBits (hBitStream, sbrEnvData->addHarmonicFlag, 1);
1015
1016   if (sbrEnvData->addHarmonicFlag) {
1017     for (i = 0; i < sbrEnvData->noHarmonics; i++) {
1018       payloadBits += FDKwriteBits (hBitStream, sbrEnvData->addHarmonic[i], 1);
1019     }
1020   }
1021
1022   return payloadBits;
1023 }
1024
1025 /*****************************************************************************
1026
1027     functionname: getSbrExtendedDataSize
1028     description:  counts the number of bits needed for encoding the
1029                   extended data (including extension id)
1030
1031     returns:      number of bits needed for the extended data
1032     input:
1033     output:
1034
1035 *****************************************************************************/
1036 static INT
1037 getSbrExtendedDataSize (HANDLE_PARAMETRIC_STEREO  hParametricStereo)
1038 {
1039   INT extDataBits = 0;
1040
1041   /* add your new extended data counting methods here */
1042
1043   /*
1044     no extended data
1045   */
1046
1047   if(hParametricStereo){
1048     /* PS extended data */
1049     extDataBits += SI_SBR_EXTENSION_ID_BITS;
1050     extDataBits += FDKsbrEnc_PSEnc_WritePSData(hParametricStereo, NULL);
1051   }
1052
1053   return (extDataBits+7) >> 3;
1054 }
1055
1056
1057
1058
1059