Home | History | Annotate | Download | only in src
      1 
      2 /* -----------------------------------------------------------------------------------------------------------
      3 Software License for The Fraunhofer FDK AAC Codec Library for Android
      4 
      5  Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V.
      6   All rights reserved.
      7 
      8  1.    INTRODUCTION
      9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
     10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
     11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
     12 
     13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
     14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
     15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
     16 of the MPEG specifications.
     17 
     18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
     19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
     20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
     21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
     22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
     23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
     24 
     25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
     26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
     27 applications information and documentation.
     28 
     29 2.    COPYRIGHT LICENSE
     30 
     31 Redistribution and use in source and binary forms, with or without modification, are permitted without
     32 payment of copyright license fees provided that you satisfy the following conditions:
     33 
     34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
     35 your modifications thereto in source code form.
     36 
     37 You must retain the complete text of this software license in the documentation and/or other materials
     38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
     39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
     40 modifications thereto to recipients of copies in binary form.
     41 
     42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
     43 prior written permission.
     44 
     45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
     46 software or your modifications thereto.
     47 
     48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
     49 and the date of any change. For modified versions of the FDK AAC Codec, the term
     50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
     51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
     52 
     53 3.    NO PATENT LICENSE
     54 
     55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
     56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
     57 respect to this software.
     58 
     59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
     60 by appropriate patent licenses.
     61 
     62 4.    DISCLAIMER
     63 
     64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
     65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
     66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
     68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
     69 or business interruption, however caused and on any theory of liability, whether in contract, strict
     70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
     71 advised of the possibility of such damage.
     72 
     73 5.    CONTACT INFORMATION
     74 
     75 Fraunhofer Institute for Integrated Circuits IIS
     76 Attention: Audio and Multimedia Departments - FDK AAC LL
     77 Am Wolfsmantel 33
     78 91058 Erlangen, Germany
     79 
     80 www.iis.fraunhofer.de/amm
     81 amm-info (at) iis.fraunhofer.de
     82 ----------------------------------------------------------------------------------------------------------- */
     83 
     84 /**************************  Fraunhofer IIS FDK SysLib  **********************
     85 
     86    Author(s):
     87    Description: - Generic memory, stdio, string, etc. function wrappers or
     88                   builtins.
     89                 - OS dependant function wrappers.
     90 
     91 ******************************************************************************/
     92 
     93 #define _CRT_SECURE_NO_WARNINGS
     94 
     95 #include "genericStds.h"
     96 
     97 #include <math.h>
     98 
     99 /* library info */
    100 #define SYS_LIB_VL0 1
    101 #define SYS_LIB_VL1 3
    102 #define SYS_LIB_VL2 4
    103 #define SYS_LIB_TITLE "System Integration Library"
    104 #define SYS_LIB_BUILD_DATE __DATE__
    105 #define SYS_LIB_BUILD_TIME __TIME__
    106 
    107   #include <stdlib.h>
    108   #include <stdio.h>
    109   #include <string.h>
    110     #include <stdarg.h>
    111 
    112 
    113 /***************************************************************
    114  * memory allocation monitoring variables
    115  ***************************************************************/
    116 
    117 
    118 /* Include OS/System specific implementations. */
    119 #if defined(__linux__)	/* cppp replaced: elif */
    120   #include "linux/genericStds_linux.cpp"
    121 #endif
    122 
    123 
    124 #if !(defined(USE_BUILTIN_STRING_FUNCTIONS) || defined(__SYMBIAN32__))
    125 #include <string.h>
    126 #include <stdlib.h>
    127 #include <stdio.h>
    128 
    129 #ifndef FUNCTION_FDKprintf
    130 void  FDKprintf( const char* szFmt, ...)    {
    131   va_list ap;
    132   va_start(ap, szFmt);
    133   vprintf(szFmt, ap);
    134   va_end(ap);
    135 #ifdef ARCH_WA_FLUSH_CONSOLE
    136   fflush(stdout);
    137 #endif
    138 }
    139 #endif
    140 
    141 #ifndef FUNCTION_FDKprintfErr
    142 void  FDKprintfErr( const char* szFmt, ...) {
    143   va_list ap;
    144   va_start(ap, szFmt);
    145 #if defined(ARCH_WA_SLOWCON)
    146   vprintf(szFmt, ap);
    147 #else
    148   vfprintf(stderr, szFmt, ap);
    149 #endif
    150   va_end(ap);
    151 #ifdef ARCH_WA_FLUSH_CONSOLE
    152   fflush(stderr);
    153 #endif
    154 }
    155 #endif
    156 
    157 int FDKgetchar(void) { return getchar(); }
    158 
    159 INT  FDKfprintf(FDKFILE  *stream,  const  char *format, ...) {
    160   INT chars = 0;
    161   va_list ap;
    162   va_start(ap, format);
    163   chars += vfprintf((FILE*)stream, format, ap);
    164   va_end(ap);
    165   return chars;
    166 }
    167 
    168 #ifndef FUNCTION_FDKsprintf
    169 INT  FDKsprintf(char *str, const char *format, ...) {
    170   INT chars = 0;
    171   va_list ap;
    172   va_start(ap, format);
    173   chars += vsprintf(str, format, ap);
    174   va_end(ap);
    175   return chars;
    176 }
    177 #endif
    178 
    179 #else
    180 
    181 void FDKprintf( const char* szFmt, ...) { /* stub! */; }
    182 void FDKprintfErr( const char* szFmt, ...) { /* stub! */; }
    183 INT  FDKfprintf(FILE  *stream,  const  char *format, ...) { /*stub ! */; }
    184 INT  FDKsprintf(char *str, const char *format, ...) { /* stub! */; }
    185 
    186 #endif
    187 
    188 /************************************************************************************************/
    189 
    190 
    191 const char *FDKstrchr(const char *s, INT c)                       { return strchr(s, c); }
    192 const char *FDKstrstr(const char *haystack, const char *needle)   { return strstr(haystack, needle); }
    193 #ifndef FUNCTION_FDKstrcpy
    194 char *FDKstrcpy(char *dest, const char *src)                      { return strcpy(dest, src); }
    195 #endif
    196 char *FDKstrncpy(char *dest, const char *src, UINT n)             { return strncpy(dest, src, n); }
    197 
    198 /*************************************************************************
    199  * DYNAMIC MEMORY management (heap)
    200  *************************************************************************/
    201 
    202 #ifndef FUNCTION_FDKcalloc
    203 void *FDKcalloc (const UINT n, const UINT size)
    204 {
    205   void* ptr;
    206 
    207   ptr = calloc(n, size);
    208 
    209   return ptr;
    210 }
    211 #endif
    212 
    213 #ifndef FUNCTION_FDKmalloc
    214 void *FDKmalloc (const UINT size)
    215 {
    216   void* ptr;
    217 
    218   ptr = malloc(size);
    219 
    220   return ptr;
    221 }
    222 #endif
    223 
    224 #ifndef FUNCTION_FDKfree
    225 void  FDKfree (void *ptr)
    226 {
    227   /* FDKprintf("f, heapSize: %d\n", heapSizeCurr); */
    228   free((INT*)ptr);
    229 }
    230 #endif
    231 
    232 #ifndef FUNCTION_FDKaalloc
    233 void *FDKaalloc(const UINT size, const UINT alignment)
    234 {
    235   void *addr, *result=NULL;
    236   addr = FDKcalloc(1, size + alignment + sizeof(void*));               /* Malloc and clear memory.         */
    237 
    238   if (addr!=NULL)
    239   {
    240     result = ALIGN_PTR((unsigned char*)addr + sizeof(void*));    /* Get aligned memory base address. */
    241     *(((void**)result) - 1) = addr;                /* Save malloc'ed memory pointer.   */
    242   }
    243 
    244   return result;                                 /* Return aligned address.          */
    245 }
    246 #endif
    247 
    248 #ifndef FUNCTION_FDKafree
    249 void  FDKafree (void *ptr)
    250 {
    251   void *addr;
    252   addr = *(((void**)ptr)-1); /* Get pointer to malloc'ed memory. */
    253   FDKfree(addr);                /* Free malloc'ed memory area.      */
    254 }
    255 #endif
    256 
    257 
    258 #ifndef FUNCTION_FDKcalloc_L
    259 
    260 /*--------------------------------------------------------------------------*
    261  * DATA MEMORY L1/L2 (fallback)
    262  *--------------------------------------------------------------------------*/
    263 
    264 
    265 
    266 /*--------------------------------------------------------------------------*
    267  * FDKcalloc_L
    268  *--------------------------------------------------------------------------*/
    269 void *FDKcalloc_L(const UINT dim, const UINT size, MEMORY_SECTION s)
    270 {
    271   int a_size;
    272 
    273   if (s == SECT_DATA_EXTERN)
    274     goto fallback;
    275 
    276   a_size = ((dim*size+3)&0xfffffffc); /* force 4 byte alignment (1111 .... 1111 1100) */
    277 
    278 
    279 
    280 
    281 
    282   //printf("Warning, out of internal memory\n");
    283 
    284 fallback:
    285   return FDKcalloc(dim, size);
    286 }
    287 #endif /* FUNCTION_FDKcalloc_L */
    288 
    289 #ifndef FUNCTION_FDKfree_L
    290 void  FDKfree_L (void *p)
    291 {
    292 
    293     FDKfree(p);
    294 }
    295 #endif /* FUNCTION_FDKfree_L */
    296 
    297 #ifndef FUNCTION_FDKaalloc_L
    298 void *FDKaalloc_L(const UINT size, const UINT alignment, MEMORY_SECTION s)
    299 {
    300   void *addr, *result=NULL;
    301   addr = FDKcalloc_L(1, size + alignment + sizeof(void*), s);       /* Malloc and clear memory.         */
    302 
    303   if (addr!=NULL)
    304   {
    305     result = ALIGN_PTR((unsigned char *)addr + sizeof(void*));    /* Get aligned memory base address. */
    306     *(((void**)result) - 1) = addr;                /* Save malloc'ed memory pointer.   */
    307   }
    308 
    309   return result;                                 /* Return aligned address.          */
    310 }
    311 #endif
    312 
    313 #ifndef FUNCTION_FDKafree_L
    314 void  FDKafree_L (void *ptr)
    315 {
    316   void *addr;
    317 
    318   addr = *(((void**)ptr)-1); /* Get pointer to malloc'ed memory. */
    319   FDKfree_L(addr);                /* Free malloc'ed memory area.      */
    320 }
    321 #endif
    322 
    323 
    324 
    325 /*---------------------------------------------------------------------------------------
    326  * FUNCTION:    FDKmemcpy
    327  * DESCRIPTION: - copies memory from "src" to "dst" with length "size" bytes
    328  *              - compiled with FDK_DEBUG will give you warnings
    329  *---------------------------------------------------------------------------------------*/
    330 void FDKmemcpy(void *dst, const void *src, const UINT size)
    331 {
    332 
    333   /* do the copy */
    334   memcpy(dst, src, size);
    335 }
    336 
    337 void FDKmemmove(void *dst, const void *src, const UINT size)     { memmove(dst, src, size); }
    338 void FDKmemset(void *memPtr, const INT value, const UINT size)   { memset(memPtr, value, size); }
    339 void FDKmemclear(void *memPtr, const UINT size)                  { FDKmemset(memPtr,0,size); }
    340 UINT FDKstrlen(const char *s)                                    { return (UINT)strlen(s); }
    341 
    342 /* Compare function wrappers */
    343 INT FDKmemcmp(const void *s1, const void *s2, const UINT size)  { return memcmp(s1, s2, size); }
    344 INT FDKstrcmp(const char *s1, const char *s2)                   { return strcmp(s1, s2); }
    345 INT FDKstrncmp(const char *s1, const char *s2, const UINT size) { return strncmp(s1, s2, size); }
    346 
    347 
    348 /* Math function wrappers. Only intended for compatibility, not to be highly optimized. */
    349 
    350 INT FDKabs(INT j) { return abs(j); }
    351 double FDKfabs(double x) { return fabs(x); }
    352 double FDKpow(double x, double y) { return pow(x,y); }
    353 double FDKsqrt(double x) { return sqrt(x); }
    354 double FDKatan(double x) { return atan(x); }
    355 double FDKlog(double x) { return log(x); }
    356 double FDKsin(double x) { return sin(x); }
    357 double FDKcos(double x) { return cos(x); }
    358 double FDKexp(double x) { return exp(x); }
    359 double FDKatan2(double y, double x) { return atan2(y, x); }
    360 double FDKacos(double x) { return acos(x); }
    361 double FDKtan(double x) { return tan(x); }
    362 double FDKfloor(double x) { return floor(x); }
    363 double FDKceil(double x) { return ceil(x); }
    364 
    365 INT   FDKatoi(const char *nptr) { return atoi(nptr); }
    366 long  FDKatol(const char *nptr) { return atol(nptr); }
    367 float FDKatof(const char *nptr) { return (float)atof(nptr); }
    368 
    369 
    370 /* ==================== FILE I/O ====================== */
    371 
    372 #if !defined(FUNCTION_FDKfopen)
    373 FDKFILE *FDKfopen(const char *filename, const char *mode) { return fopen(filename, mode); }
    374 #endif
    375 #if !defined(FUNCTION_FDKfclose)
    376 INT FDKfclose(FDKFILE *fp) { return fclose((FILE*)fp);}
    377 #endif
    378 #if !defined(FUNCTION_FDKfseek)
    379 INT FDKfseek(FDKFILE *fp, LONG OFFSET, int WHENCE) { return fseek((FILE*)fp, OFFSET, WHENCE);}
    380 #endif
    381 #if !defined(FUNCTION_FDKftell)
    382 INT FDKftell(FDKFILE *fp) { return ftell((FILE*)fp); }
    383 #endif
    384 #if !defined(FUNCTION_FDKfflush)
    385 INT FDKfflush(FDKFILE *fp) { return fflush((FILE*)fp); }
    386 #endif
    387 const INT FDKSEEK_SET = SEEK_SET;
    388 const INT FDKSEEK_CUR = SEEK_CUR;
    389 const INT FDKSEEK_END = SEEK_END;
    390 
    391 #if !defined(FUNCTION_FDKfwrite)
    392 UINT FDKfwrite(void *ptrf, INT size, UINT nmemb, FDKFILE *fp) { return fwrite(ptrf, size, nmemb, (FILE*)fp); }
    393 #endif
    394 #if !defined(FUNCTION_FDKfread)
    395 UINT FDKfread(void *dst, INT size, UINT nmemb, FDKFILE *fp) { return fread(dst, size, nmemb, (FILE*)fp); }
    396 #endif
    397 #if !defined(FUNCTION_FDKfgets)
    398 char* FDKfgets(void *dst, INT size, FDKFILE *fp) { return fgets((char *)dst, size, (FILE*)fp); }
    399 #endif
    400 #if !defined(FUNCTION_FDKrewind)
    401 void FDKrewind(FDKFILE *fp) { FDKfseek((FILE*)fp,0,FDKSEEK_SET); }
    402 #endif
    403 
    404 
    405 UINT FDKfwrite_EL(void *ptrf, INT size, UINT nmemb, FDKFILE *fp) {
    406 
    407     if (IS_LITTLE_ENDIAN()) {
    408       FDKfwrite(ptrf, size, nmemb, fp);
    409     } else {
    410       UINT n;
    411       INT s;
    412 
    413       UCHAR *ptr = (UCHAR*) ptrf;
    414 
    415       for (n=0; n<nmemb; n++) {
    416         for (s=size-1; s>=0; s--) {
    417           //FDKprintf("char = %c\n", (char)*(ptr+s));
    418           FDKfwrite(ptr + s, 1, 1, fp);
    419         }
    420         ptr = ptr + size;
    421       }
    422     }
    423     return nmemb;
    424 }
    425 
    426 
    427 UINT FDKfread_EL(void *dst, INT size, UINT nmemb, FDKFILE *fp) {
    428   UINT n, s0, s1, err;
    429   UCHAR tmp, *ptr;
    430   UCHAR tmp24[3];
    431 
    432   /* Enforce alignment of 24 bit data. */
    433   if (size == 3) {
    434     ptr = (UCHAR*)dst;
    435     err = 0;
    436     for (n=0; n<nmemb; n++) {
    437       if ((err = FDKfread(tmp24, 1, 3, fp)) != 3) {
    438         return err;
    439       }
    440       *ptr++ = tmp24[0];
    441       *ptr++ = tmp24[1];
    442       *ptr++ = tmp24[2];
    443       /* Sign extension */
    444       if (tmp24[2] & 0x80) {
    445         *ptr++ = 0xff;
    446       } else {
    447         *ptr++ = 0;
    448       }
    449     }
    450     err = nmemb;
    451     size = sizeof(LONG);
    452   } else {
    453     if ((err = FDKfread(dst, size, nmemb, fp)) != nmemb) {
    454       return err;
    455     }
    456   }
    457   if (!IS_LITTLE_ENDIAN() && size > 1) {
    458     ptr = (UCHAR*)dst;
    459     for (n=0; n<nmemb; n++) {
    460       for (s0=0, s1=size-1; s0 < s1; s0++, s1--) {
    461         tmp = ptr[s0];
    462         ptr[s0] = ptr[s1];
    463         ptr[s1] = tmp;
    464       }
    465       ptr += size;
    466     }
    467   }
    468   return err;
    469 }
    470 
    471 INT FDKfeof(FDKFILE *fp) { return feof((FILE*)fp); }
    472 
    473 /* Global initialization/cleanup */
    474 
    475 #if defined(_DEBUG) && defined(_WIN32) && !defined(_WIN32_WCE)
    476   #define _CRTDBG_MAP_ALLOC
    477   #include <crtdbg.h>
    478 #endif
    479 
    480 
    481 
    482 
    483 void FDKprintDisclaimer(void)
    484 {
    485   FDKprintf(
    486   "This program is protected by copyright law and international treaties.\n"  \
    487   "Any reproduction or distribution of this program, or any portion\n"        \
    488   "of it, may result in severe civil and criminal penalties, and will be\n"   \
    489   "prosecuted to the maximum extent possible under law.\n\n");
    490 }
    491 
    492