1
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5 � Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung 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@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
FDKprintf(const char * szFmt,...)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
FDKprintfErr(const char * szFmt,...)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
FDKgetchar(void)157 int FDKgetchar(void) { return getchar(); }
158
FDKfprintf(FDKFILE * stream,const char * format,...)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
FDKsprintf(char * str,const char * format,...)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
FDKprintf(const char * szFmt,...)181 void FDKprintf( const char* szFmt, ...) { /* stub! */; }
FDKprintfErr(const char * szFmt,...)182 void FDKprintfErr( const char* szFmt, ...) { /* stub! */; }
FDKfprintf(FILE * stream,const char * format,...)183 INT FDKfprintf(FILE *stream, const char *format, ...) { /*stub ! */; }
FDKsprintf(char * str,const char * format,...)184 INT FDKsprintf(char *str, const char *format, ...) { /* stub! */; }
185
186 #endif
187
188 /************************************************************************************************/
189
190
FDKstrchr(const char * s,INT c)191 const char *FDKstrchr(const char *s, INT c) { return strchr(s, c); }
FDKstrstr(const char * haystack,const char * needle)192 const char *FDKstrstr(const char *haystack, const char *needle) { return strstr(haystack, needle); }
193 #ifndef FUNCTION_FDKstrcpy
FDKstrcpy(char * dest,const char * src)194 char *FDKstrcpy(char *dest, const char *src) { return strcpy(dest, src); }
195 #endif
FDKstrncpy(char * dest,const char * src,UINT n)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
FDKcalloc(const UINT n,const UINT size)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
FDKmalloc(const UINT size)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
FDKfree(void * ptr)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
FDKaalloc(const UINT size,const UINT alignment)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
FDKafree(void * ptr)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 *--------------------------------------------------------------------------*/
FDKcalloc_L(const UINT dim,const UINT size,MEMORY_SECTION s)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
FDKfree_L(void * p)290 void FDKfree_L (void *p)
291 {
292
293 FDKfree(p);
294 }
295 #endif /* FUNCTION_FDKfree_L */
296
297 #ifndef FUNCTION_FDKaalloc_L
FDKaalloc_L(const UINT size,const UINT alignment,MEMORY_SECTION s)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
FDKafree_L(void * ptr)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 *---------------------------------------------------------------------------------------*/
FDKmemcpy(void * dst,const void * src,const UINT size)330 void FDKmemcpy(void *dst, const void *src, const UINT size)
331 {
332
333 /* do the copy */
334 memcpy(dst, src, size);
335 }
336
FDKmemmove(void * dst,const void * src,const UINT size)337 void FDKmemmove(void *dst, const void *src, const UINT size) { memmove(dst, src, size); }
FDKmemset(void * memPtr,const INT value,const UINT size)338 void FDKmemset(void *memPtr, const INT value, const UINT size) { memset(memPtr, value, size); }
FDKmemclear(void * memPtr,const UINT size)339 void FDKmemclear(void *memPtr, const UINT size) { FDKmemset(memPtr,0,size); }
FDKstrlen(const char * s)340 UINT FDKstrlen(const char *s) { return (UINT)strlen(s); }
341
342 /* Compare function wrappers */
FDKmemcmp(const void * s1,const void * s2,const UINT size)343 INT FDKmemcmp(const void *s1, const void *s2, const UINT size) { return memcmp(s1, s2, size); }
FDKstrcmp(const char * s1,const char * s2)344 INT FDKstrcmp(const char *s1, const char *s2) { return strcmp(s1, s2); }
FDKstrncmp(const char * s1,const char * s2,const UINT size)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
FDKabs(INT j)350 INT FDKabs(INT j) { return abs(j); }
FDKfabs(double x)351 double FDKfabs(double x) { return fabs(x); }
FDKpow(double x,double y)352 double FDKpow(double x, double y) { return pow(x,y); }
FDKsqrt(double x)353 double FDKsqrt(double x) { return sqrt(x); }
FDKatan(double x)354 double FDKatan(double x) { return atan(x); }
FDKlog(double x)355 double FDKlog(double x) { return log(x); }
FDKsin(double x)356 double FDKsin(double x) { return sin(x); }
FDKcos(double x)357 double FDKcos(double x) { return cos(x); }
FDKexp(double x)358 double FDKexp(double x) { return exp(x); }
FDKatan2(double y,double x)359 double FDKatan2(double y, double x) { return atan2(y, x); }
FDKacos(double x)360 double FDKacos(double x) { return acos(x); }
FDKtan(double x)361 double FDKtan(double x) { return tan(x); }
FDKfloor(double x)362 double FDKfloor(double x) { return floor(x); }
FDKceil(double x)363 double FDKceil(double x) { return ceil(x); }
364
FDKatoi(const char * nptr)365 INT FDKatoi(const char *nptr) { return atoi(nptr); }
FDKatol(const char * nptr)366 long FDKatol(const char *nptr) { return atol(nptr); }
FDKatof(const char * nptr)367 float FDKatof(const char *nptr) { return (float)atof(nptr); }
368
369
370 /* ==================== FILE I/O ====================== */
371
372 #if !defined(FUNCTION_FDKfopen)
FDKfopen(const char * filename,const char * mode)373 FDKFILE *FDKfopen(const char *filename, const char *mode) { return fopen(filename, mode); }
374 #endif
375 #if !defined(FUNCTION_FDKfclose)
FDKfclose(FDKFILE * fp)376 INT FDKfclose(FDKFILE *fp) { return fclose((FILE*)fp);}
377 #endif
378 #if !defined(FUNCTION_FDKfseek)
FDKfseek(FDKFILE * fp,LONG OFFSET,int WHENCE)379 INT FDKfseek(FDKFILE *fp, LONG OFFSET, int WHENCE) { return fseek((FILE*)fp, OFFSET, WHENCE);}
380 #endif
381 #if !defined(FUNCTION_FDKftell)
FDKftell(FDKFILE * fp)382 INT FDKftell(FDKFILE *fp) { return ftell((FILE*)fp); }
383 #endif
384 #if !defined(FUNCTION_FDKfflush)
FDKfflush(FDKFILE * fp)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)
FDKfwrite(void * ptrf,INT size,UINT nmemb,FDKFILE * fp)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)
FDKfread(void * dst,INT size,UINT nmemb,FDKFILE * fp)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)
FDKfgets(void * dst,INT size,FDKFILE * fp)398 char* FDKfgets(void *dst, INT size, FDKFILE *fp) { return fgets((char *)dst, size, (FILE*)fp); }
399 #endif
400 #if !defined(FUNCTION_FDKrewind)
FDKrewind(FDKFILE * fp)401 void FDKrewind(FDKFILE *fp) { FDKfseek((FILE*)fp,0,FDKSEEK_SET); }
402 #endif
403
404
FDKfwrite_EL(void * ptrf,INT size,UINT nmemb,FDKFILE * fp)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
FDKfread_EL(void * dst,INT size,UINT nmemb,FDKFILE * fp)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
FDKfeof(FDKFILE * fp)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
FDKprintDisclaimer(void)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