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
