libMpegTPDec/src/tpdec_latm.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 /*****************************  MPEG-4 AAC Decoder  **************************
  85
  86    Author(s):   Daniel Homm
  87    Description:
  88
  89 ******************************************************************************/
  90
  91 #include "tpdec_latm.h"
  92
  93
  94 #include "FDK_bitstream.h"
  95
  96
  97 #define TPDEC_TRACKINDEX(p,l) (2*(p) + (l))
  98
  99 static
 100 UINT CLatmDemux_GetValue(HANDLE_FDK_BITSTREAM bs)
 101 {
 102   UCHAR bytesForValue = 0, tmp = 0;
 103   int value = 0;
 104
 105   bytesForValue = (UCHAR) FDKreadBits(bs,2);
 106
 107   for (UINT i=0; i<=bytesForValue; i++) {
 108     value <<= 8;
 109     tmp = (UCHAR) FDKreadBits(bs,8);
 110     value += tmp;
 111   }
 112
 113   return value;
 114 }
 115
 116
 117 static
 118 TRANSPORTDEC_ERROR CLatmDemux_ReadAudioMuxElement(
 119         HANDLE_FDK_BITSTREAM bs,
 120         CLatmDemux *pLatmDemux,
 121         int m_muxConfigPresent,
 122         CSTpCallBacks *pTpDecCallbacks,
 123         CSAudioSpecificConfig *pAsc,
 124         int *pfConfigFound
 125         )
 126 {
 127   TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
 128
 129   if (m_muxConfigPresent) {
 130     pLatmDemux->m_useSameStreamMux = FDKreadBits(bs,1);
 131
 132     if (!pLatmDemux->m_useSameStreamMux) {
 133       if ((ErrorStatus = CLatmDemux_ReadStreamMuxConfig(bs, pLatmDemux, pTpDecCallbacks, pAsc, pfConfigFound))) {
 134         return (ErrorStatus);
 135       }
 136     }
 137   }
 138
 139   /* If there was no configuration read, its not possible to parse PayloadLengthInfo below. */
 140   if (! *pfConfigFound) {
 141     return TRANSPORTDEC_SYNC_ERROR;
 142   }
 143
 144   if (pLatmDemux->m_AudioMuxVersionA == 0) {
 145     /* Do only once per call, because parsing and decoding is done in-line. */
 146     if ((ErrorStatus = CLatmDemux_ReadPayloadLengthInfo(bs,pLatmDemux))) {
 147       return (ErrorStatus);
 148     }
 149   } else {
 150     /* audioMuxVersionA > 0 is reserved for future extensions */
 151     ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
 152   }
 153
 154   return (ErrorStatus);
 155 }
 156
 157 TRANSPORTDEC_ERROR CLatmDemux_Read(
 158         HANDLE_FDK_BITSTREAM bs,
 159         CLatmDemux *pLatmDemux,
 160         TRANSPORT_TYPE tt,
 161         CSTpCallBacks *pTpDecCallbacks,
 162         CSAudioSpecificConfig *pAsc,
 163         int *pfConfigFound,
 164         const INT ignoreBufferFullness
 165         )
 166 {
 167   UINT cntBits;
 168   UINT cmpBufferFullness;
 169   UINT audioMuxLengthBytesLast = 0;
 170   TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
 171
 172   cntBits = FDKgetValidBits(bs);
 173
 174   if ((INT)cntBits < MIN_LATM_HEADERLENGTH) {
 175     return TRANSPORTDEC_NOT_ENOUGH_BITS;
 176   }
 177
 178   if ((ErrorStatus = CLatmDemux_ReadAudioMuxElement(bs, pLatmDemux, (tt != TT_MP4_LATM_MCP0), pTpDecCallbacks, pAsc, pfConfigFound)))
 179     return (ErrorStatus);
 180
 181   if (!ignoreBufferFullness)
 182   {
 183     cmpBufferFullness =   24+audioMuxLengthBytesLast*8
 184                         + pLatmDemux->m_linfo[0][0].m_bufferFullness* pAsc[TPDEC_TRACKINDEX(0,0)].m_channelConfiguration*32;
 185
 186     /* evaluate buffer fullness */
 187
 188     if (pLatmDemux->m_linfo[0][0].m_bufferFullness != 0xFF)
 189     {
 190       if (!pLatmDemux->BufferFullnessAchieved)
 191       {
 192         if (cntBits < cmpBufferFullness)
 193         {
 194           /* condition for start of decoding is not fulfilled */
 195
 196           /* the current frame will not be decoded */
 197           return TRANSPORTDEC_NOT_ENOUGH_BITS;
 198         }
 199         else
 200         {
 201           pLatmDemux->BufferFullnessAchieved = 1;
 202         }
 203       }
 204     }
 205   }
 206
 207   return (ErrorStatus);
 208 }
 209
 210
 211 TRANSPORTDEC_ERROR CLatmDemux_ReadStreamMuxConfig(
 212         HANDLE_FDK_BITSTREAM bs,
 213         CLatmDemux *pLatmDemux,
 214         CSTpCallBacks *pTpDecCallbacks,
 215         CSAudioSpecificConfig *pAsc,
 216         int * pfConfigFound
 217         )
 218 {
 219   LATM_LAYER_INFO *p_linfo = NULL;
 220   TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
 221
 222   pLatmDemux->m_AudioMuxVersion = FDKreadBits(bs,1);
 223
 224   if (pLatmDemux->m_AudioMuxVersion == 0) {
 225     pLatmDemux->m_AudioMuxVersionA = 0;
 226   } else {
 227     pLatmDemux->m_AudioMuxVersionA = FDKreadBits(bs,1);
 228   }
 229
 230   if (pLatmDemux->m_AudioMuxVersionA == 0) {
 231     if (pLatmDemux->m_AudioMuxVersion == 1) {
 232       pLatmDemux->m_taraBufferFullness = CLatmDemux_GetValue(bs);
 233     }
 234     pLatmDemux->m_allStreamsSameTimeFraming = FDKreadBits(bs,1);
 235     pLatmDemux->m_noSubFrames = FDKreadBits(bs,6) + 1;
 236     pLatmDemux->m_numProgram  = FDKreadBits(bs,4) + 1;
 237
 238     if (pLatmDemux->m_numProgram > 1) {
 239       return TRANSPORTDEC_UNSUPPORTED_FORMAT;
 240     }
 241
 242     int idCnt = 0;
 243     for (UINT prog = 0; prog < pLatmDemux->m_numProgram; prog++) {
 244       pLatmDemux->m_numLayer = FDKreadBits(bs,3) + 1;
 245       if (pLatmDemux->m_numLayer > 2) {
 246         return TRANSPORTDEC_UNSUPPORTED_FORMAT;
 247       }
 248
 249       for (UINT lay = 0; lay < pLatmDemux->m_numLayer; lay++) {
 250         p_linfo = &pLatmDemux->m_linfo[prog][lay];
 251
 252         p_linfo->m_streamID = idCnt++;
 253         p_linfo->m_frameLengthInBits = 0;
 254
 255         if( (prog == 0) && (lay == 0) ) {
 256           pLatmDemux->m_useSameConfig = 0;
 257         } else {
 258           pLatmDemux->m_useSameConfig = FDKreadBits(bs,1);
 259         }
 260
 261         if (pLatmDemux->m_useSameConfig) {
 262           if (lay > 1) {
 263             FDKmemcpy(&pAsc[TPDEC_TRACKINDEX(prog,lay)], &pAsc[TPDEC_TRACKINDEX(prog,lay-1)], sizeof(CSAudioSpecificConfig));
 264           } else {
 265             return TRANSPORTDEC_PARSE_ERROR;
 266           }
 267         } else {
 268           if (pLatmDemux->m_AudioMuxVersion == 1)
 269           {
 270             FDK_BITSTREAM tmpBs;
 271             UINT ascStartPos, ascLen=0;
 272
 273             ascLen = CLatmDemux_GetValue(bs);
 274             ascStartPos = FDKgetValidBits(bs);
 275             tmpBs = *bs;
 276             FDKsyncCache(&tmpBs);
 277             tmpBs.hBitBuf.ValidBits = ascLen;
 278
 279             /* Read ASC */
 280             if ((ErrorStatus = AudioSpecificConfig_Parse(&pAsc[TPDEC_TRACKINDEX(prog,lay)], &tmpBs, 1, pTpDecCallbacks))) {
 281               return (ErrorStatus);
 282             }
 283             *pfConfigFound = 1;
 284
 285             /* The field p_linfo->m_ascLen could be wrong, so check if */
 286             if ( 0 > (INT)FDKgetValidBits(&tmpBs)) {
 287               return TRANSPORTDEC_PARSE_ERROR;
 288             }
 289             FDKpushFor(bs, ascLen); /* position bitstream after ASC */
 290           }
 291           else {
 292             /* Read ASC */
 293             if ((ErrorStatus = AudioSpecificConfig_Parse(&pAsc[TPDEC_TRACKINDEX(prog,lay)], bs, 0, pTpDecCallbacks))) {
 294               return (ErrorStatus);
 295             }
 296           }
 297           {
 298             int cbError;
 299
 300             cbError = pTpDecCallbacks->cbUpdateConfig(pTpDecCallbacks->cbUpdateConfigData, &pAsc[TPDEC_TRACKINDEX(prog,lay)]);
 301             if (cbError != 0) {
 302               return TRANSPORTDEC_UNKOWN_ERROR;
 303             }
 304             *pfConfigFound = 1;
 305           }
 306         }
 307
 308         p_linfo->m_frameLengthType = FDKreadBits(bs,3);
 309         switch( p_linfo->m_frameLengthType ) {
 310         case 0:
 311           p_linfo->m_bufferFullness = FDKreadBits(bs,8);
 312
 313           if (!pLatmDemux->m_allStreamsSameTimeFraming) {
 314             if ((lay > 0) && (pAsc[TPDEC_TRACKINDEX(prog,lay)].m_aot == AOT_AAC_SCAL || pAsc[TPDEC_TRACKINDEX(prog,lay)].m_aot == AOT_ER_AAC_SCAL)) {
 315               return TRANSPORTDEC_UNSUPPORTED_FORMAT;
 316             }
 317           }
 318           break;
 319         case 1:
 320           /* frameLength = FDKreadBits(bs,9); */
 321         case 3:
 322         case 4:
 323         case 5:
 324           /* CELP */
 325         case 6:
 326         case 7:
 327           /* HVXC */
 328         default:
 329           return TRANSPORTDEC_PARSE_ERROR; //_LATM_INVALIDFRAMELENGTHTYPE;
 330
 331         }  /* switch framelengthtype*/
 332
 333       }  /* layer loop */
 334     }  /* prog loop */
 335
 336     pLatmDemux->m_otherDataPresent = FDKreadBits(bs,1);
 337     pLatmDemux->m_otherDataLength  = 0;
 338
 339     if (pLatmDemux->m_otherDataPresent) {
 340       int otherDataLenEsc  = 0;
 341       do {
 342         pLatmDemux->m_otherDataLength <<= 8;   // *= 256
 343         otherDataLenEsc = FDKreadBits(bs,1);
 344         pLatmDemux->m_otherDataLength += FDKreadBits(bs,8);
 345       } while (otherDataLenEsc);
 346     }
 347
 348     pLatmDemux->m_crcCheckPresent = FDKreadBits(bs,1);
 349     pLatmDemux->m_crcCheckSum     = 0;
 350
 351     if (pLatmDemux->m_crcCheckPresent) {
 352       pLatmDemux->m_crcCheckSum = FDKreadBits(bs,8);
 353     }
 354
 355   }
 356   else {
 357     /* audioMuxVersionA > 0 is reserved for future extensions */
 358     ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
 359   }
 360   return (ErrorStatus);
 361 }
 362
 363 TRANSPORTDEC_ERROR CLatmDemux_ReadPayloadLengthInfo(HANDLE_FDK_BITSTREAM bs, CLatmDemux *pLatmDemux)
 364 {
 365   TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
 366   int totalPayloadBits = 0;
 367
 368   if( pLatmDemux->m_allStreamsSameTimeFraming == 1 ) {
 369     for (UINT prog=0; prog<pLatmDemux->m_numProgram; prog++ ) {
 370       for (UINT lay=0; lay<pLatmDemux->m_numLayer; lay++ ) {
 371         LATM_LAYER_INFO *p_linfo = &pLatmDemux->m_linfo[prog][lay];
 372
 373         switch (p_linfo->m_frameLengthType ) {
 374         case 0:
 375           p_linfo->m_frameLengthInBits = CLatmDemux_ReadAuChunkLengthInfo(bs);
 376           totalPayloadBits += p_linfo->m_frameLengthInBits;
 377           break;
 378         case 3:
 379         case 5:
 380         case 7:
 381         default:
 382           return TRANSPORTDEC_PARSE_ERROR; //AAC_DEC_LATM_INVALIDFRAMELENGTHTYPE;
 383         }
 384       }
 385     }
 386   }
 387   else {
 388     ErrorStatus = TRANSPORTDEC_PARSE_ERROR; //AAC_DEC_LATM_TIMEFRAMING;
 389   }
 390   if (pLatmDemux->m_audioMuxLengthBytes > (UINT)0 && totalPayloadBits > (int)pLatmDemux->m_audioMuxLengthBytes*8) {
 391     return TRANSPORTDEC_PARSE_ERROR;
 392   }
 393   return (ErrorStatus);
 394 }
 395
 396 int CLatmDemux_ReadAuChunkLengthInfo(HANDLE_FDK_BITSTREAM bs)
 397 {
 398   UCHAR endFlag;
 399   int len = 0;
 400
 401   do {
 402     UCHAR tmp = (UCHAR) FDKreadBits(bs,8);
 403     endFlag = (tmp < 255);
 404
 405     len += tmp;
 406
 407   } while( endFlag == 0 );
 408
 409   len <<= 3;  /* convert from bytes to bits */
 410
 411   return len;
 412 }
 413
 414 int CLatmDemux_GetFrameLengthInBits(CLatmDemux *pLatmDemux)
 415 {
 416   return pLatmDemux->m_linfo[0][0].m_frameLengthInBits;
 417 }
 418
 419 int CLatmDemux_GetOtherDataPresentFlag(CLatmDemux *pLatmDemux)
 420 {
 421   return pLatmDemux->m_otherDataPresent ? 1 : 0;
 422 }
 423
 424 int CLatmDemux_GetOtherDataLength(CLatmDemux *pLatmDemux)
 425 {
 426   return pLatmDemux->m_otherDataLength;
 427 }
 428
 429 UINT CLatmDemux_GetNrOfSubFrames(CLatmDemux *pLatmDemux)
 430 {
 431   return pLatmDemux->m_noSubFrames;
 432 }
 433