summaryrefslogtreecommitdiffstats
path: root/libSYS/include/genericStds.h
diff options
context:
space:
mode:
authorDave Burke <daveburke@google.com>2012-04-17 09:51:45 -0700
committerDave Burke <daveburke@google.com>2012-04-17 23:04:43 -0700
commit9bf37cc9712506b2483650c82d3c41152337ef7e (patch)
tree77db44e2bae06e3d144b255628be2b7a55c581d3 /libSYS/include/genericStds.h
parenta37315fe10ee143d6d0b28c19d41a476a23e63ea (diff)
downloadODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.gz
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.bz2
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.zip
Fraunhofer AAC codec.
License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5
Diffstat (limited to 'libSYS/include/genericStds.h')
-rw-r--r--libSYS/include/genericStds.h421
1 files changed, 421 insertions, 0 deletions
diff --git a/libSYS/include/genericStds.h b/libSYS/include/genericStds.h
new file mode 100644
index 0000000..8009050
--- /dev/null
+++ b/libSYS/include/genericStds.h
@@ -0,0 +1,421 @@
+/************************** Fraunhofer IIS FDK SysLib **********************
+
+ (C) Copyright Fraunhofer IIS (2002)
+ All Rights Reserved
+
+ Please be advised that this software and/or program delivery is
+ Confidential Information of Fraunhofer and subject to and covered by the
+
+ Fraunhofer IIS Software Evaluation Agreement
+ between Google Inc. and Fraunhofer
+ effective and in full force since March 1, 2012.
+
+ You may use this software and/or program only under the terms and
+ conditions described in the above mentioned Fraunhofer IIS Software
+ Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+ $Id$
+ Author(s):
+
+ This software and/or program is protected by copyright law and international
+ treaties. Any reproduction or distribution of this software and/or program,
+ or any portion of it, may result in severe civil and criminal penalties, and
+ will be prosecuted to the maximum extent possible under law.
+
+******************************************************************************/
+
+/** \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"
+
+/* Work around for broken android toolchain: sys/types.h:137: error: 'uint64_t' does not name a type */
+#define _SYS_TYPES_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__ */