Upgrade to FDKv2

Bug: 71430241
Test: CTS DecoderTest and DecoderTestAacDrc

original-Change-Id: Iaa20f749b8a04d553b20247cfe1a8930ebbabe30

Apply clang-format also on header files.

original-Change-Id: I14de1ef16bbc79ec0283e745f98356a10efeb2e4

Fixes for MPEG-D DRC

original-Change-Id: If1de2d74bbbac84b3f67de3b88b83f6a23b8a15c

Catch unsupported tw_mdct at an early stage

original-Change-Id: Ied9dd00d754162a0e3ca1ae3e6b854315d818afe

Fixing PVC transition frames

original-Change-Id: Ib75725abe39252806c32d71176308f2c03547a4e

Move qmf bands sanity check

original-Change-Id: Iab540c3013c174d9490d2ae100a4576f51d8dbc4

Initialize scaling variable

original-Change-Id: I3c4087101b70e998c71c1689b122b0d7762e0f9e

Add 16 qmf band configuration to getSlotNrgHQ()

original-Change-Id: I49a5d30f703a1b126ff163df9656db2540df21f1

Always apply byte alignment at the end of the AudioMuxElement

original-Change-Id: I42d560287506d65d4c3de8bfe3eb9a4ebeb4efc7

Setup SBR element only if no parse error exists

original-Change-Id: I1915b73704bc80ab882b9173d6bec59cbd073676

Additional array index check in HCR

original-Change-Id: I18cc6e501ea683b5009f1bbee26de8ddd04d8267

Fix fade-in index selection in concealment module

original-Change-Id: Ibf802ed6ed8c05e9257e1f3b6d0ac1162e9b81c1

Enable explicit backward compatible parser for AAC_LD

original-Change-Id: I27e9c678dcb5d40ed760a6d1e06609563d02482d

Skip spatial specific config in explicit backward compatible ASC

original-Change-Id: Iff7cc365561319e886090cedf30533f562ea4d6e

Update flags description in decoder API

original-Change-Id: I9a5b4f8da76bb652f5580cbd3ba9760425c43830

Add QMF domain reset function

original-Change-Id: I4f89a8a2c0277d18103380134e4ed86996e9d8d6

DRC upgrade v2.1.0

original-Change-Id: I5731c0540139dab220094cd978ef42099fc45b74

Fix integer overflow in sqrtFixp_lookup()

original-Change-Id: I429a6f0d19aa2cc957e0f181066f0ca73968c914

Fix integer overflow in invSqrtNorm2()

original-Change-Id: I84de5cbf9fb3adeb611db203fe492fabf4eb6155

Fix integer overflow in GenerateRandomVector()

original-Change-Id: I3118a641008bd9484d479e5b0b1ee2b5d7d44d74

Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I29d503c247c5c8282349b79df940416a512fb9d5

Fix integer overflow in FDKsbrEnc_codeEnvelope()

original-Change-Id: I6b34b61ebb9d525b0c651ed08de2befc1f801449

Follow-up on: Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I6f8f578cc7089e5eb7c7b93e580b72ca35ad689a

Fix integer overflow in get_pk_v2()

original-Change-Id: I63375bed40d45867f6eeaa72b20b1f33e815938c

Fix integer overflow in Syn_filt_zero()

original-Change-Id: Ie0c02fdfbe03988f9d3b20d10cd9fe4c002d1279

Fix integer overflow in CFac_CalcFacSignal()

original-Change-Id: Id2d767c40066c591b51768e978eb8af3b803f0c5

Fix integer overflow in FDKaacEnc_FDKaacEnc_calcPeNoAH()

original-Change-Id: Idcbd0f4a51ae2550ed106aa6f3d678d1f9724841

Fix integer overflow in sbrDecoder_calculateGainVec()

original-Change-Id: I7081bcbe29c5cede9821b38d93de07c7add2d507

Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4a95ddc18de150102352d4a1845f06094764c881

Fix integer overflow in Pred_Lt4()

original-Change-Id: I4dbd012b2de7d07c3e70a47b92e3bfae8dbc750a

Fix integer overflow in FDKsbrEnc_InitSbrFastTransientDetector()

original-Change-Id: I788cbec1a4a00f44c2f3a72ad7a4afa219807d04

Fix unsigned integer overflow in FDKaacEnc_WriteBitstream()

original-Change-Id: I68fc75166e7d2cd5cd45b18dbe3d8c2a92f1822a

Fix unsigned integer overflow in FDK_MetadataEnc_Init()

original-Change-Id: Ie8d025f9bcdb2442c704bd196e61065c03c10af4

Fix overflow in pseudo random number generators

original-Change-Id: I3e2551ee01356297ca14e3788436ede80bd5513c

Fix unsigned integer overflow in sbrDecoder_Parse()

original-Change-Id: I3f231b2f437e9c37db4d5b964164686710eee971

Fix unsigned integer overflow in longsub()

original-Change-Id: I73c2bc50415cac26f1f5a29e125bbe75f9180a6e

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: Ifce2db4b1454b46fa5f887e9d383f1cc43b291e4

Fix overflow at CLpdChannelStream_Read()

original-Change-Id: Idb9d822ce3a4272e4794b643644f5434e2d4bf3f

Fix unsigned integer overflow in Hcr_State_BODY_SIGN_ESC__ESC_WORD()

original-Change-Id: I1ccf77c0015684b85534c5eb97162740a870b71c

Fix unsigned integer overflow in UsacConfig_Parse()

original-Change-Id: Ie6d27f84b6ae7eef092ecbff4447941c77864d9f

Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I713f28e883eea3d70b6fa56a7b8f8c22bcf66ca0

Fix unsigned integer overflow in aacDecoder_drcReadCompression()

original-Change-Id: Ia34dfeb88c4705c558bce34314f584965cafcf7a

Fix unsigned integer overflow in CDataStreamElement_Read()

original-Change-Id: Iae896cc1d11f0a893d21be6aa90bd3e60a2c25f0

Fix unsigned integer overflow in transportDec_AdjustEndOfAccessUnit()

original-Change-Id: I64cf29a153ee784bb4a16fdc088baabebc0007dc

Fix unsigned integer overflow in transportDec_GetAuBitsRemaining()

original-Change-Id: I975b3420faa9c16a041874ba0db82e92035962e4

Fix unsigned integer overflow in extractExtendedData()

original-Change-Id: I2a59eb09e2053cfb58dfb75fcecfad6b85a80a8f

Fix signed integer overflow in CAacDecoder_ExtPayloadParse()

original-Change-Id: I4ad5ca4e3b83b5d964f1c2f8c5e7b17c477c7929

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: I29a39df77d45c52a0c9c5c83c1ba81f8d0f25090

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I8fb194ffc073a3432a380845be71036a272d388f

Fix signed integer overflow in _interpolateDrcGain()

original-Change-Id: I879ec9ab14005069a7c47faf80e8bc6e03d22e60

Fix unsigned integer overflow in FDKreadBits()

original-Change-Id: I1f47a6a8037ff70375aa8844947d5681bb4287ad

Fix unsigned integer overflow in FDKbyteAlign()

original-Change-Id: Id5f3a11a0c9e50fc6f76ed6c572dbd4e9f2af766

Fix unsigned integer overflow in FDK_get32()

original-Change-Id: I9d33b8e97e3d38cbb80629cb859266ca0acdce96

Fix unsigned integer overflow in FDK_pushBack()

original-Change-Id: Ic87f899bc8c6acf7a377a8ca7f3ba74c3a1e1c19

Fix unsigned integer overflow in FDK_pushForward()

original-Change-Id: I3b754382f6776a34be1602e66694ede8e0b8effc

Fix unsigned integer overflow in ReadPsData()

original-Change-Id: I25361664ba8139e32bbbef2ca8c106a606ce9c37

Fix signed integer overflow in E_UTIL_residu()

original-Change-Id: I8c3abd1f437ee869caa8fb5903ce7d3d641b6aad

REVERT: Follow-up on: Integer overflow in CLpc_SynthesisLattice().

original-Change-Id: I3d340099acb0414795c8dfbe6362bc0a8f045f9b

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4aedb8b3a187064e9f4d985175aa55bb99cc7590

Follow-up on: Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I2aa2e13916213bf52a67e8b0518e7bf7e57fb37d

Fix integer overflow in acelp

original-Change-Id: Ie6390c136d84055f8b728aefbe4ebef6e029dc77

Fix unsigned integer overflow in aacDecoder_UpdateBitStreamCounters()

original-Change-Id: I391ffd97ddb0b2c184cba76139bfb356a3b4d2e2

Adjust concealment default settings

original-Change-Id: I6a95db935a327c47df348030bcceafcb29f54b21

Saturate estimatedStartPos

original-Change-Id: I27be2085e0ae83ec9501409f65e003f6bcba1ab6

Negative shift exponent in _interpolateDrcGain()

original-Change-Id: I18edb26b26d002aafd5e633d4914960f7a359c29

Negative shift exponent in calculateICC()

original-Change-Id: I3dcd2ae98d2eb70ee0d59750863cbb2a6f4f8aba

Too large shift exponent in FDK_put()

original-Change-Id: Ib7d9aaa434d2d8de4a13b720ca0464b31ca9b671

Too large shift exponent in CalcInvLdData()

original-Change-Id: I43e6e78d4cd12daeb1dcd5d82d1798bdc2550262

Member access within null pointer of type SBR_CHANNEL

original-Change-Id: Idc5e4ea8997810376d2f36bbdf628923b135b097

Member access within null pointer of type CpePersistentData

original-Change-Id: Ib6c91cb0d37882768e5baf63324e429589de0d9d

Member access within null pointer FDKaacEnc_psyMain()

original-Change-Id: I7729b7f4479970531d9dc823abff63ca52e01997

Member access within null pointer FDKaacEnc_GetPnsParam()

original-Change-Id: I9aa3b9f3456ae2e0f7483dbd5b3dde95fc62da39

Member access within null pointer FDKsbrEnc_EnvEncodeFrame()

original-Change-Id: I67936f90ea714e90b3e81bc0dd1472cc713eb23a

Add HCR sanity check

original-Change-Id: I6c1d9732ebcf6af12f50b7641400752f74be39f7

Fix memory issue for HBE edge case with 8:3 SBR

original-Change-Id: I11ea58a61e69fbe8bf75034b640baee3011e63e9

Additional SBR parametrization sanity check for ELD

original-Change-Id: Ie26026fbfe174c2c7b3691f6218b5ce63e322140

Add MPEG-D DRC channel layout check

original-Change-Id: Iea70a74f171b227cce636a9eac4ba662777a2f72

Additional out-of-bounds checks in MPEG-D DRC

original-Change-Id: Ife4a8c3452c6fde8a0a09e941154a39a769777d4

Change-Id: Ic63cb2f628720f54fe9b572b0cb528e2599c624e

1 files changed, 358 insertions, 254 deletions

diff --git a/libSYS/include/genericStds.h b/libSYS/include/genericStds.h
index fe4dc36..8828ba7 100644
--- a/libSYS/include/genericStds.h
+++ b/libSYS/include/genericStds.h
@@ -1,74 +1,85 @@
-
-/* -----------------------------------------------------------------------------------------------------------
+/* -----------------------------------------------------------------------------
 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.
+© Copyright  1995 - 2018 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.
+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:
+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 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
+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.
+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.
+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."
+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.
+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.
+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.
+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
 
@@ -79,40 +90,34 @@ Am Wolfsmantel 33
 
 www.iis.fraunhofer.de/amm
 amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
+----------------------------------------------------------------------------- */
 
-/**************************  Fraunhofer IIS FDK SysLib  **********************
+/************************* System integration library **************************
 
    Author(s):
 
-******************************************************************************/
+   Description:
+
+*******************************************************************************/
 
 /** \file   genericStds.h
-    \brief  Generic Run-Time Support function wrappers and heap allocation monitoring.
+    \brief  Generic Run-Time Support function wrappers and heap allocation
+   monitoring.
  */
 
-#if !defined(__GENERICSTDS_H__)
-#define __GENERICSTDS_H__
+#if !defined(GENERICSTDS_H)
+#define GENERICSTDS_H
 
 #include "machine_type.h"
 
-
-/* Always increase verbosity of memory allocation in case of a debug built. DEBUG is defined globally in that case. */
-#if defined(DEBUG) || defined(FDK_DEBUG)
-//#define MEMORY_MEASUREMENT
-#endif
-
 #ifndef M_PI
-  #define M_PI   3.14159265358979323846  /*! Pi. Only used in example projects. */
+#define M_PI 3.14159265358979323846 /*!< Pi. Only used in example projects. */
 #endif
 
-
-/* #define _CRT_SECURE_NO_DEPRECATE */
-
-
 /**
- * Identifiers for various memory locations. They are used along with memory allocation
- * functions like FDKcalloc_L() to specify the requested memory's location.
+ * Identifiers for various memory locations. They are used along with memory
+ * allocation functions like FDKcalloc_L() to specify the requested memory's
+ * location.
  */
 typedef enum {
   /* Internal */
@@ -128,104 +133,247 @@ typedef enum {
 
 } MEMORY_SECTION;
 
-
-/**
- * The H_ prefix indicates header file version, the C_* prefix indicates the corresponding
- * object version.
+/*! \addtogroup SYSLIB_MEMORY_MACROS FDK memory macros
  *
- * Declaring memory areas requires to specify a unique name and a data type. Use the H_ macro
- * for this purpose inside a header file.
+ * The \c H_ prefix indicates that the macro is to be used in a header file, the
+ * \c C_ prefix indicates that the macro is to be used in a source file.
  *
- * For defining a memory area your require additionally one or two sizes, depending if the
- * memory should be organized into one or two dimensions.
+ * Declaring memory areas requires to specify a unique name and a data type.
  *
- * The macros containing the keyword AALLOC instead of ALLOC also do take care of returning
- * aligned memory addresses (beyond the natural alignment of its type). The preprocesor macro
- * ::ALIGNMENT_DEFAULT indicates the aligment to be used (this is hardware specific).
+ * For defining a memory area you require additionally one or two sizes,
+ * depending if the memory should be organized into one or two dimensions.
  *
- * The _L suffix indicates that the memory will be located in a specific section. This is
- * useful to allocate critical memory section into fast internal SRAM for example.
+ * The macros containing the keyword \c AALLOC instead of \c ALLOC additionally
+ * take care of returning aligned memory addresses (beyond the natural alignment
+ * of its type). The preprocesor macro
+ * ::ALIGNMENT_DEFAULT indicates the aligment to be used (this is hardware
+ * specific).
  *
+ * The \c _L suffix indicates that the memory will be located in a specific
+ * section. This is useful to allocate critical memory section into fast
+ * internal SRAM for example.
+ *
+ * @{
  */
 
-#define H_ALLOC_MEM(name,type)          type * Get ## name(int n=0); void Free ## name(type** p); \
-                                        UINT GetRequiredMem ## name(void);
-
-/** See #H_ALLOC_MEM for description. */
-#define H_ALLOC_MEM_OVERLAY(name,type)  type * Get ## name(int n=0); void Free ## name(type** p); \
-                                        UINT GetRequiredMem ## name(void);
-
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_ALLOC_MEM(name,type,num) \
-    type * Get ## name(int n) { FDK_ASSERT((n) == 0); return ((type*)FDKcalloc(num, sizeof(type))); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKfree(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((num) * sizeof(type)); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_ALLOC_MEM_STATIC(name,type,num) \
-    static type * Get ## name(int n) { FDK_ASSERT((n) == 0); return ((type*)FDKcalloc(num, sizeof(type))); } \
-    static void Free ## name(type** p) { if (p != NULL) { FDKfree(*p); *p=NULL; } } \
-    static UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((num) * sizeof(type)); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_ALLOC_MEM2(name,type,n1,n2) \
-    type * Get ## name (int n) { FDK_ASSERT((n) < (n2)); return ((type*)FDKcalloc(n1, sizeof(type))); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKfree(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((n1) * sizeof(type)) * (n2); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_AALLOC_MEM(name,type,num) \
-    type * Get ## name(int n) { FDK_ASSERT((n) == 0); return ((type*)FDKaalloc((num)*sizeof(type), ALIGNMENT_DEFAULT)); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKafree(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((num) * sizeof(type) + ALIGNMENT_DEFAULT + sizeof(void *)); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_AALLOC_MEM2(name,type,n1,n2) \
-    type * Get ## name (int n) { FDK_ASSERT((n) < (n2)); return ((type*)FDKaalloc((n1)*sizeof(type), ALIGNMENT_DEFAULT)); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKafree(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((n1) * sizeof(type) + ALIGNMENT_DEFAULT + sizeof(void *)) * (n2); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_ALLOC_MEM_L(name,type,num,s) \
-    type * Get ## name(int n) { FDK_ASSERT((n) == 0); return ((type*)FDKcalloc_L(num, sizeof(type), s)); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKfree_L(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((num) * sizeof(type)); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_ALLOC_MEM2_L(name,type,n1,n2,s) \
-    type * Get ## name (int n) { FDK_ASSERT((n) < (n2)); return (type*)FDKcalloc_L(n1, sizeof(type), s); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKfree_L(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((n1) * sizeof(type)) * (n2); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_AALLOC_MEM_L(name,type,num,s) \
-    type * Get ## name(int n) { FDK_ASSERT((n) == 0); return ((type*)FDKaalloc_L((num)*sizeof(type), ALIGNMENT_DEFAULT, s)); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKafree_L(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((num) * sizeof(type) + ALIGNMENT_DEFAULT + sizeof(void *)); }
-
-  /** See #H_ALLOC_MEM for description. */
-  #define C_AALLOC_MEM2_L(name,type,n1,n2,s) \
-    type * Get ## name (int n) { FDK_ASSERT((n) < (n2)); return ((type*)FDKaalloc_L((n1)*sizeof(type), ALIGNMENT_DEFAULT, s)); } \
-    void Free ## name(type** p) { if (p != NULL) { FDKafree_L(*p); *p=NULL; } } \
-    UINT GetRequiredMem ## name(void) { return ALGN_SIZE_EXTRES((n1) * sizeof(type) + ALIGNMENT_DEFAULT + sizeof(void *)) * (n2); }
-
-/** See #H_ALLOC_MEM_OVERLAY for description. */
-
-
-  #define C_ALLOC_MEM_OVERLAY(name,type,num,sect,tag) C_AALLOC_MEM_L(name,type,num,sect)
-
-
-   #define C_AALLOC_SCRATCH_START(name,type,n) \
-     type _ ## name[(n)+(ALIGNMENT_DEFAULT+sizeof(type)-1)]; \
-     type * name = (type*)ALIGN_PTR(_ ## name); \
-
-   #define C_ALLOC_SCRATCH_START(name,type,n) \
-     type name[n];
-
-   #define C_AALLOC_SCRATCH_END(name,type,n)
-   #define C_ALLOC_SCRATCH_END(name,type,n)
-
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define H_ALLOC_MEM(name, type) \
+  type *Get##name(int n = 0);   \
+  void Free##name(type **p);    \
+  UINT GetRequiredMem##name(void);
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define H_ALLOC_MEM_OVERLAY(name, type) \
+  type *Get##name(int n = 0);           \
+  void Free##name(type **p);            \
+  UINT GetRequiredMem##name(void);
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_MEM(name, type, num)               \
+  type *Get##name(int n) {                         \
+    FDK_ASSERT((n) == 0);                          \
+    return ((type *)FDKcalloc(num, sizeof(type))); \
+  }                                                \
+  void Free##name(type **p) {                      \
+    if (p != NULL) {                               \
+      FDKfree(*p);                                 \
+      *p = NULL;                                   \
+    }                                              \
+  }                                                \
+  UINT GetRequiredMem##name(void) {                \
+    return ALGN_SIZE_EXTRES((num) * sizeof(type)); \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_MEM2(name, type, n1, n2)                 \
+  type *Get##name(int n) {                               \
+    FDK_ASSERT((n) < (n2));                              \
+    return ((type *)FDKcalloc(n1, sizeof(type)));        \
+  }                                                      \
+  void Free##name(type **p) {                            \
+    if (p != NULL) {                                     \
+      FDKfree(*p);                                       \
+      *p = NULL;                                         \
+    }                                                    \
+  }                                                      \
+  UINT GetRequiredMem##name(void) {                      \
+    return ALGN_SIZE_EXTRES((n1) * sizeof(type)) * (n2); \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_MEM(name, type, num)                                  \
+  type *Get##name(int n) {                                             \
+    type *ap;                                                          \
+    FDK_ASSERT((n) == 0);                                              \
+    ap = ((type *)FDKaalloc((num) * sizeof(type), ALIGNMENT_DEFAULT)); \
+    return ap;                                                         \
+  }                                                                    \
+  void Free##name(type **p) {                                          \
+    if (p != NULL) {                                                   \
+      FDKafree(*p);                                                    \
+      *p = NULL;                                                       \
+    }                                                                  \
+  }                                                                    \
+  UINT GetRequiredMem##name(void) {                                    \
+    return ALGN_SIZE_EXTRES((num) * sizeof(type) + ALIGNMENT_DEFAULT + \
+                            sizeof(void *));                           \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_MEM2(name, type, n1, n2)                             \
+  type *Get##name(int n) {                                            \
+    type *ap;                                                         \
+    FDK_ASSERT((n) < (n2));                                           \
+    ap = ((type *)FDKaalloc((n1) * sizeof(type), ALIGNMENT_DEFAULT)); \
+    return ap;                                                        \
+  }                                                                   \
+  void Free##name(type **p) {                                         \
+    if (p != NULL) {                                                  \
+      FDKafree(*p);                                                   \
+      *p = NULL;                                                      \
+    }                                                                 \
+  }                                                                   \
+  UINT GetRequiredMem##name(void) {                                   \
+    return ALGN_SIZE_EXTRES((n1) * sizeof(type) + ALIGNMENT_DEFAULT + \
+                            sizeof(void *)) *                         \
+           (n2);                                                      \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_MEM_L(name, type, num, s)               \
+  type *Get##name(int n) {                              \
+    FDK_ASSERT((n) == 0);                               \
+    return ((type *)FDKcalloc_L(num, sizeof(type), s)); \
+  }                                                     \
+  void Free##name(type **p) {                           \
+    if (p != NULL) {                                    \
+      FDKfree_L(*p);                                    \
+      *p = NULL;                                        \
+    }                                                   \
+  }                                                     \
+  UINT GetRequiredMem##name(void) {                     \
+    return ALGN_SIZE_EXTRES((num) * sizeof(type));      \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_MEM2_L(name, type, n1, n2, s)            \
+  type *Get##name(int n) {                               \
+    FDK_ASSERT((n) < (n2));                              \
+    return (type *)FDKcalloc_L(n1, sizeof(type), s);     \
+  }                                                      \
+  void Free##name(type **p) {                            \
+    if (p != NULL) {                                     \
+      FDKfree_L(*p);                                     \
+      *p = NULL;                                         \
+    }                                                    \
+  }                                                      \
+  UINT GetRequiredMem##name(void) {                      \
+    return ALGN_SIZE_EXTRES((n1) * sizeof(type)) * (n2); \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_MEM_L(name, type, num, s)                                  \
+  type *Get##name(int n) {                                                  \
+    type *ap;                                                               \
+    FDK_ASSERT((n) == 0);                                                   \
+    ap = ((type *)FDKaalloc_L((num) * sizeof(type), ALIGNMENT_DEFAULT, s)); \
+    return ap;                                                              \
+  }                                                                         \
+  void Free##name(type **p) {                                               \
+    if (p != NULL) {                                                        \
+      FDKafree_L(*p);                                                       \
+      *p = NULL;                                                            \
+    }                                                                       \
+  }                                                                         \
+  UINT GetRequiredMem##name(void) {                                         \
+    return ALGN_SIZE_EXTRES((num) * sizeof(type) + ALIGNMENT_DEFAULT +      \
+                            sizeof(void *));                                \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_MEM2_L(name, type, n1, n2, s)                             \
+  type *Get##name(int n) {                                                 \
+    type *ap;                                                              \
+    FDK_ASSERT((n) < (n2));                                                \
+    ap = ((type *)FDKaalloc_L((n1) * sizeof(type), ALIGNMENT_DEFAULT, s)); \
+    return ap;                                                             \
+  }                                                                        \
+  void Free##name(type **p) {                                              \
+    if (p != NULL) {                                                       \
+      FDKafree_L(*p);                                                      \
+      *p = NULL;                                                           \
+    }                                                                      \
+  }                                                                        \
+  UINT GetRequiredMem##name(void) {                                        \
+    return ALGN_SIZE_EXTRES((n1) * sizeof(type) + ALIGNMENT_DEFAULT +      \
+                            sizeof(void *)) *                              \
+           (n2);                                                           \
+  }
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_MEM_OVERLAY(name, type, num, sect, tag) \
+  C_AALLOC_MEM_L(name, type, num, sect)
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_SCRATCH_START(name, type, n)                 \
+  type _##name[(n) + (ALIGNMENT_DEFAULT + sizeof(type) - 1)]; \
+  type *name = (type *)ALIGN_PTR(_##name);                    \
+  C_ALLOC_ALIGNED_REGISTER(name, (n) * sizeof(type));
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_SCRATCH_START(name, type, n) type name[n];
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_SCRATCH_END(name, type, n) C_ALLOC_ALIGNED_UNREGISTER(name);
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_ALLOC_SCRATCH_END(name, type, n)
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_STACK_START(name, type, n)                   \
+  type _##name[(n) + (ALIGNMENT_DEFAULT + sizeof(type) - 1)]; \
+  type *name = (type *)ALIGN_PTR(_##name);                    \
+  C_ALLOC_ALIGNED_REGISTER(name, (n) * sizeof(type));
+
+/** See \ref SYSLIB_MEMORY_MACROS for description. */
+#define C_AALLOC_STACK_END(name, type, n) C_ALLOC_ALIGNED_UNREGISTER(name);
+
+/*! @} */
+
+#define C_ALLOC_ALIGNED_REGISTER(x, size)
+#define C_ALLOC_ALIGNED_UNREGISTER(x)
+#define C_ALLOC_ALIGNED_CHECK(x)
+#define C_ALLOC_ALIGNED_CHECK2(x, y)
+#define FDK_showBacktrace(a, b)
+
+/*! \addtogroup SYSLIB_EXITCODES Unified exit codes
+ *  Exit codes to be used as return values of FDK software test and
+ * demonstration applications. Not as return values of product modules and/or
+ * libraries.
+ *  @{
+ */
+#define FDK_EXITCODE_OK 0 /*!< Successful termination. No errors. */
+#define FDK_EXITCODE_USAGE                                                  \
+  64 /*!< The command/application was used incorrectly, e.g. with the wrong \
+        number of arguments, a bad flag, a bad syntax in a parameter, or    \
+        whatever. */
+#define FDK_EXITCODE_DATAERROR                                               \
+  65 /*!< The input data was incorrect in some way. This should only be used \
+        for user data and not system files. */
+#define FDK_EXITCODE_NOINPUT                                                   \
+  66 /*!< An input file (not a system file) did not exist or was not readable. \
+      */
+#define FDK_EXITCODE_UNAVAILABLE                                              \
+  69 /*!< A service is unavailable. This can occur if a support program or    \
+        file does not exist. This can also be used as a catchall message when \
+        something you wanted to do doesn't work, but you don't know why. */
+#define FDK_EXITCODE_SOFTWARE                                                  \
+  70 /*!< An internal software error has been detected. This should be limited \
+        to non- operating system related errors as possible. */
+#define FDK_EXITCODE_CANTCREATE \
+  73 /*!< A (user specified) output file cannot be created. */
+#define FDK_EXITCODE_IOERROR \
+  74 /*!< An error occurred while doing I/O on some file. */
+/*! @} */
 
 /*--------------------------------------------
  * Runtime support declarations
@@ -234,57 +382,52 @@ typedef enum {
 extern "C" {
 #endif
 
-/** printf() using stdout. If ::ARCH_WA_FLUSH_CONSOLE defined, a flush is  done additionally after printf(). */
-void FDKprintf    ( const char* szFmt, ...);
+void FDKprintf(const char *szFmt, ...);
 
-/** printf() using stderr. If ::ARCH_WA_FLUSH_CONSOLE defined, a flush is done additionally after printf(). */
-void FDKprintfErr ( const char* szFmt, ...);
+void FDKprintfErr(const char *szFmt, ...);
 
 /** Wrapper for <stdio.h>'s getchar(). */
 int FDKgetchar(void);
 
-INT  FDKfprintf(void  *stream,  const  char *format, ...);
-INT  FDKsprintf(char *str, const char *format, ...);
+INT FDKfprintf(void *stream, const char *format, ...);
+INT FDKsprintf(char *str, const char *format, ...);
 
-
-
-const char *FDKstrchr(const char *s, INT c);
+char *FDKstrchr(char *s, INT c);
 const char *FDKstrstr(const char *haystack, const char *needle);
 char *FDKstrcpy(char *dest, const char *src);
 char *FDKstrncpy(char *dest, const char *src, const UINT n);
 
-#define FDK_MAX_OVERLAYS 8   /**< Maximum number of memory overlays. */
-
+#define FDK_MAX_OVERLAYS 8 /**< Maximum number of memory overlays. */
 
-void *FDKcalloc (const UINT n, const UINT size);
-void *FDKmalloc (const UINT size);
-void  FDKfree   (void *ptr);
+void *FDKcalloc(const UINT n, const UINT size);
+void *FDKmalloc(const UINT size);
+void FDKfree(void *ptr);
 
 /**
- *  Allocate and clear an aligned memory area. Use FDKafree() instead of FDKfree() for these memory areas.
+ *  Allocate and clear an aligned memory area. Use FDKafree() instead of
+ * FDKfree() for these memory areas.
  *
  * \param size       Size of requested memory in bytes.
  * \param alignment  Alignment of requested memory in bytes.
  * \return           Pointer to allocated memory.
  */
-void *FDKaalloc (const UINT size, const UINT alignment);
+void *FDKaalloc(const UINT size, const UINT alignment);
 
 /**
  *  Free an aligned memory area.
  *
  * \param ptr  Pointer to be freed.
- * \return     void
  */
-void FDKafree (void *ptr);
-
+void FDKafree(void *ptr);
 
 /**
  *  Allocate memory in a specific memory section.
  *  Requests can be made for internal or external memory. If internal memory is
- *  requested, FDKcalloc_L() first tries to use L1 memory, which sizes are defined
- *  by ::DATA_L1_A_SIZE and ::DATA_L1_B_SIZE. If no L1 memory is available, then
- *  FDKcalloc_L() tries to use L2 memory. If that fails as well, the requested
- *  memory is allocated at an extern location using the fallback FDKcalloc().
+ *  requested, FDKcalloc_L() first tries to use L1 memory, which sizes are
+ * defined by ::DATA_L1_A_SIZE and ::DATA_L1_B_SIZE. If no L1 memory is
+ * available, then FDKcalloc_L() tries to use L2 memory. If that fails as well,
+ * the requested memory is allocated at an extern location using the fallback
+ * FDKcalloc().
  *
  * \param n     See MSDN documentation on calloc().
  * \param size  See MSDN documentation on calloc().
@@ -302,21 +445,20 @@ void *FDKaalloc_L(const UINT size, const UINT alignment, MEMORY_SECTION s);
 /**
  *  Free memory that was allocated in a specific memory section.
  */
-void  FDKfree_L(void *ptr);
+void FDKfree_L(void *ptr);
 
 /**
  *  Free aligned memory that was allocated in a specific memory section.
  */
-void  FDKafree_L(void *ptr);
-
+void FDKafree_L(void *ptr);
 
 /**
  * Copy memory. Source and destination memory must not overlap.
  * Either use implementation from a Standard Library, or, if no Standard Library
  * is available, a generic implementation.
- * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to use.
- * The function arguments correspond to the standard memcpy(). Please see MSDN
- * documentation for details on how to use it.
+ * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to
+ * use. The function arguments correspond to the standard memcpy(). Please see
+ * MSDN documentation for details on how to use it.
  */
 void FDKmemcpy(void *dst, const void *src, const UINT size);
 
@@ -324,20 +466,20 @@ void FDKmemcpy(void *dst, const void *src, const UINT size);
  * Copy memory. Source and destination memory are allowed to overlap.
  * Either use implementation from a Standard Library, or, if no Standard Library
  * is available, a generic implementation.
- * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to use.
- * The function arguments correspond to the standard memmove(). Please see MSDN
- * documentation for details on how to use it.
-*/
+ * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to
+ * use. The function arguments correspond to the standard memmove(). Please see
+ * MSDN documentation for details on how to use it.
+ */
 void FDKmemmove(void *dst, const void *src, const UINT size);
 
 /**
  * Clear memory.
  * Either use implementation from a Standard Library, or, if no Standard Library
  * is available, a generic implementation.
- * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to use.
- * The function arguments correspond to the standard memclear(). Please see MSDN
- * documentation for details on how to use it.
-*/
+ * The define ::USE_BUILTIN_MEM_FUNCTIONS in genericStds.cpp controls what to
+ * use. The function arguments correspond to the standard memclear(). Please see
+ * MSDN documentation for details on how to use it.
+ */
 void FDKmemclear(void *memPtr, const UINT size);
 
 /**
@@ -348,45 +490,18 @@ void FDKmemclear(void *memPtr, const UINT size);
 void FDKmemset(void *memPtr, const INT value, const UINT size);
 
 /* Compare function wrappers */
-INT   FDKmemcmp(const void *s1, const void *s2, const UINT size);
-INT   FDKstrcmp(const char *s1, const char *s2);
-INT   FDKstrncmp(const char *s1, const char *s2, const UINT size);
+INT FDKmemcmp(const void *s1, const void *s2, const UINT size);
+INT FDKstrcmp(const char *s1, const char *s2);
+INT FDKstrncmp(const char *s1, const char *s2, const UINT size);
 
-UINT  FDKstrlen(const char *s);
+UINT FDKstrlen(const char *s);
 
-#define FDKmax(a,b) ( (a) > (b) ? (a):(b))
-#define FDKmin(a,b) ( (a) < (b) ? (a):(b))
+#define FDKmax(a, b) ((a) > (b) ? (a) : (b))
+#define FDKmin(a, b) ((a) < (b) ? (a) : (b))
 
 #define FDK_INT_MAX ((INT)0x7FFFFFFF)
 #define FDK_INT_MIN ((INT)0x80000000)
 
-/* Math function wrappers. Only intended for compatibility, not to be highly optimized. */
-/* Used for debugging, dev code .. */
-
-INT FDKabs(INT j);
-double FDKfabs(double x);
-double FDKpow(double x, double y);
-double FDKsqrt(double x);
-double FDKatan(double x);
-double FDKlog(double x);
-double FDKsin(double x);
-double FDKcos(double x);
-double FDKexp(double x);
-#define FDKlog2(a) (FDKlog(a)*1.442695041) /* log(2.0) = 1.442695041 */
-#define FDKlog10(a) (FDKlog(a)*0.434294482) /* 1.0/log(10.0) = 0.434294482 */
-double FDKatan2(double y, double x);
-double FDKacos(double x);
-double FDKtan(double x);
-double FDKfloor(double x);
-double FDKceil(double x);
-INT   FDKatoi(const char *nptr);
-long  FDKatol(const char *nptr);
-float FDKatof(const char *nptr);
-/* LONG LONG FDKatoll(const char *nptr); */
-/* LONG LONG FDKatoq(const char *nptr); */
-
-
-
 /* FILE I/O */
 
 /*!
@@ -394,15 +509,7 @@ float FDKatof(const char *nptr);
  *
  * \return  1 if platform is little endian, non-1 if platform is big endian.
  */
-#ifdef __cplusplus
-inline
-#else
-static
-#endif
-int IS_LITTLE_ENDIAN(void) {
-  int __dummy = 1;
-  return ( *( (UCHAR*)(&(__dummy) ) ) );
-}
+int IS_LITTLE_ENDIAN(void);
 
 /*!
  *  Convert input value to little endian format.
@@ -410,11 +517,7 @@ int IS_LITTLE_ENDIAN(void) {
  * \param val  Value to be converted. It may be in both big or little endian.
  * \return     Value in little endian format.
  */
-#define TO_LITTLE_ENDIAN(val) \
-  ( (IS_LITTLE_ENDIAN()) ? \
-     (val) \
-   : ( (((val) & 0xff) << 24) || (((val) & 0xff00)<< 8) || (((val) & 0xff0000)>>8) || (((val) & 0xff000000) >> 24) ) )
-
+UINT TO_LITTLE_ENDIAN(UINT val);
 
 /*!
  * \fn     FDKFILE *FDKfopen(const char *filename, const char *mode);
@@ -427,7 +530,7 @@ int IS_LITTLE_ENDIAN(void) {
  *         Standard ftell() wrapper.
  * \fn     INT FDKfflush(FDKFILE *fp);
  *         Standard fflush() wrapper.
- * \fn     UINT FDKfwrite(void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
+ * \fn     UINT FDKfwrite(const void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
  *         Standard fwrite() wrapper.
  * \fn     UINT FDKfread(void *dst, INT size, UINT nmemb, FDKFILE *fp);
  *         Standard fread() wrapper.
@@ -440,25 +543,27 @@ INT FDKfclose(FDKFILE *FP);
 INT FDKfseek(FDKFILE *FP, LONG OFFSET, int WHENCE);
 INT FDKftell(FDKFILE *FP);
 INT FDKfflush(FDKFILE *fp);
-UINT FDKfwrite(void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
+UINT FDKfwrite(const void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
 UINT FDKfread(void *dst, INT size, UINT nmemb, FDKFILE *fp);
-char* FDKfgets(void *dst, INT size, FDKFILE *fp);
+char *FDKfgets(void *dst, INT size, FDKFILE *fp);
 void FDKrewind(FDKFILE *fp);
 INT FDKfeof(FDKFILE *fp);
 
 /**
- * \brief        Write each member in little endian order. Convert automatically to host endianess.
+ * \brief        Write each member in little endian order. Convert automatically
+ * to host endianess.
  * \param ptrf   Pointer to memory where to read data from.
  * \param size   Size of each item to be written.
  * \param nmemb  Number of items to be written.
  * \param fp     File pointer of type FDKFILE.
  * \return       Number of items read on success and fread() error on failure.
  */
-UINT FDKfwrite_EL(void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
+UINT FDKfwrite_EL(const void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
 
 /**
- * \brief        Read variable of size "size" as little endian. Convert automatically to host endianess.
- *                4-byte alignment is enforced for 24 bit data, at 32 bit full scale.
+ * \brief        Read variable of size "size" as little endian. Convert
+ * automatically to host endianess. 4-byte alignment is enforced for 24 bit
+ * data, at 32 bit full scale.
  * \param dst    Pointer to memory where to store data into.
  * \param size   Size of each item to be read.
  * \param nmemb  Number of items to be read.
@@ -467,7 +572,6 @@ UINT FDKfwrite_EL(void *ptrf, INT size, UINT nmemb, FDKFILE *fp);
  */
 UINT FDKfread_EL(void *dst, INT size, UINT nmemb, FDKFILE *fp);
 
-
 /**
  * \brief  Print FDK software disclaimer.
  */
@@ -477,4 +581,4 @@ void FDKprintDisclaimer(void);
 }
 #endif
 
-#endif /* __GENERICSTDS_H__ */
+#endif /* GENERICSTDS_H */