Remove FDK-AAC

10 files changed, 0 insertions, 4006 deletions

diff --git a/libMpegTPDec/src/mpegFileFormat.h b/libMpegTPDec/src/mpegFileFormat.h
deleted file mode 100644
index b0cfe9e..0000000
--- a/libMpegTPDec/src/mpegFileFormat.h
+++ /dev/null
@@ -1,114 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/***************************  Fraunhofer IIS FDK Tools  ***********************
-
-   Author(s):   Oliver Moser
-   Description: bitstream format detection routines
-
-******************************************************************************/
-
-#if !defined(__BITSTREAM_FORMAT_H__)
-#define __BITSTREAM_FORMAT_H__
-
-#include "machine_type.h"
-#include "FDK_audio.h"
-
-/**
- * \brief Try to find out the format of a file, given the few first bytes.
- * \param fileData pointer to a buffer holding the first bytes of a file.
- * \param pAu pointer to UCHAR*, returns the address of the first AU found or NULL.
- * \param length pointer to the length of the buffer fileData. Return length of first AU.
- * \return the detected file format, or FF_UNKNOWN in case of failure.
- */
-FILE_FORMAT GetFileFormat(UCHAR *fileData, UCHAR **pAu, UINT *length);
-
-/**
- * \brief Try to find out the transport type contained in a given file.
- * \param filename name of the file to be analysed.
- * \param fileFormat pointer to a variable where the detected file format is stored into.
- * \return the detected transport type or TT_UNKNOWN in case of failure.
- */
-TRANSPORT_TYPE GetTransportType(const char* filename, FILE_FORMAT *fileFormat);
-
-#endif
diff --git a/libMpegTPDec/src/tpdec_adif.cpp b/libMpegTPDec/src/tpdec_adif.cpp
deleted file mode 100644
index 237e881..0000000
--- a/libMpegTPDec/src/tpdec_adif.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Josef Hoepfl
-   Description: ADIF reader
-
-******************************************************************************/
-
-#include "tpdec_adif.h"
-
-
-#include "FDK_bitstream.h"
-#include "genericStds.h"
-
-TRANSPORTDEC_ERROR adifRead_DecodeHeader(
-        CAdifHeader          *pAdifHeader,
-        CProgramConfig       *pPce,
-        HANDLE_FDK_BITSTREAM  bs
-        )
-{
-  int i;
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-  UINT startAnchor = FDKgetValidBits(bs);
-
-  if ((INT)startAnchor < MIN_ADIF_HEADERLENGTH) {
-    return (TRANSPORTDEC_NOT_ENOUGH_BITS);
-  }
-
-  if (FDKreadBits(bs,8) != 'A') {
-    return (TRANSPORTDEC_SYNC_ERROR);
-  }
-  if (FDKreadBits(bs,8) != 'D') {
-    return (TRANSPORTDEC_SYNC_ERROR);
-  }
-  if (FDKreadBits(bs,8) != 'I') {
-    return (TRANSPORTDEC_SYNC_ERROR);
-  }
-  if (FDKreadBits(bs,8) != 'F') {
-    return (TRANSPORTDEC_SYNC_ERROR);
-  }
-
-  if ( (pAdifHeader->CopyrightIdPresent = FDKreadBits(bs,1)) != 0 )
-    FDKpushBiDirectional(bs,72);  /* CopyrightId */
-
-
-  pAdifHeader->OriginalCopy = FDKreadBits(bs,1);
-  pAdifHeader->Home = FDKreadBits(bs,1);
-  pAdifHeader->BitstreamType = FDKreadBits(bs,1);
-
-  /* pAdifHeader->BitRate = FDKreadBits(bs, 23); */
-  pAdifHeader->BitRate = FDKreadBits(bs,16);
-  pAdifHeader->BitRate <<= 7;
-  pAdifHeader->BitRate |= FDKreadBits(bs,7);
-
-  pAdifHeader->NumProgramConfigElements = FDKreadBits(bs,4) + 1;
-
-  if (pAdifHeader->BitstreamType == 0) {
-    FDKpushBiDirectional(bs,20);  /* adif_buffer_fullness */
-  }
-
-  /* Parse all PCEs but keep only one */
-  for (i=0; i < pAdifHeader->NumProgramConfigElements; i++)
-  {
-    CProgramConfig_Read(pPce, bs, startAnchor);
-  }
-
-  FDKbyteAlign(bs, startAnchor);
-
-  return (ErrorStatus);
-}
-
-
-
diff --git a/libMpegTPDec/src/tpdec_adif.h b/libMpegTPDec/src/tpdec_adif.h
deleted file mode 100644
index d6780a7..0000000
--- a/libMpegTPDec/src/tpdec_adif.h
+++ /dev/null
@@ -1,123 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Josef Hoepfl
-   Description: ADIF reader
-
-******************************************************************************/
-
-#ifndef TPDEC_ADIF_H
-#define TPDEC_ADIF_H
-
-#include "tpdec_lib.h"
-
-#define MIN_ADIF_HEADERLENGTH  63  /* in bits */
-
-typedef struct
-{
-  INT NumProgramConfigElements;
-  UINT BitRate;
-  UCHAR CopyrightIdPresent;
-  UCHAR OriginalCopy;
-  UCHAR Home;
-  UCHAR BitstreamType;
-} CAdifHeader;
-
-/**
- * \brief Parse a ADIF header at the given bitstream and store the parsed data into a given CAdifHeader
- *        and CProgramConfig struct
- *
- * \param pAdifHeader pointer to a CAdifHeader structure to hold the parsed ADIF header data.
- * \param pPce pointer to a CProgramConfig structure where the last PCE will remain.
- *
- * \return TRANSPORTDEC_ERROR error code
- */
-TRANSPORTDEC_ERROR adifRead_DecodeHeader(
-        CAdifHeader         *pAdifHeader,
-        CProgramConfig      *pPce,
-        HANDLE_FDK_BITSTREAM bs
-        );
-
-#endif /* TPDEC_ADIF_H */
diff --git a/libMpegTPDec/src/tpdec_adts.cpp b/libMpegTPDec/src/tpdec_adts.cpp
deleted file mode 100644
index c455681..0000000
--- a/libMpegTPDec/src/tpdec_adts.cpp
+++ /dev/null
@@ -1,388 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Josef Hoepfl
-   Description: ADTS interface
-
-******************************************************************************/
-
-#include "tpdec_adts.h"
-
-
-#include "FDK_bitstream.h"
-
-
-
-void adtsRead_CrcInit(HANDLE_ADTS pAdts) /*!< pointer to adts crc info stucture */
-{
-  FDKcrcInit(&pAdts->crcInfo, 0x8005, 0xFFFF, 16);
-}
-
-int adtsRead_CrcStartReg(
-                     HANDLE_ADTS pAdts,          /*!< pointer to adts stucture */
-                     HANDLE_FDK_BITSTREAM hBs,   /*!< handle to current bit buffer structure */
-                     int mBits                   /*!< number of bits in crc region */
-                   )
-{
-  if (pAdts->bs.protection_absent) {
-    return 0;
-  }
-
-  return ( FDKcrcStartReg(&pAdts->crcInfo, hBs, mBits) );
-
-}
-
-void adtsRead_CrcEndReg(
-                    HANDLE_ADTS pAdts, /*!< pointer to adts crc info stucture */
-                    HANDLE_FDK_BITSTREAM hBs,   /*!< handle to current bit buffer structure */
-                    int reg                    /*!< crc region */
-                  )
-{
-  if (pAdts->bs.protection_absent == 0)
-  {
-    FDKcrcEndReg(&pAdts->crcInfo, hBs, reg);
-  }
-}
-
-TRANSPORTDEC_ERROR adtsRead_CrcCheck( HANDLE_ADTS pAdts )
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-  USHORT crc;
-
-  if (pAdts->bs.protection_absent)
-    return TRANSPORTDEC_OK;
-
-  crc = FDKcrcGetCRC(&pAdts->crcInfo);
-  if (crc != pAdts->crcReadValue)
-  {
-    return (TRANSPORTDEC_CRC_ERROR);
-  }
-
-  return (ErrorStatus);
-}
-
-
-
-#define Adts_Length_SyncWord                     12
-#define Adts_Length_Id                            1
-#define Adts_Length_Layer                         2
-#define Adts_Length_ProtectionAbsent              1
-#define Adts_Length_Profile                       2
-#define Adts_Length_SamplingFrequencyIndex        4
-#define Adts_Length_PrivateBit                    1
-#define Adts_Length_ChannelConfiguration          3
-#define Adts_Length_OriginalCopy                  1
-#define Adts_Length_Home                          1
-#define Adts_Length_CopyrightIdentificationBit    1
-#define Adts_Length_CopyrightIdentificationStart  1
-#define Adts_Length_FrameLength                  13
-#define Adts_Length_BufferFullness               11
-#define Adts_Length_NumberOfRawDataBlocksInFrame  2
-#define Adts_Length_CrcCheck                     16
-
-TRANSPORTDEC_ERROR adtsRead_DecodeHeader(
-        HANDLE_ADTS           pAdts,
-        CSAudioSpecificConfig *pAsc,
-        HANDLE_FDK_BITSTREAM  hBs,
-        const INT             ignoreBufferFullness
-        )
-{
-  INT crcReg;
-
-  INT valBits;
-  INT cmp_buffer_fullness;
-  int i, adtsHeaderLength;
-
-  STRUCT_ADTS_BS bs;
-
-#ifdef TP_PCE_ENABLE
-  CProgramConfig oldPce;
-  /* Store the old PCE temporarily. Maybe we'll need it later if we
-     have channelConfig=0 and no PCE in this frame. */
-  FDKmemcpy(&oldPce, &pAsc->m_progrConfigElement, sizeof(CProgramConfig));
-#endif
-
-  valBits = FDKgetValidBits(hBs);
-
-  /* adts_fixed_header */
-  bs.mpeg_id           = FDKreadBits(hBs, Adts_Length_Id);
-  bs.layer             = FDKreadBits(hBs, Adts_Length_Layer);
-  bs.protection_absent = FDKreadBits(hBs, Adts_Length_ProtectionAbsent);
-  bs.profile           = FDKreadBits(hBs, Adts_Length_Profile);
-  bs.sample_freq_index = FDKreadBits(hBs, Adts_Length_SamplingFrequencyIndex);
-  bs.private_bit       = FDKreadBits(hBs, Adts_Length_PrivateBit);
-  bs.channel_config    = FDKreadBits(hBs, Adts_Length_ChannelConfiguration);
-  bs.original          = FDKreadBits(hBs, Adts_Length_OriginalCopy);
-  bs.home              = FDKreadBits(hBs, Adts_Length_Home);
-
-  /* adts_variable_header */
-  bs.copyright_id    = FDKreadBits(hBs, Adts_Length_CopyrightIdentificationBit);
-  bs.copyright_start = FDKreadBits(hBs, Adts_Length_CopyrightIdentificationStart);
-  bs.frame_length    = FDKreadBits(hBs, Adts_Length_FrameLength);
-  bs.adts_fullness   = FDKreadBits(hBs, Adts_Length_BufferFullness);
-  bs.num_raw_blocks  = FDKreadBits(hBs, Adts_Length_NumberOfRawDataBlocksInFrame);
-  bs.num_pce_bits    = 0;
-
-  adtsHeaderLength = ADTS_HEADERLENGTH;
-
-  if (!bs.protection_absent) {
-    FDKcrcReset(&pAdts->crcInfo);
-    FDKpushBack(hBs, 56);   /* complete fixed and variable header! */
-    crcReg = FDKcrcStartReg(&pAdts->crcInfo, hBs, 0);
-    FDKpushFor(hBs, 56);
-  }
-
-  if (! bs.protection_absent && bs.num_raw_blocks>0) {
-    for (i=0; i<bs.num_raw_blocks; i++) {
-      pAdts->rawDataBlockDist[i] = (USHORT)FDKreadBits(hBs, 16);
-      adtsHeaderLength += 16;
-    }
-    /* Change raw data blocks to delta values */
-    pAdts->rawDataBlockDist[bs.num_raw_blocks] = bs.frame_length - 7 - bs.num_raw_blocks*2 - 2 ;
-    for (i=bs.num_raw_blocks; i>0; i--) {
-      pAdts->rawDataBlockDist[i] -= pAdts->rawDataBlockDist[i-1];
-    }
-  }
-
-  /* adts_error_check */
-  if (!bs.protection_absent)
-  {
-    USHORT crc_check;
-
-    FDKcrcEndReg(&pAdts->crcInfo, hBs, crcReg);
-    crc_check = FDKreadBits(hBs, Adts_Length_CrcCheck);
-    adtsHeaderLength += Adts_Length_CrcCheck;
-
-    pAdts->crcReadValue = crc_check;
-    /* Check header CRC in case of multiple raw data blocks */
-    if (bs.num_raw_blocks > 0) {
-      if (pAdts->crcReadValue != FDKcrcGetCRC(&pAdts->crcInfo)) {
-        return TRANSPORTDEC_CRC_ERROR;
-      }
-      /* Reset CRC for the upcoming raw_data_block() */
-      FDKcrcReset(&pAdts->crcInfo);
-    }
-  }
-
-
-  /* check if valid header */
-  if (
-      (bs.layer != 0) ||                          // we only support MPEG ADTS
-      (bs.sample_freq_index >= 13)                // we only support 96kHz - 7350kHz
-      ) {
-    FDKpushFor(hBs, bs.frame_length * 8);   // try again one frame later
-    return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-  }
-
-  /* special treatment of id-bit */
-  if ( (bs.mpeg_id == 0) && (pAdts->decoderCanDoMpeg4 == 0) )
-  {
-    /* MPEG-2 decoder cannot play MPEG-4 bitstreams */
-
-
-    FDKpushFor(hBs, bs.frame_length * 8);  // try again one frame later
-    return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-  }
-
-  if (!ignoreBufferFullness)
-  {
-    cmp_buffer_fullness = bs.frame_length*8 + bs.adts_fullness*32*getNumberOfEffectiveChannels(bs.channel_config);
-
-
-    /* Evaluate buffer fullness */
-    if (bs.adts_fullness != 0x7FF)
-    {
-      if (pAdts->BufferFullnesStartFlag)
-      {
-        if ( valBits < cmp_buffer_fullness )
-        {
-          /* Condition for start of decoding is not fulfilled */
-
-          /* The current frame will not be decoded */
-          FDKpushBack(hBs, adtsHeaderLength);
-
-          if ( (cmp_buffer_fullness+adtsHeaderLength) > ((TRANSPORTDEC_INBUF_SIZE<<3)-7) ) {
-            return TRANSPORTDEC_SYNC_ERROR;
-          } else {
-            return TRANSPORTDEC_NOT_ENOUGH_BITS;
-          }
-        }
-        else
-        {
-          pAdts->BufferFullnesStartFlag = 0;
-        }
-      }
-    }
-  }
-
-
-  /* Get info from ADTS header */
-  AudioSpecificConfig_Init(pAsc);
-  pAsc->m_aot                    = (AUDIO_OBJECT_TYPE)(bs.profile + 1);
-  pAsc->m_samplingFrequencyIndex = bs.sample_freq_index;
-  pAsc->m_samplingFrequency      = SamplingRateTable[bs.sample_freq_index];
-  pAsc->m_channelConfiguration   = bs.channel_config;
-  pAsc->m_samplesPerFrame        = 1024;
-
-#ifdef TP_PCE_ENABLE
-  if (bs.channel_config == 0)
-  {
-    int pceBits = 0;
-    UINT alignAnchor = FDKgetValidBits(hBs);
-    
-    if (FDKreadBits(hBs,3) == ID_PCE) {
-      /* Got luck! Parse the PCE */
-      int crcReg;
-      crcReg = adtsRead_CrcStartReg(pAdts, hBs, 0);
-
-      CProgramConfig_Read(&pAsc->m_progrConfigElement, hBs, alignAnchor);
-
-      adtsRead_CrcEndReg(pAdts, hBs, crcReg);
-      pceBits = alignAnchor - FDKgetValidBits(hBs);
-      /* store the number of PCE bits */
-      bs.num_pce_bits = pceBits;
-    }
-    else {
-      /* No PCE in this frame! Push back the ID tag bits. */
-      FDKpushBack(hBs,3);
-
-      /* Encoders do not have to write a PCE in each frame.
-         So if we already have a valid PCE we have to use it. */
-      if (  oldPce.isValid
-        && (bs.sample_freq_index == pAdts->bs.sample_freq_index)  /* we could compare the complete fixed header (bytes) here! */
-        && (bs.channel_config    == pAdts->bs.channel_config) /* == 0 */
-        && (bs.mpeg_id           == pAdts->bs.mpeg_id) )
-      { /* Restore previous PCE which is still valid */
-        FDKmemcpy(&pAsc->m_progrConfigElement, &oldPce, sizeof(CProgramConfig));
-      }
-      else if (bs.mpeg_id == 0) {
-        /* If not it seems that we have a implicit channel configuration.
-           This mode is not allowed in the context of ISO/IEC 14496-3.
-           Skip this frame and try the next one. */
-        FDKpushFor(hBs, (bs.frame_length<<3) - adtsHeaderLength - 3);
-        return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-      }
-      /* else {
-         ISO/IEC 13818-7 implicit channel mapping is allowed.
-         So just open the box of chocolates to see what we got.
-      } */
-    }
-  }
-#endif /* TP_PCE_ENABLE */
-
-  /* Copy bit stream data struct to persistent memory now, once we passed all sanity checks above. */
-  FDKmemcpy(&pAdts->bs, &bs, sizeof(STRUCT_ADTS_BS));
-
-  return TRANSPORTDEC_OK;
-}
-
-int adtsRead_GetRawDataBlockLength(
-        HANDLE_ADTS pAdts,
-        INT         blockNum
-        )
-{
-  int length;
-
-  if (pAdts->bs.num_raw_blocks == 0) {
-    length = (pAdts->bs.frame_length - 7) << 3;    /* aac_frame_length subtracted by the header size (7 bytes). */
-    if (pAdts->bs.protection_absent == 0)
-      length -= 16;                                                                   /* substract 16 bit CRC */
-  } else {
-    if (pAdts->bs.protection_absent) {
-      length = -1; /* raw data block length is unknown */
-    } else {
-      if (blockNum < 0 || blockNum > 3) {
-        length = -1;
-      }
-      length = (pAdts->rawDataBlockDist[blockNum] << 3) - 16;
-    }
-  }
-  if (blockNum == 0 && length > 0) {
-    length -= pAdts->bs.num_pce_bits;
-  }
-  return length;
-}
-
-
diff --git a/libMpegTPDec/src/tpdec_adts.h b/libMpegTPDec/src/tpdec_adts.h
deleted file mode 100644
index a3b83a5..0000000
--- a/libMpegTPDec/src/tpdec_adts.h
+++ /dev/null
@@ -1,236 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Josef Hoepfl
-   Description: ADTS interface
-
-******************************************************************************/
-
-#ifndef TPDEC_ADTS_H
-#define TPDEC_ADTS_H
-
-#include "tpdec_lib.h"
-
-
-#define ADTS_SYNCWORD               ( 0xfff )
-#define ADTS_SYNCLENGTH             ( 12 )     /* in bits */
-#define ADTS_HEADERLENGTH           ( 56 )     /* minimum header size in bits */
-#define ADTS_FIXED_HEADERLENGTH     ( 28 )     /* in bits */
-#define ADTS_VARIABLE_HEADERLENGTH  ( ADTS_HEADERLENGTH - ADTS_FIXED_HEADERLENGTH )
-
-#ifdef CHECK_TWO_SYNCS
- #define ADTS_MIN_TP_BUF_SIZE       ( 8191 + 2 )
-#else
- #define ADTS_MIN_TP_BUF_SIZE       ( 8191 )
-#endif
-
-#include "FDK_crc.h"
-
-typedef struct {
-  /* ADTS header fields */
-  UCHAR mpeg_id;
-  UCHAR layer;
-  UCHAR protection_absent;
-  UCHAR profile;
-  UCHAR sample_freq_index;
-  UCHAR private_bit;
-  UCHAR channel_config;
-  UCHAR original;
-  UCHAR home;
-  UCHAR copyright_id;
-  UCHAR copyright_start;
-  USHORT frame_length;
-  USHORT adts_fullness;
-  UCHAR num_raw_blocks;
-  UCHAR num_pce_bits;
-} STRUCT_ADTS_BS;
-
-struct STRUCT_ADTS {
-
-  STRUCT_ADTS_BS bs;
-
-  UCHAR decoderCanDoMpeg4;
-  UCHAR BufferFullnesStartFlag;
-
-  FDK_CRCINFO crcInfo;             /* CRC state info */
-  USHORT      crcReadValue;        /* CRC value read from bitstream data */
-  USHORT      rawDataBlockDist[4]; /* distance between each raw data block. Not the same as found in the bitstream */
-} ;
-
-typedef struct STRUCT_ADTS *HANDLE_ADTS;
-
-/*!
-  \brief Initialize ADTS CRC
-
-  The function initialzes the crc buffer and the crc lookup table.
-
-  \return  none
-*/
-void adtsRead_CrcInit( HANDLE_ADTS pAdts );
-
-/**
- * \brief Starts CRC region with a maximum number of bits
- *        If mBits is positive zero padding will be used for CRC calculation, if there
- *        are less than mBits bits available.
- *        If mBits is negative no zero padding is done.
- *        If mBits is zero the memory for the buffer is allocated dynamically, the
- *        number of bits is not limited.
- *
- * \param pAdts ADTS data handle
- * \param hBs bitstream handle, on which the CRC region referes to
- * \param mBits max number of bits in crc region to be considered
- *
- * \return  ID for the created region, -1 in case of an error
- */
-int adtsRead_CrcStartReg(
-        HANDLE_ADTS pAdts,
-        HANDLE_FDK_BITSTREAM hBs,
-        int mBits
-        );
-
-/**
- * \brief Ends CRC region identified by reg
- *
- * \param pAdts ADTS data handle
- * \param hBs bitstream handle, on which the CRC region referes to
- * \param reg CRC regions ID returned by adtsRead_CrcStartReg()
- *
- * \return  none
- */
-void adtsRead_CrcEndReg(
-        HANDLE_ADTS pAdts,
-        HANDLE_FDK_BITSTREAM hBs,
-        int reg
-        );
-
-/**
- * \brief Check CRC
- *
- * Checks if the currently calculated CRC matches the CRC field read from the bitstream
- * Deletes all CRC regions.
- *
- * \param pAdts ADTS data handle
- *
- * \return Returns 0 if they are identical otherwise 1
- */
-TRANSPORTDEC_ERROR adtsRead_CrcCheck( HANDLE_ADTS pAdts );
-
-
-/**
- * \brief Check if we have a valid ADTS frame at the current bitbuffer position
- *
- * This function assumes enough bits in buffer for the current frame.
- * It reads out the header bits to prepare the bitbuffer for the decode loop.
- * In case the header bits show an invalid bitstream/frame, the whole frame is skipped.
- *
- * \param pAdts ADTS data handle which is filled with parsed ADTS header data
- * \param bs handle of bitstream from whom the ADTS header is read
- *
- * \return  error status
- */
-TRANSPORTDEC_ERROR adtsRead_DecodeHeader(
-        HANDLE_ADTS           pAdts,
-        CSAudioSpecificConfig *pAsc,
-        HANDLE_FDK_BITSTREAM  bs,
-        const INT             ignoreBufferFullness
-        );
-
-/**
- * \brief Get the raw data block length of the given block number.
- *
- * \param pAdts ADTS data handle
- * \param blockNum current raw data block index
- * \param pLength pointer to an INT where the length of the given raw data block is stored into
- *                the returned value might be -1, in which case the raw data block length is unknown.
- *
- * \return  error status
- */
-int adtsRead_GetRawDataBlockLength(
-        HANDLE_ADTS pAdts,
-        INT         blockNum
-        );
-
-
-#endif /* TPDEC_ADTS_H */
diff --git a/libMpegTPDec/src/tpdec_asc.cpp b/libMpegTPDec/src/tpdec_asc.cpp
deleted file mode 100644
index 4d7cc02..0000000
--- a/libMpegTPDec/src/tpdec_asc.cpp
+++ /dev/null
@@ -1,1050 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Daniel Homm
-   Description:
-
-******************************************************************************/
-
-#include "tpdec_lib.h"
-#include "tp_data.h"
-
-
-void CProgramConfig_Reset(CProgramConfig *pPce)
-{
-  pPce->elCounter = 0;
-}
-
-void CProgramConfig_Init(CProgramConfig *pPce)
-{
-  FDKmemclear(pPce, sizeof(CProgramConfig));
-#ifdef TP_PCE_ENABLE
-  pPce->SamplingFrequencyIndex = 0xf;
-#endif
-}
-
-int  CProgramConfig_IsValid ( const CProgramConfig *pPce )
-{
-  return ( (pPce->isValid) ? 1 : 0);
-}
-
-#ifdef TP_PCE_ENABLE
-void CProgramConfig_Read(
-                          CProgramConfig *pPce,
-                          HANDLE_FDK_BITSTREAM bs,
-                          UINT alignmentAnchor
-                        )
-{
-  int i;
-
-  pPce->NumEffectiveChannels = 0;
-  pPce->NumChannels = 0;
-  pPce->ElementInstanceTag = (UCHAR) FDKreadBits(bs,4);
-  pPce->Profile = (UCHAR) FDKreadBits(bs,2);
-  pPce->SamplingFrequencyIndex = (UCHAR) FDKreadBits(bs,4);
-  pPce->NumFrontChannelElements = (UCHAR) FDKreadBits(bs,4);
-  pPce->NumSideChannelElements = (UCHAR) FDKreadBits(bs,4);
-  pPce->NumBackChannelElements = (UCHAR) FDKreadBits(bs,4);
-  pPce->NumLfeChannelElements = (UCHAR) FDKreadBits(bs,2);
-  pPce->NumAssocDataElements = (UCHAR) FDKreadBits(bs,3);
-  pPce->NumValidCcElements = (UCHAR) FDKreadBits(bs,4);
-
-  if ((pPce->MonoMixdownPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
-  {
-    pPce->MonoMixdownElementNumber = (UCHAR) FDKreadBits(bs,4);
-  }
-
-  if ((pPce->StereoMixdownPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
-  {
-    pPce->StereoMixdownElementNumber = (UCHAR) FDKreadBits(bs,4);
-  }
-
-  if ((pPce->MatrixMixdownIndexPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
-  {
-    pPce->MatrixMixdownIndex = (UCHAR) FDKreadBits(bs,2);
-    pPce->PseudoSurroundEnable = (UCHAR) FDKreadBits(bs,1);
-  }
-
-  for (i=0; i < pPce->NumFrontChannelElements; i++)
-  {
-    pPce->FrontElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
-    pPce->FrontElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-    pPce->NumChannels += pPce->FrontElementIsCpe[i] ? 2 : 1;
-  }
-
-  for (i=0; i < pPce->NumSideChannelElements; i++)
-  {
-    pPce->SideElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
-    pPce->SideElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-    pPce->NumChannels += pPce->SideElementIsCpe[i] ? 2 : 1;
-  }
-
-  for (i=0; i < pPce->NumBackChannelElements; i++)
-  {
-    pPce->BackElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
-    pPce->BackElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-    pPce->NumChannels += pPce->BackElementIsCpe[i] ? 2 : 1;
-  }
-
-  pPce->NumEffectiveChannels = pPce->NumChannels;
-
-  for (i=0; i < pPce->NumLfeChannelElements; i++)
-  {
-    pPce->LfeElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-    pPce->NumChannels += 1;
-  }
-
-  for (i=0; i < pPce->NumAssocDataElements; i++)
-  {
-    pPce->AssocDataElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-  }
-
-  for (i=0; i < pPce->NumValidCcElements; i++)
-  {
-    pPce->CcElementIsIndSw[i] = (UCHAR) FDKreadBits(bs,1);
-    pPce->ValidCcElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
-  }
-
-  FDKbyteAlign(bs, alignmentAnchor);
-
-  pPce->CommentFieldBytes = (UCHAR) FDKreadBits(bs,8);
-
-  for (i=0; i < pPce->CommentFieldBytes; i++)
-  {
-    UCHAR text;
-
-    text = (UCHAR)FDKreadBits(bs,8);
-
-    if (i < PC_COMMENTLENGTH)
-    {
-      pPce->Comment[i] = text;
-    }
-  }
-
-  pPce->isValid = 1;
-}
-
-/*
- * Compare two program configurations.
- * Returns the result of the comparison:
- *  -1 - completely different
- *   0 - completely equal
- *   1 - different but same channel configuration
- *   2 - different channel configuration but same number of channels
- */
-int CProgramConfig_Compare ( const CProgramConfig * const pPce1,
-                             const CProgramConfig * const pPce2 )
-{
-  int result = 0;  /* Innocent until proven false. */
-
-  if (FDKmemcmp(pPce1, pPce2, sizeof(CProgramConfig)) != 0)
-  { /* Configurations are not completely different.
-       So look into details and analyse the channel configurations: */
-    result = -1;
-
-    if (pPce1->NumChannels == pPce2->NumChannels)
-    { /* Now the logic changes. We first assume to have the same channel configuration
-         and then prove if this assumption is true. */
-      result = 1;
-
-      /* Front channels */
-      if (pPce1->NumFrontChannelElements != pPce2->NumFrontChannelElements) {
-        result = 2;  /* different number of front channel elements */
-      } else {
-        int el, numCh1 = 0, numCh2 = 0;
-        for (el = 0; el < pPce1->NumFrontChannelElements; el += 1) {
-          numCh1 += pPce1->FrontElementIsCpe[el] ? 2 : 1;
-          numCh2 += pPce2->FrontElementIsCpe[el] ? 2 : 1;
-        }
-        if (numCh1 != numCh2) {
-          result = 2;  /* different number of front channels */
-        }
-      }
-      /* Side channels */
-      if (pPce1->NumSideChannelElements != pPce2->NumSideChannelElements) {
-        result = 2;  /* different number of side channel elements */
-      } else {
-        int el, numCh1 = 0, numCh2 = 0;
-        for (el = 0; el < pPce1->NumSideChannelElements; el += 1) {
-          numCh1 += pPce1->SideElementIsCpe[el] ? 2 : 1;
-          numCh2 += pPce2->SideElementIsCpe[el] ? 2 : 1;
-        }
-        if (numCh1 != numCh2) {
-          result = 2;  /* different number of side channels */
-        }
-      }
-      /* Back channels */
-      if (pPce1->NumBackChannelElements != pPce2->NumBackChannelElements) {
-        result = 2;  /* different number of back channel elements */
-      } else {
-        int el, numCh1 = 0, numCh2 = 0;
-        for (el = 0; el < pPce1->NumBackChannelElements; el += 1) {
-          numCh1 += pPce1->BackElementIsCpe[el] ? 2 : 1;
-          numCh2 += pPce2->BackElementIsCpe[el] ? 2 : 1;
-        }
-        if (numCh1 != numCh2) {
-          result = 2;  /* different number of back channels */
-        }
-      }
-      /* LFE channels */
-      if (pPce1->NumLfeChannelElements != pPce2->NumLfeChannelElements) {
-        result = 2;  /* different number of lfe channels */
-      }
-      /* LFEs are always SCEs so we don't need to count the channels. */
-    }
-  }
-
-  return result;
-}
-
-void CProgramConfig_GetDefault( CProgramConfig *pPce,
-                                const UINT channelConfig )
-{
-  FDK_ASSERT(pPce != NULL);
-
-  /* Init PCE */
-  CProgramConfig_Init(pPce);
-  pPce->Profile = 1;  /* Set AAC LC because it is the only supported object type. */
-
-  switch (channelConfig) {
-  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-  case 6:   /* 3/0/2.1ch */
-    pPce->NumLfeChannelElements   += 1;
-    pPce->NumChannels             += 1;
-  case 5:   /* 3/0/2.0ch */
-  case 4:   /* 3/0/1.0ch */
-    pPce->NumBackChannelElements  += 1;
-    pPce->BackElementIsCpe[0]      = (channelConfig>4) ? 1 : 0;
-    pPce->NumChannels             += (channelConfig>4) ? 2 : 1;
-    pPce->NumEffectiveChannels    += (channelConfig>4) ? 2 : 1;
-  case 3:   /* 3/0/0.0ch */
-    pPce->NumFrontChannelElements += 1;
-    pPce->FrontElementIsCpe[1]     = 1;
-    pPce->NumChannels             += 2;
-    pPce->NumEffectiveChannels    += 2;
-  case 1:   /* 1/0/0.0ch */
-    pPce->NumFrontChannelElements += 1;
-    pPce->FrontElementIsCpe[0]     = 0;
-    pPce->NumChannels             += 1;
-    pPce->NumEffectiveChannels    += 1;
-    pPce->isValid                  = 1;
-    break;
-  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-  case 2:   /* 2/0/0.ch */
-    pPce->NumFrontChannelElements  = 1;
-    pPce->FrontElementIsCpe[0]     = 1;
-    pPce->NumChannels             += 2;
-    pPce->NumEffectiveChannels    += 2;
-    pPce->isValid                  = 1;
-    break;
-  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-  default:
-    pPce->isValid                  = 0;   /* To be explicit! */
-    break;
-  }
-
-  if (pPce->isValid) {
-    /* Create valid element instance tags */
-    int el, elTagSce = 0, elTagCpe = 0;
-
-    for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
-      pPce->FrontElementTagSelect[el] = (pPce->FrontElementIsCpe) ? elTagCpe++ : elTagSce++;
-    }
-    for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
-      pPce->SideElementTagSelect[el] = (pPce->SideElementIsCpe) ? elTagCpe++ : elTagSce++;
-    }
-    for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
-      pPce->BackElementTagSelect[el] = (pPce->BackElementIsCpe) ? elTagCpe++ : elTagSce++;
-    }
-    elTagSce = 0;
-    for (el = 0; el < pPce->NumLfeChannelElements; el += 1) {
-      pPce->LfeElementTagSelect[el] = elTagSce++;
-    }
-  }
-}
-#endif /* TP_PCE_ENABLE */
-
-/**
- * \brief get implicit audio channel type for given channelConfig and MPEG ordered channel index
- * \param channelConfig MPEG channelConfiguration from 1 upto 7
- * \param index MPEG channel order index
- * \return audio channel type.
- */
-void getImplicitAudioChannelTypeAndIndex(
-        AUDIO_CHANNEL_TYPE *chType,
-        UCHAR *chIndex,
-        UINT channelConfig,
-        UINT index
-        )
-{
-  if (index < 3) {
-    *chType = ACT_FRONT;
-    *chIndex = index;
-  } else {
-    switch (channelConfig) {
-      case MODE_1_2_1:
-      case MODE_1_2_2:
-      case MODE_1_2_2_1:
-        switch (index) {
-          case 3:
-          case 4:
-            *chType = ACT_BACK;
-            *chIndex = index - 3;
-            break;
-          case 5:
-            *chType = ACT_LFE;
-            *chIndex = 0;
-            break;
-        }
-        break;
-      case MODE_1_2_2_2_1:
-        switch (index) {
-          case 3:
-          case 4:
-            *chType = ACT_SIDE;
-            *chIndex = index - 3;
-            break;
-          case 5:
-          case 6:
-            *chType = ACT_BACK;
-            *chIndex = index - 5;
-            break;
-          case 7:
-            *chType = ACT_LFE;
-            *chIndex = 0;
-            break;
-        }
-        break;
-      default:
-        *chType = ACT_NONE;
-        break;
-    }
-  }
-}
-
-int CProgramConfig_LookupElement(
-        CProgramConfig *pPce,
-        UINT            channelConfig,
-        const UINT      tag,
-        const UINT      channelIdx,
-        UCHAR           chMapping[],
-        AUDIO_CHANNEL_TYPE chType[],
-        UCHAR           chIndex[],
-        UCHAR          *elMapping,
-        MP4_ELEMENT_ID  elList[],
-        MP4_ELEMENT_ID  elType
-       )
-{
-  if (channelConfig > 0)
-  {
-    /* Constant channel mapping must have
-       been set during initialization. */
-    if ( elType == ID_SCE
-      || elType == ID_CPE
-      || elType == ID_LFE )
-    {
-      *elMapping = pPce->elCounter;
-      if (elList[pPce->elCounter] != elType) {
-        /* Not in the list */
-        if ( (channelConfig == 2) && (elType == ID_SCE) )
-        { /* This scenario occurs with HE-AAC v2 streams of buggy encoders.
-             Due to other decoder implementations decoding of these kind of streams is desired. */
-          channelConfig = 1;
-        } else {
-          return 0;
-        }
-      }
-      /* Assume all front channels */
-      getImplicitAudioChannelTypeAndIndex(&chType[channelIdx], &chIndex[channelIdx], channelConfig, channelIdx);
-      if (elType == ID_CPE) {
-        chType[channelIdx+1] = chType[channelIdx];
-        chIndex[channelIdx+1] = chIndex[channelIdx]+1;
-      }
-      pPce->elCounter++;
-    }
-    /* Accept all non-channel elements, too. */
-    return 1;
-  }
-  else
-  {
-#ifdef TP_PCE_ENABLE
-    if (!pPce->isValid)
-#endif /* TP_PCE_ENABLE */
-    {
-      /* Implicit channel mapping. */
-      if ( elType == ID_SCE
-        || elType == ID_CPE
-        || elType == ID_LFE )
-      {
-        /* Store all channel element IDs */
-        elList[pPce->elCounter] = elType;
-        *elMapping = pPce->elCounter++;
-      }
-    }
-#ifdef  TP_PCE_ENABLE
-    else {
-      /* Accept the additional channel(s), only if the tag is in the lists */
-      int isCpe = 0, i;
-      int cc = 0, fc = 0, sc = 0, bc = 0, lc = 0, ec = 0; /* Channel and element counters */
-
-      switch (elType)
-      {
-      case ID_CPE:
-        isCpe = 1;
-      case ID_SCE:
-        /* search in front channels */
-        for (i = 0; i < pPce->NumFrontChannelElements; i++) {
-          if (isCpe == pPce->FrontElementIsCpe[i] && pPce->FrontElementTagSelect[i] == tag) {
-            chMapping[cc] = channelIdx;
-            chType[cc] = ACT_FRONT;
-            chIndex[cc] = fc;
-            if (isCpe) {
-              chMapping[cc+1] = channelIdx+1;
-              chType[cc+1] = ACT_FRONT;
-              chIndex[cc+1] = fc+1;
-            }
-            *elMapping = ec;
-            return 1;
-          }
-          ec++;
-          if (pPce->FrontElementIsCpe[i]) {
-            cc+=2; fc+=2;
-          } else {
-            cc++; fc++;
-          }
-        }
-        /* search in side channels */
-        for (i = 0; i < pPce->NumSideChannelElements; i++) {
-          if (isCpe == pPce->SideElementIsCpe[i] && pPce->SideElementTagSelect[i] == tag) {
-            chMapping[cc] = channelIdx;
-            chType[cc] = ACT_SIDE;
-            chIndex[cc] = sc;
-            if (isCpe) {
-              chMapping[cc+1] = channelIdx+1;
-              chType[cc+1] = ACT_SIDE;
-              chIndex[cc+1] = sc+1;
-            }
-            *elMapping = ec;
-            return 1;
-          }
-          ec++;
-          if (pPce->SideElementIsCpe[i]) {
-            cc+=2; sc+=2;
-          } else {
-            cc++; sc++;
-          }
-        }
-        /* search in back channels */
-        for (i = 0; i < pPce->NumBackChannelElements; i++) {
-          if (isCpe == pPce->BackElementIsCpe[i] && pPce->BackElementTagSelect[i] == tag) {
-            chMapping[cc] = channelIdx;
-            chType[cc] = ACT_BACK;
-            chIndex[cc] = bc;
-            if (isCpe) {
-              chMapping[cc+1] = channelIdx+1;
-              chType[cc+1] = ACT_BACK;
-              chIndex[cc+1] = bc+1;
-            }
-            *elMapping = ec;
-            return 1;
-          }
-          ec++;
-          if (pPce->BackElementIsCpe[i]) {
-            cc+=2; bc+=2;
-          } else {
-            cc++; bc++;
-          }
-        }
-        break;
-
-      case ID_LFE:
-        /* Initialize channel counter and element counter */
-        cc = pPce->NumEffectiveChannels;
-        ec = pPce->NumFrontChannelElements+ pPce->NumSideChannelElements + pPce->NumBackChannelElements;
-        /* search in lfe channels */
-        for (i = 0; i < pPce->NumLfeChannelElements; i++) {
-          if ( pPce->LfeElementTagSelect[i] == tag ) {
-            chMapping[cc] = channelIdx;
-            *elMapping = ec;
-            chType[cc] = ACT_LFE;
-            chIndex[cc] = lc;
-            return 1;
-          }
-          ec++;
-          cc++;
-          lc++;
-        }
-        break;
-
-      /* Non audio elements */
-      case ID_CCE:
-        /* search in cce channels */
-        for (i = 0; i < pPce->NumValidCcElements; i++) {
-          if (pPce->ValidCcElementTagSelect[i] == tag) {
-            return 1;
-          }
-        }
-        break;
-      case ID_DSE:
-        /* search associated data elements */
-        for (i = 0; i < pPce->NumAssocDataElements; i++) {
-          if (pPce->AssocDataElementTagSelect[i] == tag) {
-            return 1;
-          }
-        }
-        break;
-      default:
-        return 0;
-      }
-      return 0;  /* not found in any list */
-    }
-#endif /* TP_PCE_ENABLE */
-  }
-
-  return 1;
-}
-
-#ifdef  TP_PCE_ENABLE
-int CProgramConfig_GetElementTable(
-        const CProgramConfig *pPce,
-        MP4_ELEMENT_ID  elList[],
-        const INT elListSize
-       )
-{
-  int i, el = 0;
-
-  if ( elListSize 
-    < pPce->NumFrontChannelElements + pPce->NumSideChannelElements + pPce->NumBackChannelElements + pPce->NumLfeChannelElements 
-    )
-  {
-    return 0;
-  }
-
-  for (i=0; i < pPce->NumFrontChannelElements; i++)
-  {
-    elList[el++] = (pPce->FrontElementIsCpe[i]) ?  ID_CPE : ID_SCE;
-  }
-
-  for (i=0; i < pPce->NumSideChannelElements; i++)
-  {
-    elList[el++] = (pPce->SideElementIsCpe[i]) ?  ID_CPE : ID_SCE;
-  }
-
-  for (i=0; i < pPce->NumBackChannelElements; i++)
-  {
-    elList[el++] = (pPce->BackElementIsCpe[i]) ?  ID_CPE : ID_SCE;
-  }
-
-  for (i=0; i < pPce->NumLfeChannelElements; i++)
-  {
-    elList[el++] = ID_LFE;
-  }
-
-
-  return el;
-}
-#endif
-
-static AUDIO_OBJECT_TYPE getAOT(HANDLE_FDK_BITSTREAM bs)
-{
-  int tmp = 0;
-
-  tmp = FDKreadBits(bs,5);
-  if (tmp == AOT_ESCAPE) {
-    int tmp2 = FDKreadBits(bs,6);
-    tmp = 32 + tmp2;
-  }
-
-  return (AUDIO_OBJECT_TYPE)tmp;
-}
-
-static INT getSampleRate(HANDLE_FDK_BITSTREAM bs, UCHAR *index, int nBits)
-{
-  INT sampleRate;
-  int idx;
-
-  idx = FDKreadBits(bs, nBits);
-  if( idx == (1<<nBits)-1 ) {
-    if(FDKgetValidBits(bs) < 24) {
-      return 0;
-    }
-    sampleRate = FDKreadBits(bs,24);
-  } else {
-    sampleRate = SamplingRateTable[idx];
-  }
-
-  *index = idx;
-
-  return sampleRate;
-}
-
-#ifdef TP_GA_ENABLE
-static
-TRANSPORTDEC_ERROR GaSpecificConfig_Parse( CSGaSpecificConfig    *self,
-                                           CSAudioSpecificConfig *asc,
-                                           HANDLE_FDK_BITSTREAM   bs,
-                                           UINT                   ascStartAnchor )
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-
-  self->m_frameLengthFlag = FDKreadBits(bs,1);
-
-  self->m_dependsOnCoreCoder = FDKreadBits(bs,1);
-
-  if( self->m_dependsOnCoreCoder )
-    self->m_coreCoderDelay = FDKreadBits(bs,14);
-
-  self->m_extensionFlag = FDKreadBits(bs,1);
-
-  if( asc->m_channelConfiguration == 0 ) {
-    CProgramConfig_Read(&asc->m_progrConfigElement, bs, ascStartAnchor);
-  }
-
-  if ((asc->m_aot == AOT_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_SCAL)) {
-    self->m_layer = FDKreadBits(bs,3);
-  }
-
-  if (self->m_extensionFlag) {
-    if (asc->m_aot == AOT_ER_BSAC) {
-      self->m_numOfSubFrame = FDKreadBits(bs,5);
-      self->m_layerLength   = FDKreadBits(bs,11);
-    }
-
-    if ((asc->m_aot == AOT_ER_AAC_LC)   || (asc->m_aot == AOT_ER_AAC_LTP)  ||
-        (asc->m_aot == AOT_ER_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_LD))
-    {
-      asc->m_vcb11Flag = FDKreadBits(bs,1); /* aacSectionDataResilienceFlag */
-      asc->m_rvlcFlag  = FDKreadBits(bs,1); /* aacScalefactorDataResilienceFlag */
-      asc->m_hcrFlag   = FDKreadBits(bs,1); /* aacSpectralDataResilienceFlag */
-    }
-
-    self->m_extensionFlag3 = FDKreadBits(bs,1);
-
-  }
-  return (ErrorStatus);
-}
-#endif /* TP_GA_ENABLE */
-
-
-
-
-
-#ifdef TP_ELD_ENABLE
-
-static INT ld_sbr_header( const CSAudioSpecificConfig *asc,
-                           HANDLE_FDK_BITSTREAM hBs, 
-                           CSTpCallBacks *cb )
-{
-  const int channelConfiguration = asc->m_channelConfiguration;
-  int i = 0;
-  INT error = 0;
-
-  if (channelConfiguration == 2) {
-    error = cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_CPE, i++);
-  } else {
-    error = cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_SCE, i++);
-  }
-
-  switch ( channelConfiguration ) {
-    case 7:
-      error |= cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_CPE, i++);
-    case 6:
-    case 5:
-      error |= cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_CPE, i++);
-    case 3:
-      error |= cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_CPE, i++);
-      break;
-
-    case 4:
-      error |= cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_CPE, i++);
-      error |= cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency, asc->m_extensionSamplingFrequency, asc->m_samplesPerFrame, AOT_ER_AAC_ELD, ID_SCE, i++);
-      break;
-  }
-
-  return error;
-}
-
-static
-TRANSPORTDEC_ERROR EldSpecificConfig_Parse(
-        CSAudioSpecificConfig *asc,
-        HANDLE_FDK_BITSTREAM hBs,
-        CSTpCallBacks *cb
-        )
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-  CSEldSpecificConfig *esc = &asc->m_sc.m_eldSpecificConfig;
-  ASC_ELD_EXT_TYPE eldExtType;
-  int eldExtLen, len, cnt;
-
-  FDKmemclear(esc, sizeof(CSEldSpecificConfig));
-
-  esc->m_frameLengthFlag = FDKreadBits(hBs, 1 );
-  if (esc->m_frameLengthFlag) {
-    asc->m_samplesPerFrame = 480;
-  } else {
-    asc->m_samplesPerFrame = 512;
-  }
-
-  asc->m_vcb11Flag = FDKreadBits(hBs, 1 );
-  asc->m_rvlcFlag  = FDKreadBits(hBs, 1 );
-  asc->m_hcrFlag   = FDKreadBits(hBs, 1 );
-
-  esc->m_sbrPresentFlag     = FDKreadBits(hBs, 1 );
-
-  if (esc->m_sbrPresentFlag == 1) {
-    esc->m_sbrSamplingRate    = FDKreadBits(hBs, 1 ); /* 0: single rate, 1: dual rate */
-    esc->m_sbrCrcFlag         = FDKreadBits(hBs, 1 );
-
-    asc->m_extensionSamplingFrequency = asc->m_samplingFrequency << esc->m_sbrSamplingRate;
-
-    if (cb->cbSbr != NULL){
-      if ( 0 != ld_sbr_header(asc, hBs, cb) ) {
-        return TRANSPORTDEC_PARSE_ERROR;
-      }
-    }
-  }
-  esc->m_useLdQmfTimeAlign = 0;
-
-  /* new ELD syntax */
-  /* parse ExtTypeConfigData */
-  while ((eldExtType = (ASC_ELD_EXT_TYPE)FDKreadBits(hBs, 4 )) != ELDEXT_TERM) {
-    eldExtLen = len = FDKreadBits(hBs, 4 );
-    if ( len == 0xf ) {
-      len = FDKreadBits(hBs, 8 );
-      eldExtLen += len;
-
-      if ( len == 0xff ) {
-        len = FDKreadBits(hBs, 16 );
-        eldExtLen += len;
-      }
-    }
-
-    switch (eldExtType) {
-      case ELDEXT_LDSAC:
-        esc->m_useLdQmfTimeAlign = 1;
-        if (cb->cbSsc != NULL) {
-          ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbSsc(
-                  cb->cbSscData,
-                  hBs,
-                  asc->m_aot,
-                  asc->m_samplingFrequency,
-                  1,  /* muxMode */
-                  len
-                  );
-        } else {
-          ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
-        }
-        if (ErrorStatus != TRANSPORTDEC_OK) {
-          goto bail;
-        }
-        break;
-      default:
-        for(cnt=0; cnt<len; cnt++) {
-          FDKreadBits(hBs, 8 );
-        }
-        break;
-      /* add future eld extension configs here */
-    }
-  }
-bail:
-  return (ErrorStatus);
-}
-#endif /* TP_ELD_ENABLE */
-
-
-static
-TRANSPORTDEC_ERROR AudioSpecificConfig_ExtensionParse(CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs, CSTpCallBacks *cb)
-{
-  TP_ASC_EXTENSION_ID  lastAscExt, ascExtId = ASCEXT_UNKOWN;
-  INT  bitsAvailable = (INT)FDKgetValidBits(bs);
-
-  while (bitsAvailable >= 11)
-  {
-    lastAscExt = ascExtId;
-    ascExtId   = (TP_ASC_EXTENSION_ID)FDKreadBits(bs, 11);
-    bitsAvailable -= 11;
-
-    switch (ascExtId) {
-    case ASCEXT_SBR:    /* 0x2b7 */
-      if ( (self->m_extensionAudioObjectType != AOT_SBR) && (bitsAvailable >= 5) ) {
-        self->m_extensionAudioObjectType = getAOT(bs);
-
-        if ( (self->m_extensionAudioObjectType == AOT_SBR)
-          || (self->m_extensionAudioObjectType == AOT_ER_BSAC) )
-        { /* Get SBR extension configuration */
-          self->m_sbrPresentFlag = FDKreadBits(bs, 1);
-          bitsAvailable -= 1;
-
-          if ( self->m_sbrPresentFlag == 1 ) {
-            self->m_extensionSamplingFrequency = getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
-
-            if ((INT)self->m_extensionSamplingFrequency <= 0) {
-              return TRANSPORTDEC_PARSE_ERROR;
-            }
-          }
-          if ( self->m_extensionAudioObjectType == AOT_ER_BSAC ) {
-            self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
-            bitsAvailable -= 4;
-          }
-        }
-        /* Update counter because of variable length fields (AOT and sampling rate) */
-        bitsAvailable = (INT)FDKgetValidBits(bs);
-      }
-      break;
-    case ASCEXT_PS:     /* 0x548 */
-      if ( (lastAscExt == ASCEXT_SBR)
-        && (self->m_extensionAudioObjectType == AOT_SBR)
-        && (bitsAvailable > 0) )
-      { /* Get PS extension configuration */
-        self->m_psPresentFlag = FDKreadBits(bs, 1);
-        bitsAvailable -= 1;
-      }
-      break;
-    default:
-      /* Just ignore anything. */
-      return TRANSPORTDEC_OK;
-    }
-  }
-
-  return TRANSPORTDEC_OK;
-}
-
-/*
- * API Functions
- */
-
-void AudioSpecificConfig_Init(CSAudioSpecificConfig *asc)
-{
-  FDKmemclear(asc, sizeof(CSAudioSpecificConfig));
-
-  /* Init all values that should not be zero. */
-  asc->m_aot                    = AOT_NONE;
-  asc->m_samplingFrequencyIndex = 0xf;
-  asc->m_epConfig               = -1;
-  asc->m_extensionAudioObjectType        = AOT_NULL_OBJECT;
-#ifdef TP_PCE_ENABLE
-  CProgramConfig_Init(&asc->m_progrConfigElement);
-#endif
-}
-
-TRANSPORTDEC_ERROR AudioSpecificConfig_Parse(
-        CSAudioSpecificConfig *self,
-        HANDLE_FDK_BITSTREAM   bs,
-        int                    fExplicitBackwardCompatible,
-        CSTpCallBacks      *cb
-        )
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-  UINT ascStartAnchor = FDKgetValidBits(bs);
-  int frameLengthFlag = -1;
-
-  AudioSpecificConfig_Init(self);
-
-  self->m_aot = getAOT(bs);
-  self->m_samplingFrequency = getSampleRate(bs, &self->m_samplingFrequencyIndex, 4);
-  if (self->m_samplingFrequency <= 0) {
-    return TRANSPORTDEC_PARSE_ERROR;
-  }
-
-  self->m_channelConfiguration = FDKreadBits(bs,4);
-
-  /* SBR extension ( explicit non-backwards compatible mode ) */
-  self->m_sbrPresentFlag = 0;
-  self->m_psPresentFlag  = 0;
-
-  if ( self->m_aot == AOT_SBR || self->m_aot == AOT_PS ) {
-    self->m_extensionAudioObjectType = AOT_SBR;
-
-    self->m_sbrPresentFlag = 1;
-    if ( self->m_aot == AOT_PS ) {
-      self->m_psPresentFlag = 1;
-    }
-
-    self->m_extensionSamplingFrequency = getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
-    self->m_aot = getAOT(bs);
-
-  } else {
-    self->m_extensionAudioObjectType = AOT_NULL_OBJECT;
-  }
-
-  /* Parse whatever specific configs */
-  switch (self->m_aot)
-  {
-#ifdef TP_GA_ENABLE
-    case AOT_AAC_LC:
-    case AOT_ER_AAC_LC:
-    case AOT_ER_AAC_LD:
-    case AOT_ER_AAC_SCAL:
-    case AOT_ER_BSAC:
-      if ((ErrorStatus = GaSpecificConfig_Parse(&self->m_sc.m_gaSpecificConfig, self, bs, ascStartAnchor)) != TRANSPORTDEC_OK ) {
-        return (ErrorStatus);
-      }
-      frameLengthFlag = self->m_sc.m_gaSpecificConfig.m_frameLengthFlag;
-      break;
-#endif /* TP_GA_ENABLE */
-    case AOT_MPEGS:
-      if (cb->cbSsc != NULL) {
-        cb->cbSsc(
-                cb->cbSscData,
-                bs,
-                self->m_aot,
-                self->m_samplingFrequency,
-                1,
-                0  /* don't know the length */
-                );
-      } else {
-        return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-      }
-      break;
-#ifdef TP_ELD_ENABLE
-    case AOT_ER_AAC_ELD:
-      if ((ErrorStatus = EldSpecificConfig_Parse(self, bs, cb)) != TRANSPORTDEC_OK ) {
-        return (ErrorStatus);
-      }
-      frameLengthFlag = self->m_sc.m_eldSpecificConfig.m_frameLengthFlag;
-      self->m_sbrPresentFlag = self->m_sc.m_eldSpecificConfig.m_sbrPresentFlag;
-      self->m_extensionSamplingFrequency = (self->m_sc.m_eldSpecificConfig.m_sbrSamplingRate+1) * self->m_samplingFrequency;
-      break;
-#endif /* TP_ELD_ENABLE */
-
-    default:
-      return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-      break;
-  }
-
-  /* Frame length */
-  switch (self->m_aot)
-  {
-#if defined(TP_GA_ENABLE) || defined(TP_USAC_ENABLE)
-    case AOT_AAC_LC:
-    case AOT_ER_AAC_LC:
-    case AOT_ER_AAC_SCAL:
-    case AOT_ER_BSAC:
-    /*case AOT_USAC:*/
-      if (!frameLengthFlag)
-        self->m_samplesPerFrame = 1024;
-      else
-        self->m_samplesPerFrame = 960;
-      break;
-#endif /* TP_GA_ENABLE */
-#if defined(TP_GA_ENABLE)
-    case AOT_ER_AAC_LD:
-      if (!frameLengthFlag)
-        self->m_samplesPerFrame = 512;
-      else
-        self->m_samplesPerFrame = 480;
-      break;
-#endif /* defined(TP_GA_ENABLE) */
-    default:
-      break;
-  }
-
-  switch (self->m_aot)
-  {
-    case AOT_ER_AAC_LC:
-    case AOT_ER_AAC_LD:
-    case AOT_ER_AAC_ELD:
-    case AOT_ER_AAC_SCAL:
-    case AOT_ER_CELP:
-    case AOT_ER_HVXC:
-    case AOT_ER_BSAC:
-      self->m_epConfig = FDKreadBits(bs,2);
-
-      if (self->m_epConfig > 1) {
-        return TRANSPORTDEC_UNSUPPORTED_FORMAT; // EPCONFIG;
-      }
-      break;
-    default:
-      break;
-  }
-
-  if (fExplicitBackwardCompatible) {
-    ErrorStatus = AudioSpecificConfig_ExtensionParse(self, bs, cb);
-  }
-
-  return (ErrorStatus);
-}
-
-
diff --git a/libMpegTPDec/src/tpdec_latm.cpp b/libMpegTPDec/src/tpdec_latm.cpp
deleted file mode 100644
index 5710d77..0000000
--- a/libMpegTPDec/src/tpdec_latm.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Daniel Homm
-   Description:
-
-******************************************************************************/
-
-#include "tpdec_latm.h"
-
-
-#include "FDK_bitstream.h"
-
-
-#define TPDEC_TRACKINDEX(p,l) (2*(p) + (l))
-
-static
-UINT CLatmDemux_GetValue(HANDLE_FDK_BITSTREAM bs)
-{
-  UCHAR bytesForValue = 0, tmp = 0;
-  int value = 0;
-
-  bytesForValue = (UCHAR) FDKreadBits(bs,2);
-
-  for (UINT i=0; i<=bytesForValue; i++) {
-    value <<= 8;
-    tmp = (UCHAR) FDKreadBits(bs,8);
-    value += tmp;
-  }
-
-  return value;
-}
-
-
-static
-TRANSPORTDEC_ERROR CLatmDemux_ReadAudioMuxElement(
-        HANDLE_FDK_BITSTREAM bs,
-        CLatmDemux *pLatmDemux,
-        int m_muxConfigPresent,
-        CSTpCallBacks *pTpDecCallbacks,
-        CSAudioSpecificConfig *pAsc,
-        int *pfConfigFound
-        )
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-
-  if (m_muxConfigPresent) {
-    pLatmDemux->m_useSameStreamMux = FDKreadBits(bs,1);
-
-    if (!pLatmDemux->m_useSameStreamMux) {
-      if ((ErrorStatus = CLatmDemux_ReadStreamMuxConfig(bs, pLatmDemux, pTpDecCallbacks, pAsc, pfConfigFound))) {
-        return (ErrorStatus);
-      }
-    }
-  }
-
-  /* If there was no configuration read, its not possible to parse PayloadLengthInfo below. */
-  if (! *pfConfigFound) {
-    return TRANSPORTDEC_SYNC_ERROR;
-  }
-
-  if (pLatmDemux->m_AudioMuxVersionA == 0) {
-    /* Do only once per call, because parsing and decoding is done in-line. */
-    if ((ErrorStatus = CLatmDemux_ReadPayloadLengthInfo(bs,pLatmDemux))) {
-      return (ErrorStatus);
-    }
-  } else {
-    /* audioMuxVersionA > 0 is reserved for future extensions */
-    ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
-  }
-
-  return (ErrorStatus);
-}
-
-TRANSPORTDEC_ERROR CLatmDemux_Read(
-        HANDLE_FDK_BITSTREAM bs,
-        CLatmDemux *pLatmDemux,
-        TRANSPORT_TYPE tt,
-        CSTpCallBacks *pTpDecCallbacks,
-        CSAudioSpecificConfig *pAsc,
-        int *pfConfigFound,
-        const INT ignoreBufferFullness
-        )
-{
-  UINT cntBits;
-  UINT cmpBufferFullness;
-  UINT audioMuxLengthBytesLast = 0;
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-
-  cntBits = FDKgetValidBits(bs);
-
-  if ((INT)cntBits < MIN_LATM_HEADERLENGTH) {
-    return TRANSPORTDEC_NOT_ENOUGH_BITS;
-  }
-
-  if ((ErrorStatus = CLatmDemux_ReadAudioMuxElement(bs, pLatmDemux, (tt != TT_MP4_LATM_MCP0), pTpDecCallbacks, pAsc, pfConfigFound)))
-    return (ErrorStatus);
-
-  if (!ignoreBufferFullness)
-  {
-    cmpBufferFullness =   24+audioMuxLengthBytesLast*8
-                        + pLatmDemux->m_linfo[0][0].m_bufferFullness* pAsc[TPDEC_TRACKINDEX(0,0)].m_channelConfiguration*32;
-
-    /* evaluate buffer fullness */
-
-    if (pLatmDemux->m_linfo[0][0].m_bufferFullness != 0xFF)
-    {
-      if (!pLatmDemux->BufferFullnessAchieved)
-      {
-        if (cntBits < cmpBufferFullness)
-        {
-          /* condition for start of decoding is not fulfilled */
-
-          /* the current frame will not be decoded */
-          return TRANSPORTDEC_NOT_ENOUGH_BITS;
-        }
-        else
-        {
-          pLatmDemux->BufferFullnessAchieved = 1;
-        }
-      }
-    }
-  }
-
-  return (ErrorStatus);
-}
-
-
-TRANSPORTDEC_ERROR CLatmDemux_ReadStreamMuxConfig(
-        HANDLE_FDK_BITSTREAM bs,
-        CLatmDemux *pLatmDemux,
-        CSTpCallBacks *pTpDecCallbacks,
-        CSAudioSpecificConfig *pAsc,
-        int * pfConfigFound
-        )
-{
-  LATM_LAYER_INFO *p_linfo = NULL;
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-
-  pLatmDemux->m_AudioMuxVersion = FDKreadBits(bs,1);
-
-  if (pLatmDemux->m_AudioMuxVersion == 0) {
-    pLatmDemux->m_AudioMuxVersionA = 0;
-  } else {
-    pLatmDemux->m_AudioMuxVersionA = FDKreadBits(bs,1);
-  }
-
-  if (pLatmDemux->m_AudioMuxVersionA == 0) {
-    if (pLatmDemux->m_AudioMuxVersion == 1) {
-      pLatmDemux->m_taraBufferFullness = CLatmDemux_GetValue(bs);
-    }
-    pLatmDemux->m_allStreamsSameTimeFraming = FDKreadBits(bs,1);
-    pLatmDemux->m_noSubFrames = FDKreadBits(bs,6) + 1;
-    pLatmDemux->m_numProgram  = FDKreadBits(bs,4) + 1;
-
-    if (pLatmDemux->m_numProgram > 1) {
-      return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-    }
-
-    int idCnt = 0;
-    for (UINT prog = 0; prog < pLatmDemux->m_numProgram; prog++) {
-      pLatmDemux->m_numLayer = FDKreadBits(bs,3) + 1;
-      if (pLatmDemux->m_numLayer > 2) {
-        return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-      }
-
-      for (UINT lay = 0; lay < pLatmDemux->m_numLayer; lay++) {
-        p_linfo = &pLatmDemux->m_linfo[prog][lay];
-
-        p_linfo->m_streamID = idCnt++;
-        p_linfo->m_frameLengthInBits = 0;
-
-        if( (prog == 0) && (lay == 0) ) {
-          pLatmDemux->m_useSameConfig = 0;
-        } else {
-          pLatmDemux->m_useSameConfig = FDKreadBits(bs,1);
-        }
-
-        if (pLatmDemux->m_useSameConfig) {
-          if (lay > 1) {
-            FDKmemcpy(&pAsc[TPDEC_TRACKINDEX(prog,lay)], &pAsc[TPDEC_TRACKINDEX(prog,lay-1)], sizeof(CSAudioSpecificConfig));
-          } else {
-            return TRANSPORTDEC_PARSE_ERROR;
-          }
-        } else {
-          if (pLatmDemux->m_AudioMuxVersion == 1)
-          {
-            FDK_BITSTREAM tmpBs;
-            UINT ascStartPos, ascLen=0;
-
-            ascLen = CLatmDemux_GetValue(bs);
-            ascStartPos = FDKgetValidBits(bs);
-            tmpBs = *bs;
-            FDKsyncCache(&tmpBs);
-            tmpBs.hBitBuf.ValidBits = ascLen;
-            
-            /* Read ASC */
-            if ((ErrorStatus = AudioSpecificConfig_Parse(&pAsc[TPDEC_TRACKINDEX(prog,lay)], &tmpBs, 1, pTpDecCallbacks))) {
-              return (ErrorStatus);
-            }
-            *pfConfigFound = 1;
-
-            /* The field p_linfo->m_ascLen could be wrong, so check if */
-            if ( 0 > (INT)FDKgetValidBits(&tmpBs)) {
-              return TRANSPORTDEC_PARSE_ERROR;
-            }
-            FDKpushFor(bs, ascLen); /* position bitstream after ASC */
-          }
-          else {
-            /* Read ASC */
-            if ((ErrorStatus = AudioSpecificConfig_Parse(&pAsc[TPDEC_TRACKINDEX(prog,lay)], bs, 0, pTpDecCallbacks))) {
-              return (ErrorStatus);
-            }
-          }
-          {
-            int cbError;
-
-            cbError = pTpDecCallbacks->cbUpdateConfig(pTpDecCallbacks->cbUpdateConfigData, &pAsc[TPDEC_TRACKINDEX(prog,lay)]);
-            if (cbError != 0) {
-              return TRANSPORTDEC_UNKOWN_ERROR;
-            }
-            *pfConfigFound = 1;
-          }
-        }
-
-        p_linfo->m_frameLengthType = FDKreadBits(bs,3);
-        switch( p_linfo->m_frameLengthType ) {
-        case 0:
-          p_linfo->m_bufferFullness = FDKreadBits(bs,8);
-
-          if (!pLatmDemux->m_allStreamsSameTimeFraming) {
-            if ((lay > 0) && (pAsc[TPDEC_TRACKINDEX(prog,lay)].m_aot == AOT_AAC_SCAL || pAsc[TPDEC_TRACKINDEX(prog,lay)].m_aot == AOT_ER_AAC_SCAL)) {
-              return TRANSPORTDEC_UNSUPPORTED_FORMAT;
-            }
-          }
-          break;
-        case 1:
-          /* frameLength = FDKreadBits(bs,9); */
-        case 3:
-        case 4:
-        case 5:
-          /* CELP */
-        case 6:
-        case 7:
-          /* HVXC */
-        default:
-          return TRANSPORTDEC_PARSE_ERROR; //_LATM_INVALIDFRAMELENGTHTYPE;
-
-        }  /* switch framelengthtype*/
-
-      }  /* layer loop */
-    }  /* prog loop */
-
-    pLatmDemux->m_otherDataPresent = FDKreadBits(bs,1);
-    pLatmDemux->m_otherDataLength  = 0;
-
-    if (pLatmDemux->m_otherDataPresent) {
-      int otherDataLenEsc  = 0;
-      do {
-        pLatmDemux->m_otherDataLength <<= 8;   // *= 256
-        otherDataLenEsc = FDKreadBits(bs,1);
-        pLatmDemux->m_otherDataLength += FDKreadBits(bs,8);
-      } while (otherDataLenEsc);
-    }
-
-    pLatmDemux->m_crcCheckPresent = FDKreadBits(bs,1);
-    pLatmDemux->m_crcCheckSum     = 0;
-
-    if (pLatmDemux->m_crcCheckPresent) {
-      pLatmDemux->m_crcCheckSum = FDKreadBits(bs,8);
-    }
-
-  }
-  else {
-    /* audioMuxVersionA > 0 is reserved for future extensions */
-    ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
-  }
-  return (ErrorStatus);
-}
-
-TRANSPORTDEC_ERROR CLatmDemux_ReadPayloadLengthInfo(HANDLE_FDK_BITSTREAM bs, CLatmDemux *pLatmDemux)
-{
-  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
-  int totalPayloadBits = 0;
-
-  if( pLatmDemux->m_allStreamsSameTimeFraming == 1 ) {
-    for (UINT prog=0; prog<pLatmDemux->m_numProgram; prog++ ) {
-      for (UINT lay=0; lay<pLatmDemux->m_numLayer; lay++ ) {
-        LATM_LAYER_INFO *p_linfo = &pLatmDemux->m_linfo[prog][lay];
-
-        switch (p_linfo->m_frameLengthType ) {
-        case 0:
-          p_linfo->m_frameLengthInBits = CLatmDemux_ReadAuChunkLengthInfo(bs);
-          totalPayloadBits += p_linfo->m_frameLengthInBits;
-          break;
-        case 3:
-        case 5:
-        case 7:
-        default:
-          return TRANSPORTDEC_PARSE_ERROR; //AAC_DEC_LATM_INVALIDFRAMELENGTHTYPE;
-        }
-      }
-    }
-  }
-  else {
-    ErrorStatus = TRANSPORTDEC_PARSE_ERROR; //AAC_DEC_LATM_TIMEFRAMING;
-  }
-  if (pLatmDemux->m_audioMuxLengthBytes > (UINT)0 && totalPayloadBits > (int)pLatmDemux->m_audioMuxLengthBytes*8) {
-    return TRANSPORTDEC_PARSE_ERROR;
-  }
-  return (ErrorStatus);
-}
-
-int CLatmDemux_ReadAuChunkLengthInfo(HANDLE_FDK_BITSTREAM bs)
-{
-  UCHAR endFlag;
-  int len = 0;
-
-  do {
-    UCHAR tmp = (UCHAR) FDKreadBits(bs,8);
-    endFlag = (tmp < 255);
-
-    len += tmp;
-
-  } while( endFlag == 0 );
-
-  len <<= 3;  /* convert from bytes to bits */
-
-  return len;
-}
-
-int CLatmDemux_GetFrameLengthInBits(CLatmDemux *pLatmDemux)
-{
-  return pLatmDemux->m_linfo[0][0].m_frameLengthInBits;
-}
-
-int CLatmDemux_GetOtherDataPresentFlag(CLatmDemux *pLatmDemux)
-{
-  return pLatmDemux->m_otherDataPresent ? 1 : 0;
-}
-
-int CLatmDemux_GetOtherDataLength(CLatmDemux *pLatmDemux)
-{
-  return pLatmDemux->m_otherDataLength;
-}
-
-UINT CLatmDemux_GetNrOfSubFrames(CLatmDemux *pLatmDemux)
-{
-  return pLatmDemux->m_noSubFrames;
-}
-
diff --git a/libMpegTPDec/src/tpdec_latm.h b/libMpegTPDec/src/tpdec_latm.h
deleted file mode 100644
index 6dc13e8..0000000
--- a/libMpegTPDec/src/tpdec_latm.h
+++ /dev/null
@@ -1,176 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Daniel Homm
-   Description:
-
-******************************************************************************/
-
-#ifndef LATM_DEMUX_H
-#define LATM_DEMUX_H
-
-#include "tpdec_lib.h"
-
-
-#include "FDK_bitstream.h"
-
-#define MIN_LATM_HEADERLENGTH  9
-#define MIN_LOAS_HEADERLENGTH  MIN_LATM_HEADERLENGTH + 24   /* both in bits */
- #define MIN_TP_BUF_SIZE_LOAS   ( 8194 )
-
-enum {
-  LATM_MAX_PROG = 1,
-  LATM_MAX_LAYER = 2,
-  LATM_MAX_VAR_CHUNKS=16,
-  LATM_MAX_ID=16
-};
-
-typedef struct {
-  UINT m_frameLengthType;
-  UINT m_bufferFullness;
-  UINT m_streamID;
-  UINT m_frameLengthInBits;
-} LATM_LAYER_INFO;
-
-typedef struct {
-  LATM_LAYER_INFO m_linfo[LATM_MAX_PROG][LATM_MAX_LAYER];
-  UINT m_taraBufferFullness;
-  UINT m_otherDataLength;
-  UINT m_audioMuxLengthBytes;          /* Length of LOAS payload */
-
-  UCHAR m_useSameStreamMux;
-  UCHAR m_AudioMuxVersion;
-  UCHAR m_AudioMuxVersionA;
-  UCHAR m_allStreamsSameTimeFraming;
-  UCHAR m_noSubFrames;
-  UCHAR m_numProgram;
-  UCHAR m_numLayer;
-  UCHAR m_useSameConfig;
-
-  UCHAR m_otherDataPresent;
-  UCHAR m_crcCheckPresent;
-  UCHAR m_crcCheckSum;
-
-  SCHAR BufferFullnessAchieved;
-} CLatmDemux;
-
-int CLatmDemux_ReadAuChunkLengthInfo(HANDLE_FDK_BITSTREAM bs);
-
-TRANSPORTDEC_ERROR CLatmDemux_Read(
-        HANDLE_FDK_BITSTREAM bs,
-        CLatmDemux *pLatmDemux,
-        TRANSPORT_TYPE tt,
-        CSTpCallBacks *pTpDecCallbacks,
-        CSAudioSpecificConfig *pAsc,
-        int *pfConfigFound,
-        const INT ignoreBufferFullness
-        );
-
-/**
- * \brief Read StreamMuxConfig
- * \param bs bit stream handle as data source
- * \param pLatmDemux pointer to CLatmDemux struct of current LATM context
- * \param pTpDecCallbacks Call back structure for configuration callbacks
- * \param pAsc pointer to a ASC for configuration storage
- * \param pfConfigFound pointer to a flag which is set to 1 if a configuration was found and processed successfully
- * \return error code
- */
-TRANSPORTDEC_ERROR CLatmDemux_ReadStreamMuxConfig(
-        HANDLE_FDK_BITSTREAM bs,
-        CLatmDemux *pLatmDemux,
-        CSTpCallBacks *pTpDecCallbacks,
-        CSAudioSpecificConfig *pAsc,
-        int * pfConfigFound
-        );
-
-TRANSPORTDEC_ERROR CLatmDemux_ReadPayloadLengthInfo(HANDLE_FDK_BITSTREAM bs, CLatmDemux *pLatmDemux);
-
-int  CLatmDemux_GetFrameLengthInBits(CLatmDemux *pLatmDemux);
-int  CLatmDemux_GetOtherDataPresentFlag(CLatmDemux *pLatmDemux);
-int  CLatmDemux_GetOtherDataLength(CLatmDemux *pLatmDemux);
-UINT CLatmDemux_GetNrOfSubFrames(CLatmDemux *pLatmDemux);
-
-
-#endif /* LATM_DEMUX_H */
diff --git a/libMpegTPDec/src/tpdec_lib.cpp b/libMpegTPDec/src/tpdec_lib.cpp
deleted file mode 100644
index 1f9f29b..0000000
--- a/libMpegTPDec/src/tpdec_lib.cpp
+++ /dev/null
@@ -1,1323 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/**************************  MPEG-4 Transport Decoder  ************************
-
-   Author(s): Manuel Jander
-   Description: MPEG Transport decoder
-
-******************************************************************************/
-
-#include "tpdec_lib.h"
-
-/* library version */
-#include "version"
-
-
-#include "tp_data.h"
-
-#include "tpdec_adts.h"
-
-#include "tpdec_adif.h"
-
-#include "tpdec_latm.h"
-
-
-
-#define MODULE_NAME "transportDec"
-
-typedef union {
-  STRUCT_ADTS adts;
-
-  CAdifHeader adif;
-
-  CLatmDemux latm;
-
-
-} transportdec_parser_t;
-
-struct TRANSPORTDEC
-{
-  TRANSPORT_TYPE transportFmt;     /*!< MPEG4 transportDec type. */
-
-  CSTpCallBacks callbacks;         /*!< Struct holding callback and its data */
-
-  FDK_BITSTREAM bitStream[2]; /* Bitstream reader */
-  UCHAR *bsBuffer;                 /* Internal bitstreamd data buffer (unallocated in case of TT_MP4_RAWPACKETS) */
-
-  transportdec_parser_t parser;    /* Format specific parser structs. */
-
-  CSAudioSpecificConfig asc[(1*2)]; /* Audio specific config from the last config found. */
-  UINT  globalFramePos;            /* Global transport frame reference bit position. */
-  UINT  accessUnitAnchor[2];    /* Current access unit start bit position. */
-  INT   auLength[2];            /* Length of current access unit. */
-  INT   numberOfRawDataBlocks;     /* Current number of raw data blocks contained remaining from the current transport frame. */
-  UINT  avgBitRate;                /* Average bit rate used for frame loss estimation. */
-  UINT  lastValidBufferFullness;   /* Last valid buffer fullness value for frame loss estimation */
-  INT   remainder;                 /* Reminder in division during lost access unit estimation. */
-  INT   missingAccessUnits;        /* Estimated missing access units. */
-  UINT  burstPeriod;               /* Data burst period in mili seconds. */
-  UINT  holdOffFrames;             /* Amount of frames that were already hold off due to buffer fullness condition not being met. */
-  UINT  flags;                     /* Flags. */
-};
-
-/* Flag bitmasks for "flags" member of struct TRANSPORTDEC */
-#define TPDEC_SYNCOK                1
-#define TPDEC_MINIMIZE_DELAY        2
-#define TPDEC_IGNORE_BUFFERFULLNESS 4
-#define TPDEC_EARLY_CONFIG          8
-#define TPDEC_LOST_FRAMES_PENDING  16
-#define TPDEC_CONFIG_FOUND         32
-
-C_ALLOC_MEM(Ram_TransportDecoder, TRANSPORTDEC, 1)
-C_ALLOC_MEM(Ram_TransportDecoderBuffer, UCHAR, TRANSPORTDEC_INBUF_SIZE)
-
-
-
-
-HANDLE_TRANSPORTDEC transportDec_Open( const TRANSPORT_TYPE transportFmt, const UINT flags)
-{
-  HANDLE_TRANSPORTDEC hInput;
-
-  hInput = GetRam_TransportDecoder(0);
-  if ( hInput == NULL ) {
-    return NULL;
-  }
-
-  /* Init transportDec struct. */
-  hInput->transportFmt = transportFmt;
-
-  switch (transportFmt) {
-
-  case TT_MP4_ADIF:
-    break;
-
-  case TT_MP4_ADTS:
-    if (flags & TP_FLAG_MPEG4)
-      hInput->parser.adts.decoderCanDoMpeg4 = 1;
-    else
-      hInput->parser.adts.decoderCanDoMpeg4 = 0;
-    adtsRead_CrcInit(&hInput->parser.adts);
-    hInput->parser.adts.BufferFullnesStartFlag = 1;
-    hInput->numberOfRawDataBlocks = 0;
-    break;
-
-
-  case TT_MP4_LATM_MCP0:
-  case TT_MP4_LATM_MCP1:
-  case TT_MP4_LOAS:
-  case TT_MP4_RAW:
-    break;
-
-  default:
-    FreeRam_TransportDecoder(&hInput);
-    hInput = NULL;
-    break;
-  }
-
-  if (hInput != NULL) {
-    /* Create bitstream */
-    if ( TT_IS_PACKET(transportFmt) ) {
-      hInput->bsBuffer = NULL;
-    } else {
-      hInput->bsBuffer = GetRam_TransportDecoderBuffer(0);
-      if (hInput->bsBuffer == NULL) {
-          transportDec_Close( &hInput );
-          return NULL;
-      }
-      FDKinitBitStream(&hInput->bitStream[0], hInput->bsBuffer, TRANSPORTDEC_INBUF_SIZE, 0, BS_READER);
-    }
-
-    hInput->burstPeriod = 0;
-  }
-
-  return hInput;
-}
-
-TRANSPORTDEC_ERROR transportDec_OutOfBandConfig(HANDLE_TRANSPORTDEC hTp, UCHAR *conf, const UINT length, UINT layer )
-{
-  TRANSPORTDEC_ERROR     err        = TRANSPORTDEC_OK;
-
-  FDK_BITSTREAM bs;
-  HANDLE_FDK_BITSTREAM  hBs        = &bs;
-
-  FDKinitBitStream(hBs, conf, 0x10000000, length<<3, BS_READER);
-
-  int fConfigFound = 0;
-
-  /* config transport decoder */
-  switch (hTp->transportFmt) {
-    case TT_MP4_LATM_MCP0:
-    case TT_MP4_LATM_MCP1:
-    case TT_MP4_LOAS:
-      {
-        if (layer != 0) {
-          return TRANSPORTDEC_INVALID_PARAMETER;
-        }
-        CLatmDemux *pLatmDemux = &hTp->parser.latm;
-        err = CLatmDemux_ReadStreamMuxConfig(hBs, pLatmDemux, &hTp->callbacks, hTp->asc, &fConfigFound);
-        if (err != TRANSPORTDEC_OK) {
-          return err;
-        }
-      }
-      break;
-    default:
-      fConfigFound = 1;
-      err = AudioSpecificConfig_Parse(&hTp->asc[layer], hBs, 1, &hTp->callbacks);
-      if (err == TRANSPORTDEC_OK) {
-        int errC;
-
-        errC = hTp->callbacks.cbUpdateConfig(hTp->callbacks.cbUpdateConfigData, &hTp->asc[layer]);
-        if (errC != 0) {
-          err = TRANSPORTDEC_PARSE_ERROR;
-        }
-      }
-      break;
-  }
-
-  if (err == TRANSPORTDEC_OK && fConfigFound) {
-    hTp->flags |= TPDEC_CONFIG_FOUND;
-  }
-
-  return err;
-}
-
-int transportDec_RegisterAscCallback( HANDLE_TRANSPORTDEC hTpDec, const cbUpdateConfig_t cbUpdateConfig, void* user_data)
-{
-  if (hTpDec == NULL) {
-    return -1;
-  }
-  hTpDec->callbacks.cbUpdateConfig = cbUpdateConfig;
-  hTpDec->callbacks.cbUpdateConfigData = user_data;
-  return 0;
-}
-
-int transportDec_RegisterSscCallback( HANDLE_TRANSPORTDEC hTpDec, const cbSsc_t cbSsc, void* user_data)
-{
-  if (hTpDec == NULL) {
-    return -1;
-  }
-  hTpDec->callbacks.cbSsc = cbSsc;
-  hTpDec->callbacks.cbSscData = user_data;
-  return 0;
-}
-
-int transportDec_RegisterSbrCallback( HANDLE_TRANSPORTDEC hTpDec, const cbSbr_t cbSbr, void* user_data)
-{
-  if (hTpDec == NULL) {
-    return -1;
-  }
-  hTpDec->callbacks.cbSbr = cbSbr;
-  hTpDec->callbacks.cbSbrData = user_data;
-  return 0;
-}
-
-TRANSPORTDEC_ERROR transportDec_FillData(
-        const HANDLE_TRANSPORTDEC  hTp,
-        UCHAR                     *pBuffer,
-        const UINT                 bufferSize,
-        UINT                      *pBytesValid,
-        const INT                  layer )
-{
-  HANDLE_FDK_BITSTREAM hBs;
-
-  if ( (hTp == NULL)
-    || (layer >= 2) ) {
-    return TRANSPORTDEC_INVALID_PARAMETER;
-  }
-
-  if (*pBytesValid == 0) {
-    /* nothing to do */
-    return TRANSPORTDEC_OK;
-  }
-
-  /* set bitbuffer shortcut */
-  hBs = &hTp->bitStream[layer];
-
-  if ( TT_IS_PACKET(hTp->transportFmt) ) {
-    if (hTp->numberOfRawDataBlocks == 0) {
-    /* For packet based transport, pass input buffer to bitbuffer without copying the data.
-       Unfortunately we do not know the actual buffer size. And the FDK bit buffer implementation
-       needs a number 2^x. So we assume the maximum of 48 channels with 6144 bits per channel
-       and round it up to the next power of 2 => 65536 bytes */
-    FDKinitBitStream(hBs, pBuffer, 0x10000, (*pBytesValid)<<3, BS_READER);
-    *pBytesValid = 0;
-    }
-  } else {
-    /* ... else feed bitbuffer with new stream data (append). */
-    if (hTp->numberOfRawDataBlocks <= 0) {
-      FDKfeedBuffer (hBs, pBuffer, bufferSize, pBytesValid) ;
-    }
-  }
-
-  return TRANSPORTDEC_OK;
-}
-
-HANDLE_FDK_BITSTREAM transportDec_GetBitstream( const HANDLE_TRANSPORTDEC hTp, const UINT layer )
-{
-  return &hTp->bitStream[layer];
-}
-
-TRANSPORT_TYPE transportDec_GetFormat( const HANDLE_TRANSPORTDEC hTp )
-{
-  return hTp->transportFmt;
-}
-
-INT transportDec_GetBufferFullness( const HANDLE_TRANSPORTDEC hTp )
-{
-  INT bufferFullness = -1;
-
-  switch (hTp->transportFmt) {
-    case TT_MP4_ADTS:
-      if (hTp->parser.adts.bs.adts_fullness != 0x7ff) {
-        bufferFullness = hTp->parser.adts.bs.frame_length*8 + hTp->parser.adts.bs.adts_fullness * 32 * getNumberOfEffectiveChannels(hTp->parser.adts.bs.channel_config);
-      }
-      break;
-    case TT_MP4_LOAS:
-    case TT_MP4_LATM_MCP0:
-    case TT_MP4_LATM_MCP1:
-      if (hTp->parser.latm.m_linfo[0][0].m_bufferFullness != 0xff) {
-        bufferFullness = hTp->parser.latm.m_linfo[0][0].m_bufferFullness;
-      }
-      break;
-    default:
-      break;
-  }
-
-  return bufferFullness;
-}
-
-/**
- * \brief adjust bit stream position and the end of an access unit.
- * \param hTp transport decoder handle.
- * \return error code.
- */
-static
-TRANSPORTDEC_ERROR transportDec_AdjustEndOfAccessUnit(HANDLE_TRANSPORTDEC hTp)
-{
-  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
-  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
-
-  switch (hTp->transportFmt) {
-    case TT_MP4_LOAS:
-    case TT_MP4_LATM_MCP0:
-    case TT_MP4_LATM_MCP1:
-      if ( hTp->numberOfRawDataBlocks == 0 )
-      {
-        /* Do byte align at the end of AudioMuxElement. */
-        FDKbyteAlign(hBs, hTp->globalFramePos);
-
-        /* Check global frame length */
-        if (hTp->transportFmt == TT_MP4_LOAS && hTp->parser.latm.m_audioMuxLengthBytes > 0)
-        {
-          int loasOffset;
-
-          loasOffset = (hTp->parser.latm.m_audioMuxLengthBytes*8 + FDKgetValidBits(hBs)) - hTp->globalFramePos;
-          if (loasOffset != 0) {
-            FDKpushBiDirectional(hBs, loasOffset);
-            /* For ELD and other payloads there is an unknown amount of padding, so ignore unread bits, but
-               throw an error only if too many bits where read. */
-            if (loasOffset < 0) {
-              err = TRANSPORTDEC_PARSE_ERROR;
-            }
-          }
-        }
-      }
-      break;
-
-    case TT_MP4_ADTS:
-      if (hTp->parser.adts.bs.protection_absent == 0)
-      {
-        int offset;
-
-        /* Calculate offset to end of AU */
-        offset  = hTp->parser.adts.rawDataBlockDist[hTp->parser.adts.bs.num_raw_blocks-hTp->numberOfRawDataBlocks]<<3;
-        /* CAUTION: The PCE (if available) is declared to be a part of the header! */
-        offset -= hTp->accessUnitAnchor[0] - FDKgetValidBits(hBs) + 16 + hTp->parser.adts.bs.num_pce_bits;
-        FDKpushBiDirectional(hBs, offset);
-      }
-      if (hTp->parser.adts.bs.num_raw_blocks > 0 && hTp->parser.adts.bs.protection_absent == 0) {
-        /* Note this CRC read currently happens twice because of transportDec_CrcCheck() */
-        hTp->parser.adts.crcReadValue = FDKreadBits(hBs, 16);
-      }
-      if ( hTp->numberOfRawDataBlocks == 0 )
-      {
-        /* Check global frame length */
-        if (hTp->parser.adts.bs.protection_absent == 0)
-        {
-          int offset;
-
-          offset = (hTp->parser.adts.bs.frame_length*8 - ADTS_SYNCLENGTH + FDKgetValidBits(hBs)) - hTp->globalFramePos;
-          if (offset != 0) {
-            FDKpushBiDirectional(hBs, offset);
-          }
-        }
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  return err;
-}
-
-
-/**
- * \brief Determine additional buffer fullness contraint due to burst data reception.
- *        The parameter TPDEC_PARAM_BURSTPERIOD must have been set as a precondition.
- * \param hTp transport decoder handle.
- * \param bufferFullness the buffer fullness value of the first frame to be decoded.
- * \param bitsAvail the amount of available bits at the end of the first frame to be decoded.
- * \return error code
- */
-static 
-TRANSPORTDEC_ERROR additionalHoldOffNeeded(
-        HANDLE_TRANSPORTDEC hTp,
-        INT                 bufferFullness,
-        INT                 bitsAvail
-        )
-{
-  INT checkLengthBits, avgBitsPerFrame;
-  INT maxAU; /* maximum number of frames per Master Frame */
-  INT samplesPerFrame = hTp->asc->m_samplesPerFrame;
-  INT samplingFrequency = (INT)hTp->asc->m_samplingFrequency;
-
-  if ( (hTp->avgBitRate == 0) || (hTp->burstPeriod == 0) ) {
-    return TRANSPORTDEC_OK;
-  }
-  if ( (samplesPerFrame == 0 ) || (samplingFrequency == 0) ) {
-    return TRANSPORTDEC_NOT_ENOUGH_BITS;
-  }
-
-  /* One Master Frame is sent every hTp->burstPeriod ms */
-  maxAU = hTp->burstPeriod * samplingFrequency + (samplesPerFrame*1000 - 1);
-  maxAU = maxAU / (samplesPerFrame*1000);
-  /* Subtract number of frames which were already held off. */
-  maxAU -= hTp->holdOffFrames;
-
-  avgBitsPerFrame = hTp->avgBitRate * samplesPerFrame + (samplingFrequency-1);
-  avgBitsPerFrame = avgBitsPerFrame / samplingFrequency;
-
-  /* Consider worst case of bufferFullness quantization. */
-  switch (hTp->transportFmt) {
-    case TT_MP4_ADIF:
-    case TT_MP4_ADTS:
-    case TT_MP4_LOAS:
-    case TT_MP4_LATM_MCP0:
-    case TT_MP4_LATM_MCP1:
-      bufferFullness += 31;
-      break;
-    default:
-      break;
-  }
-
-  checkLengthBits = bufferFullness + (maxAU-1)*avgBitsPerFrame;
-
-  /* Check if buffer is big enough to fullfill buffer fullness condition */
-  if ( (checkLengthBits /*+headerBits*/) > ((TRANSPORTDEC_INBUF_SIZE<<3)-7) ) {
-    return TRANSPORTDEC_SYNC_ERROR;
-  }
-
-  if ( bitsAvail < checkLengthBits ) {
-    return TRANSPORTDEC_NOT_ENOUGH_BITS;
-  }
-  else {
-    return TRANSPORTDEC_OK;
-  }
-}
-
-static TRANSPORTDEC_ERROR transportDec_readHeader(
-        HANDLE_TRANSPORTDEC hTp,
-        HANDLE_FDK_BITSTREAM hBs,
-        int syncLength,
-        int ignoreBufferFullness,
-        int *pRawDataBlockLength,
-        int *pfTraverseMoreFrames,
-        int *pSyncLayerFrameBits,
-        int *pfConfigFound,
-        int *pHeaderBits
-        )
-{
-  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
-  int rawDataBlockLength = *pRawDataBlockLength;
-  int fTraverseMoreFrames = (pfTraverseMoreFrames != NULL) ? *pfTraverseMoreFrames : 0;
-  int syncLayerFrameBits = (pSyncLayerFrameBits != NULL) ? *pSyncLayerFrameBits : 0;
-  int fConfigFound = (pfConfigFound != NULL) ? *pfConfigFound : 0;
-  int startPos;
-
-  startPos = FDKgetValidBits(hBs);
-
-  switch (hTp->transportFmt) {
-    case TT_MP4_ADTS:
-      if (hTp->numberOfRawDataBlocks <= 0)
-      {
-        int errC;
-
-        hTp->globalFramePos = FDKgetValidBits(hBs);
-
-        /* Parse ADTS header */
-        err = adtsRead_DecodeHeader( &hTp->parser.adts, &hTp->asc[0], hBs, ignoreBufferFullness );
-        if (err != TRANSPORTDEC_OK) {
-          if (err != TRANSPORTDEC_NOT_ENOUGH_BITS) {
-            err = TRANSPORTDEC_SYNC_ERROR;
-          }
-        } else {
-          errC = hTp->callbacks.cbUpdateConfig(hTp->callbacks.cbUpdateConfigData, &hTp->asc[0]);
-          if (errC != 0) {
-            if (errC == TRANSPORTDEC_NEED_TO_RESTART) {
-              err = TRANSPORTDEC_NEED_TO_RESTART;
-              goto bail;
-            } else {
-              err = TRANSPORTDEC_SYNC_ERROR;
-            }
-          } else {
-            fConfigFound = 1;
-            hTp->numberOfRawDataBlocks = hTp->parser.adts.bs.num_raw_blocks+1;
-          }
-        }
-      }
-      else {
-        /* Reset CRC because the next bits are the beginning of a raw_data_block() */
-        FDKcrcReset(&hTp->parser.adts.crcInfo);
-        hTp->parser.adts.bs.num_pce_bits = 0;
-      }
-      if (err == TRANSPORTDEC_OK) {
-        hTp->numberOfRawDataBlocks--;
-        rawDataBlockLength = adtsRead_GetRawDataBlockLength(&hTp->parser.adts, (hTp->parser.adts.bs.num_raw_blocks-hTp->numberOfRawDataBlocks));
-        if (rawDataBlockLength <= 0) {
-          /* No further frame traversal possible. */
-          fTraverseMoreFrames = 0;
-        }
-        syncLayerFrameBits = (hTp->parser.adts.bs.frame_length<<3) - (startPos - FDKgetValidBits(hBs)) - syncLength;
-        if (syncLayerFrameBits <= 0) {
-          err = TRANSPORTDEC_SYNC_ERROR;
-        }
-      } else {
-        hTp->numberOfRawDataBlocks = 0;
-      }
-      break;
-    case TT_MP4_LOAS:
-      if (hTp->numberOfRawDataBlocks <= 0)
-      {
-        syncLayerFrameBits = FDKreadBits(hBs, 13);
-        hTp->parser.latm.m_audioMuxLengthBytes = syncLayerFrameBits;
-        syncLayerFrameBits <<= 3;
-      }
-    case TT_MP4_LATM_MCP1:
-    case TT_MP4_LATM_MCP0:
-      if (hTp->numberOfRawDataBlocks <= 0)
-      {
-        hTp->globalFramePos = FDKgetValidBits(hBs);
-
-        err = CLatmDemux_Read(
-                hBs,
-               &hTp->parser.latm,
-                hTp->transportFmt,
-               &hTp->callbacks,
-                hTp->asc,
-               &fConfigFound,
-                ignoreBufferFullness);
-
-        if (err != TRANSPORTDEC_OK) {
-          if (err != TRANSPORTDEC_NOT_ENOUGH_BITS) {
-            err = TRANSPORTDEC_SYNC_ERROR;
-          }
-        } else {
-          hTp->numberOfRawDataBlocks = CLatmDemux_GetNrOfSubFrames(&hTp->parser.latm);
-          if (hTp->transportFmt == TT_MP4_LOAS) {
-            syncLayerFrameBits -= startPos - FDKgetValidBits(hBs) - (13);            
-          }
-        }
-      } else {
-        err = CLatmDemux_ReadPayloadLengthInfo(hBs, &hTp->parser.latm);
-        if (err != TRANSPORTDEC_OK) {
-          err = TRANSPORTDEC_SYNC_ERROR;
-        }
-      }
-      if (err == TRANSPORTDEC_OK) {
-        rawDataBlockLength = CLatmDemux_GetFrameLengthInBits(&hTp->parser.latm);
-        hTp->numberOfRawDataBlocks--;
-      } else {
-        hTp->numberOfRawDataBlocks = 0;
-      }
-      break;
-    default:
-      {
-        syncLayerFrameBits = 0;
-      }
-      break;
-  }
-
-bail:
-
-  *pRawDataBlockLength = rawDataBlockLength;
-
-  if (pHeaderBits != NULL) {
-    *pHeaderBits += startPos - (INT)FDKgetValidBits(hBs);
-  }
-  if (pfConfigFound != NULL) {
-    *pfConfigFound = fConfigFound;
-  }
-
-  if (pfTraverseMoreFrames != NULL) {
-    *pfTraverseMoreFrames = fTraverseMoreFrames;
-  }
-  if  (pSyncLayerFrameBits != NULL) {
-    *pSyncLayerFrameBits = syncLayerFrameBits;
-  }
-  if (pfConfigFound != NULL) {
-    *pfConfigFound = fConfigFound;
-  }
-
-  return err;
-}
-
-/* How many bits to advance for synchronization search. */
-#define TPDEC_SYNCSKIP 8
-
-static
-TRANSPORTDEC_ERROR synchronization(
-        HANDLE_TRANSPORTDEC hTp,
-        INT                *pHeaderBits
-        )
-{
-  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK, errFirstFrame = TRANSPORTDEC_OK;
-  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
-
-  INT syncLayerFrameBits = 0; /* Length of sync layer frame (i.e. LOAS) */
-  INT rawDataBlockLength = 0, rawDataBlockLengthPrevious;
-  INT totalBits;
-  INT headerBits = 0, headerBitsFirstFrame = 0, headerBitsPrevious;
-  INT numFramesTraversed = 0, fTraverseMoreFrames, fConfigFound = (hTp->flags & TPDEC_CONFIG_FOUND), startPosFirstFrame = -1;
-  INT numRawDataBlocksFirstFrame = 0, numRawDataBlocksPrevious, globalFramePosFirstFrame = 0, rawDataBlockLengthFirstFrame = 0;
-  INT ignoreBufferFullness = hTp->flags & (TPDEC_LOST_FRAMES_PENDING|TPDEC_IGNORE_BUFFERFULLNESS|TPDEC_SYNCOK);
-
-  /* Synch parameters */
-  INT syncLength;      /* Length of sync word in bits */
-  UINT syncWord;       /* Sync word to be found */
-  UINT syncMask;       /* Mask for sync word (for adding one bit, so comprising one bit less) */
-  C_ALLOC_SCRATCH_START(contextFirstFrame, transportdec_parser_t, 1);
-
-  totalBits = (INT)FDKgetValidBits(hBs);
-
-  if (totalBits <= 0) {
-    err = TRANSPORTDEC_NOT_ENOUGH_BITS;
-    goto bail;
-  }
-
-  fTraverseMoreFrames = (hTp->flags & (TPDEC_MINIMIZE_DELAY|TPDEC_EARLY_CONFIG)) && ! (hTp->flags & TPDEC_SYNCOK);
-
-  /* Set transport specific sync parameters */
-  switch (hTp->transportFmt) {
-    case TT_MP4_ADTS:
-      syncWord = ADTS_SYNCWORD;
-      syncLength = ADTS_SYNCLENGTH;
-      break;
-    case TT_MP4_LOAS:
-      syncWord = 0x2B7;
-      syncLength = 11;
-      break;
-    default:
-      syncWord = 0;
-      syncLength = 0;
-      break;
-  }
-
-  syncMask = (1<<syncLength)-1;
-
-  do {
-    INT bitsAvail = 0;     /* Bits available in bitstream buffer    */
-    INT checkLengthBits;   /* Helper to check remaining bits and buffer boundaries */
-    UINT synch;            /* Current sync word read from bitstream */
-
-    headerBitsPrevious = headerBits;
-
-    bitsAvail = (INT)FDKgetValidBits(hBs);
-
-    if (hTp->numberOfRawDataBlocks == 0) {
-      /* search synchword */
-
-      FDK_ASSERT( (bitsAvail % TPDEC_SYNCSKIP) == 0);
-
-      if ((bitsAvail-syncLength) < TPDEC_SYNCSKIP) {
-        err = TRANSPORTDEC_NOT_ENOUGH_BITS;
-        headerBits = 0;
-      } else {
-
-        synch = FDKreadBits(hBs, syncLength);
-
-        if ( !(hTp->flags & TPDEC_SYNCOK) ) {
-          for (; (bitsAvail-syncLength) >= TPDEC_SYNCSKIP; bitsAvail-=TPDEC_SYNCSKIP) {
-            if (synch == syncWord) {
-              break;
-            }
-            synch = ((synch << TPDEC_SYNCSKIP) & syncMask) | FDKreadBits(hBs, TPDEC_SYNCSKIP);
-          }
-        }
-        if (synch != syncWord) {
-          /* No correct syncword found. */
-          err = TRANSPORTDEC_SYNC_ERROR;
-        } else {
-          err = TRANSPORTDEC_OK;
-        }
-        headerBits = syncLength;
-      }
-    } else {
-      headerBits = 0;
-    }
-
-    /* Save previous raw data block data */
-    rawDataBlockLengthPrevious = rawDataBlockLength;
-    numRawDataBlocksPrevious = hTp->numberOfRawDataBlocks;
-
-    /* Parse transport header (raw data block granularity) */
-
-    if (err == TRANSPORTDEC_OK )
-    {
-      err = transportDec_readHeader(
-              hTp,
-              hBs,
-              syncLength,
-              ignoreBufferFullness,
-             &rawDataBlockLength,
-             &fTraverseMoreFrames,
-             &syncLayerFrameBits,
-             &fConfigFound,
-             &headerBits
-              );
-    }
-
-    bitsAvail -= headerBits;
-
-    checkLengthBits  = syncLayerFrameBits;
-
-    /* Check if the whole frame would fit the bitstream buffer */
-    if (err == TRANSPORTDEC_OK) {
-      if ( (checkLengthBits+headerBits) > ((TRANSPORTDEC_INBUF_SIZE<<3)-7) ) {
-        /* We assume that the size of the transport bit buffer has been
-           chosen to meet all system requirements, thus this condition
-           is considered a synchronisation error. */
-        err = TRANSPORTDEC_SYNC_ERROR;
-      } else {
-        if ( bitsAvail < checkLengthBits ) {
-          err = TRANSPORTDEC_NOT_ENOUGH_BITS;
-        }
-      }
-    }
-
-    if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
-      break;
-    }
-
-
-    if (err == TRANSPORTDEC_SYNC_ERROR) {
-      int bits;
-
-      /* Enforce re-sync of transport headers. */
-      hTp->numberOfRawDataBlocks = 0;
-
-      /* Ensure that the bit amount lands at a multiple of TPDEC_SYNCSKIP */
-      bits = (bitsAvail + headerBits) % TPDEC_SYNCSKIP;
-      /* Rewind - TPDEC_SYNCSKIP, in order to look for a synch one bit ahead next time. */
-      FDKpushBiDirectional(hBs, -(headerBits - TPDEC_SYNCSKIP) + bits);
-      bitsAvail += headerBits - TPDEC_SYNCSKIP - bits;
-      headerBits = 0;
-    }
-
-    /* Frame traversal */
-    if ( fTraverseMoreFrames )
-    {
-      /* Save parser context for early config discovery "rewind all frames" */
-      if ( (hTp->flags & TPDEC_EARLY_CONFIG) && !(hTp->flags & TPDEC_MINIMIZE_DELAY))
-      {
-        /* ignore buffer fullness if just traversing additional frames for ECD */
-        ignoreBufferFullness = 1;
-
-        /* Save context in order to return later */
-        if ( err == TRANSPORTDEC_OK && startPosFirstFrame == -1 ) {
-          startPosFirstFrame = FDKgetValidBits(hBs);
-          numRawDataBlocksFirstFrame = hTp->numberOfRawDataBlocks;
-          globalFramePosFirstFrame = hTp->globalFramePos;
-          rawDataBlockLengthFirstFrame = rawDataBlockLength;
-          headerBitsFirstFrame = headerBits;
-          errFirstFrame = err;
-          FDKmemcpy(contextFirstFrame, &hTp->parser, sizeof(transportdec_parser_t));
-        }
-
-        /* Break when config was found or it is not possible anymore to find a config */
-        if (startPosFirstFrame != -1 && (fConfigFound || err != TRANSPORTDEC_OK))
-        {
-          /* In case of ECD and sync error, do not rewind anywhere. */
-          if (err == TRANSPORTDEC_SYNC_ERROR)
-          {
-            startPosFirstFrame = -1;
-            fConfigFound = 0;
-            numFramesTraversed = 0;
-          }
-          break;
-        }
-      }
-
-      if (err == TRANSPORTDEC_OK) {
-        FDKpushFor(hBs, rawDataBlockLength);
-        bitsAvail -= rawDataBlockLength;
-        numFramesTraversed++;
-        /* Ignore error here itentionally. */
-        transportDec_AdjustEndOfAccessUnit(hTp);
-      }
-    }
-  } while ( fTraverseMoreFrames || (err == TRANSPORTDEC_SYNC_ERROR && !(hTp->flags & TPDEC_SYNCOK)));
-
-  /* Restore context in case of ECD frame traversal */
-  if ( startPosFirstFrame != -1 && (fConfigFound || err != TRANSPORTDEC_OK) ) {
-    FDKpushBiDirectional(hBs, FDKgetValidBits(hBs) - startPosFirstFrame);
-    FDKmemcpy(&hTp->parser, contextFirstFrame, sizeof(transportdec_parser_t));
-    hTp->numberOfRawDataBlocks = numRawDataBlocksFirstFrame;
-    hTp->globalFramePos = globalFramePosFirstFrame;
-    rawDataBlockLength = rawDataBlockLengthFirstFrame;
-    headerBits = headerBitsFirstFrame;
-    err = errFirstFrame;
-    numFramesTraversed = 0;
-  } 
-
-  /* Additional burst data mode buffer fullness check. */
-  if ( !(hTp->flags & (TPDEC_LOST_FRAMES_PENDING|TPDEC_IGNORE_BUFFERFULLNESS|TPDEC_SYNCOK)) && err == TRANSPORTDEC_OK) {
-    err = additionalHoldOffNeeded(hTp, transportDec_GetBufferFullness(hTp), FDKgetValidBits(hBs) - syncLayerFrameBits);
-    if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
-      hTp->holdOffFrames++;
-    }
-  }
-  
-  /* Rewind for retry because of not enough bits */
-  if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
-    FDKpushBack(hBs, headerBits);
-    headerBits = 0;
-  }
-  else {
-    /* reset hold off frame counter */
-    hTp->holdOffFrames = 0;
-  }
-
-  /* Return to last good frame in case of frame traversal but not ECD. */
-  if (numFramesTraversed > 0) {
-    FDKpushBack(hBs, rawDataBlockLengthPrevious);
-    if (err != TRANSPORTDEC_OK) {
-      hTp->numberOfRawDataBlocks = numRawDataBlocksPrevious;
-      headerBits = headerBitsPrevious;
-    }
-    err = TRANSPORTDEC_OK;
-  }
-
-bail:
-  hTp->auLength[0] = rawDataBlockLength;
-
-  /* Detect pointless TRANSPORTDEC_NOT_ENOUGH_BITS error case, were the bit buffer is already full,
-     or no new burst packet fits. Recover by advancing the bit buffer. */
-  if ( (TRANSPORTDEC_NOT_ENOUGH_BITS == err) &&  (FDKgetValidBits(hBs) >= ((TRANSPORTDEC_INBUF_SIZE*8 - ((hTp->avgBitRate*hTp->burstPeriod)/1000)) - 7)) )
-  {
-    FDKpushFor(hBs, TPDEC_SYNCSKIP);
-    err = TRANSPORTDEC_SYNC_ERROR;
-  }
-
-  if (err == TRANSPORTDEC_OK) {
-    hTp->flags |= TPDEC_SYNCOK;
-  }
-
-  if (fConfigFound) {
-    hTp->flags |= TPDEC_CONFIG_FOUND;
-  }
-
-  if (pHeaderBits != NULL) {
-    *pHeaderBits = headerBits;
-  }
-
-  if (err == TRANSPORTDEC_SYNC_ERROR) {
-    hTp->flags &= ~TPDEC_SYNCOK;
-  }
-
-  C_ALLOC_SCRATCH_END(contextFirstFrame, transportdec_parser_t, 1);
-
-  return err;
-}
-
-/**
- * \brief Synchronize to stream and estimate the amount of missing access units due
- *        to a current synchronization error in case of constant average bit rate.
- */
-static
-TRANSPORTDEC_ERROR transportDec_readStream ( HANDLE_TRANSPORTDEC hTp, const UINT layer )
-{
-
-  TRANSPORTDEC_ERROR error = TRANSPORTDEC_OK;
-  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[layer];
-  INT nAU = -1;
-  INT headerBits;
-  INT bitDistance, bfDelta;
-
-  /* Obtain distance to next synch word */
-  bitDistance = FDKgetValidBits(hBs);
-  error = synchronization(hTp, &headerBits);
-  bitDistance -= FDKgetValidBits(hBs);
-
-
-  FDK_ASSERT(bitDistance >= 0);
-
-  if (error == TRANSPORTDEC_SYNC_ERROR || (hTp->flags & TPDEC_LOST_FRAMES_PENDING))
-  {
-    /* Check if estimating lost access units is feasible. */
-    if (hTp->avgBitRate > 0 && hTp->asc[0].m_samplesPerFrame > 0 && hTp->asc[0].m_samplingFrequency > 0)
-    {
-      if (error == TRANSPORTDEC_OK)
-      {
-        int aj;
-
-        aj = transportDec_GetBufferFullness(hTp);
-        if (aj > 0) {
-          bfDelta = aj;
-        } else {
-          bfDelta = 0;
-        }
-        /* sync was ok: last of a series of bad access units. */
-        hTp->flags &= ~TPDEC_LOST_FRAMES_PENDING;
-        /* Add up bitDistance until end of the current frame. Later we substract
-           this frame from the grand total, since this current successfully synchronized
-           frame should not be skipped of course; but it must be accounted into the
-           bufferfulness math. */
-        bitDistance += hTp->auLength[0];
-      } else {
-        if ( !(hTp->flags & TPDEC_LOST_FRAMES_PENDING) ) {
-          /* sync not ok: one of many bad access units. */
-          hTp->flags |= TPDEC_LOST_FRAMES_PENDING;
-          bfDelta = - (INT)hTp->lastValidBufferFullness;
-        } else {
-          bfDelta = 0;
-        }
-      }
-
-      {
-        int num, denom;
-
-        /* Obtain estimate of number of lost frames */
-        num = hTp->asc[0].m_samplingFrequency * (bfDelta + bitDistance) + hTp->remainder;
-        denom = hTp->avgBitRate * hTp->asc[0].m_samplesPerFrame;
-        if (num > 0) {
-          nAU = num / denom;
-          hTp->remainder = num % denom;
-        } else {
-          hTp->remainder = num;
-        }
-
-        if (error == TRANSPORTDEC_OK)
-        {
-          /* Final adjustment of remainder, taken -1 into account because current
-             frame should not be skipped, thus substract -1 or do nothing instead
-             of +1-1 accordingly. */
-          if ( (denom - hTp->remainder) >= hTp->remainder ) {
-            nAU--;
-          }
-            
-          if (nAU < 0) {
-            /* There was one frame too much concealed, so unfortunately we will have to skip one good frame. */
-            transportDec_EndAccessUnit(hTp);
-            error = synchronization(hTp, &headerBits);             
-            nAU = -1;
-#ifdef DEBUG
-            FDKprintf("ERROR: Bufferfullness accounting failed. remainder=%d, nAU=%d\n", hTp->remainder, nAU);
-#endif
-          }
-          hTp->remainder = 0;
-          /* Enforce last missed frames to be concealed. */
-          if (nAU > 0) {
-            FDKpushBack(hBs, headerBits);
-          }
-        }
-      }
-    }
-  }
-
-  /* Be sure that lost frames are handled correctly. This is necessary due to some
-     sync error sequences where later it turns out that there is not enough data, but
-     the bits upto the sync word are discarded, thus causing a value of nAU > 0 */
-  if (nAU > 0) {
-    error = TRANSPORTDEC_SYNC_ERROR;
-  }
-
-  hTp->missingAccessUnits = nAU;
-
-  return error;
-}
-
-/* returns error code */
-TRANSPORTDEC_ERROR transportDec_ReadAccessUnit( const HANDLE_TRANSPORTDEC hTp, const UINT layer )
-{
-  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
-  HANDLE_FDK_BITSTREAM hBs;
-
-  if (!hTp) {
-    return TRANSPORTDEC_INVALID_PARAMETER;
-  }
-
-  hBs = &hTp->bitStream[layer];
-
-  if ((INT)FDKgetValidBits(hBs) <= 0) {
-    err = TRANSPORTDEC_NOT_ENOUGH_BITS;
-  }
-
-  switch (hTp->transportFmt) {
-
-    case TT_MP4_ADIF:
-      /* Read header if not already done */
-      if (!(hTp->flags & TPDEC_CONFIG_FOUND))
-      {
-        CProgramConfig *pce;
-
-        AudioSpecificConfig_Init(&hTp->asc[0]);
-        pce = &hTp->asc[0].m_progrConfigElement;
-        err = adifRead_DecodeHeader(&hTp->parser.adif, pce, hBs);
-        if (err)
-          goto bail;
-
-        /* Map adif header to ASC */
-        hTp->asc[0].m_aot                    = (AUDIO_OBJECT_TYPE)(pce->Profile + 1);
-        hTp->asc[0].m_samplingFrequencyIndex = pce->SamplingFrequencyIndex;
-        hTp->asc[0].m_samplingFrequency      = SamplingRateTable[pce->SamplingFrequencyIndex];
-        hTp->asc[0].m_channelConfiguration   = 0;
-        hTp->asc[0].m_samplesPerFrame        = 1024;
-        hTp->avgBitRate                      = hTp->parser.adif.BitRate;
-
-        /* Call callback to decoder. */
-        {
-          int errC;
-
-          errC = hTp->callbacks.cbUpdateConfig(hTp->callbacks.cbUpdateConfigData, &hTp->asc[0]);
-          if (errC == 0) {
-            hTp->flags |= TPDEC_CONFIG_FOUND;
-          } else {
-            err = TRANSPORTDEC_PARSE_ERROR;
-            goto bail;
-          }
-        }
-      }
-      hTp->auLength[layer] = -1; /* Access Unit data length is unknown. */
-      break;
-
-    case TT_MP4_RAW:
-      /* One Access Unit was filled into buffer.
-         So get the length out of the buffer. */
-      hTp->auLength[layer] = FDKgetValidBits(hBs);
-      hTp->flags |= TPDEC_SYNCOK;
-      break;
-
-    case TT_MP4_LATM_MCP0:
-    case TT_MP4_LATM_MCP1:
-      {
-        int fConfigFound = hTp->flags & TPDEC_CONFIG_FOUND;
-        err = transportDec_readHeader(hTp, hBs, 0, 1, &hTp->auLength[layer], NULL, NULL, &fConfigFound, NULL);
-        if (fConfigFound) {
-          hTp->flags |= TPDEC_CONFIG_FOUND;
-        }
-      }
-      break;
-
-    case TT_RSVD50:
-    case TT_MP4_ADTS:
-    case TT_MP4_LOAS:
-      err = transportDec_readStream(hTp, layer);
-      break;
-
-    default:
-      err = TRANSPORTDEC_UNSUPPORTED_FORMAT;
-      break;
-  }
-
-  if (err == TRANSPORTDEC_OK) {
-    hTp->accessUnitAnchor[layer] = FDKgetValidBits(hBs);
-  } else {
-    hTp->accessUnitAnchor[layer] = 0;
-  }
-
-bail:
-  return err;
-}
-
-INT transportDec_GetAuBitsRemaining( const HANDLE_TRANSPORTDEC hTp, const UINT layer )
-{
-  INT bits;
-
-  if (hTp->accessUnitAnchor[layer] > 0 && hTp->auLength[layer] > 0) {
-    bits = hTp->auLength[layer] - (hTp->accessUnitAnchor[layer] - FDKgetValidBits(&hTp->bitStream[layer]));
-  } else {
-    bits = FDKgetValidBits(&hTp->bitStream[layer]);
-  }
-
-  return bits;
-}
-
-INT transportDec_GetAuBitsTotal( const HANDLE_TRANSPORTDEC hTp, const UINT layer )
-{
-  return hTp->auLength[layer];
-}
-
-TRANSPORTDEC_ERROR transportDec_GetMissingAccessUnitCount ( INT *pNAccessUnits, HANDLE_TRANSPORTDEC hTp )
-{
-  *pNAccessUnits = hTp->missingAccessUnits;
-
-  return TRANSPORTDEC_OK;
-}
-
-/* Inform the transportDec layer that reading of access unit has finished. */
-TRANSPORTDEC_ERROR transportDec_EndAccessUnit(HANDLE_TRANSPORTDEC hTp)
-{
-  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
-
-
-  err = transportDec_AdjustEndOfAccessUnit(hTp);
-
-  switch (hTp->transportFmt) {
-    default:
-      break;
-  }
-
-  return err;
-}
-
-TRANSPORTDEC_ERROR transportDec_SetParam ( const HANDLE_TRANSPORTDEC hTp,
-                                           const TPDEC_PARAM        param,
-                                           const INT                value)
-{
-  TRANSPORTDEC_ERROR error = TRANSPORTDEC_OK;
-
-  switch (param) {
-    case TPDEC_PARAM_MINIMIZE_DELAY:
-      if (value) {
-        hTp->flags |= TPDEC_MINIMIZE_DELAY;
-      } else {
-        hTp->flags &= ~TPDEC_MINIMIZE_DELAY;
-      }
-      break;
-    case TPDEC_PARAM_EARLY_CONFIG:
-      if (value) {
-        hTp->flags |= TPDEC_EARLY_CONFIG;
-      } else {
-        hTp->flags &= ~TPDEC_EARLY_CONFIG;
-      }
-      break;
-    case TPDEC_PARAM_IGNORE_BUFFERFULLNESS:
-      if (value) {
-        hTp->flags |= TPDEC_IGNORE_BUFFERFULLNESS;
-      } else {
-        hTp->flags &= ~TPDEC_IGNORE_BUFFERFULLNESS;
-      }
-      break;
-    case TPDEC_PARAM_SET_BITRATE:
-      hTp->avgBitRate = value;
-      break;
-    case TPDEC_PARAM_BURST_PERIOD:
-      hTp->burstPeriod = value;
-      break;
-    case TPDEC_PARAM_RESET:
-      {
-        int i;
-
-        for (i=0; i<(1*2); i++) {
-          FDKresetBitbuffer(&hTp->bitStream[i]);
-          hTp->auLength[i] = 0;
-          hTp->accessUnitAnchor[i] = 0;
-        }
-        hTp->flags &= ~(TPDEC_SYNCOK|TPDEC_LOST_FRAMES_PENDING);
-        if (hTp->transportFmt != TT_MP4_ADIF) {
-          hTp->flags &= ~TPDEC_CONFIG_FOUND;
-        }
-        hTp->remainder = 0;
-        hTp->avgBitRate = 0;
-        hTp->missingAccessUnits = 0;
-        hTp->numberOfRawDataBlocks = 0;
-        hTp->globalFramePos = 0;
-        hTp->holdOffFrames = 0;
-      }
-      break;
-  }
-
-  return error;
-}
-
-UINT transportDec_GetNrOfSubFrames(HANDLE_TRANSPORTDEC hTp)
-{
-  UINT nSubFrames = 0;
-
-  if (hTp == NULL)
-    return 0;
-
-  if (hTp->transportFmt==TT_MP4_LATM_MCP1 || hTp->transportFmt==TT_MP4_LATM_MCP0 || hTp->transportFmt==TT_MP4_LOAS)
-    nSubFrames = CLatmDemux_GetNrOfSubFrames(&hTp->parser.latm);
-  else if (hTp->transportFmt==TT_MP4_ADTS)
-    nSubFrames = hTp->parser.adts.bs.num_raw_blocks;
-
-  return nSubFrames;
-}
-
-void transportDec_Close(HANDLE_TRANSPORTDEC *phTp)
-{
-  if (phTp != NULL)
-  {
-    if (*phTp != NULL) {
-      if ( ! TT_IS_PACKET((*phTp)->transportFmt) ) {
-        FreeRam_TransportDecoderBuffer(&(*phTp)->bsBuffer);
-      }
-      if (*phTp != NULL) {
-        FreeRam_TransportDecoder(phTp);
-      }
-    }
-  }
-}
-
-TRANSPORTDEC_ERROR transportDec_GetLibInfo( LIB_INFO *info )
-{
-  int i;
-
-  if (info == NULL) {
-    return TRANSPORTDEC_UNKOWN_ERROR;
-  }
-
-  /* search for next free tab */
-  for (i = 0; i < FDK_MODULE_LAST; i++) {
-    if (info[i].module_id == FDK_NONE) break;
-  }
-  if (i == FDK_MODULE_LAST) return TRANSPORTDEC_UNKOWN_ERROR;
-  info += i;
-
-  info->module_id  = FDK_TPDEC;
-  info->build_date = __DATE__;
-  info->build_time = __TIME__;
-  info->title      = TP_LIB_TITLE;
-  info->version    = LIB_VERSION(TP_LIB_VL0, TP_LIB_VL1, TP_LIB_VL2);
-  LIB_VERSION_STRING(info);
-  info->flags = 0
-    | CAPF_ADIF
-    | CAPF_ADTS
-    | CAPF_LATM
-    | CAPF_LOAS
-    | CAPF_RAWPACKETS
-    ;
-
-  return TRANSPORTDEC_OK; /* FDKERR_NOERROR; */
-}
-
-
-int  transportDec_CrcStartReg(HANDLE_TRANSPORTDEC pTp, INT mBits)
-{
-  switch (pTp->transportFmt) {
-  case TT_MP4_ADTS:
-    return adtsRead_CrcStartReg(&pTp->parser.adts, &pTp->bitStream[0], mBits);
-  default:
-    return 0;
-  }
-}
-
-void transportDec_CrcEndReg(HANDLE_TRANSPORTDEC pTp, INT reg)
-{
-  switch (pTp->transportFmt) {
-  case TT_MP4_ADTS:
-    adtsRead_CrcEndReg(&pTp->parser.adts, &pTp->bitStream[0], reg);
-    break;
-  default:
-    break;
-  }
-}
-
-TRANSPORTDEC_ERROR transportDec_CrcCheck(HANDLE_TRANSPORTDEC pTp)
-{
-  switch (pTp->transportFmt) {
-  case TT_MP4_ADTS:
-    if ( (pTp->parser.adts.bs.num_raw_blocks > 0) && (pTp->parser.adts.bs.protection_absent == 0) )
-    {
-      HANDLE_FDK_BITSTREAM hBs = &pTp->bitStream[0];
-      
-      transportDec_AdjustEndOfAccessUnit(pTp);
-    }
-    return adtsRead_CrcCheck(&pTp->parser.adts);
-  default:
-    return TRANSPORTDEC_OK;
-  }
-}
diff --git a/libMpegTPDec/src/version b/libMpegTPDec/src/version
deleted file mode 100644
index 2803347..0000000
--- a/libMpegTPDec/src/version
+++ /dev/null
@@ -1,8 +0,0 @@
-
-/* library info */
-#define TP_LIB_VL0 2
-#define TP_LIB_VL1 3
-#define TP_LIB_VL2 3
-#define TP_LIB_TITLE "MPEG Transport"
-#define TP_LIB_BUILD_DATE __DATE__
-#define TP_LIB_BUILD_TIME __TIME__