diff options
Diffstat (limited to 'libSYS/include/genericStds.h')
| -rw-r--r-- | libSYS/include/genericStds.h | 480 |
1 files changed, 0 insertions, 480 deletions
diff --git a/libSYS/include/genericStds.h b/libSYS/include/genericStds.h deleted file mode 100644 index fe4dc36..0000000 --- a/libSYS/include/genericStds.h +++ /dev/null @@ -1,480 +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 SysLib ********************** - - Author(s): - -******************************************************************************/ - -/** \file genericStds.h - \brief Generic Run-Time Support function wrappers and heap allocation monitoring. - */ - -#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. */ -#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. - */ -typedef enum { - /* Internal */ - SECT_DATA_L1 = 0x2000, - SECT_DATA_L2, - SECT_DATA_L1_A, - SECT_DATA_L1_B, - SECT_CONSTDATA_L1, - - /* External */ - SECT_DATA_EXTERN = 0x4000, - SECT_CONSTDATA_EXTERN - -} MEMORY_SECTION; - - -/** - * The H_ prefix indicates header file version, the C_* prefix indicates the corresponding - * object version. - * - * Declaring memory areas requires to specify a unique name and a data type. Use the H_ macro - * for this purpose inside a header 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. - * - * 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). - * - * 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. - * - */ - -#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) - - -/*-------------------------------------------- - * Runtime support declarations - *---------------------------------------------*/ -#ifdef __cplusplus -extern "C" { -#endif - -/** printf() using stdout. If ::ARCH_WA_FLUSH_CONSOLE defined, a flush is done additionally after printf(). */ -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, ...); - -/** Wrapper for <stdio.h>'s getchar(). */ -int FDKgetchar(void); - -INT FDKfprintf(void *stream, const char *format, ...); -INT FDKsprintf(char *str, const char *format, ...); - - - -const char *FDKstrchr(const 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. */ - - -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. - * - * \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); - -/** - * Free an aligned memory area. - * - * \param ptr Pointer to be freed. - * \return void - */ -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(). - * - * \param n See MSDN documentation on calloc(). - * \param size See MSDN documentation on calloc(). - * \param s Memory section. - * \return See MSDN documentation on calloc(). - */ -void *FDKcalloc_L(const UINT n, const UINT size, MEMORY_SECTION s); - -/** - * Allocate aligned memory in a specific memory section. - * See FDKcalloc_L() description for details - same applies here. - */ -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); - -/** - * Free aligned memory that was allocated in a specific memory section. - */ -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. - */ -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. -*/ -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. -*/ -void FDKmemclear(void *memPtr, const UINT size); - -/** - * Fill memory with values. - * The function arguments correspond to the standard memset(). Please see MSDN - * documentation for details on how to use it. - */ -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); - -UINT FDKstrlen(const char *s); - -#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 */ - -/*! - * Check platform for endianess. - * - * \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) ) ) ); -} - -/*! - * Convert input value to little endian format. - * - * \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) ) ) - - -/*! - * \fn FDKFILE *FDKfopen(const char *filename, const char *mode); - * Standard fopen() wrapper. - * \fn INT FDKfclose(FDKFILE *FP); - * Standard fclose() wrapper. - * \fn INT FDKfseek(FDKFILE *FP, LONG OFFSET, int WHENCE); - * Standard fseek() wrapper. - * \fn INT FDKftell(FDKFILE *FP); - * Standard ftell() wrapper. - * \fn INT FDKfflush(FDKFILE *fp); - * Standard fflush() wrapper. - * \fn UINT FDKfwrite(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. - */ -typedef void FDKFILE; -extern const INT FDKSEEK_SET, FDKSEEK_CUR, FDKSEEK_END; - -FDKFILE *FDKfopen(const char *filename, const char *mode); -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 FDKfread(void *dst, INT size, UINT nmemb, 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. - * \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); - -/** - * \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. - * \param fp File pointer of type FDKFILE. - * \return Number of items read on success and fread() error on failure. - */ -UINT FDKfread_EL(void *dst, INT size, UINT nmemb, FDKFILE *fp); - - -/** - * \brief Print FDK software disclaimer. - */ -void FDKprintDisclaimer(void); - -#ifdef __cplusplus -} -#endif - -#endif /* __GENERICSTDS_H__ */ |