├── SimpleLameLibForAndroid
    ├── res
    │   └── .gitignore
    ├── jni
    │   ├── Application.mk
    │   ├── com_uraroji_garage_android_lame_Lame.c
    │   ├── com_uraroji_garage_android_lame_Encoder_Builder.h
    │   ├── com_uraroji_garage_android_lame_Lame.h
    │   ├── lame-3.99.5_libmp3lame
    │   │   ├── lameerror.h
    │   │   ├── newmdct.h
    │   │   ├── vector
    │   │   │   ├── lame_intrin.h
    │   │   │   ├── Makefile.am
    │   │   │   ├── xmm_quantize_sub.c
    │   │   │   └── Makefile.in
    │   │   ├── vbrquantize.h
    │   │   ├── reservoir.h
    │   │   ├── fft.h
    │   │   ├── quantize.h
    │   │   ├── bitstream.h
    │   │   ├── id3tag.h
    │   │   ├── psymodel.h
    │   │   ├── version.h
    │   │   ├── l3side.h
    │   │   ├── tables.h
    │   │   ├── set_get.h
    │   │   ├── VbrTag.h
    │   │   ├── lame-analysis.h
    │   │   ├── gain_analysis.h
    │   │   ├── encoder.h
    │   │   ├── quantize_pvt.h
    │   │   ├── machine.h
    │   │   ├── version.c
    │   │   ├── lame_global_flags.h
    │   │   ├── fft.c
    │   │   ├── reservoir.c
    │   │   ├── mpglib_interface.c
    │   │   ├── presets.c
    │   │   └── encoder.c
    │   ├── simple_lame_lib.h
    │   ├── Android.mk
    │   ├── com_uraroji_garage_android_lame_Encoder.h
    │   ├── com_uraroji_garage_android_lame_Encoder.cpp
    │   ├── Note.txt
    │   └── simple_lame_lib.c
    ├── .settings
    │   └── org.eclipse.core.resources.prefs
    ├── libs
    │   ├── mips
    │   │   └── libmp3lame.so
    │   ├── x86
    │   │   └── libmp3lame.so
    │   ├── armeabi
    │   │   └── libmp3lame.so
    │   └── armeabi-v7a
    │   │   └── libmp3lame.so
    ├── create_jni_header.sh
    ├── AndroidManifest.xml
    ├── .classpath
    ├── project.properties
    ├── .project
    ├── src
    │   └── com
    │   │   └── uraroji
    │   │       └── garage
    │   │           └── android
    │   │               └── lame
    │   │                   ├── Lame.java
    │   │                   └── Encoder.java
    └── build.xml
├── .gitignore
└── README.md


/SimpleLameLibForAndroid/res/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/Application.mk:
--------------------------------------------------------------------------------
1 | APP_ABI := all
2 | APP_STL := stlport_static


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | SimpleLameLibForAndroid/bin/
2 | SimpleLameLibForAndroid/gen/
3 | SimpleLameLibForAndroid/obj/
4 | .DS_Store
5 | 
6 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/.settings/org.eclipse.core.resources.prefs:
--------------------------------------------------------------------------------
1 | #Sat Nov 19 12:41:55 JST 2011
2 | eclipse.preferences.version=1
3 | encoding/<project>=UTF-8
4 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/libs/mips/libmp3lame.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yhirano/SimpleLameLibForAndroid/HEAD/SimpleLameLibForAndroid/libs/mips/libmp3lame.so


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/libs/x86/libmp3lame.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yhirano/SimpleLameLibForAndroid/HEAD/SimpleLameLibForAndroid/libs/x86/libmp3lame.so


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/libs/armeabi/libmp3lame.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yhirano/SimpleLameLibForAndroid/HEAD/SimpleLameLibForAndroid/libs/armeabi/libmp3lame.so


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/libs/armeabi-v7a/libmp3lame.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yhirano/SimpleLameLibForAndroid/HEAD/SimpleLameLibForAndroid/libs/armeabi-v7a/libmp3lame.so


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/create_jni_header.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | javah -classpath bin/classes -d jni com.uraroji.garage.android.lame.Encoder
3 | javah -classpath bin/classes -d jni com.uraroji.garage.android.lame.Lame
4 | 
5 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/com_uraroji_garage_android_lame_Lame.c:
--------------------------------------------------------------------------------
1 | #include "com_uraroji_garage_android_lame_Encoder.h"
2 | #include "simple_lame_lib.h"
3 | 
4 | JNIEXPORT void JNICALL Java_com_uraroji_garage_android_lame_Lame_log
5 |   (JNIEnv *env, jclass cls, jboolean on) {
6 | 	simple_lame_lib_log(on);
7 | }
8 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3 |     package="com.uraroji.garage.android.lame"
4 |     android:versionCode="1"
5 |     android:versionName="1.0" >
6 | 
7 |     <uses-sdk android:minSdkVersion="7" />
8 | 
9 | </manifest>


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/.classpath:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <classpath>
3 | 	<classpathentry kind="src" path="src"/>
4 | 	<classpathentry kind="src" path="gen"/>
5 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
6 | 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
7 | 	<classpathentry kind="output" path="bin/classes"/>
8 | </classpath>
9 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/project.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must be checked in Version Control Systems.
 5 | #
 6 | # To customize properties used by the Ant build system use,
 7 | # "ant.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | 
10 | # Project target.
11 | target=android-7
12 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/com_uraroji_garage_android_lame_Encoder_Builder.h:
--------------------------------------------------------------------------------
 1 | /* DO NOT EDIT THIS FILE - it is machine generated */
 2 | #include <jni.h>
 3 | /* Header for class com_uraroji_garage_android_lame_Encoder_Builder */
 4 | 
 5 | #ifndef _Included_com_uraroji_garage_android_lame_Encoder_Builder
 6 | #define _Included_com_uraroji_garage_android_lame_Encoder_Builder
 7 | #ifdef __cplusplus
 8 | extern "C" {
 9 | #endif
10 | #ifdef __cplusplus
11 | }
12 | #endif
13 | #endif
14 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/com_uraroji_garage_android_lame_Lame.h:
--------------------------------------------------------------------------------
 1 | /* DO NOT EDIT THIS FILE - it is machine generated */
 2 | #include <jni.h>
 3 | /* Header for class com_uraroji_garage_android_lame_Lame */
 4 | 
 5 | #ifndef _Included_com_uraroji_garage_android_lame_Lame
 6 | #define _Included_com_uraroji_garage_android_lame_Lame
 7 | #ifdef __cplusplus
 8 | extern "C" {
 9 | #endif
10 | /*
11 |  * Class:     com_uraroji_garage_android_lame_Lame
12 |  * Method:    log
13 |  * Signature: (Z)V
14 |  */
15 | JNIEXPORT void JNICALL Java_com_uraroji_garage_android_lame_Lame_log
16 |   (JNIEnv *, jclass, jboolean);
17 | 
18 | #ifdef __cplusplus
19 | }
20 | #endif
21 | #endif
22 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/lameerror.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *  A collection of LAME Error Codes
 3 |  *
 4 |  *  Please use the constants defined here instead of some arbitrary
 5 |  *  values. Currently the values starting at -10 to avoid intersection
 6 |  *  with the -1, -2, -3 and -4 used in the current code.
 7 |  *
 8 |  *  May be this should be a part of the include/lame.h.
 9 |  */
10 | 
11 | typedef enum {
12 |     LAME_OKAY = 0,
13 |     LAME_NOERROR = 0,
14 |     LAME_GENERICERROR = -1,
15 |     LAME_NOMEM = -10,
16 |     LAME_BADBITRATE = -11,
17 |     LAME_BADSAMPFREQ = -12,
18 |     LAME_INTERNALERROR = -13,
19 | 
20 |     FRONTEND_READERROR = -80,
21 |     FRONTEND_WRITEERROR = -81,
22 |     FRONTEND_FILETOOLARGE = -82,
23 | 
24 | } lame_errorcodes_t;
25 | 
26 | /* end of lameerror.h */
27 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>SimpleLameLibForAndroid</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 		<buildCommand>
19 | 			<name>org.eclipse.jdt.core.javabuilder</name>
20 | 			<arguments>
21 | 			</arguments>
22 | 		</buildCommand>
23 | 		<buildCommand>
24 | 			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
25 | 			<arguments>
26 | 			</arguments>
27 | 		</buildCommand>
28 | 	</buildSpec>
29 | 	<natures>
30 | 		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
31 | 		<nature>org.eclipse.jdt.core.javanature</nature>
32 | 	</natures>
33 | </projectDescription>
34 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/simple_lame_lib.h:
--------------------------------------------------------------------------------
 1 | #include <jni.h>
 2 | #include "lame.h"
 3 | 
 4 | #ifndef __SIMPLE_LAME_LIB_H__
 5 | #define __SIMPLE_LAME_LIB_H__
 6 | 
 7 | #ifdef __cplusplus
 8 | extern "C" {
 9 | #endif
10 | 
11 | lame_global_flags* simple_lame_lib_init(
12 | 		JNIEnv* env,
13 | 		jint inSamplerate, jint outChannel,
14 | 		jint outSamplerate, jint outBitrate, jint quality,
15 | 		jstring id3tagTitle, jstring id3tagArtist, jstring id3tagAlbum,
16 | 		jstring id3tagYear, jstring id3tagComment);
17 | 
18 | jint simple_lame_lib_encode(
19 | 		JNIEnv* env, lame_global_flags* glf, 
20 | 		jshortArray buffer_l, jshortArray buffer_r,
21 | 		jint samples, jbyteArray mp3buf);
22 | 
23 | jint simple_lame_lib_encodeBufferInterleaved(
24 | 		JNIEnv *env, lame_global_flags* glf, 
25 | 		jshortArray pcm, jint samples, jbyteArray mp3buf);
26 | 
27 | jint simple_lame_lib_flush(
28 | 		JNIEnv* env, lame_global_flags* glf, 
29 | 		jbyteArray mp3buf);
30 | 
31 | void simple_lame_lib_close(
32 | 		lame_global_flags* glf);
33 | 
34 | void simple_lame_lib_log(
35 | 		jboolean on);
36 | 
37 | #ifdef __cplusplus
38 | }
39 | #endif
40 | #endif


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # SimpleLameLibForAndroid
 2 | [LAME](http://lame.sourceforge.net/) MP3 encoder simple interface library for Android.
 3 | 
 4 | ## License
 5 | ### LAME
 6 | 
 7 | LAME source code licensed under the LGPL.
 8 | 
 9 | ### SimpleLameLibForAndroid
10 | 
11 | zlib License
12 | 
13 | Copyright (C) 2011-2012 Yuichi Hirano
14 | 
15 | This software is provided 'as-is', without any express or implied warranty.  In no event will the authors be held liable for any damages arising from the use of this software.
16 | 
17 | Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
18 | 
19 | 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
20 | 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
21 | 3. This notice may not be removed or altered from any source distribution.
22 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/newmdct.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	New Modified DCT include file
 3 |  *
 4 |  *	Copyright (c) 1999 Takehiro TOMINAGA
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_NEWMDCT_H
23 | #define LAME_NEWMDCT_H
24 | 
25 | void    mdct_sub48(lame_internal_flags * gfc, const sample_t * w0, const sample_t * w1);
26 | 
27 | #endif /* LAME_NEWMDCT_H */
28 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/vector/lame_intrin.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *      lame_intrin.h include file
 3 |  *
 4 |  *      Copyright (c) 2006 Gabriel Bouvigne
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | 
23 | #ifndef LAME_INTRIN_H
24 | #define LAME_INTRIN_H
25 | 
26 | 
27 | void
28 | init_xrpow_core_sse(gr_info * const cod_info, FLOAT xrpow[576], int upper, FLOAT * sum);
29 | 
30 | void
31 | fht_SSE2(FLOAT* , int);
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/vbrquantize.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MP3 VBR quantization
 3 |  *
 4 |  * Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_VBRQUANTIZE_H
23 | #define LAME_VBRQUANTIZE_H
24 | 
25 | int     VBR_encode_frame(lame_internal_flags * gfc, const FLOAT xr34orig[2][2][576],
26 |                          const FLOAT l3_xmin[2][2][SFBMAX], const int maxbits[2][2]);
27 | 
28 | #endif /* LAME_VBRQUANTIZE_H */
29 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/vector/Makefile.am:
--------------------------------------------------------------------------------
 1 | ## $Id: Makefile.am,v 1.1 2007/01/09 10:15:53 aleidinger Exp $
 2 | 
 3 | include $(top_srcdir)/Makefile.am.global
 4 | 
 5 | if WITH_XMM
 6 | noinst_LTLIBRARIES = liblamevectorroutines.la
 7 | endif
 8 | 
 9 | ##liblamecpuroutines_la_LIBADD = 
10 | ##liblamecpuroutines_la_LDFLAGS =
11 | 
12 | INCLUDES = @INCLUDES@ \
13 | 	-I$(top_srcdir)/libmp3lame \
14 | 	-I$(top_srcdir)/mpglib \
15 | 	-I$(top_builddir)
16 | 
17 | DEFS = @DEFS@ @CONFIG_DEFS@
18 | 
19 | xmm_sources = xmm_quantize_sub.c
20 | 
21 | if WITH_XMM
22 | liblamevectorroutines_la_SOURCES = $(xmm_sources)
23 | endif
24 | 
25 | noinst_HEADERS = lame_intrin.h
26 | 
27 | EXTRA_liblamevectorroutines_la_SOURCES = $(xmm_sources)
28 | 
29 | CLEANFILES = lclint.txt
30 | 
31 | LCLINTFLAGS= \
32 | 	+posixlib \
33 | 	+showsummary \
34 | 	+showalluses \
35 | 	+whichlib \
36 | 	+forcehints \
37 | 	-fixedformalarray \
38 | 	+matchanyintegral \
39 | 	-Dlint
40 | 
41 | lclint.txt: ${liblamecpuroutines_la_SOURCES} ${noinst_HEADERS}
42 | 	@lclint ${LCLINTFLAGS} ${INCLUDES} ${DEFS} ${liblamecpuroutines_la_SOURCES} 2>&1 >lclint.txt || true
43 | 
44 | lclint: lclint.txt
45 | 	more lclint.txt
46 | 
47 | #$(OBJECTS): libtool
48 | #libtool: $(LIBTOOL_DEPS)
49 | #	$(SHELL) $(top_builddir)/config.status --recheck
50 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/reservoir.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	bit reservoir include file
 3 |  *
 4 |  *	Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_RESERVOIR_H
23 | #define LAME_RESERVOIR_H
24 | 
25 | int     ResvFrameBegin(lame_internal_flags * gfc, int *mean_bits);
26 | void    ResvMaxBits(lame_internal_flags * gfc, int mean_bits, int *targ_bits, int *max_bits,
27 |                     int cbr);
28 | void    ResvAdjust(lame_internal_flags * gfc, gr_info const *gi);
29 | void    ResvFrameEnd(lame_internal_flags * gfc, int mean_bits);
30 | 
31 | #endif /* LAME_RESERVOIR_H */
32 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/fft.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	Fast Fourier Transform include file
 3 |  *
 4 |  *	Copyright (c) 2000 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_FFT_H
23 | #define LAME_FFT_H
24 | 
25 | void    fft_long(lame_internal_flags const *const gfc, FLOAT x_real[BLKSIZE],
26 |                  int chn, const sample_t *const data[2]);
27 | 
28 | void    fft_short(lame_internal_flags const *const gfc, FLOAT x_real[3][BLKSIZE_s],
29 |                   int chn, const sample_t *const data[2]);
30 | 
31 | void    init_fft(lame_internal_flags * const gfc);
32 | 
33 | #endif
34 | 
35 | /* End of fft.h */
36 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/src/com/uraroji/garage/android/lame/Lame.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (C) 2011-2012 Yuichi Hirano
 3 |  *
 4 |  * This software is provided 'as-is', without any express or implied
 5 |  * warranty.  In no event will the authors be held liable for any damages
 6 |  * arising from the use of this software.
 7 |  * 
 8 |  * Permission is granted to anyone to use this software for any purpose,
 9 |  * including commercial applications, and to alter it and redistribute it
10 |  * freely, subject to the following restrictions:
11 |  * 
12 |  * 1. The origin of this software must not be misrepresented; you must not
13 |  *    claim that you wrote the original software. If you use this software
14 |  *    in a product, an acknowledgment in the product documentation would be
15 |  *    appreciated but is not required.
16 |  * 2. Altered source versions must be plainly marked as such, and must not be
17 |  *    misrepresented as being the original software.
18 |  * 3. This notice may not be removed or altered from any source distribution.
19 |  */
20 | 
21 | package com.uraroji.garage.android.lame;
22 | 
23 | import android.util.Log;
24 | 
25 | public class Lame {
26 |     public static final String TAG = "SimpleLameLib";
27 | 
28 |     static {
29 |         System.loadLibrary("mp3lame");
30 |         Log.d(TAG, "Loaded native library.");
31 |     }
32 | 
33 |     /**
34 |      * Display log.
35 |      * 
36 |      * @param instanceIndex Instance index.
37 |      * @param on display log setting.
38 |      */
39 |     public native static void log(boolean on);
40 | }
41 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/Android.mk:
--------------------------------------------------------------------------------
 1 | LOCAL_PATH := $(call my-dir)
 2 | 
 3 | include $(CLEAR_VARS)
 4 | 
 5 | LAME_LIBMP3_DIR := lame-3.99.5_libmp3lame
 6 | 
 7 | LOCAL_LDLIBS    := -llog
 8 | LOCAL_MODULE    := mp3lame
 9 | LOCAL_ARM_MODE  := arm
10 | LOCAL_CFLAGS    += -ffast-math -I $(LAME_LIBMP3_DIR)
11 | LOCAL_SRC_FILES := $(LAME_LIBMP3_DIR)/bitstream.c \
12 |                    $(LAME_LIBMP3_DIR)/fft.c \
13 |                    $(LAME_LIBMP3_DIR)/id3tag.c \
14 |                    $(LAME_LIBMP3_DIR)/mpglib_interface.c \
15 |                    $(LAME_LIBMP3_DIR)/presets.c \
16 |                    $(LAME_LIBMP3_DIR)/quantize.c \
17 |                    $(LAME_LIBMP3_DIR)/reservoir.c \
18 |                    $(LAME_LIBMP3_DIR)/tables.c \
19 |                    $(LAME_LIBMP3_DIR)/util.c \
20 |                    $(LAME_LIBMP3_DIR)/VbrTag.c \
21 |                    $(LAME_LIBMP3_DIR)/encoder.c \
22 |                    $(LAME_LIBMP3_DIR)/gain_analysis.c \
23 |                    $(LAME_LIBMP3_DIR)/lame.c \
24 |                    $(LAME_LIBMP3_DIR)/newmdct.c \
25 |                    $(LAME_LIBMP3_DIR)/psymodel.c \
26 |                    $(LAME_LIBMP3_DIR)/quantize_pvt.c \
27 |                    $(LAME_LIBMP3_DIR)/set_get.c \
28 |                    $(LAME_LIBMP3_DIR)/takehiro.c \
29 |                    $(LAME_LIBMP3_DIR)/vbrquantize.c \
30 |                    $(LAME_LIBMP3_DIR)/version.c \
31 |                    simple_lame_lib.c \
32 |                    com_uraroji_garage_android_lame_Encoder.cpp \
33 |                    com_uraroji_garage_android_lame_Lame.c
34 | 
35 | include $(BUILD_SHARED_LIBRARY)
36 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/quantize.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MP3 quantization
 3 |  *
 4 |  * Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_QUANTIZE_H
23 | #define LAME_QUANTIZE_H
24 | 
25 | void    CBR_iteration_loop(lame_internal_flags * gfc, const FLOAT pe[2][2],
26 |                            const FLOAT ms_ratio[2], const III_psy_ratio ratio[2][2]);
27 | 
28 | void    VBR_old_iteration_loop(lame_internal_flags * gfc, const FLOAT pe[2][2],
29 |                                const FLOAT ms_ratio[2], const III_psy_ratio ratio[2][2]);
30 | 
31 | void    VBR_new_iteration_loop(lame_internal_flags * gfc, const FLOAT pe[2][2],
32 |                                const FLOAT ms_ratio[2], const III_psy_ratio ratio[2][2]);
33 | 
34 | void    ABR_iteration_loop(lame_internal_flags * gfc, const FLOAT pe[2][2],
35 |                            const FLOAT ms_ratio[2], const III_psy_ratio ratio[2][2]);
36 | 
37 | 
38 | #endif /* LAME_QUANTIZE_H */
39 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/bitstream.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	MP3 bitstream Output interface for LAME
 3 |  *
 4 |  *	Copyright (c) 1999 Takehiro TOMINAGA
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_BITSTREAM_H
23 | #define LAME_BITSTREAM_H
24 | 
25 | int     getframebits(const lame_internal_flags * gfc);
26 | 
27 | int     format_bitstream(lame_internal_flags * gfc);
28 | 
29 | void    flush_bitstream(lame_internal_flags * gfc);
30 | void    add_dummy_byte(lame_internal_flags * gfc, unsigned char val, unsigned int n);
31 | 
32 | int     copy_buffer(lame_internal_flags * gfc, unsigned char *buffer, int buffer_size,
33 |                     int update_crc);
34 | void    init_bit_stream_w(lame_internal_flags * gfc);
35 | void    CRC_writeheader(lame_internal_flags const *gfc, char *buffer);
36 | int     compute_flushbits(const lame_internal_flags * gfp, int *nbytes);
37 | 
38 | int     get_max_frame_buffer_size_by_constraint(SessionConfig_t const * cfg, int constraint);
39 | 
40 | #endif
41 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/com_uraroji_garage_android_lame_Encoder.h:
--------------------------------------------------------------------------------
 1 | /* DO NOT EDIT THIS FILE - it is machine generated */
 2 | #include <jni.h>
 3 | /* Header for class com_uraroji_garage_android_lame_Encoder */
 4 | 
 5 | #ifndef _Included_com_uraroji_garage_android_lame_Encoder
 6 | #define _Included_com_uraroji_garage_android_lame_Encoder
 7 | #ifdef __cplusplus
 8 | extern "C" {
 9 | #endif
10 | /*
11 |  * Class:     com_uraroji_garage_android_lame_Encoder
12 |  * Method:    init
13 |  * Signature: (IIIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I
14 |  */
15 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_init
16 |   (JNIEnv *, jclass, jint, jint, jint, jint, jint, jstring, jstring, jstring, jstring, jstring);
17 | 
18 | /*
19 |  * Class:     com_uraroji_garage_android_lame_Encoder
20 |  * Method:    encode
21 |  * Signature: (I[S[SI[B)I
22 |  */
23 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_encode
24 |   (JNIEnv *, jclass, jint, jshortArray, jshortArray, jint, jbyteArray);
25 | 
26 | /*
27 |  * Class:     com_uraroji_garage_android_lame_Encoder
28 |  * Method:    encodeBufferInterleaved
29 |  * Signature: (I[SI[B)I
30 |  */
31 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_encodeBufferInterleaved
32 |   (JNIEnv *, jclass, jint, jshortArray, jint, jbyteArray);
33 | 
34 | /*
35 |  * Class:     com_uraroji_garage_android_lame_Encoder
36 |  * Method:    flush
37 |  * Signature: (I[B)I
38 |  */
39 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_flush
40 |   (JNIEnv *, jclass, jint, jbyteArray);
41 | 
42 | /*
43 |  * Class:     com_uraroji_garage_android_lame_Encoder
44 |  * Method:    close
45 |  * Signature: (I)V
46 |  */
47 | JNIEXPORT void JNICALL Java_com_uraroji_garage_android_lame_Encoder_close
48 |   (JNIEnv *, jclass, jint);
49 | 
50 | #ifdef __cplusplus
51 | }
52 | #endif
53 | #endif
54 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/id3tag.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef LAME_ID3_H
 3 | #define LAME_ID3_H
 4 | 
 5 | 
 6 | #define CHANGED_FLAG    (1U << 0)
 7 | #define ADD_V2_FLAG     (1U << 1)
 8 | #define V1_ONLY_FLAG    (1U << 2)
 9 | #define V2_ONLY_FLAG    (1U << 3)
10 | #define SPACE_V1_FLAG   (1U << 4)
11 | #define PAD_V2_FLAG     (1U << 5)
12 | 
13 | enum {
14 |     MIMETYPE_NONE = 0,
15 |     MIMETYPE_JPEG,
16 |     MIMETYPE_PNG,
17 |     MIMETYPE_GIF,
18 | };
19 | 
20 | typedef struct FrameDataNode {
21 |     struct FrameDataNode *nxt;
22 |     uint32_t fid;             /* Frame Identifier                 */
23 |     char    lng[4];          /* 3-character language descriptor  */
24 |     struct {
25 |         union {
26 |             char   *l;       /* ptr to Latin-1 chars             */
27 |             unsigned short *u; /* ptr to UCS-2 text                */
28 |             unsigned char *b; /* ptr to raw bytes                 */
29 |         } ptr;
30 |         size_t  dim;
31 |         int     enc;         /* 0:Latin-1, 1:UCS-2, 2:RAW        */
32 |     } dsc  , txt;
33 | } FrameDataNode;
34 | 
35 | 
36 | typedef struct id3tag_spec {
37 |     /* private data members */
38 |     unsigned int flags;
39 |     int     year;
40 |     char   *title;
41 |     char   *artist;
42 |     char   *album;
43 |     char   *comment;
44 |     int     track_id3v1;
45 |     int     genre_id3v1;
46 |     unsigned char *albumart;
47 |     unsigned int albumart_size;
48 |     unsigned int padding_size;
49 |     int     albumart_mimetype;
50 |     FrameDataNode *v2_head, *v2_tail;
51 | } id3tag_spec;
52 | 
53 | 
54 | /* write tag into stream at current position */
55 | extern int id3tag_write_v2(lame_global_flags * gfp);
56 | extern int id3tag_write_v1(lame_global_flags * gfp);
57 | /*
58 |  * NOTE: A version 2 tag will NOT be added unless one of the text fields won't
59 |  * fit in a version 1 tag (e.g. the title string is longer than 30 characters),
60 |  * or the "id3tag_add_v2" or "id3tag_v2_only" functions are used.
61 |  */
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/com_uraroji_garage_android_lame_Encoder.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include "com_uraroji_garage_android_lame_Encoder.h"
 3 | #include "simple_lame_lib.h"
 4 | 
 5 | static std::vector<lame_global_flags*> glfList(2);
 6 | 
 7 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_init(
 8 | 		JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
 9 | 		jint outSamplerate, jint outBitrate, jint quality,
10 | 		jstring id3tagTitle, jstring id3tagArtist, jstring id3tagAlbum,
11 | 		jstring id3tagYear, jstring id3tagComment) {
12 | 	lame_global_flags* glf = simple_lame_lib_init(env, inSamplerate, outChannel, outSamplerate, outBitrate,
13 | 		quality, id3tagTitle, id3tagArtist, id3tagAlbum, id3tagYear, id3tagComment);
14 | 	glfList.push_back(glf);
15 | 
16 | 	return glfList.size() - 1;
17 | }
18 | 
19 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_encode(
20 | 		JNIEnv *env, jclass cls, jint instanceIndex, jshortArray buffer_l,
21 | 		jshortArray buffer_r, jint samples, jbyteArray mp3buf) {
22 | 	return simple_lame_lib_encode(env, glfList.at(instanceIndex), buffer_l, buffer_r, samples, mp3buf);
23 | }
24 | 
25 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_encodeBufferInterleaved(
26 | 		JNIEnv *env, jclass cls, jint instanceIndex, jshortArray pcm,
27 | 		jint samples, jbyteArray mp3buf) {
28 | 	return simple_lame_lib_encodeBufferInterleaved(env, glfList.at(instanceIndex), pcm, samples, mp3buf);
29 | }
30 | 
31 | JNIEXPORT jint JNICALL Java_com_uraroji_garage_android_lame_Encoder_flush(
32 | 		JNIEnv *env, jclass cls, jint instanceIndex, jbyteArray mp3buf) {
33 | 	return simple_lame_lib_flush(env, glfList.at(instanceIndex), mp3buf);
34 | }
35 | 
36 | JNIEXPORT void JNICALL Java_com_uraroji_garage_android_lame_Encoder_close(
37 | 		JNIEnv *env, jclass cls, jint instanceIndex) {
38 | 	simple_lame_lib_close(glfList.at(instanceIndex));
39 | }
40 | 
41 | JNIEXPORT void JNICALL Java_com_uraroji_garage_android_lame_Encoder_log
42 |   (JNIEnv *env, jclass cls, jboolean on) {
43 | 	simple_lame_lib_log(on);
44 | }
45 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/psymodel.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	psymodel.h
 3 |  *
 4 |  *	Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_PSYMODEL_H
23 | #define LAME_PSYMODEL_H
24 | 
25 | 
26 | int     L3psycho_anal_ns(lame_internal_flags * gfc,
27 |                          const sample_t *const buffer[2], int gr,
28 |                          III_psy_ratio ratio[2][2],
29 |                          III_psy_ratio MS_ratio[2][2],
30 |                          FLOAT pe[2], FLOAT pe_MS[2], FLOAT ener[2], int blocktype_d[2]);
31 | 
32 | int     L3psycho_anal_vbr(lame_internal_flags * gfc,
33 |                           const sample_t *const buffer[2], int gr,
34 |                           III_psy_ratio ratio[2][2],
35 |                           III_psy_ratio MS_ratio[2][2],
36 |                           FLOAT pe[2], FLOAT pe_MS[2], FLOAT ener[2], int blocktype_d[2]);
37 | 
38 | 
39 | int     psymodel_init(lame_global_flags const* gfp);
40 | 
41 | 
42 | #define rpelev 2
43 | #define rpelev2 16
44 | #define rpelev_s 2
45 | #define rpelev2_s 16
46 | 
47 | /* size of each partition band, in barks: */
48 | #define DELBARK .34
49 | 
50 | 
51 | /* tuned for output level (sensitive to energy scale) */
52 | #define VO_SCALE (1./( 14752*14752 )/(BLKSIZE/2))
53 | 
54 | #define temporalmask_sustain_sec 0.01
55 | 
56 | #define NS_PREECHO_ATT0 0.8
57 | #define NS_PREECHO_ATT1 0.6
58 | #define NS_PREECHO_ATT2 0.3
59 | 
60 | #define NS_MSFIX 3.5
61 | #define NSATTACKTHRE 4.4
62 | #define NSATTACKTHRE_S 25
63 | 
64 | #endif /* LAME_PSYMODEL_H */
65 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/build.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project default="jar">
 3 | 	<property name="version" value="1.5.1" />
 4 | 
 5 | 	<property environment="env" />
 6 | 	<condition property="android-home" value="${env.ANDROID_HOME}">
 7 | 		<isset property="env.ANDROID_HOME"/>
 8 | 	</condition>
 9 | 	<condition property="android-ndk-root" value="${env.ANDROID_NDK_ROOT}">
10 | 		<isset property="env.ANDROID_NDK_ROOT"/>
11 | 	</condition>
12 | 	<property name="build.jar" value="./simplelamelib.jar" />
13 | 	<property name="build.src" value="./src" />
14 | 	<property name="build.dest" value="./jarbin" />
15 | 	<property name="jni.src" value="./jni" />
16 | 	<property name="jar.specification.title" value="SimpleLameLibForAndroid" />
17 | 	<property name="jar.specification.version" value="${version}" />
18 | 	<property name="jar.specification.vendor" value="garage.uraroji.com" />
19 | 	<property name="jar.specification.title" value="com.uraroji.garage.android.lame" />
20 | 	<property name="jar.specification.version" value="${version}" />
21 | 	<property name="jar.specification.vendor" value="garage.uraroji.com" />
22 | 
23 | 	<target name="clean">
24 | 		<delete file="${build.jar}" />
25 | 		<delete dir="${build.dest}" />
26 | 		<exec executable="${android-ndk-root}/ndk-build" dir="${jni.src}" failonerror="true">
27 | 			<arg value="clean" />
28 | 		</exec>
29 | 	</target>
30 | 
31 | 	<target name="compile" depends="clean">
32 | 		<mkdir dir="${build.dest}" />
33 | 		<javac destdir="${build.dest}" srcdir="${build.src}" includeantruntime="false" bootclasspath="${android-home}/platforms/android-7/android.jar">
34 | 			<include name="**/*.java" />
35 | 		</javac>
36 | 		<exec executable="${android-ndk-root}/ndk-build" dir="${jni.src}" failonerror="true" />
37 | 	</target>
38 | 
39 | 	<target name="jar" depends="compile">
40 | 		<jar destfile="${build.jar}">
41 | 			<fileset dir="${build.dest}" />
42 | 			<manifest>
43 | 				<attribute name="Specification-Title" value="${jar.specification.title}"/>
44 | 				<attribute name="Specification-Version" value="${jar.specification.version}"/>
45 | 				<attribute name="Specification-Vendor"  value="${jar.specification.vendor}"/>
46 | 				<attribute name="Implementation-Title" value="${jar.specification.title}"/>
47 | 				<attribute name="Implementation-Version" value="${jar.specification.version}"/>
48 | 				<attribute name="Implementation-Vendor"  value="${jar.specification.vendor}"/>
49 | 			</manifest>
50 |   		</jar>
51 | 		<delete dir="${build.dest}" />
52 | 	</target>
53 | </project>
54 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/Note.txt:
--------------------------------------------------------------------------------
 1 | The instructions for building LAME on Android.
 2 | 
 3 | - Referred to the http://blog.libertadtech.com/2011/02/porting-lame-encoder-to-android-arm.html
 4 | 
 5 | 1. Download LAME sources, extract, copy all sources from directory libmp3lame to
 6 |    jni/lame-3.99.5_libmp3lame directory. Also copy lame.h which is located in
 7 |    include directory of LAME sources to jni/lame-3.99.5_libmp3lame.
 8 | 
 9 | 2. Create jni/Android.mk file. it should look like this:
10 | 
11 | ===
12 | LOCAL_PATH := $(call my-dir)
13 | 
14 | include $(CLEAR_VARS)
15 | 
16 | LAME_LIBMP3_DIR := lame-3.99.5_libmp3lame
17 | 
18 | LOCAL_LDLIBS    := -llog
19 | LOCAL_MODULE    := mp3lame
20 | LOCAL_ARM_MODE  := arm
21 | LOCAL_CFLAGS    += -ffast-math
22 | LOCAL_CFLAGS    += -I $(LAME_LIBMP3_DIR)
23 | LOCAL_SRC_FILES := $(LAME_LIBMP3_DIR)/bitstream.c \
24 |                    $(LAME_LIBMP3_DIR)/fft.c \
25 |                    $(LAME_LIBMP3_DIR)/id3tag.c \
26 |                    $(LAME_LIBMP3_DIR)/mpglib_interface.c \
27 |                    $(LAME_LIBMP3_DIR)/presets.c \
28 |                    $(LAME_LIBMP3_DIR)/quantize.c \
29 |                    $(LAME_LIBMP3_DIR)/reservoir.c \
30 |                    $(LAME_LIBMP3_DIR)/tables.c \
31 |                    $(LAME_LIBMP3_DIR)/util.c \
32 |                    $(LAME_LIBMP3_DIR)/VbrTag.c \
33 |                    $(LAME_LIBMP3_DIR)/encoder.c \
34 |                    $(LAME_LIBMP3_DIR)/gain_analysis.c \
35 |                    $(LAME_LIBMP3_DIR)/lame.c \
36 |                    $(LAME_LIBMP3_DIR)/newmdct.c \
37 |                    $(LAME_LIBMP3_DIR)/psymodel.c \
38 |                    $(LAME_LIBMP3_DIR)/quantize_pvt.c \
39 |                    $(LAME_LIBMP3_DIR)/set_get.c \
40 |                    $(LAME_LIBMP3_DIR)/takehiro.c \
41 |                    $(LAME_LIBMP3_DIR)/vbrquantize.c \
42 |                    $(LAME_LIBMP3_DIR)/version.c \
43 |                    simple_lame_lib.c \
44 |                    com_uraroji_garage_android_lame_SimpleLame.c \
45 |                    com_uraroji_garage_android_lame_Lame.cpp
46 | 
47 | include $(BUILD_SHARED_LIBRARY)
48 | ===
49 | 
50 | 3. Remove Makefile.am, Makefile.in, logoe.ico, depcomp, lame.rc and i386 directory.
51 | 
52 | 4. Edit file jni/lame-3.99.5_libmp3lame/utils.h, and replace definition
53 |      extern ieee754_float32_t fast_log2(ieee754_float32_t x);
54 |    with this
55 |      extern float fast_log2(float x);
56 | 
57 | 5. Go to the jni directory and run $pathtoandroidndk/ndk-build and you're done,
58 |    you'll have limp3lame.so compiled.
59 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/version.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *      Version numbering for LAME.
 3 |  *
 4 |  *      Copyright (c) 1999 A.L. Faber
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_VERSION_H
23 | #define LAME_VERSION_H
24 | 
25 | 
26 | /*
27 |  * To make a string from a token, use the # operator:
28 |  */
29 | #ifndef STR
30 | # define __STR(x)  #x
31 | # define STR(x)    __STR(x)
32 | #endif
33 | 
34 | # define LAME_URL              "http://lame.sf.net"
35 | 
36 | 
37 | # define LAME_MAJOR_VERSION      3 /* Major version number */
38 | # define LAME_MINOR_VERSION     99 /* Minor version number */
39 | # define LAME_TYPE_VERSION       2 /* 0:alpha 1:beta 2:release */
40 | # define LAME_PATCH_VERSION      5 /* Patch level */
41 | # define LAME_ALPHA_VERSION     (LAME_TYPE_VERSION==0)
42 | # define LAME_BETA_VERSION      (LAME_TYPE_VERSION==1)
43 | # define LAME_RELEASE_VERSION   (LAME_TYPE_VERSION==2)
44 | 
45 | # define PSY_MAJOR_VERSION       1 /* Major version number */
46 | # define PSY_MINOR_VERSION       0 /* Minor version number */
47 | # define PSY_ALPHA_VERSION       0 /* Set number if this is an alpha version, otherwise zero */
48 | # define PSY_BETA_VERSION        0 /* Set number if this is a beta version, otherwise zero */
49 | 
50 | #if LAME_ALPHA_VERSION
51 | #define LAME_PATCH_LEVEL_STRING " alpha " STR(LAME_PATCH_VERSION)
52 | #endif
53 | #if LAME_BETA_VERSION
54 | #define LAME_PATCH_LEVEL_STRING " beta " STR(LAME_PATCH_VERSION)
55 | #endif
56 | #if LAME_RELEASE_VERSION
57 | #if LAME_PATCH_VERSION
58 | #define LAME_PATCH_LEVEL_STRING " release " STR(LAME_PATCH_VERSION)
59 | #else
60 | #define LAME_PATCH_LEVEL_STRING ""
61 | #endif
62 | #endif
63 | 
64 | # define LAME_VERSION_STRING STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) LAME_PATCH_LEVEL_STRING
65 | 
66 | #endif /* LAME_VERSION_H */
67 | 
68 | /* End of version.h */
69 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/l3side.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	Layer 3 side include file
 3 |  *
 4 |  *	Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_L3SIDE_H
23 | #define LAME_L3SIDE_H
24 | 
25 | /* max scalefactor band, max(SBMAX_l, SBMAX_s*3, (SBMAX_s-3)*3+8) */
26 | #define SFBMAX (SBMAX_s*3)
27 | 
28 | /* Layer III side information. */
29 | typedef struct {
30 |     int     l[1 + SBMAX_l];
31 |     int     s[1 + SBMAX_s];
32 |     int     psfb21[1 + PSFB21];
33 |     int     psfb12[1 + PSFB12];
34 | } scalefac_struct;
35 | 
36 | 
37 | typedef struct {
38 |     FLOAT   l[SBMAX_l];
39 |     FLOAT   s[SBMAX_s][3];
40 | } III_psy_xmin;
41 | 
42 | typedef struct {
43 |     III_psy_xmin thm;
44 |     III_psy_xmin en;
45 | } III_psy_ratio;
46 | 
47 | typedef struct {
48 |     FLOAT   xr[576];
49 |     int     l3_enc[576];
50 |     int     scalefac[SFBMAX];
51 |     FLOAT   xrpow_max;
52 | 
53 |     int     part2_3_length;
54 |     int     big_values;
55 |     int     count1;
56 |     int     global_gain;
57 |     int     scalefac_compress;
58 |     int     block_type;
59 |     int     mixed_block_flag;
60 |     int     table_select[3];
61 |     int     subblock_gain[3 + 1];
62 |     int     region0_count;
63 |     int     region1_count;
64 |     int     preflag;
65 |     int     scalefac_scale;
66 |     int     count1table_select;
67 | 
68 |     int     part2_length;
69 |     int     sfb_lmax;
70 |     int     sfb_smin;
71 |     int     psy_lmax;
72 |     int     sfbmax;
73 |     int     psymax;
74 |     int     sfbdivide;
75 |     int     width[SFBMAX];
76 |     int     window[SFBMAX];
77 |     int     count1bits;
78 |     /* added for LSF */
79 |     const int *sfb_partition_table;
80 |     int     slen[4];
81 | 
82 |     int     max_nonzero_coeff;
83 |     char    energy_above_cutoff[SFBMAX];
84 | } gr_info;
85 | 
86 | typedef struct {
87 |     gr_info tt[2][2];
88 |     int     main_data_begin;
89 |     int     private_bits;
90 |     int     resvDrain_pre;
91 |     int     resvDrain_post;
92 |     int     scfsi[2][4];
93 | } III_side_info_t;
94 | 
95 | #endif
96 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/tables.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *	MPEG layer 3 tables include file
 3 |  *
 4 |  *	Copyright (c) 1999 Albert L Faber
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_TABLES_H
23 | #define LAME_TABLES_H
24 | 
25 | #if 0
26 | typedef struct {
27 |     unsigned char no;
28 |     unsigned char width;
29 |     unsigned char minval_2;
30 |     float   quiet_thr;
31 |     float   norm;
32 |     float   bark;
33 | } type1_t;
34 | 
35 | typedef struct {
36 |     unsigned char no;
37 |     unsigned char width;
38 |     float   quiet_thr;
39 |     float   norm;
40 |     float   SNR;
41 |     float   bark;
42 | } type2_t;
43 | 
44 | typedef struct {
45 |     unsigned int no:5;
46 |     unsigned int cbw:3;
47 |     unsigned int bu:6;
48 |     unsigned int bo:6;
49 |     unsigned int w1_576:10;
50 |     unsigned int w2_576:10;
51 | } type34_t;
52 | 
53 | typedef struct {
54 |     size_t  len1;
55 |     const type1_t *const tab1;
56 |     size_t  len2;
57 |     const type2_t *const tab2;
58 |     size_t  len3;
59 |     const type34_t *const tab3;
60 |     size_t  len4;
61 |     const type34_t *const tab4;
62 | } type5_t;
63 | 
64 | extern const type5_t table5[6];
65 | 
66 | #endif
67 | 
68 | #define HTN	34
69 | 
70 | struct huffcodetab {
71 |     const unsigned int xlen;          /* max. x-index+   */
72 |     const unsigned int linmax;        /* max number to be stored in linbits */
73 |     const uint16_t *table;      /* pointer to array[xlen][ylen]  */
74 |     const uint8_t *hlen;        /* pointer to array[xlen][ylen]  */
75 | };
76 | 
77 | extern const struct huffcodetab ht[HTN];
78 |     /* global memory block   */
79 |     /* array of all huffcodtable headers */
80 |     /* 0..31 Huffman code table 0..31  */
81 |     /* 32,33 count1-tables   */
82 | 
83 | extern const uint8_t t32l[];
84 | extern const uint8_t t33l[];
85 | 
86 | extern const uint32_t largetbl[16 * 16];
87 | extern const uint32_t table23[3 * 3];
88 | extern const uint32_t table56[4 * 4];
89 | 
90 | extern const int scfsi_band[5];
91 | 
92 | extern const int bitrate_table    [3][16];
93 | extern const int samplerate_table [3][ 4];
94 | 
95 | #endif /* LAME_TABLES_H */
96 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/set_get.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * set_get.h -- Internal set/get definitions
 3 |  *
 4 |  * Copyright (C) 2003 Gabriel Bouvigne / Lame project
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the Free Software
18 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
19 |  */
20 | 
21 | #ifndef __SET_GET_H__
22 | #define __SET_GET_H__
23 | 
24 | #include <lame.h>
25 | 
26 | #if defined(__cplusplus)
27 | extern  "C" {
28 | #endif
29 | 
30 | /* select psychoacoustic model */
31 | 
32 | /* manage short blocks */
33 |     int CDECL lame_set_short_threshold(lame_global_flags *, float, float);
34 |     int CDECL lame_set_short_threshold_lrm(lame_global_flags *, float);
35 |     float CDECL lame_get_short_threshold_lrm(const lame_global_flags *);
36 |     int CDECL lame_set_short_threshold_s(lame_global_flags *, float);
37 |     float CDECL lame_get_short_threshold_s(const lame_global_flags *);
38 | 
39 | 
40 |     int CDECL lame_set_maskingadjust(lame_global_flags *, float);
41 |     float CDECL lame_get_maskingadjust(const lame_global_flags *);
42 | 
43 |     int CDECL lame_set_maskingadjust_short(lame_global_flags *, float);
44 |     float CDECL lame_get_maskingadjust_short(const lame_global_flags *);
45 | 
46 | /* select ATH formula 4 shape */
47 |     int CDECL lame_set_ATHcurve(lame_global_flags *, float);
48 |     float CDECL lame_get_ATHcurve(const lame_global_flags *);
49 | 
50 |     int CDECL lame_set_preset_notune(lame_global_flags *, int);
51 | 
52 | /* substep shaping method */
53 |     int CDECL lame_set_substep(lame_global_flags *, int);
54 |     int CDECL lame_get_substep(const lame_global_flags *);
55 | 
56 | /* scalefactors scale */
57 |     int CDECL lame_set_sfscale(lame_global_flags *, int);
58 |     int CDECL lame_get_sfscale(const lame_global_flags *);
59 | 
60 | /* subblock gain */
61 |     int CDECL lame_set_subblock_gain(lame_global_flags *, int);
62 |     int CDECL lame_get_subblock_gain(const lame_global_flags *);
63 | 
64 | 
65 | 
66 | /*presets*/
67 |     int     apply_preset(lame_global_flags *, int preset, int enforce);
68 | 
69 |     void CDECL lame_set_tune(lame_t, float); /* FOR INTERNAL USE ONLY */
70 |     void CDECL lame_set_msfix(lame_t gfp, double msfix);
71 | 
72 | 
73 | #if defined(__cplusplus)
74 | }
75 | #endif
76 | #endif
77 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/VbrTag.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *      Xing VBR tagging for LAME.
 3 |  *
 4 |  *      Copyright (c) 1999 A.L. Faber
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_VRBTAG_H
23 | #define LAME_VRBTAG_H
24 | 
25 | 
26 | /* -----------------------------------------------------------
27 |  * A Vbr header may be present in the ancillary
28 |  * data field of the first frame of an mp3 bitstream
29 |  * The Vbr header (optionally) contains
30 |  *      frames      total number of audio frames in the bitstream
31 |  *      bytes       total number of bytes in the bitstream
32 |  *      toc         table of contents
33 | 
34 |  * toc (table of contents) gives seek points
35 |  * for random access
36 |  * the ith entry determines the seek point for
37 |  * i-percent duration
38 |  * seek point in bytes = (toc[i]/256.0) * total_bitstream_bytes
39 |  * e.g. half duration seek point = (toc[50]/256.0) * total_bitstream_bytes
40 |  */
41 | 
42 | 
43 | #define FRAMES_FLAG     0x0001
44 | #define BYTES_FLAG      0x0002
45 | #define TOC_FLAG        0x0004
46 | #define VBR_SCALE_FLAG  0x0008
47 | 
48 | #define NUMTOCENTRIES 100
49 | 
50 | #ifndef lame_internal_flags_defined
51 | #define lame_internal_flags_defined
52 | struct lame_internal_flags;
53 | typedef struct lame_internal_flags lame_internal_flags;
54 | #endif
55 | 
56 | 
57 | /*structure to receive extracted header */
58 | /* toc may be NULL*/
59 | typedef struct {
60 |     int     h_id;            /* from MPEG header, 0=MPEG2, 1=MPEG1 */
61 |     int     samprate;        /* determined from MPEG header */
62 |     int     flags;           /* from Vbr header data */
63 |     int     frames;          /* total bit stream frames from Vbr header data */
64 |     int     bytes;           /* total bit stream bytes from Vbr header data */
65 |     int     vbr_scale;       /* encoded vbr scale from Vbr header data */
66 |     unsigned char toc[NUMTOCENTRIES]; /* may be NULL if toc not desired */
67 |     int     headersize;      /* size of VBR header, in bytes */
68 |     int     enc_delay;       /* encoder delay */
69 |     int     enc_padding;     /* encoder paddign added at end of stream */
70 | } VBRTAGDATA;
71 | 
72 | int     GetVbrTag(VBRTAGDATA * pTagData, const unsigned char *buf);
73 | 
74 | int     InitVbrTag(lame_global_flags * gfp);
75 | int     PutVbrTag(lame_global_flags const *gfp, FILE * fid);
76 | void    AddVbrFrame(lame_internal_flags * gfc);
77 | void    UpdateMusicCRC(uint16_t * crc, const unsigned char *buffer, int size);
78 | 
79 | #endif
80 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/lame-analysis.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *      GTK plotting routines source file
 3 |  *
 4 |  *      Copyright (c) 1999 Mark Taylor
 5 |  *
 6 |  * This library is free software; you can redistribute it and/or
 7 |  * modify it under the terms of the GNU Library General Public
 8 |  * License as published by the Free Software Foundation; either
 9 |  * version 2 of the License, or (at your option) any later version.
10 |  *
11 |  * This library is distributed in the hope that it will be useful,
12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 |  * Library General Public License for more details.
15 |  *
16 |  * You should have received a copy of the GNU Library General Public
17 |  * License along with this library; if not, write to the
18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 |  * Boston, MA 02111-1307, USA.
20 |  */
21 | 
22 | #ifndef LAME_GTKANAL_H
23 | #define LAME_GTKANAL_H
24 | 
25 | 
26 | #define READ_AHEAD 40   /* number of frames to read ahead */
27 | #define MAXMPGLAG READ_AHEAD /* if the mpg123 lag becomes bigger than this
28 |                                 we have to stop */
29 | #define NUMBACK 6       /* number of frames we can back up */
30 | #define NUMPINFO (NUMBACK+READ_AHEAD+1)
31 | 
32 | 
33 | 
34 | struct plotting_data {
35 |     int     frameNum;        /* current frame number */
36 |     int     frameNum123;
37 |     int     num_samples;     /* number of pcm samples read for this frame */
38 |     double  frametime;       /* starting time of frame, in seconds */
39 |     double  pcmdata[2][1600];
40 |     double  pcmdata2[2][1152 + 1152 - DECDELAY];
41 |     double  xr[2][2][576];
42 |     double  mpg123xr[2][2][576];
43 |     double  ms_ratio[2];
44 |     double  ms_ener_ratio[2];
45 | 
46 |     /* L,R, M and S values */
47 |     double  energy_save[4][BLKSIZE]; /* psymodel is one ahead */
48 |     double  energy[2][4][BLKSIZE];
49 |     double  pe[2][4];
50 |     double  thr[2][4][SBMAX_l];
51 |     double  en[2][4][SBMAX_l];
52 |     double  thr_s[2][4][3 * SBMAX_s];
53 |     double  en_s[2][4][3 * SBMAX_s];
54 |     double  ers_save[4];     /* psymodel is one ahead */
55 |     double  ers[2][4];
56 | 
57 |     double  sfb[2][2][SBMAX_l];
58 |     double  sfb_s[2][2][3 * SBMAX_s];
59 |     double  LAMEsfb[2][2][SBMAX_l];
60 |     double  LAMEsfb_s[2][2][3 * SBMAX_s];
61 | 
62 |     int     LAMEqss[2][2];
63 |     int     qss[2][2];
64 |     int     big_values[2][2];
65 |     int     sub_gain[2][2][3];
66 | 
67 |     double  xfsf[2][2][SBMAX_l];
68 |     double  xfsf_s[2][2][3 * SBMAX_s];
69 | 
70 |     int     over[2][2];
71 |     double  tot_noise[2][2];
72 |     double  max_noise[2][2];
73 |     double  over_noise[2][2];
74 |     int     over_SSD[2][2];
75 |     int     blocktype[2][2];
76 |     int     scalefac_scale[2][2];
77 |     int     preflag[2][2];
78 |     int     mpg123blocktype[2][2];
79 |     int     mixed[2][2];
80 |     int     mainbits[2][2];
81 |     int     sfbits[2][2];
82 |     int     LAMEmainbits[2][2];
83 |     int     LAMEsfbits[2][2];
84 |     int     framesize, stereo, js, ms_stereo, i_stereo, emph, bitrate, sampfreq, maindata;
85 |     int     crc, padding;
86 |     int     scfsi[2], mean_bits, resvsize;
87 |     int     totbits;
88 | };
89 | #ifndef plotting_data_defined
90 | #define plotting_data_defined
91 | typedef struct plotting_data plotting_data;
92 | #endif
93 | #if 0
94 | extern plotting_data *pinfo;
95 | #endif
96 | #endif
97 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/gain_analysis.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *  ReplayGainAnalysis - analyzes input samples and give the recommended dB change
  3 |  *  Copyright (C) 2001 David Robinson and Glen Sawyer
  4 |  *
  5 |  *  This library is free software; you can redistribute it and/or
  6 |  *  modify it under the terms of the GNU Lesser General Public
  7 |  *  License as published by the Free Software Foundation; either
  8 |  *  version 2.1 of the License, or (at your option) any later version.
  9 |  *
 10 |  *  This library is distributed in the hope that it will be useful,
 11 |  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 13 |  *  Lesser General Public License for more details.
 14 |  *
 15 |  *  You should have received a copy of the GNU Lesser General Public
 16 |  *  License along with this library; if not, write to the Free Software
 17 |  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 18 |  *
 19 |  *  concept and filter values by David Robinson (David@Robinson.org)
 20 |  *    -- blame him if you think the idea is flawed
 21 |  *  coding by Glen Sawyer (mp3gain@hotmail.com) 735 W 255 N, Orem, UT 84057-4505 USA
 22 |  *    -- blame him if you think this runs too slowly, or the coding is otherwise flawed
 23 |  *
 24 |  *  For an explanation of the concepts and the basic algorithms involved, go to:
 25 |  *    http://www.replaygain.org/
 26 |  */
 27 | 
 28 | #ifndef GAIN_ANALYSIS_H
 29 | #define GAIN_ANALYSIS_H
 30 | 
 31 | #ifdef HAVE_INTTYPES_H
 32 | # include <inttypes.h>
 33 | #else
 34 | # ifdef HAVE_STDINT_H
 35 | #  include <stdint.h>
 36 | # endif
 37 | #endif
 38 | 
 39 | #ifdef __cplusplus
 40 | extern  "C" {
 41 | #endif
 42 | 
 43 | 
 44 |     typedef sample_t Float_t; /* Type used for filtering */
 45 | 
 46 | 
 47 | #define PINK_REF                64.82       /* 298640883795 */ /* calibration value for 89dB */
 48 | 
 49 | 
 50 | #define YULE_ORDER         10
 51 | #define BUTTER_ORDER        2
 52 | #define YULE_FILTER     filterYule
 53 | #define BUTTER_FILTER   filterButter
 54 | #define RMS_PERCENTILE      0.95 /* percentile which is louder than the proposed level */
 55 | #define MAX_SAMP_FREQ   48000L /* maximum allowed sample frequency [Hz] */
 56 | #define RMS_WINDOW_TIME_NUMERATOR    1L
 57 | #define RMS_WINDOW_TIME_DENOMINATOR 20L /* numerator / denominator = time slice size [s] */
 58 | #define STEPS_per_dB      100 /* Table entries per dB */
 59 | #define MAX_dB            120 /* Table entries for 0...MAX_dB (normal max. values are 70...80 dB) */
 60 | 
 61 |     enum { GAIN_NOT_ENOUGH_SAMPLES = -24601, GAIN_ANALYSIS_ERROR = 0, GAIN_ANALYSIS_OK =
 62 |             1, INIT_GAIN_ANALYSIS_ERROR = 0, INIT_GAIN_ANALYSIS_OK = 1
 63 |     };
 64 | 
 65 |     enum { MAX_ORDER = (BUTTER_ORDER > YULE_ORDER ? BUTTER_ORDER : YULE_ORDER)
 66 |             , MAX_SAMPLES_PER_WINDOW = ((MAX_SAMP_FREQ * RMS_WINDOW_TIME_NUMERATOR) / RMS_WINDOW_TIME_DENOMINATOR + 1) /* max. Samples per Time slice */
 67 |     };
 68 | 
 69 |     struct replaygain_data {
 70 |         Float_t linprebuf[MAX_ORDER * 2];
 71 |         Float_t *linpre;     /* left input samples, with pre-buffer */
 72 |         Float_t lstepbuf[MAX_SAMPLES_PER_WINDOW + MAX_ORDER];
 73 |         Float_t *lstep;      /* left "first step" (i.e. post first filter) samples */
 74 |         Float_t loutbuf[MAX_SAMPLES_PER_WINDOW + MAX_ORDER];
 75 |         Float_t *lout;       /* left "out" (i.e. post second filter) samples */
 76 |         Float_t rinprebuf[MAX_ORDER * 2];
 77 |         Float_t *rinpre;     /* right input samples ... */
 78 |         Float_t rstepbuf[MAX_SAMPLES_PER_WINDOW + MAX_ORDER];
 79 |         Float_t *rstep;
 80 |         Float_t routbuf[MAX_SAMPLES_PER_WINDOW + MAX_ORDER];
 81 |         Float_t *rout;
 82 |         long    sampleWindow; /* number of samples required to reach number of milliseconds required for RMS window */
 83 |         long    totsamp;
 84 |         double  lsum;
 85 |         double  rsum;
 86 |         int     freqindex;
 87 |         int     first;
 88 |         uint32_t A[STEPS_per_dB * MAX_dB];
 89 |         uint32_t B[STEPS_per_dB * MAX_dB];
 90 | 
 91 |     };
 92 | #ifndef replaygain_data_defined
 93 | #define replaygain_data_defined
 94 |     typedef struct replaygain_data replaygain_t;
 95 | #endif
 96 | 
 97 | 
 98 | 
 99 | 
100 |     int     InitGainAnalysis(replaygain_t * rgData, long samplefreq);
101 |     int     AnalyzeSamples(replaygain_t * rgData, const Float_t * left_samples,
102 |                            const Float_t * right_samples, size_t num_samples, int num_channels);
103 |     Float_t GetTitleGain(replaygain_t * rgData);
104 | 
105 | 
106 | #ifdef __cplusplus
107 | }
108 | #endif
109 | #endif                       /* GAIN_ANALYSIS_H */
110 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/simple_lame_lib.c:
--------------------------------------------------------------------------------
  1 | #include <android/log.h>
  2 | #include "simple_lame_lib.h"
  3 | 
  4 | static jboolean local_log = JNI_FALSE;
  5 | static const char* TAG = "SimpleLameLib";
  6 | 
  7 | lame_global_flags* simple_lame_lib_init(
  8 | 		JNIEnv* env,
  9 | 		jint inSamplerate, jint outChannel,
 10 | 		jint outSamplerate, jint outBitrate, jint quality,
 11 | 		jstring id3tagTitle, jstring id3tagArtist, jstring id3tagAlbum,
 12 | 		jstring id3tagYear, jstring id3tagComment) {
 13 | 	if (local_log) {
 14 | 		__android_log_print(ANDROID_LOG_VERBOSE, TAG, "Start lame init.");
 15 | 	}
 16 | 
 17 | 	lame_global_flags* glf = lame_init();
 18 | 	lame_set_in_samplerate(glf, inSamplerate);
 19 | 	lame_set_num_channels(glf, outChannel);
 20 | 	lame_set_out_samplerate(glf, outSamplerate);
 21 | 	lame_set_brate(glf, outBitrate);
 22 | 	lame_set_quality(glf, quality);
 23 | 
 24 | 	const jchar* title = NULL;
 25 | 	const jchar* artist = NULL;
 26 | 	const jchar* album = NULL;
 27 | 	const jchar* year = NULL;
 28 | 	const jchar* comment = NULL;
 29 | 	if (id3tagTitle) {
 30 | 		title = (*env)->GetStringChars(env, id3tagTitle, NULL);
 31 | 	}
 32 | 	if (id3tagArtist) {
 33 | 		artist = (*env)->GetStringChars(env, id3tagArtist, NULL);
 34 | 	}
 35 | 	if (id3tagAlbum) {
 36 | 		album = (*env)->GetStringChars(env, id3tagAlbum, NULL);
 37 | 	}
 38 | 	if (id3tagYear) {
 39 | 		year = (*env)->GetStringChars(env, id3tagYear, NULL);
 40 | 	}
 41 | 	if (id3tagComment) {
 42 | 		comment = (*env)->GetStringChars(env, id3tagComment, NULL);
 43 | 	}
 44 | 
 45 | 	if (title || artist || album || year || comment) {
 46 | 		id3tag_init(glf);
 47 | 
 48 | 		if (title) {
 49 | 			id3tag_set_title(glf, (const char*)title);
 50 | 			(*env)->ReleaseStringChars(env, id3tagTitle, title);
 51 | 		}
 52 | 		if (artist) {
 53 | 			id3tag_set_artist(glf, (const char*)artist);
 54 | 			(*env)->ReleaseStringChars(env, id3tagArtist, artist);
 55 | 		}
 56 | 		if (album) {
 57 | 			id3tag_set_album(glf, (const char*)album);
 58 | 			(*env)->ReleaseStringChars(env, id3tagAlbum, album);
 59 | 		}
 60 | 		if (year) {
 61 | 			id3tag_set_year(glf, (const char*)year);
 62 | 			(*env)->ReleaseStringChars(env, id3tagYear, year);
 63 | 		}
 64 | 		if (comment) {
 65 | 			id3tag_set_comment(glf, (const char*)comment);
 66 | 			(*env)->ReleaseStringChars(env, id3tagComment, comment);
 67 | 		}
 68 | 	}
 69 | 
 70 | 	lame_init_params(glf);
 71 | 
 72 | 	if (local_log) {
 73 | 		__android_log_print(ANDROID_LOG_VERBOSE, TAG, "End lame init.");
 74 | 	}
 75 | 	
 76 | 	return glf;
 77 | }
 78 | 
 79 | jint simple_lame_lib_encode(
 80 | 		JNIEnv* env, lame_global_flags* glf, 
 81 | 		jshortArray buffer_l, jshortArray buffer_r,
 82 | 		jint samples, jbyteArray mp3buf) {
 83 | 	jshort* j_buffer_l = (*env)->GetShortArrayElements(env, buffer_l, NULL);
 84 | 
 85 | 	jshort* j_buffer_r = (*env)->GetShortArrayElements(env, buffer_r, NULL);
 86 | 
 87 | 	const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
 88 | 	jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
 89 | 
 90 | 	int result = lame_encode_buffer(glf, j_buffer_l, j_buffer_r,
 91 | 			samples, j_mp3buf, mp3buf_size);
 92 | 
 93 | 	(*env)->ReleaseShortArrayElements(env, buffer_l, j_buffer_l, 0);
 94 | 	(*env)->ReleaseShortArrayElements(env, buffer_r, j_buffer_r, 0);
 95 | 	(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
 96 | 
 97 | 	return result;
 98 | }
 99 | 
100 | jint simple_lame_lib_encodeBufferInterleaved(
101 | 		JNIEnv* env, lame_global_flags* glf, 
102 | 		jshortArray pcm, jint samples, jbyteArray mp3buf) {
103 | 	jshort* j_pcm = (*env)->GetShortArrayElements(env, pcm, NULL);
104 | 
105 | 	const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
106 | 	jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
107 | 
108 | 	int result = lame_encode_buffer_interleaved(glf, j_pcm,
109 | 			samples, j_mp3buf, mp3buf_size);
110 | 
111 | 	(*env)->ReleaseShortArrayElements(env, pcm, j_pcm, 0);
112 | 	(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
113 | 
114 | 	return result;
115 | }
116 | 
117 | jint simple_lame_lib_flush(
118 | 		JNIEnv* env, lame_global_flags* glf, 
119 | 		jbyteArray mp3buf) {
120 | 	const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
121 | 	jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
122 | 
123 | 	int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
124 | 
125 | 	(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
126 | 
127 | 	return result;
128 | }
129 | 
130 | void simple_lame_lib_close(
131 | 		lame_global_flags* glf) {
132 | 	lame_close(glf);
133 | 	glf = NULL;
134 | 
135 | 	if (local_log) {
136 | 		__android_log_print(ANDROID_LOG_VERBOSE, TAG, "Closed lame.");
137 | 	}
138 | }
139 | 
140 | void simple_lame_lib_log(
141 | 		jboolean on) {
142 | 	local_log = on;
143 | }
144 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/encoder.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *      encoder.h include file
  3 |  *
  4 |  *      Copyright (c) 2000 Mark Taylor
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | 
 23 | #ifndef LAME_ENCODER_H
 24 | #define LAME_ENCODER_H
 25 | 
 26 | /***********************************************************************
 27 | *
 28 | *  encoder and decoder delays
 29 | *
 30 | ***********************************************************************/
 31 | 
 32 | /* 
 33 |  * layer III enc->dec delay:  1056 (1057?)   (observed)
 34 |  * layer  II enc->dec delay:   480  (481?)   (observed)
 35 |  *
 36 |  * polyphase 256-16             (dec or enc)        = 240
 37 |  * mdct      256+32  (9*32)     (dec or enc)        = 288
 38 |  * total:    512+16
 39 |  *
 40 |  * My guess is that delay of polyphase filterbank is actualy 240.5
 41 |  * (there are technical reasons for this, see postings in mp3encoder).
 42 |  * So total Encode+Decode delay = ENCDELAY + 528 + 1
 43 |  */
 44 | 
 45 | /* 
 46 |  * ENCDELAY  The encoder delay.  
 47 |  *
 48 |  * Minimum allowed is MDCTDELAY (see below)
 49 |  *  
 50 |  * The first 96 samples will be attenuated, so using a value less than 96
 51 |  * will result in corrupt data for the first 96-ENCDELAY samples.
 52 |  *
 53 |  * suggested: 576
 54 |  * set to 1160 to sync with FhG.
 55 |  */
 56 | 
 57 | #define ENCDELAY      576
 58 | 
 59 | 
 60 | 
 61 | /*
 62 |  * make sure there is at least one complete frame after the
 63 |  * last frame containing real data
 64 |  *
 65 |  * Using a value of 288 would be sufficient for a 
 66 |  * a very sophisticated decoder that can decode granule-by-granule instead
 67 |  * of frame by frame.  But lets not assume this, and assume the decoder  
 68 |  * will not decode frame N unless it also has data for frame N+1
 69 |  *
 70 |  */
 71 | /*#define POSTDELAY   288*/
 72 | #define POSTDELAY   1152
 73 | 
 74 | 
 75 | 
 76 | /* 
 77 |  * delay of the MDCT used in mdct.c
 78 |  * original ISO routines had a delay of 528!  
 79 |  * Takehiro's routines: 
 80 |  */
 81 | 
 82 | #define MDCTDELAY     48
 83 | #define FFTOFFSET     (224+MDCTDELAY)
 84 | 
 85 | /*
 86 |  * Most decoders, including the one we use, have a delay of 528 samples.  
 87 |  */
 88 | 
 89 | #define DECDELAY      528
 90 | 
 91 | 
 92 | /* number of subbands */
 93 | #define SBLIMIT       32
 94 | 
 95 | /* parition bands bands */
 96 | #define CBANDS        64
 97 | 
 98 | /* number of critical bands/scale factor bands where masking is computed*/
 99 | #define SBPSY_l       21
100 | #define SBPSY_s       12
101 | 
102 | /* total number of scalefactor bands encoded */
103 | #define SBMAX_l       22
104 | #define SBMAX_s       13
105 | #define PSFB21         6
106 | #define PSFB12         6
107 | 
108 | 
109 | 
110 | /* FFT sizes */
111 | #define BLKSIZE       1024
112 | #define HBLKSIZE      (BLKSIZE/2 + 1)
113 | #define BLKSIZE_s     256
114 | #define HBLKSIZE_s    (BLKSIZE_s/2 + 1)
115 | 
116 | 
117 | /* #define switch_pe        1800 */
118 | #define NORM_TYPE     0
119 | #define START_TYPE    1
120 | #define SHORT_TYPE    2
121 | #define STOP_TYPE     3
122 | 
123 | /* 
124 |  * Mode Extention:
125 |  * When we are in stereo mode, there are 4 possible methods to store these
126 |  * two channels. The stereo modes -m? are using a subset of them.
127 |  *
128 |  *  -ms: MPG_MD_LR_LR
129 |  *  -mj: MPG_MD_LR_LR and MPG_MD_MS_LR
130 |  *  -mf: MPG_MD_MS_LR
131 |  *  -mi: all
132 |  */
133 | #if 0
134 | #define MPG_MD_LR_LR  0
135 | #define MPG_MD_LR_I   1
136 | #define MPG_MD_MS_LR  2
137 | #define MPG_MD_MS_I   3
138 | #endif
139 | enum MPEGChannelMode
140 | {   MPG_MD_LR_LR = 0
141 | ,   MPG_MD_LR_I  = 1
142 | ,   MPG_MD_MS_LR = 2
143 | ,   MPG_MD_MS_I  = 3
144 | };
145 | 
146 | #ifndef lame_internal_flags_defined
147 | #define lame_internal_flags_defined
148 | struct lame_internal_flags;
149 | typedef struct lame_internal_flags lame_internal_flags;
150 | #endif
151 | 
152 | int     lame_encode_mp3_frame(lame_internal_flags * gfc,
153 |                               sample_t const *inbuf_l,
154 |                               sample_t const *inbuf_r, unsigned char *mp3buf, int mp3buf_size);
155 | 
156 | #endif /* LAME_ENCODER_H */
157 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/quantize_pvt.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *	quantize_pvt include file
  3 |  *
  4 |  *	Copyright (c) 1999 Takehiro TOMINAGA
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | #ifndef LAME_QUANTIZE_PVT_H
 23 | #define LAME_QUANTIZE_PVT_H
 24 | 
 25 | #define IXMAX_VAL 8206  /* ix always <= 8191+15.    see count_bits() */
 26 | 
 27 | /* buggy Winamp decoder cannot handle values > 8191 */
 28 | /* #define IXMAX_VAL 8191 */
 29 | 
 30 | #define PRECALC_SIZE (IXMAX_VAL+2)
 31 | 
 32 | 
 33 | extern const int nr_of_sfb_block[6][3][4];
 34 | extern const int pretab[SBMAX_l];
 35 | extern const int slen1_tab[16];
 36 | extern const int slen2_tab[16];
 37 | 
 38 | extern const scalefac_struct sfBandIndex[9];
 39 | 
 40 | extern FLOAT pow43[PRECALC_SIZE];
 41 | #ifdef TAKEHIRO_IEEE754_HACK
 42 | extern FLOAT adj43asm[PRECALC_SIZE];
 43 | #else
 44 | extern FLOAT adj43[PRECALC_SIZE];
 45 | #endif
 46 | 
 47 | #define Q_MAX (256+1)
 48 | #define Q_MAX2 116      /* minimum possible number of
 49 |                            -cod_info->global_gain
 50 |                            + ((scalefac[] + (cod_info->preflag ? pretab[sfb] : 0))
 51 |                            << (cod_info->scalefac_scale + 1))
 52 |                            + cod_info->subblock_gain[cod_info->window[sfb]] * 8;
 53 | 
 54 |                            for long block, 0+((15+3)<<2) = 18*4 = 72
 55 |                            for short block, 0+(15<<2)+7*8 = 15*4+56 = 116
 56 |                          */
 57 | 
 58 | extern FLOAT pow20[Q_MAX + Q_MAX2 + 1];
 59 | extern FLOAT ipow20[Q_MAX];
 60 | 
 61 | typedef struct calc_noise_result_t {
 62 |     FLOAT   over_noise;      /* sum of quantization noise > masking */
 63 |     FLOAT   tot_noise;       /* sum of all quantization noise */
 64 |     FLOAT   max_noise;       /* max quantization noise */
 65 |     int     over_count;      /* number of quantization noise > masking */
 66 |     int     over_SSD;        /* SSD-like cost of distorted bands */
 67 |     int     bits;
 68 | } calc_noise_result;
 69 | 
 70 | 
 71 | /**
 72 | * allows re-use of previously
 73 | * computed noise values
 74 | */
 75 | typedef struct calc_noise_data_t {
 76 |     int     global_gain;
 77 |     int     sfb_count1;
 78 |     int     step[39];
 79 |     FLOAT   noise[39];
 80 |     FLOAT   noise_log[39];
 81 | } calc_noise_data;
 82 | 
 83 | 
 84 | int     on_pe(lame_internal_flags * gfc, const FLOAT pe[2][2],
 85 |               int targ_bits[2], int mean_bits, int gr, int cbr);
 86 | 
 87 | void    reduce_side(int targ_bits[2], FLOAT ms_ener_ratio, int mean_bits, int max_bits);
 88 | 
 89 | 
 90 | void    iteration_init(lame_internal_flags * gfc);
 91 | 
 92 | 
 93 | int     calc_xmin(lame_internal_flags const *gfc,
 94 |                   III_psy_ratio const *const ratio, gr_info * const cod_info, FLOAT * l3_xmin);
 95 | 
 96 | int     calc_noise(const gr_info * const cod_info,
 97 |                    const FLOAT * l3_xmin,
 98 |                    FLOAT * distort, calc_noise_result * const res, calc_noise_data * prev_noise);
 99 | 
100 | void    set_frame_pinfo(lame_internal_flags * gfc, const III_psy_ratio ratio[2][2]);
101 | 
102 | 
103 | 
104 | 
105 | /* takehiro.c */
106 | 
107 | int     count_bits(lame_internal_flags const *const gfc, const FLOAT * const xr,
108 |                    gr_info * const cod_info, calc_noise_data * prev_noise);
109 | int     noquant_count_bits(lame_internal_flags const *const gfc,
110 |                            gr_info * const cod_info, calc_noise_data * prev_noise);
111 | 
112 | 
113 | void    best_huffman_divide(const lame_internal_flags * const gfc, gr_info * const cod_info);
114 | 
115 | void    best_scalefac_store(const lame_internal_flags * gfc, const int gr, const int ch,
116 |                             III_side_info_t * const l3_side);
117 | 
118 | int     scale_bitcount(const lame_internal_flags * gfc, gr_info * cod_info);
119 | 
120 | void    huffman_init(lame_internal_flags * const gfc);
121 | 
122 | void    init_xrpow_core_init(lame_internal_flags * const gfc);
123 | 
124 | FLOAT   athAdjust(FLOAT a, FLOAT x, FLOAT athFloor, float ATHfixpoint);
125 | 
126 | #define LARGE_BITS 100000
127 | 
128 | #endif /* LAME_QUANTIZE_PVT_H */
129 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/machine.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *      Machine dependent defines/includes for LAME.
  3 |  *
  4 |  *      Copyright (c) 1999 A.L. Faber
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | #ifndef LAME_MACHINE_H
 23 | #define LAME_MACHINE_H
 24 | 
 25 | #include "version.h"
 26 | 
 27 | #if (LAME_RELEASE_VERSION == 0)
 28 | #undef NDEBUG
 29 | #endif
 30 | 
 31 | #include <stdio.h>
 32 | #include <assert.h>
 33 | 
 34 | #ifdef STDC_HEADERS
 35 | # include <stdlib.h>
 36 | # include <string.h>
 37 | #else
 38 | # ifndef HAVE_STRCHR
 39 | #  define strchr index
 40 | #  define strrchr rindex
 41 | # endif
 42 | char   *strchr(), *strrchr();
 43 | # ifndef HAVE_MEMCPY
 44 | #  define memcpy(d, s, n) bcopy ((s), (d), (n))
 45 | #  define memmove(d, s, n) bcopy ((s), (d), (n))
 46 | # endif
 47 | #endif
 48 | 
 49 | #if  defined(__riscos__)  &&  defined(FPA10)
 50 | # include "ymath.h"
 51 | #else
 52 | # include <math.h>
 53 | #endif
 54 | #include <limits.h>
 55 | 
 56 | #include <ctype.h>
 57 | 
 58 | #ifdef HAVE_ERRNO_H
 59 | # include <errno.h>
 60 | #endif
 61 | #ifdef HAVE_FCNTL_H
 62 | # include <fcntl.h>
 63 | #endif
 64 | 
 65 | #if defined(macintosh)
 66 | # include <types.h>
 67 | # include <stat.h>
 68 | #else
 69 | # include <sys/types.h>
 70 | # include <sys/stat.h>
 71 | #endif
 72 | 
 73 | #ifdef HAVE_INTTYPES_H
 74 | # include <inttypes.h>
 75 | #else
 76 | # ifdef HAVE_STDINT_H
 77 | #  include <stdint.h>
 78 | # endif
 79 | #endif
 80 | 
 81 | #ifdef WITH_DMALLOC
 82 | #include <dmalloc.h>
 83 | #endif
 84 | 
 85 | /*
 86 |  * 3 different types of pow() functions:
 87 |  *   - table lookup
 88 |  *   - pow()
 89 |  *   - exp()   on some machines this is claimed to be faster than pow()
 90 |  */
 91 | 
 92 | #define POW20(x) (assert(0 <= (x+Q_MAX2) && x < Q_MAX), pow20[x+Q_MAX2])
 93 | /*#define POW20(x)  pow(2.0,((double)(x)-210)*.25) */
 94 | /*#define POW20(x)  exp( ((double)(x)-210)*(.25*LOG2) ) */
 95 | 
 96 | #define IPOW20(x)  (assert(0 <= x && x < Q_MAX), ipow20[x])
 97 | /*#define IPOW20(x)  exp( -((double)(x)-210)*.1875*LOG2 ) */
 98 | /*#define IPOW20(x)  pow(2.0,-((double)(x)-210)*.1875) */
 99 | 
100 | /* in case this is used without configure */
101 | #ifndef inline
102 | # define inline
103 | #endif
104 | 
105 | #if defined(_MSC_VER)
106 | # undef inline
107 | # define inline _inline
108 | #elif defined(__SASC) || defined(__GNUC__) || defined(__ICC) || defined(__ECC)
109 | /* if __GNUC__ we always want to inline, not only if the user requests it */
110 | # undef inline
111 | # define inline __inline
112 | #endif
113 | 
114 | #if    defined(_MSC_VER)
115 | # pragma warning( disable : 4244 )
116 | /*# pragma warning( disable : 4305 ) */
117 | #endif
118 | 
119 | /*
120 |  * FLOAT    for variables which require at least 32 bits
121 |  * FLOAT8   for variables which require at least 64 bits
122 |  *
123 |  * On some machines, 64 bit will be faster than 32 bit.  Also, some math
124 |  * routines require 64 bit float, so setting FLOAT=float will result in a
125 |  * lot of conversions.
126 |  */
127 | 
128 | #if ( defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) )
129 | # define WIN32_LEAN_AND_MEAN
130 | # include <windows.h>
131 | # include <float.h>
132 | # define FLOAT_MAX FLT_MAX
133 | #else
134 | # ifndef FLOAT
135 | typedef float FLOAT;
136 | #  ifdef FLT_MAX
137 | #   define FLOAT_MAX FLT_MAX
138 | #  else
139 | #   define FLOAT_MAX 1e37 /* approx */
140 | #  endif
141 | # endif
142 | #endif
143 | 
144 | #ifndef FLOAT8
145 | typedef double FLOAT8;
146 | # ifdef DBL_MAX
147 | #  define FLOAT8_MAX DBL_MAX
148 | # else
149 | #  define FLOAT8_MAX 1e99 /* approx */
150 | # endif
151 | #else
152 | # ifdef FLT_MAX
153 | #  define FLOAT8_MAX FLT_MAX
154 | # else
155 | #  define FLOAT8_MAX 1e37 /* approx */
156 | # endif
157 | #endif
158 | 
159 | /* sample_t must be floating point, at least 32 bits */
160 | typedef FLOAT sample_t;
161 | 
162 | #define dimension_of(array) (sizeof(array)/sizeof(array[0]))
163 | #define beyond(array) (array+dimension_of(array))
164 | #define compiletime_assert(expression) extern char static_assert_##FILE##_##LINE[expression?1:0]
165 | 
166 | #if 1
167 | #define EQ(a,b) (\
168 | (fabs(a) > fabs(b)) \
169 |  ? (fabs((a)-(b)) <= (fabs(a) * 1e-6f)) \
170 |  : (fabs((a)-(b)) <= (fabs(b) * 1e-6f)))
171 | #else
172 | #define EQ(a,b) (fabs((a)-(b))<1E-37)
173 | #endif
174 | 
175 | #define NEQ(a,b) (!EQ(a,b))
176 | 
177 | #endif
178 | 
179 | #ifdef _MSC_VER
180 | #  if _MSC_VER < 1400
181 | #  define fabsf fabs
182 | #  define powf pow
183 | #  define log10f log10
184 | #  endif
185 | #endif
186 | 
187 | 
188 | /* end of machine.h */
189 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/version.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *      Version numbering for LAME.
  3 |  *
  4 |  *      Copyright (c) 1999 A.L. Faber
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | /*!
 23 |   \file   version.c
 24 |   \brief  Version numbering for LAME.
 25 | 
 26 |   Contains functions which describe the version of LAME.
 27 | 
 28 |   \author A.L. Faber
 29 |   \version \$Id: version.c,v 1.32.2.2 2011/11/18 09:18:28 robert Exp $
 30 |   \ingroup libmp3lame
 31 | */
 32 | 
 33 | 
 34 | #ifdef HAVE_CONFIG_H
 35 | # include <config.h>
 36 | #endif
 37 | 
 38 | 
 39 | #include "lame.h"
 40 | #include "machine.h"
 41 | 
 42 | #include "version.h"    /* macros of version numbers */
 43 | 
 44 | 
 45 | 
 46 | 
 47 | 
 48 | /*! Get the LAME version string. */
 49 | /*!
 50 |   \param void
 51 |   \return a pointer to a string which describes the version of LAME.
 52 | */
 53 | const char *
 54 | get_lame_version(void)
 55 | {                       /* primary to write screen reports */
 56 |     /* Here we can also add informations about compile time configurations */
 57 | 
 58 | #if   LAME_ALPHA_VERSION
 59 |     static /*@observer@ */ const char *const str =
 60 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) " "
 61 |         "(alpha " STR(LAME_PATCH_VERSION) ", " __DATE__ " " __TIME__ ")";
 62 | #elif LAME_BETA_VERSION
 63 |     static /*@observer@ */ const char *const str =
 64 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) " "
 65 |         "(beta " STR(LAME_PATCH_VERSION) ", " __DATE__ ")";
 66 | #elif LAME_RELEASE_VERSION && (LAME_PATCH_VERSION > 0)
 67 |     static /*@observer@ */ const char *const str =
 68 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) "." STR(LAME_PATCH_VERSION);
 69 | #else
 70 |     static /*@observer@ */ const char *const str =
 71 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION);
 72 | #endif
 73 | 
 74 |     return str;
 75 | }
 76 | 
 77 | 
 78 | /*! Get the short LAME version string. */
 79 | /*!
 80 |   It's mainly for inclusion into the MP3 stream.
 81 | 
 82 |   \param void   
 83 |   \return a pointer to the short version of the LAME version string.
 84 | */
 85 | const char *
 86 | get_lame_short_version(void)
 87 | {
 88 |     /* adding date and time to version string makes it harder for output
 89 |        validation */
 90 | 
 91 | #if   LAME_ALPHA_VERSION
 92 |     static /*@observer@ */ const char *const str =
 93 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) " (alpha " STR(LAME_PATCH_VERSION) ")";
 94 | #elif LAME_BETA_VERSION
 95 |     static /*@observer@ */ const char *const str =
 96 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) " (beta " STR(LAME_PATCH_VERSION) ")";
 97 | #elif LAME_RELEASE_VERSION && (LAME_PATCH_VERSION > 0)
 98 |     static /*@observer@ */ const char *const str =
 99 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) "." STR(LAME_PATCH_VERSION);
100 | #else
101 |     static /*@observer@ */ const char *const str =
102 |         STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION);
103 | #endif
104 | 
105 |     return str;
106 | }
107 | 
108 | /*! Get the _very_ short LAME version string. */
109 | /*!
110 |   It's used in the LAME VBR tag only.
111 | 
112 |   \param void   
113 |   \return a pointer to the short version of the LAME version string.
114 | */
115 | const char *
116 | get_lame_very_short_version(void)
117 | {
118 |     /* adding date and time to version string makes it harder for output
119 |        validation */
120 | #if   LAME_ALPHA_VERSION
121 | #define P "a"
122 | #elif LAME_BETA_VERSION
123 | #define P "b"
124 | #elif LAME_RELEASE_VERSION && (LAME_PATCH_VERSION > 0)
125 | #define P "r"
126 | #else
127 | #define P ""
128 | #endif
129 |     static /*@observer@ */ const char *const str =
130 | #if (LAME_PATCH_VERSION > 0)
131 |       "LAME" STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) P STR(LAME_PATCH_VERSION)
132 | #else
133 |       "LAME" STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) P
134 | #endif
135 |       ;
136 |     return str;
137 | }
138 | 
139 | /*! Get the _very_ short LAME version string. */
140 | /*!
141 |   It's used in the LAME VBR tag only, limited to 9 characters max.
142 |   Due to some 3rd party HW/SW decoders, it has to start with LAME.
143 | 
144 |   \param void   
145 |   \return a pointer to the short version of the LAME version string.
146 |  */
147 | const char*
148 | get_lame_tag_encoder_short_version(void)
149 | {
150 |     static /*@observer@ */ const char *const str =
151 |             /* FIXME: new scheme / new version counting / drop versioning here ? */
152 |     "LAME" STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) P
153 |     ;
154 |     return str;
155 | }
156 | 
157 | /*! Get the version string for GPSYCHO. */
158 | /*!
159 |   \param void
160 |   \return a pointer to a string which describes the version of GPSYCHO.
161 | */
162 | const char *
163 | get_psy_version(void)
164 | {
165 | #if   PSY_ALPHA_VERSION > 0
166 |     static /*@observer@ */ const char *const str =
167 |         STR(PSY_MAJOR_VERSION) "." STR(PSY_MINOR_VERSION)
168 |         " (alpha " STR(PSY_ALPHA_VERSION) ", " __DATE__ " " __TIME__ ")";
169 | #elif PSY_BETA_VERSION > 0
170 |     static /*@observer@ */ const char *const str =
171 |         STR(PSY_MAJOR_VERSION) "." STR(PSY_MINOR_VERSION)
172 |         " (beta " STR(PSY_BETA_VERSION) ", " __DATE__ ")";
173 | #else
174 |     static /*@observer@ */ const char *const str =
175 |         STR(PSY_MAJOR_VERSION) "." STR(PSY_MINOR_VERSION);
176 | #endif
177 | 
178 |     return str;
179 | }
180 | 
181 | 
182 | /*! Get the URL for the LAME website. */
183 | /*!
184 |   \param void
185 |   \return a pointer to a string which is a URL for the LAME website.
186 | */
187 | const char *
188 | get_lame_url(void)
189 | {
190 |     static /*@observer@ */ const char *const str = LAME_URL;
191 | 
192 |     return str;
193 | }
194 | 
195 | 
196 | /*! Get the numerical representation of the version. */
197 | /*!
198 |   Writes the numerical representation of the version of LAME and
199 |   GPSYCHO into lvp.
200 | 
201 |   \param lvp    
202 | */
203 | void
204 | get_lame_version_numerical(lame_version_t * lvp)
205 | {
206 |     static /*@observer@ */ const char *const features = ""; /* obsolete */
207 | 
208 |     /* generic version */
209 |     lvp->major = LAME_MAJOR_VERSION;
210 |     lvp->minor = LAME_MINOR_VERSION;
211 | #if LAME_ALPHA_VERSION
212 |     lvp->alpha = LAME_PATCH_VERSION;
213 |     lvp->beta = 0;
214 | #elif LAME_BETA_VERSION
215 |     lvp->alpha = 0;
216 |     lvp->beta = LAME_PATCH_VERSION;
217 | #else
218 |     lvp->alpha = 0;
219 |     lvp->beta = 0;
220 | #endif
221 | 
222 |     /* psy version */
223 |     lvp->psy_major = PSY_MAJOR_VERSION;
224 |     lvp->psy_minor = PSY_MINOR_VERSION;
225 |     lvp->psy_alpha = PSY_ALPHA_VERSION;
226 |     lvp->psy_beta = PSY_BETA_VERSION;
227 | 
228 |     /* compile time features */
229 |     /*@-mustfree@ */
230 |     lvp->features = features;
231 |     /*@=mustfree@ */
232 | }
233 | 
234 | 
235 | const char *
236 | get_lame_os_bitness(void)
237 | {
238 |     static /*@observer@ */ const char *const strXX = "";
239 |     static /*@observer@ */ const char *const str32 = "32bits";
240 |     static /*@observer@ */ const char *const str64 = "64bits";
241 | 
242 |     switch (sizeof(void *)) {
243 |     case 4:
244 |         return str32;
245 | 
246 |     case 8:
247 |         return str64;
248 | 
249 |     default:
250 |         return strXX;
251 |     }
252 | }
253 | 
254 | /* end of version.c */
255 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/lame_global_flags.h:
--------------------------------------------------------------------------------
  1 | #ifndef LAME_GLOBAL_FLAGS_H
  2 | #define LAME_GLOBAL_FLAGS_H
  3 | 
  4 | #ifndef lame_internal_flags_defined
  5 | #define lame_internal_flags_defined
  6 | struct lame_internal_flags;
  7 | typedef struct lame_internal_flags lame_internal_flags;
  8 | #endif
  9 | 
 10 | 
 11 | typedef enum short_block_e {
 12 |     short_block_not_set = -1, /* allow LAME to decide */
 13 |     short_block_allowed = 0, /* LAME may use them, even different block types for L/R */
 14 |     short_block_coupled, /* LAME may use them, but always same block types in L/R */
 15 |     short_block_dispensed, /* LAME will not use short blocks, long blocks only */
 16 |     short_block_forced  /* LAME will not use long blocks, short blocks only */
 17 | } short_block_t;
 18 | 
 19 | /***********************************************************************
 20 | *
 21 | *  Control Parameters set by User.  These parameters are here for
 22 | *  backwards compatibility with the old, non-shared lib API.
 23 | *  Please use the lame_set_variablename() functions below
 24 | *
 25 | *
 26 | ***********************************************************************/
 27 | struct lame_global_struct {
 28 |     unsigned int class_id;
 29 | 
 30 |     /* input description */
 31 |     unsigned long num_samples; /* number of samples. default=2^32-1           */
 32 |     int     num_channels;    /* input number of channels. default=2         */
 33 |     int     samplerate_in;   /* input_samp_rate in Hz. default=44.1 kHz     */
 34 |     int     samplerate_out;  /* output_samp_rate.
 35 |                                 default: LAME picks best value
 36 |                                 at least not used for MP3 decoding:
 37 |                                 Remember 44.1 kHz MP3s and AC97           */
 38 |     float   scale;           /* scale input by this amount before encoding
 39 |                                 at least not used for MP3 decoding          */
 40 |     float   scale_left;      /* scale input of channel 0 (left) by this
 41 |                                 amount before encoding                      */
 42 |     float   scale_right;     /* scale input of channel 1 (right) by this
 43 |                                 amount before encoding                      */
 44 | 
 45 |     /* general control params */
 46 |     int     analysis;        /* collect data for a MP3 frame analyzer?      */
 47 |     int     write_lame_tag;  /* add Xing VBR tag?                           */
 48 |     int     decode_only;     /* use lame/mpglib to convert mp3 to wav       */
 49 |     int     quality;         /* quality setting 0=best,  9=worst  default=5 */
 50 |     MPEG_mode mode;          /* see enum in lame.h
 51 |                                 default = LAME picks best value             */
 52 |     int     force_ms;        /* force M/S mode.  requires mode=1            */
 53 |     int     free_format;     /* use free format? default=0                  */
 54 |     int     findReplayGain;  /* find the RG value? default=0       */
 55 |     int     decode_on_the_fly; /* decode on the fly? default=0                */
 56 |     int     write_id3tag_automatic; /* 1 (default) writes ID3 tags, 0 not */
 57 | 
 58 |     int     nogap_total;
 59 |     int     nogap_current;
 60 | 
 61 |     int     substep_shaping;
 62 |     int     noise_shaping;
 63 |     int     subblock_gain;   /*  0 = no, 1 = yes */
 64 |     int     use_best_huffman; /* 0 = no.  1=outside loop  2=inside loop(slow) */
 65 | 
 66 |     /*
 67 |      * set either brate>0  or compression_ratio>0, LAME will compute
 68 |      * the value of the variable not set.
 69 |      * Default is compression_ratio = 11.025
 70 |      */
 71 |     int     brate;           /* bitrate                                    */
 72 |     float   compression_ratio; /* sizeof(wav file)/sizeof(mp3 file)          */
 73 | 
 74 | 
 75 |     /* frame params */
 76 |     int     copyright;       /* mark as copyright. default=0           */
 77 |     int     original;        /* mark as original. default=1            */
 78 |     int     extension;       /* the MP3 'private extension' bit.
 79 |                                 Meaningless                            */
 80 |     int     emphasis;        /* Input PCM is emphased PCM (for
 81 |                                 instance from one of the rarely
 82 |                                 emphased CDs), it is STRONGLY not
 83 |                                 recommended to use this, because
 84 |                                 psycho does not take it into account,
 85 |                                 and last but not least many decoders
 86 |                                 don't care about these bits          */
 87 |     int     error_protection; /* use 2 bytes per frame for a CRC
 88 |                                  checksum. default=0                    */
 89 |     int     strict_ISO;      /* enforce ISO spec as much as possible   */
 90 | 
 91 |     int     disable_reservoir; /* use bit reservoir?                     */
 92 | 
 93 |     /* quantization/noise shaping */
 94 |     int     quant_comp;
 95 |     int     quant_comp_short;
 96 |     int     experimentalY;
 97 |     int     experimentalZ;
 98 |     int     exp_nspsytune;
 99 | 
100 |     int     preset;
101 | 
102 |     /* VBR control */
103 |     vbr_mode VBR;
104 |     float   VBR_q_frac;      /* Range [0,...,1[ */
105 |     int     VBR_q;           /* Range [0,...,9] */
106 |     int     VBR_mean_bitrate_kbps;
107 |     int     VBR_min_bitrate_kbps;
108 |     int     VBR_max_bitrate_kbps;
109 |     int     VBR_hard_min;    /* strictly enforce VBR_min_bitrate
110 |                                 normaly, it will be violated for analog
111 |                                 silence                                 */
112 | 
113 | 
114 |     /* resampling and filtering */
115 |     int     lowpassfreq;     /* freq in Hz. 0=lame choses.
116 |                                 -1=no filter                          */
117 |     int     highpassfreq;    /* freq in Hz. 0=lame choses.
118 |                                 -1=no filter                          */
119 |     int     lowpasswidth;    /* freq width of filter, in Hz
120 |                                 (default=15%)                         */
121 |     int     highpasswidth;   /* freq width of filter, in Hz
122 |                                 (default=15%)                         */
123 | 
124 | 
125 | 
126 |     /*
127 |      * psycho acoustics and other arguments which you should not change
128 |      * unless you know what you are doing
129 |      */
130 |     float   maskingadjust;
131 |     float   maskingadjust_short;
132 |     int     ATHonly;         /* only use ATH                         */
133 |     int     ATHshort;        /* only use ATH for short blocks        */
134 |     int     noATH;           /* disable ATH                          */
135 |     int     ATHtype;         /* select ATH formula                   */
136 |     float   ATHcurve;        /* change ATH formula 4 shape           */
137 |     float   ATH_lower_db;    /* lower ATH by this many db            */
138 |     int     athaa_type;      /* select ATH auto-adjust scheme        */
139 |     float   athaa_sensitivity; /* dB, tune active region of auto-level */
140 |     short_block_t short_blocks;
141 |     int     useTemporal;     /* use temporal masking effect          */
142 |     float   interChRatio;
143 |     float   msfix;           /* Naoki's adjustment of Mid/Side maskings */
144 | 
145 |     int     tune;            /* 0 off, 1 on */
146 |     float   tune_value_a;    /* used to pass values for debugging and stuff */
147 | 
148 |     float   attackthre;      /* attack threshold for L/R/M channel */
149 |     float   attackthre_s;    /* attack threshold for S channel */
150 | 
151 | 
152 |     struct {
153 |         void    (*msgf) (const char *format, va_list ap);
154 |         void    (*debugf) (const char *format, va_list ap);
155 |         void    (*errorf) (const char *format, va_list ap);
156 |     } report;
157 | 
158 |   /************************************************************************/
159 |     /* internal variables, do not set...                                    */
160 |     /* provided because they may be of use to calling application           */
161 |   /************************************************************************/
162 | 
163 |     int     lame_allocated_gfp; /* is this struct owned by calling
164 |                                    program or lame?                     */
165 | 
166 | 
167 | 
168 |   /**************************************************************************/
169 |     /* more internal variables are stored in this structure:                  */
170 |   /**************************************************************************/
171 |     lame_internal_flags *internal_flags;
172 | 
173 | 
174 |     struct {
175 |         int     mmx;
176 |         int     amd3dnow;
177 |         int     sse;
178 | 
179 |     } asm_optimizations;
180 | };
181 | 
182 | int     is_lame_global_flags_valid(const lame_global_flags * gfp);
183 | 
184 | #endif /* LAME_GLOBAL_FLAGS_H */
185 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/vector/xmm_quantize_sub.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * MP3 quantization, intrinsics functions
  3 |  *
  4 |  *      Copyright (c) 2005-2006 Gabriel Bouvigne
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | 
 23 | #ifdef HAVE_CONFIG_H
 24 | # include <config.h>
 25 | #endif
 26 | 
 27 | #include "lame.h"
 28 | #include "machine.h"
 29 | #include "encoder.h"
 30 | #include "util.h"
 31 | #include "lame_intrin.h"
 32 | 
 33 | 
 34 | 
 35 | #ifdef HAVE_XMMINTRIN_H
 36 | 
 37 | #include <xmmintrin.h>
 38 | 
 39 | typedef union {
 40 |     int32_t _i_32[4]; /* unions are initialized by its first member */
 41 |     float   _float[4];
 42 |     __m128  _m128;
 43 | } vecfloat_union;
 44 | 
 45 | #define TRI_SIZE (5-1)  /* 1024 =  4**5 */
 46 | static const FLOAT costab[TRI_SIZE * 2] = {
 47 |     9.238795325112867e-01, 3.826834323650898e-01,
 48 |     9.951847266721969e-01, 9.801714032956060e-02,
 49 |     9.996988186962042e-01, 2.454122852291229e-02,
 50 |     9.999811752826011e-01, 6.135884649154475e-03
 51 | };
 52 | 
 53 | 
 54 | 
 55 | void
 56 | init_xrpow_core_sse(gr_info * const cod_info, FLOAT xrpow[576], int upper, FLOAT * sum)
 57 | {
 58 |     int     i;
 59 |     float   tmp_max = 0;
 60 |     float   tmp_sum = 0;
 61 |     int     upper4 = (upper / 4) * 4;
 62 |     int     rest = upper-upper4;
 63 | 
 64 |     const vecfloat_union fabs_mask = {{ 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF }};
 65 |     const __m128 vec_fabs_mask = _mm_loadu_ps(&fabs_mask._float[0]);
 66 |     vecfloat_union vec_xrpow_max;
 67 |     vecfloat_union vec_sum;
 68 |     vecfloat_union vec_tmp;
 69 | 
 70 |     _mm_prefetch((char *) cod_info->xr, _MM_HINT_T0);
 71 |     _mm_prefetch((char *) xrpow, _MM_HINT_T0);
 72 | 
 73 |     vec_xrpow_max._m128 = _mm_set_ps1(0);
 74 |     vec_sum._m128 = _mm_set_ps1(0);
 75 | 
 76 |     for (i = 0; i < upper4; i += 4) {
 77 |         vec_tmp._m128 = _mm_loadu_ps(&(cod_info->xr[i])); /* load */
 78 |         vec_tmp._m128 = _mm_and_ps(vec_tmp._m128, vec_fabs_mask); /* fabs */
 79 |         vec_sum._m128 = _mm_add_ps(vec_sum._m128, vec_tmp._m128);
 80 |         vec_tmp._m128 = _mm_sqrt_ps(_mm_mul_ps(vec_tmp._m128, _mm_sqrt_ps(vec_tmp._m128)));
 81 |         vec_xrpow_max._m128 = _mm_max_ps(vec_xrpow_max._m128, vec_tmp._m128); /* retrieve max */
 82 |         _mm_storeu_ps(&(xrpow[i]), vec_tmp._m128); /* store into xrpow[] */
 83 |     }
 84 |     vec_tmp._m128 = _mm_set_ps1(0);
 85 |     switch (rest) {
 86 |         case 3: vec_tmp._float[2] = cod_info->xr[upper4+2];
 87 |         case 2: vec_tmp._float[1] = cod_info->xr[upper4+1];
 88 |         case 1: vec_tmp._float[0] = cod_info->xr[upper4+0];
 89 |             vec_tmp._m128 = _mm_and_ps(vec_tmp._m128, vec_fabs_mask); /* fabs */
 90 |             vec_sum._m128 = _mm_add_ps(vec_sum._m128, vec_tmp._m128);
 91 |             vec_tmp._m128 = _mm_sqrt_ps(_mm_mul_ps(vec_tmp._m128, _mm_sqrt_ps(vec_tmp._m128)));
 92 |             vec_xrpow_max._m128 = _mm_max_ps(vec_xrpow_max._m128, vec_tmp._m128); /* retrieve max */
 93 |             switch (rest) {
 94 |                 case 3: xrpow[upper4+2] = vec_tmp._float[2];
 95 |                 case 2: xrpow[upper4+1] = vec_tmp._float[1];
 96 |                 case 1: xrpow[upper4+0] = vec_tmp._float[0];
 97 |                 default:
 98 |                     break;
 99 |             }
100 |         default:
101 |             break;
102 |     }
103 |     tmp_sum = vec_sum._float[0] + vec_sum._float[1] + vec_sum._float[2] + vec_sum._float[3];
104 |     {
105 |         float ma = vec_xrpow_max._float[0] > vec_xrpow_max._float[1]
106 |                 ? vec_xrpow_max._float[0] : vec_xrpow_max._float[1];
107 |         float mb = vec_xrpow_max._float[2] > vec_xrpow_max._float[3]
108 |                 ? vec_xrpow_max._float[2] : vec_xrpow_max._float[3];
109 |         tmp_max = ma > mb ? ma : mb;
110 |     }
111 |     cod_info->xrpow_max = tmp_max;
112 |     *sum = tmp_sum;
113 | }
114 | 
115 | 
116 | static void store4(__m128 v, float* f0, float* f1, float* f2, float* f3)
117 | {
118 |     vecfloat_union r;
119 |     r._m128 = v;
120 |     *f0 = r._float[0];
121 |     *f1 = r._float[1];
122 |     *f2 = r._float[2];
123 |     *f3 = r._float[3];
124 | }
125 | 
126 | 
127 | void
128 | fht_SSE2(FLOAT * fz, int n)
129 | {
130 |     const FLOAT *tri = costab;
131 |     int     k4;
132 |     FLOAT  *fi, *gi;
133 |     FLOAT const *fn;
134 | 
135 |     n <<= 1;            /* to get BLKSIZE, because of 3DNow! ASM routine */
136 |     fn = fz + n;
137 |     k4 = 4;
138 |     do {
139 |         FLOAT   s1, c1;
140 |         int     i, k1, k2, k3, kx;
141 |         kx = k4 >> 1;
142 |         k1 = k4;
143 |         k2 = k4 << 1;
144 |         k3 = k2 + k1;
145 |         k4 = k2 << 1;
146 |         fi = fz;
147 |         gi = fi + kx;
148 |         do {
149 |             FLOAT   f0, f1, f2, f3;
150 |             f1 = fi[0] - fi[k1];
151 |             f0 = fi[0] + fi[k1];
152 |             f3 = fi[k2] - fi[k3];
153 |             f2 = fi[k2] + fi[k3];
154 |             fi[k2] = f0 - f2;
155 |             fi[0] = f0 + f2;
156 |             fi[k3] = f1 - f3;
157 |             fi[k1] = f1 + f3;
158 |             f1 = gi[0] - gi[k1];
159 |             f0 = gi[0] + gi[k1];
160 |             f3 = SQRT2 * gi[k3];
161 |             f2 = SQRT2 * gi[k2];
162 |             gi[k2] = f0 - f2;
163 |             gi[0] = f0 + f2;
164 |             gi[k3] = f1 - f3;
165 |             gi[k1] = f1 + f3;
166 |             gi += k4;
167 |             fi += k4;
168 |         } while (fi < fn);
169 |         c1 = tri[0];
170 |         s1 = tri[1];
171 |         for (i = 1; i < kx; i++) {
172 |             __m128 v_s2;
173 |             __m128 v_c2;
174 |             __m128 v_c1;
175 |             __m128 v_s1;
176 |             FLOAT   c2, s2, s1_2 = s1+s1;
177 |             c2 = 1 - s1_2 * s1;
178 |             s2 = s1_2 * c1;
179 |             fi = fz + i;
180 |             gi = fz + k1 - i;
181 |             v_c1 = _mm_set_ps1(c1);
182 |             v_s1 = _mm_set_ps1(s1);
183 |             v_c2 = _mm_set_ps1(c2);
184 |             v_s2 = _mm_set_ps1(s2);
185 |             {
186 |                 static const vecfloat_union sign_mask = {{0x80000000,0,0,0}};
187 |                 v_c1 = _mm_xor_ps(sign_mask._m128, v_c1); /* v_c1 := {-c1, +c1, +c1, +c1} */
188 |             }
189 |             {
190 |                 static const vecfloat_union sign_mask = {{0,0x80000000,0,0}};
191 |                 v_s1 = _mm_xor_ps(sign_mask._m128, v_s1); /* v_s1 := {+s1, -s1, +s1, +s1} */
192 |             }
193 |             {
194 |                 static const vecfloat_union sign_mask = {{0,0,0x80000000,0x80000000}};
195 |                 v_c2 = _mm_xor_ps(sign_mask._m128, v_c2); /* v_c2 := {+c2, +c2, -c2, -c2} */
196 |             }
197 |             do {
198 |                 __m128 p, q, r;
199 | 
200 |                 q = _mm_setr_ps(fi[k1], fi[k3], gi[k1], gi[k3]); /* Q := {fi_k1,fi_k3,gi_k1,gi_k3}*/
201 |                 p = _mm_mul_ps(_mm_set_ps1(s2), q);              /* P := s2 * Q */
202 |                 q = _mm_mul_ps(v_c2, q);                         /* Q := c2 * Q */
203 |                 q = _mm_shuffle_ps(q, q, _MM_SHUFFLE(1,0,3,2));  /* Q := {-c2*gi_k1,-c2*gi_k3,c2*fi_k1,c2*fi_k3} */
204 |                 p = _mm_add_ps(p, q);
205 |                 
206 |                 r = _mm_setr_ps(gi[0], gi[k2], fi[0], fi[k2]);   /* R := {gi_0,gi_k2,fi_0,fi_k2} */
207 |                 q = _mm_sub_ps(r, p);                            /* Q := {gi_0-p0,gi_k2-p1,fi_0-p2,fi_k2-p3} */
208 |                 r = _mm_add_ps(r, p);                            /* R := {gi_0+p0,gi_k2+p1,fi_0+p2,fi_k2+p3} */
209 |                 p = _mm_shuffle_ps(q, r, _MM_SHUFFLE(2,0,2,0));  /* P := {q0,q2,r0,r2} */
210 |                 p = _mm_shuffle_ps(p, p, _MM_SHUFFLE(3,1,2,0));  /* P := {q0,r0,q2,r2} */
211 |                 q = _mm_shuffle_ps(q, r, _MM_SHUFFLE(3,1,3,1));  /* Q := {q1,q3,r1,r3} */
212 |                 r = _mm_mul_ps(v_c1, q);
213 |                 q = _mm_mul_ps(v_s1, q);
214 |                 q = _mm_shuffle_ps(q, q, _MM_SHUFFLE(0,1,2,3));  /* Q := {q3,q2,q1,q0} */
215 |                 q = _mm_add_ps(q, r);
216 | 
217 |                 store4(_mm_sub_ps(p, q), &gi[k3], &gi[k2], &fi[k3], &fi[k2]);
218 |                 store4(_mm_add_ps(p, q), &gi[k1], &gi[ 0], &fi[k1], &fi[ 0]);
219 | 
220 |                 gi += k4;
221 |                 fi += k4;
222 |             } while (fi < fn);
223 |             c2 = c1;
224 |             c1 = c2 * tri[0] - s1 * tri[1];
225 |             s1 = c2 * tri[1] + s1 * tri[0];
226 |         }
227 |         tri += 2;
228 |     } while (k4 < n);
229 | }
230 | 
231 | #endif	/* HAVE_XMMINTRIN_H */
232 | 
233 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/fft.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** FFT and FHT routines
  3 | **  Copyright 1988, 1993; Ron Mayer
  4 | **      Copyright (c) 1999-2000 Takehiro Tominaga
  5 | **
  6 | **  fht(fz,n);
  7 | **      Does a hartley transform of "n" points in the array "fz".
  8 | **
  9 | ** NOTE: This routine uses at least 2 patented algorithms, and may be
 10 | **       under the restrictions of a bunch of different organizations.
 11 | **       Although I wrote it completely myself; it is kind of a derivative
 12 | **       of a routine I once authored and released under the GPL, so it
 13 | **       may fall under the free software foundation's restrictions;
 14 | **       it was worked on as a Stanford Univ project, so they claim
 15 | **       some rights to it; it was further optimized at work here, so
 16 | **       I think this company claims parts of it.  The patents are
 17 | **       held by R. Bracewell (the FHT algorithm) and O. Buneman (the
 18 | **       trig generator), both at Stanford Univ.
 19 | **       If it were up to me, I'd say go do whatever you want with it;
 20 | **       but it would be polite to give credit to the following people
 21 | **       if you use this anywhere:
 22 | **           Euler     - probable inventor of the fourier transform.
 23 | **           Gauss     - probable inventor of the FFT.
 24 | **           Hartley   - probable inventor of the hartley transform.
 25 | **           Buneman   - for a really cool trig generator
 26 | **           Mayer(me) - for authoring this particular version and
 27 | **                       including all the optimizations in one package.
 28 | **       Thanks,
 29 | **       Ron Mayer; mayer@acuson.com
 30 | ** and added some optimization by
 31 | **           Mather    - idea of using lookup table
 32 | **           Takehiro  - some dirty hack for speed up
 33 | */
 34 | 
 35 | /* $Id: fft.c,v 1.38 2009/04/20 21:48:00 robert Exp $ */
 36 | 
 37 | #ifdef HAVE_CONFIG_H
 38 | # include <config.h>
 39 | #endif
 40 | 
 41 | #include "lame.h"
 42 | #include "machine.h"
 43 | #include "encoder.h"
 44 | #include "util.h"
 45 | #include "fft.h"
 46 | 
 47 | #include "vector/lame_intrin.h"
 48 | 
 49 | 
 50 | 
 51 | #define TRI_SIZE (5-1)  /* 1024 =  4**5 */
 52 | 
 53 | /* fft.c    */
 54 | static FLOAT window[BLKSIZE], window_s[BLKSIZE_s / 2];
 55 | 
 56 | static const FLOAT costab[TRI_SIZE * 2] = {
 57 |     9.238795325112867e-01, 3.826834323650898e-01,
 58 |     9.951847266721969e-01, 9.801714032956060e-02,
 59 |     9.996988186962042e-01, 2.454122852291229e-02,
 60 |     9.999811752826011e-01, 6.135884649154475e-03
 61 | };
 62 | 
 63 | static void
 64 | fht(FLOAT * fz, int n)
 65 | {
 66 |     const FLOAT *tri = costab;
 67 |     int     k4;
 68 |     FLOAT  *fi, *gi;
 69 |     FLOAT const *fn;
 70 | 
 71 |     n <<= 1;            /* to get BLKSIZE, because of 3DNow! ASM routine */
 72 |     fn = fz + n;
 73 |     k4 = 4;
 74 |     do {
 75 |         FLOAT   s1, c1;
 76 |         int     i, k1, k2, k3, kx;
 77 |         kx = k4 >> 1;
 78 |         k1 = k4;
 79 |         k2 = k4 << 1;
 80 |         k3 = k2 + k1;
 81 |         k4 = k2 << 1;
 82 |         fi = fz;
 83 |         gi = fi + kx;
 84 |         do {
 85 |             FLOAT   f0, f1, f2, f3;
 86 |             f1 = fi[0] - fi[k1];
 87 |             f0 = fi[0] + fi[k1];
 88 |             f3 = fi[k2] - fi[k3];
 89 |             f2 = fi[k2] + fi[k3];
 90 |             fi[k2] = f0 - f2;
 91 |             fi[0] = f0 + f2;
 92 |             fi[k3] = f1 - f3;
 93 |             fi[k1] = f1 + f3;
 94 |             f1 = gi[0] - gi[k1];
 95 |             f0 = gi[0] + gi[k1];
 96 |             f3 = SQRT2 * gi[k3];
 97 |             f2 = SQRT2 * gi[k2];
 98 |             gi[k2] = f0 - f2;
 99 |             gi[0] = f0 + f2;
100 |             gi[k3] = f1 - f3;
101 |             gi[k1] = f1 + f3;
102 |             gi += k4;
103 |             fi += k4;
104 |         } while (fi < fn);
105 |         c1 = tri[0];
106 |         s1 = tri[1];
107 |         for (i = 1; i < kx; i++) {
108 |             FLOAT   c2, s2;
109 |             c2 = 1 - (2 * s1) * s1;
110 |             s2 = (2 * s1) * c1;
111 |             fi = fz + i;
112 |             gi = fz + k1 - i;
113 |             do {
114 |                 FLOAT   a, b, g0, f0, f1, g1, f2, g2, f3, g3;
115 |                 b = s2 * fi[k1] - c2 * gi[k1];
116 |                 a = c2 * fi[k1] + s2 * gi[k1];
117 |                 f1 = fi[0] - a;
118 |                 f0 = fi[0] + a;
119 |                 g1 = gi[0] - b;
120 |                 g0 = gi[0] + b;
121 |                 b = s2 * fi[k3] - c2 * gi[k3];
122 |                 a = c2 * fi[k3] + s2 * gi[k3];
123 |                 f3 = fi[k2] - a;
124 |                 f2 = fi[k2] + a;
125 |                 g3 = gi[k2] - b;
126 |                 g2 = gi[k2] + b;
127 |                 b = s1 * f2 - c1 * g3;
128 |                 a = c1 * f2 + s1 * g3;
129 |                 fi[k2] = f0 - a;
130 |                 fi[0] = f0 + a;
131 |                 gi[k3] = g1 - b;
132 |                 gi[k1] = g1 + b;
133 |                 b = c1 * g2 - s1 * f3;
134 |                 a = s1 * g2 + c1 * f3;
135 |                 gi[k2] = g0 - a;
136 |                 gi[0] = g0 + a;
137 |                 fi[k3] = f1 - b;
138 |                 fi[k1] = f1 + b;
139 |                 gi += k4;
140 |                 fi += k4;
141 |             } while (fi < fn);
142 |             c2 = c1;
143 |             c1 = c2 * tri[0] - s1 * tri[1];
144 |             s1 = c2 * tri[1] + s1 * tri[0];
145 |         }
146 |         tri += 2;
147 |     } while (k4 < n);
148 | }
149 | 
150 | 
151 | static const unsigned char rv_tbl[] = {
152 |     0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
153 |     0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
154 |     0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
155 |     0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
156 |     0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
157 |     0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
158 |     0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
159 |     0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
160 |     0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
161 |     0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
162 |     0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
163 |     0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
164 |     0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
165 |     0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
166 |     0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
167 |     0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe
168 | };
169 | 
170 | #define ch01(index)  (buffer[chn][index])
171 | 
172 | #define ml00(f) (window[i        ] * f(i))
173 | #define ml10(f) (window[i + 0x200] * f(i + 0x200))
174 | #define ml20(f) (window[i + 0x100] * f(i + 0x100))
175 | #define ml30(f) (window[i + 0x300] * f(i + 0x300))
176 | 
177 | #define ml01(f) (window[i + 0x001] * f(i + 0x001))
178 | #define ml11(f) (window[i + 0x201] * f(i + 0x201))
179 | #define ml21(f) (window[i + 0x101] * f(i + 0x101))
180 | #define ml31(f) (window[i + 0x301] * f(i + 0x301))
181 | 
182 | #define ms00(f) (window_s[i       ] * f(i + k))
183 | #define ms10(f) (window_s[0x7f - i] * f(i + k + 0x80))
184 | #define ms20(f) (window_s[i + 0x40] * f(i + k + 0x40))
185 | #define ms30(f) (window_s[0x3f - i] * f(i + k + 0xc0))
186 | 
187 | #define ms01(f) (window_s[i + 0x01] * f(i + k + 0x01))
188 | #define ms11(f) (window_s[0x7e - i] * f(i + k + 0x81))
189 | #define ms21(f) (window_s[i + 0x41] * f(i + k + 0x41))
190 | #define ms31(f) (window_s[0x3e - i] * f(i + k + 0xc1))
191 | 
192 | 
193 | void
194 | fft_short(lame_internal_flags const *const gfc,
195 |           FLOAT x_real[3][BLKSIZE_s], int chn, const sample_t *const buffer[2])
196 | {
197 |     int     i;
198 |     int     j;
199 |     int     b;
200 | 
201 |     for (b = 0; b < 3; b++) {
202 |         FLOAT  *x = &x_real[b][BLKSIZE_s / 2];
203 |         short const k = (576 / 3) * (b + 1);
204 |         j = BLKSIZE_s / 8 - 1;
205 |         do {
206 |             FLOAT   f0, f1, f2, f3, w;
207 | 
208 |             i = rv_tbl[j << 2];
209 | 
210 |             f0 = ms00(ch01);
211 |             w = ms10(ch01);
212 |             f1 = f0 - w;
213 |             f0 = f0 + w;
214 |             f2 = ms20(ch01);
215 |             w = ms30(ch01);
216 |             f3 = f2 - w;
217 |             f2 = f2 + w;
218 | 
219 |             x -= 4;
220 |             x[0] = f0 + f2;
221 |             x[2] = f0 - f2;
222 |             x[1] = f1 + f3;
223 |             x[3] = f1 - f3;
224 | 
225 |             f0 = ms01(ch01);
226 |             w = ms11(ch01);
227 |             f1 = f0 - w;
228 |             f0 = f0 + w;
229 |             f2 = ms21(ch01);
230 |             w = ms31(ch01);
231 |             f3 = f2 - w;
232 |             f2 = f2 + w;
233 | 
234 |             x[BLKSIZE_s / 2 + 0] = f0 + f2;
235 |             x[BLKSIZE_s / 2 + 2] = f0 - f2;
236 |             x[BLKSIZE_s / 2 + 1] = f1 + f3;
237 |             x[BLKSIZE_s / 2 + 3] = f1 - f3;
238 |         } while (--j >= 0);
239 | 
240 |         gfc->fft_fht(x, BLKSIZE_s / 2);
241 |         /* BLKSIZE_s/2 because of 3DNow! ASM routine */
242 |     }
243 | }
244 | 
245 | void
246 | fft_long(lame_internal_flags const *const gfc,
247 |          FLOAT x[BLKSIZE], int chn, const sample_t *const buffer[2])
248 | {
249 |     int     i;
250 |     int     jj = BLKSIZE / 8 - 1;
251 |     x += BLKSIZE / 2;
252 | 
253 |     do {
254 |         FLOAT   f0, f1, f2, f3, w;
255 | 
256 |         i = rv_tbl[jj];
257 |         f0 = ml00(ch01);
258 |         w = ml10(ch01);
259 |         f1 = f0 - w;
260 |         f0 = f0 + w;
261 |         f2 = ml20(ch01);
262 |         w = ml30(ch01);
263 |         f3 = f2 - w;
264 |         f2 = f2 + w;
265 | 
266 |         x -= 4;
267 |         x[0] = f0 + f2;
268 |         x[2] = f0 - f2;
269 |         x[1] = f1 + f3;
270 |         x[3] = f1 - f3;
271 | 
272 |         f0 = ml01(ch01);
273 |         w = ml11(ch01);
274 |         f1 = f0 - w;
275 |         f0 = f0 + w;
276 |         f2 = ml21(ch01);
277 |         w = ml31(ch01);
278 |         f3 = f2 - w;
279 |         f2 = f2 + w;
280 | 
281 |         x[BLKSIZE / 2 + 0] = f0 + f2;
282 |         x[BLKSIZE / 2 + 2] = f0 - f2;
283 |         x[BLKSIZE / 2 + 1] = f1 + f3;
284 |         x[BLKSIZE / 2 + 3] = f1 - f3;
285 |     } while (--jj >= 0);
286 | 
287 |     gfc->fft_fht(x, BLKSIZE / 2);
288 |     /* BLKSIZE/2 because of 3DNow! ASM routine */
289 | }
290 | 
291 | #ifdef HAVE_NASM
292 | extern void fht_3DN(FLOAT * fz, int n);
293 | extern void fht_SSE(FLOAT * fz, int n);
294 | #endif
295 | 
296 | void
297 | init_fft(lame_internal_flags * const gfc)
298 | {
299 |     int     i;
300 | 
301 |     /* The type of window used here will make no real difference, but */
302 |     /* in the interest of merging nspsytune stuff - switch to blackman window */
303 |     for (i = 0; i < BLKSIZE; i++)
304 |         /* blackman window */
305 |         window[i] = 0.42 - 0.5 * cos(2 * PI * (i + .5) / BLKSIZE) +
306 |             0.08 * cos(4 * PI * (i + .5) / BLKSIZE);
307 | 
308 |     for (i = 0; i < BLKSIZE_s / 2; i++)
309 |         window_s[i] = 0.5 * (1.0 - cos(2.0 * PI * (i + 0.5) / BLKSIZE_s));
310 | 
311 |     gfc->fft_fht = fht;
312 | #ifdef HAVE_NASM
313 |     if (gfc->CPU_features.AMD_3DNow) {
314 |         gfc->fft_fht = fht_3DN;
315 |     }
316 |     else if (gfc->CPU_features.SSE) {
317 |         gfc->fft_fht = fht_SSE;
318 |     }
319 |     else {
320 |         gfc->fft_fht = fht;
321 |     }
322 | #else
323 | #ifdef HAVE_XMMINTRIN_H
324 | #ifdef MIN_ARCH_SSE
325 |     gfc->fft_fht = fht_SSE2;
326 | #endif
327 | #endif
328 | #endif
329 | }
330 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/reservoir.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *      bit reservoir source file
  3 |  *
  4 |  *      Copyright (c) 1999-2000 Mark Taylor
  5 |  *
  6 |  * This library is free software; you can redistribute it and/or
  7 |  * modify it under the terms of the GNU Library General Public
  8 |  * License as published by the Free Software Foundation; either
  9 |  * version 2 of the License, or (at your option) any later version.
 10 |  *
 11 |  * This library is distributed in the hope that it will be useful,
 12 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14 |  * Library General Public License for more details.
 15 |  *
 16 |  * You should have received a copy of the GNU Library General Public
 17 |  * License along with this library; if not, write to the
 18 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19 |  * Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | /* $Id: reservoir.c,v 1.45 2011/05/07 16:05:17 rbrito Exp $ */
 23 | 
 24 | #ifdef HAVE_CONFIG_H
 25 | # include <config.h>
 26 | #endif
 27 | 
 28 | 
 29 | #include "lame.h"
 30 | #include "machine.h"
 31 | #include "encoder.h"
 32 | #include "util.h"
 33 | #include "reservoir.h"
 34 | 
 35 | #include "bitstream.h"
 36 | #include "lame-analysis.h"
 37 | #include "lame_global_flags.h"
 38 | 
 39 | 
 40 | /*
 41 |   ResvFrameBegin:
 42 |   Called (repeatedly) at the beginning of a frame. Updates the maximum
 43 |   size of the reservoir, and checks to make sure main_data_begin
 44 |   was set properly by the formatter
 45 | */
 46 | 
 47 | /*
 48 |  *  Background information:
 49 |  *
 50 |  *  This is the original text from the ISO standard. Because of
 51 |  *  sooo many bugs and irritations correcting comments are added
 52 |  *  in brackets []. A '^W' means you should remove the last word.
 53 |  *
 54 |  *  1) The following rule can be used to calculate the maximum
 55 |  *     number of bits used for one granule [^W frame]:
 56 |  *     At the highest possible bitrate of Layer III (320 kbps
 57 |  *     per stereo signal [^W^W^W], 48 kHz) the frames must be of
 58 |  *     [^W^W^W are designed to have] constant length, i.e.
 59 |  *     one buffer [^W^W the frame] length is:
 60 |  *
 61 |  *         320 kbps * 1152/48 kHz = 7680 bit = 960 byte
 62 |  *
 63 |  *     This value is used as the maximum buffer per channel [^W^W] at
 64 |  *     lower bitrates [than 320 kbps]. At 64 kbps mono or 128 kbps
 65 |  *     stereo the main granule length is 64 kbps * 576/48 kHz = 768 bit
 66 |  *     [per granule and channel] at 48 kHz sampling frequency.
 67 |  *     This means that there is a maximum deviation (short time buffer
 68 |  *     [= reservoir]) of 7680 - 2*2*768 = 4608 bits is allowed at 64 kbps.
 69 |  *     The actual deviation is equal to the number of bytes [with the
 70 |  *     meaning of octets] denoted by the main_data_end offset pointer.
 71 |  *     The actual maximum deviation is (2^9-1)*8 bit = 4088 bits
 72 |  *     [for MPEG-1 and (2^8-1)*8 bit for MPEG-2, both are hard limits].
 73 |  *     ... The xchange of buffer bits between the left and right channel
 74 |  *     is allowed without restrictions [exception: dual channel].
 75 |  *     Because of the [constructed] constraint on the buffer size
 76 |  *     main_data_end is always set to 0 in the case of bit_rate_index==14,
 77 |  *     i.e. data rate 320 kbps per stereo signal [^W^W^W]. In this case
 78 |  *     all data are allocated between adjacent header [^W sync] words
 79 |  *     [, i.e. there is no buffering at all].
 80 |  */
 81 | 
 82 | int
 83 | ResvFrameBegin(lame_internal_flags * gfc, int *mean_bits)
 84 | {
 85 |     SessionConfig_t const *const cfg = &gfc->cfg;
 86 |     EncStateVar_t *const esv = &gfc->sv_enc;
 87 |     int     fullFrameBits;
 88 |     int     resvLimit;
 89 |     int     maxmp3buf;
 90 |     III_side_info_t *const l3_side = &gfc->l3_side;
 91 |     int     frameLength;
 92 |     int     meanBits;
 93 | 
 94 |     frameLength = getframebits(gfc);
 95 |     meanBits = (frameLength - cfg->sideinfo_len * 8) / cfg->mode_gr;
 96 | 
 97 | /*
 98 |  *  Meaning of the variables:
 99 |  *      resvLimit: (0, 8, ..., 8*255 (MPEG-2), 8*511 (MPEG-1))
100 |  *          Number of bits can be stored in previous frame(s) due to
101 |  *          counter size constaints
102 |  *      maxmp3buf: ( ??? ... 8*1951 (MPEG-1 and 2), 8*2047 (MPEG-2.5))
103 |  *          Number of bits allowed to encode one frame (you can take 8*511 bit
104 |  *          from the bit reservoir and at most 8*1440 bit from the current
105 |  *          frame (320 kbps, 32 kHz), so 8*1951 bit is the largest possible
106 |  *          value for MPEG-1 and -2)
107 |  *
108 |  *          maximum allowed granule/channel size times 4 = 8*2047 bits.,
109 |  *          so this is the absolute maximum supported by the format.
110 |  *
111 |  *
112 |  *      fullFrameBits:  maximum number of bits available for encoding
113 |  *                      the current frame.
114 |  *
115 |  *      mean_bits:      target number of bits per granule.
116 |  *
117 |  *      frameLength:
118 |  *
119 |  *      gfc->ResvMax:   maximum allowed reservoir
120 |  *
121 |  *      gfc->ResvSize:  current reservoir size
122 |  *
123 |  *      l3_side->resvDrain_pre:
124 |  *         ancillary data to be added to previous frame:
125 |  *         (only usefull in VBR modes if it is possible to have
126 |  *         maxmp3buf < fullFrameBits)).  Currently disabled,
127 |  *         see #define NEW_DRAIN
128 |  *         2010-02-13: RH now enabled, it seems to be needed for CBR too,
129 |  *                     as there exists one example, where the FhG decoder
130 |  *                     can't decode a -b320 CBR file anymore.
131 |  *
132 |  *      l3_side->resvDrain_post:
133 |  *         ancillary data to be added to this frame:
134 |  *
135 |  */
136 | 
137 |     /* main_data_begin has 9 bits in MPEG-1, 8 bits MPEG-2 */
138 |     resvLimit = (8 * 256) * cfg->mode_gr - 8;
139 | 
140 |     /* maximum allowed frame size.  dont use more than this number of
141 |        bits, even if the frame has the space for them: */
142 |     maxmp3buf = cfg->buffer_constraint;
143 |     esv->ResvMax = maxmp3buf - frameLength;
144 |     if (esv->ResvMax > resvLimit)
145 |         esv->ResvMax = resvLimit;
146 |     if (esv->ResvMax < 0 || cfg->disable_reservoir)
147 |         esv->ResvMax = 0;
148 |     
149 |     fullFrameBits = meanBits * cfg->mode_gr + Min(esv->ResvSize, esv->ResvMax);
150 | 
151 |     if (fullFrameBits > maxmp3buf)
152 |         fullFrameBits = maxmp3buf;
153 | 
154 |     assert(0 == esv->ResvMax % 8);
155 |     assert(esv->ResvMax >= 0);
156 | 
157 |     l3_side->resvDrain_pre = 0;
158 | 
159 |     if (gfc->pinfo != NULL) {
160 |         gfc->pinfo->mean_bits = meanBits / 2; /* expected bits per channel per granule [is this also right for mono/stereo, MPEG-1/2 ?] */
161 |         gfc->pinfo->resvsize = esv->ResvSize;
162 |     }
163 |     *mean_bits = meanBits;
164 |     return fullFrameBits;
165 | }
166 | 
167 | 
168 | /*
169 |   ResvMaxBits
170 |   returns targ_bits:  target number of bits to use for 1 granule
171 |          extra_bits:  amount extra available from reservoir
172 |   Mark Taylor 4/99
173 | */
174 | void
175 | ResvMaxBits(lame_internal_flags * gfc, int mean_bits, int *targ_bits, int *extra_bits, int cbr)
176 | {
177 |     SessionConfig_t const *const cfg = &gfc->cfg;
178 |     EncStateVar_t *const esv = &gfc->sv_enc;
179 |     int     add_bits, targBits, extraBits;
180 |     int     ResvSize = esv->ResvSize, ResvMax = esv->ResvMax;
181 | 
182 |     /* conpensate the saved bits used in the 1st granule */
183 |     if (cbr)
184 |         ResvSize += mean_bits;
185 | 
186 |     if (gfc->sv_qnt.substep_shaping & 1)
187 |         ResvMax *= 0.9;
188 | 
189 |     targBits = mean_bits;
190 | 
191 |     /* extra bits if the reservoir is almost full */
192 |     if (ResvSize * 10 > ResvMax * 9) {
193 |         add_bits = ResvSize - (ResvMax * 9) / 10;
194 |         targBits += add_bits;
195 |         gfc->sv_qnt.substep_shaping |= 0x80;
196 |     }
197 |     else {
198 |         add_bits = 0;
199 |         gfc->sv_qnt.substep_shaping &= 0x7f;
200 |         /* build up reservoir.  this builds the reservoir a little slower
201 |          * than FhG.  It could simple be mean_bits/15, but this was rigged
202 |          * to always produce 100 (the old value) at 128kbs */
203 |         /*    *targ_bits -= (int) (mean_bits/15.2); */
204 |         if (!cfg->disable_reservoir && !(gfc->sv_qnt.substep_shaping & 1))
205 |             targBits -= .1 * mean_bits;
206 |     }
207 | 
208 | 
209 |     /* amount from the reservoir we are allowed to use. ISO says 6/10 */
210 |     extraBits = (ResvSize < (esv->ResvMax * 6) / 10 ? ResvSize : (esv->ResvMax * 6) / 10);
211 |     extraBits -= add_bits;
212 | 
213 |     if (extraBits < 0)
214 |         extraBits = 0;
215 | 
216 |     *targ_bits = targBits;
217 |     *extra_bits = extraBits;
218 | }
219 | 
220 | /*
221 |   ResvAdjust:
222 |   Called after a granule's bit allocation. Readjusts the size of
223 |   the reservoir to reflect the granule's usage.
224 | */
225 | void
226 | ResvAdjust(lame_internal_flags * gfc, gr_info const *gi)
227 | {
228 |     gfc->sv_enc.ResvSize -= gi->part2_3_length + gi->part2_length;
229 | }
230 | 
231 | 
232 | /*
233 |   ResvFrameEnd:
234 |   Called after all granules in a frame have been allocated. Makes sure
235 |   that the reservoir size is within limits, possibly by adding stuffing
236 |   bits.
237 | */
238 | void
239 | ResvFrameEnd(lame_internal_flags * gfc, int mean_bits)
240 | {
241 |     SessionConfig_t const *const cfg = &gfc->cfg;
242 |     EncStateVar_t *const esv = &gfc->sv_enc;
243 |     III_side_info_t *const l3_side = &gfc->l3_side;
244 |     int     stuffingBits;
245 |     int     over_bits;
246 | 
247 |     esv->ResvSize += mean_bits * cfg->mode_gr;
248 |     stuffingBits = 0;
249 |     l3_side->resvDrain_post = 0;
250 |     l3_side->resvDrain_pre = 0;
251 | 
252 |     /* we must be byte aligned */
253 |     if ((over_bits = esv->ResvSize % 8) != 0)
254 |         stuffingBits += over_bits;
255 | 
256 | 
257 |     over_bits = (esv->ResvSize - stuffingBits) - esv->ResvMax;
258 |     if (over_bits > 0) {
259 |         assert(0 == over_bits % 8);
260 |         assert(over_bits >= 0);
261 |         stuffingBits += over_bits;
262 |     }
263 | 
264 | 
265 |     /* NOTE: enabling the NEW_DRAIN code fixes some problems with FhG decoder
266 |              shipped with MS Windows operating systems. Using this, it is even
267 |              possible to use Gabriel's lax buffer consideration again, which
268 |              assumes, any decoder should have a buffer large enough
269 |              for a 320 kbps frame at 32 kHz sample rate.
270 | 
271 |        old drain code:
272 |              lame -b320 BlackBird.wav ---> does not play with GraphEdit.exe using FhG decoder V1.5 Build 50
273 | 
274 |        new drain code:
275 |              lame -b320 BlackBird.wav ---> plays fine with GraphEdit.exe using FhG decoder V1.5 Build 50
276 | 
277 |              Robert Hegemann, 2010-02-13.
278 |      */
279 |     /* drain as many bits as possible into previous frame ancillary data
280 |      * In particular, in VBR mode ResvMax may have changed, and we have
281 |      * to make sure main_data_begin does not create a reservoir bigger
282 |      * than ResvMax  mt 4/00*/
283 |     {
284 |         int     mdb_bytes = Min(l3_side->main_data_begin * 8, stuffingBits) / 8;
285 |         l3_side->resvDrain_pre += 8 * mdb_bytes;
286 |         stuffingBits -= 8 * mdb_bytes;
287 |         esv->ResvSize -= 8 * mdb_bytes;
288 |         l3_side->main_data_begin -= mdb_bytes;
289 |     }
290 |     /* drain the rest into this frames ancillary data */
291 |     l3_side->resvDrain_post += stuffingBits;
292 |     esv->ResvSize -= stuffingBits;
293 | }
294 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/src/com/uraroji/garage/android/lame/Encoder.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (C) 2011-2012 Yuichi Hirano
  3 |  *
  4 |  * This software is provided 'as-is', without any express or implied
  5 |  * warranty.  In no event will the authors be held liable for any damages
  6 |  * arising from the use of this software.
  7 |  * 
  8 |  * Permission is granted to anyone to use this software for any purpose,
  9 |  * including commercial applications, and to alter it and redistribute it
 10 |  * freely, subject to the following restrictions:
 11 |  * 
 12 |  * 1. The origin of this software must not be misrepresented; you must not
 13 |  *    claim that you wrote the original software. If you use this software
 14 |  *    in a product, an acknowledgment in the product documentation would be
 15 |  *    appreciated but is not required.
 16 |  * 2. Altered source versions must be plainly marked as such, and must not be
 17 |  *    misrepresented as being the original software.
 18 |  * 3. This notice may not be removed or altered from any source distribution.
 19 |  */
 20 | 
 21 | package com.uraroji.garage.android.lame;
 22 | 
 23 | /**
 24 |  * LAME interface class.
 25 |  * 
 26 |  * This class is object-oriented interface.
 27 |  */
 28 | public class Encoder {
 29 | 
 30 |     /**
 31 |      * Lame builder class.
 32 |      */
 33 |     public static class Builder {
 34 |         
 35 |         /**
 36 |          * Input sample rate in Hz.
 37 |          */
 38 |         private final int mInSamplerate;
 39 |         
 40 |         /**
 41 |          * Number of channels in input stream.
 42 |          */
 43 |         private final int mOutChannel;
 44 |         
 45 |         /**
 46 |          * Output sample rate in Hz.
 47 |          */
 48 |         private final int mOutSamplerate;
 49 |         
 50 |         /**
 51 |          * Brate compression ratio in KHz.
 52 |          */
 53 |         private final int mOutBitrate;
 54 |         
 55 |         /**
 56 |          * Encode quality.
 57 |          */
 58 |         private int mQuality = 7;
 59 |         
 60 |         /**
 61 |          * ID3 Tag title.
 62 |          */
 63 |         private String mId3tagTitle = null;
 64 | 
 65 |         /**
 66 |          * ID3 Tag artist.
 67 |          */
 68 |         private String mId3tagArtist = null;
 69 |         
 70 |         /**
 71 |          * ID3 Tag album.
 72 |          */
 73 |         private String mId3tagAlbum = null;
 74 |         
 75 |         /**
 76 |          * ID3 Tag year.
 77 |          */
 78 |         private String mId3tagYear = null;
 79 |         
 80 |         /**
 81 |          * ID3 Tag comment.
 82 |          */
 83 |         private String mId3tagComment = null;
 84 |         
 85 |         /**
 86 |          * Constructor.
 87 |          * 
 88 |          * @param inSamplerate Input sample rate in Hz.
 89 |          * @param outChannel Number of channels in input stream.
 90 |          * @param outSamplerate Output sample rate in Hz.
 91 |          * @param outBitrate Brate compression ratio in KHz.
 92 |          */
 93 |         public Builder(int inSamplerate, int outChannel,
 94 |                 int outSamplerate, int outBitrate) {
 95 |             mInSamplerate = inSamplerate;
 96 |             mOutChannel = outChannel;
 97 |             mOutSamplerate = outSamplerate;
 98 |             mOutBitrate = outBitrate;
 99 |         }
100 |         
101 |         /**
102 |          * Encode quality.
103 |          * 
104 |          * @param quality quality=0..9. 0=best (very slow). 9=worst.<br />
105 |          *            recommended:<br />
106 |          *            2 near-best quality, not too slow<br />
107 |          *            5 good quality, fast<br />
108 |          *            7 ok quality, really fast
109 |          * @return Builder
110 |          */
111 |         public Builder quality(int quality) {
112 |             mQuality = quality;
113 |             return this;
114 |         }
115 |         
116 |         /**
117 |          * ID3 Tag title.
118 |          * 
119 |          * @param id3tagTitle ID3 title.
120 |          * @return Builder
121 |          */
122 |         public Builder id3tagTitle(String id3tagTitle) {
123 |             mId3tagTitle = id3tagTitle;
124 |             return this;
125 |         }
126 | 
127 |         /**
128 |          * ID3 Tag artist.
129 |          * 
130 |          * @param id3tagArtist ID3 artist.
131 |          * @return Builder
132 |          */
133 |         public Builder id3tagArtist(String id3tagArtist) {
134 |             mId3tagArtist = id3tagArtist;
135 |             return this;
136 |         }
137 | 
138 |         /**
139 |          * ID3 Tag album.
140 |          * 
141 |          * @param id3tagAlbum ID3 album.
142 |          * @return Builder
143 |          */
144 |         public Builder id3tagAlbum(String id3tagAlbum) {
145 |             mId3tagAlbum = id3tagAlbum;
146 |             return this;
147 |         }
148 | 
149 |         /**
150 |          * ID3 Tag year.
151 |          * 
152 |          * @param id3tagYear ID3 year.
153 |          * @return Builder
154 |          */
155 |         public Builder id3tagYear(String id3tagYear) {
156 |             mId3tagYear = id3tagYear;
157 |             return this;
158 |         }
159 | 
160 |         /**
161 |          * ID3 Tag comment.
162 |          * 
163 |          * @param id3tagComment ID3 comment.
164 |          * @return Builder
165 |          */
166 |         public Builder id3tagComment(String id3tagComment) {
167 |             mId3tagComment = id3tagComment;
168 |             return this;
169 |         }
170 |         
171 |         /**
172 |          * Create {@link Encoder} instance.
173 |          * 
174 |          * @return {@link Encoder} instance.
175 |          */
176 |         public Encoder create() {
177 |             return new Encoder(this);
178 |         }
179 |     }
180 | 
181 |     /**
182 |      * Instance index.
183 |      */
184 |     private final int mInstanceIndex;
185 |     
186 |     /**
187 |      * Constructor.
188 |      * 
189 |      * @param builder Builder.
190 |      */
191 |     private Encoder(Builder builder) {
192 |         mInstanceIndex = init(builder.mInSamplerate, builder.mOutChannel, builder.mOutSamplerate,
193 |                 builder.mOutBitrate, builder.mQuality, builder.mId3tagTitle, builder.mId3tagArtist,
194 |                 builder.mId3tagAlbum, builder.mId3tagYear, builder.mId3tagComment);
195 |     }
196 | 
197 |     /**
198 |      * Encode buffer to mp3.
199 |      * 
200 |      * @param buffer_l PCM data for left channel.
201 |      * @param buffer_r PCM data for right channel.
202 |      * @param sambles number of samples per channel.
203 |      * @param mp3buf result encoded MP3 stream. You must specified
204 |      *            "7200 + (1.25 * samples)" length array.
205 |      * @return number of bytes output in mp3buf. Can be 0.<br />
206 |      *         -1: mp3buf was too small<br />
207 |      *         -2: malloc() problem<br />
208 |      *         -3: lame_init_params() not called<br />
209 |      *         -4: psycho acoustic problems
210 |      */
211 |     public int encode(short[] buffer_l, short[] buffer_r, int samples, byte[] mp3buf) {
212 |         return encode(mInstanceIndex, buffer_l, buffer_r, samples, mp3buf);
213 |     }
214 | 
215 |     /**
216 |      * Encode buffer L & R channel data interleaved to mp3.
217 |      * 
218 |      * @param pcm PCM data for left and right channel, interleaved.
219 |      * @param sambles number of samples per channel. <strong>not</strong> number
220 |      *            of samples in pcm[].
221 |      * @param mp3buf result encoded MP3 stream. You must specified
222 |      *            "7200 + (1.25 * samples)" length array.
223 |      * @return number of bytes output in mp3buf. Can be 0.<br />
224 |      *         -1: mp3buf was too small<br />
225 |      *         -2: malloc() problem<br />
226 |      *         -3: lame_init_params() not called<br />
227 |      *         -4: psycho acoustic problems
228 |      */
229 |     public int encodeBufferInterleaved(short[] pcm, int samples, byte[] mp3buf) {
230 |         return encodeBufferInterleaved(mInstanceIndex, pcm, samples, mp3buf);
231 |     }
232 | 
233 |     /**
234 |      * Flush LAME buffer.
235 |      * 
236 |      * @param mp3buf result encoded MP3 stream. You must specified at least 7200
237 |      *            bytes.
238 |      * @return number of bytes output to mp3buf. Can be 0.
239 |      */
240 |     public int flush(byte[] mp3buf) {
241 |         return flush(mInstanceIndex, mp3buf);
242 |     }
243 | 
244 |     /**
245 |      * Close LAME.
246 |      */
247 |     public void close() {
248 |         close(mInstanceIndex);
249 |     }
250 | 
251 |     /**
252 |      * Initialize LAME.
253 |      * 
254 |      * @param inSamplerate input sample rate in Hz.
255 |      * @param outChannel number of channels in input stream.
256 |      * @param outSamplerate output sample rate in Hz.
257 |      * @param outBitrate brate compression ratio in KHz.
258 |      * @param quality quality=0..9. 0=best (very slow). 9=worst.<br />
259 |      *            recommended:<br />
260 |      *            2 near-best quality, not too slow<br />
261 |      *            5 good quality, fast<br />
262 |      *            7 ok quality, really fast
263 |      * @param id3tagTitle ID3 Tag title.
264 |      * @param id3tagArtist ID3 Tag artist.
265 |      * @param id3tagAlbum ID3 Tag album.
266 |      * @param id3tagYear ID3 Tag year.
267 |      * @param id3tagComment ID3 Tag comment.
268 |      */
269 |     private native static int init(int inSamplerate, int outChannel,
270 |             int outSamplerate, int outBitrate, int quality, String id3tagTitle,
271 |             String id3tagArtist, String id3tagAlbum, String id3tagYear,
272 |             String id3tagComment);
273 | 
274 |     /**
275 |      * Encode buffer to mp3.
276 |      * 
277 |      * @param instanceIndex Instance index.
278 |      * @param buffer_l PCM data for left channel.
279 |      * @param buffer_r PCM data for right channel.
280 |      * @param sambles number of samples per channel.
281 |      * @param mp3buf result encoded MP3 stream. You must specified
282 |      *            "7200 + (1.25 * samples)" length array.
283 |      * @return number of bytes output in mp3buf. Can be 0.<br />
284 |      *         -1: mp3buf was too small<br />
285 |      *         -2: malloc() problem<br />
286 |      *         -3: lame_init_params() not called<br />
287 |      *         -4: psycho acoustic problems
288 |      */
289 |     private native static int encode(int instanceIndex, short[] buffer_l, short[] buffer_r,
290 |             int samples, byte[] mp3buf);
291 | 
292 |     /**
293 |      * Encode buffer L & R channel data interleaved to mp3.
294 |      * 
295 |      * @param instanceIndex Instance index.
296 |      * @param pcm PCM data for left and right channel, interleaved.
297 |      * @param sambles number of samples per channel. <strong>not</strong> number
298 |      *            of samples in pcm[].
299 |      * @param mp3buf result encoded MP3 stream. You must specified
300 |      *            "7200 + (1.25 * samples)" length array.
301 |      * @return number of bytes output in mp3buf. Can be 0.<br />
302 |      *         -1: mp3buf was too small<br />
303 |      *         -2: malloc() problem<br />
304 |      *         -3: lame_init_params() not called<br />
305 |      *         -4: psycho acoustic problems
306 |      */
307 |     private native static int encodeBufferInterleaved(int instanceIndex, short[] pcm, int samples,
308 |             byte[] mp3buf);
309 | 
310 |     /**
311 |      * Flush LAME buffer.
312 |      * 
313 |      * @param instanceIndex Instance index.
314 |      * @param mp3buf result encoded MP3 stream. You must specified at least 7200
315 |      *            bytes.
316 |      * @return number of bytes output to mp3buf. Can be 0.
317 |      */
318 |     private native static int flush(int instanceIndex, byte[] mp3buf);
319 | 
320 |     /**
321 |      * Close LAME.
322 |      * 
323 |      * @param instanceIndex Instance index.
324 |      */
325 |     private native static void close(int instanceIndex);
326 | }
327 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/mpglib_interface.c:
--------------------------------------------------------------------------------
  1 | /* -*- mode: C; mode: fold -*- */
  2 | /*
  3 |  *      LAME MP3 encoding engine
  4 |  *
  5 |  *      Copyright (c) 1999-2000 Mark Taylor
  6 |  *      Copyright (c) 2003 Olcios
  7 |  *      Copyright (c) 2008 Robert Hegemann
  8 |  *
  9 |  * This library is free software; you can redistribute it and/or
 10 |  * modify it under the terms of the GNU Library General Public
 11 |  * License as published by the Free Software Foundation; either
 12 |  * version 2 of the License, or (at your option) any later version.
 13 |  *
 14 |  * This library is distributed in the hope that it will be useful,
 15 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 17 |  * Library General Public License for more details.
 18 |  *
 19 |  * You should have received a copy of the GNU Library General Public
 20 |  * License along with this library; if not, write to the
 21 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 22 |  * Boston, MA 02111-1307, USA.
 23 |  */
 24 | 
 25 | /* $Id: mpglib_interface.c,v 1.42 2011/05/07 16:05:17 rbrito Exp $ */
 26 | 
 27 | #ifdef HAVE_CONFIG_H
 28 | # include <config.h>
 29 | #endif
 30 | 
 31 | #ifdef HAVE_MPGLIB
 32 | #define hip_global_struct mpstr_tag 
 33 | #include "lame.h"
 34 | #include "machine.h"
 35 | #include "encoder.h"
 36 | #include "interface.h"
 37 | 
 38 | #include "util.h"
 39 | 
 40 | 
 41 | 
 42 | #if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
 43 | /*
 44 |  * OBSOLETE:
 45 |  * - kept to let it link
 46 |  * - forward declaration to silence compiler
 47 |  */
 48 | int CDECL lame_decode_init(void);
 49 | int CDECL lame_decode(
 50 |         unsigned char *  mp3buf,
 51 |         int              len,
 52 |         short            pcm_l[],
 53 |         short            pcm_r[] );
 54 | int CDECL lame_decode_headers(
 55 |         unsigned char*   mp3buf,
 56 |         int              len,
 57 |         short            pcm_l[],
 58 |         short            pcm_r[],
 59 |         mp3data_struct*  mp3data );
 60 | int CDECL lame_decode1(
 61 |         unsigned char*  mp3buf,
 62 |         int             len,
 63 |         short           pcm_l[],
 64 |         short           pcm_r[] );
 65 | int CDECL lame_decode1_headers(
 66 |         unsigned char*   mp3buf,
 67 |         int              len,
 68 |         short            pcm_l[],
 69 |         short            pcm_r[],
 70 |         mp3data_struct*  mp3data );
 71 | int CDECL lame_decode1_headersB(
 72 |         unsigned char*   mp3buf,
 73 |         int              len,
 74 |         short            pcm_l[],
 75 |         short            pcm_r[],
 76 |         mp3data_struct*  mp3data,
 77 |         int              *enc_delay,
 78 |         int              *enc_padding );
 79 | int CDECL lame_decode_exit(void);
 80 | #endif
 81 | 
 82 | 
 83 | static MPSTR   mp;
 84 | 
 85 | int
 86 | lame_decode_exit(void)
 87 | {
 88 |     ExitMP3(&mp);
 89 |     return 0;
 90 | }
 91 | 
 92 | 
 93 | int
 94 | lame_decode_init(void)
 95 | {
 96 |     (void) InitMP3(&mp);
 97 |     return 0;
 98 | }
 99 | 
100 | 
101 | 
102 | 
103 | /* copy mono samples */
104 | #define COPY_MONO(DST_TYPE, SRC_TYPE)                                                           \
105 |     DST_TYPE *pcm_l = (DST_TYPE *)pcm_l_raw;                                                    \
106 |     SRC_TYPE const *p_samples = (SRC_TYPE const *)p;                                            \
107 |     for (i = 0; i < processed_samples; i++)                                                     \
108 |       *pcm_l++ = (DST_TYPE)(*p_samples++);
109 | 
110 | /* copy stereo samples */
111 | #define COPY_STEREO(DST_TYPE, SRC_TYPE)                                                         \
112 |     DST_TYPE *pcm_l = (DST_TYPE *)pcm_l_raw, *pcm_r = (DST_TYPE *)pcm_r_raw;                    \
113 |     SRC_TYPE const *p_samples = (SRC_TYPE const *)p;                                            \
114 |     for (i = 0; i < processed_samples; i++) {                                                   \
115 |       *pcm_l++ = (DST_TYPE)(*p_samples++);                                                      \
116 |       *pcm_r++ = (DST_TYPE)(*p_samples++);                                                      \
117 |     }
118 | 
119 | 
120 | 
121 | /*
122 |  * For lame_decode:  return code
123 |  * -1     error
124 |  *  0     ok, but need more data before outputing any samples
125 |  *  n     number of samples output.  either 576 or 1152 depending on MP3 file.
126 |  */
127 | 
128 | static int
129 | decode1_headersB_clipchoice(PMPSTR pmp, unsigned char *buffer, int len,
130 |                             char pcm_l_raw[], char pcm_r_raw[], mp3data_struct * mp3data,
131 |                             int *enc_delay, int *enc_padding,
132 |                             char *p, size_t psize, int decoded_sample_size,
133 |                             int (*decodeMP3_ptr) (PMPSTR, unsigned char *, int, char *, int,
134 |                             int *))
135 | {
136 |     static const int smpls[2][4] = {
137 |         /* Layer   I    II   III */
138 |         {0, 384, 1152, 1152}, /* MPEG-1     */
139 |         {0, 384, 1152, 576} /* MPEG-2(.5) */
140 |     };
141 | 
142 |     int     processed_bytes;
143 |     int     processed_samples; /* processed samples per channel */
144 |     int     ret;
145 |     int     i;
146 | 
147 |     mp3data->header_parsed = 0;
148 | 
149 |     ret = (*decodeMP3_ptr) (pmp, buffer, len, p, (int) psize, &processed_bytes);
150 |     /* three cases:  
151 |      * 1. headers parsed, but data not complete
152 |      *       pmp->header_parsed==1 
153 |      *       pmp->framesize=0           
154 |      *       pmp->fsizeold=size of last frame, or 0 if this is first frame
155 |      *
156 |      * 2. headers, data parsed, but ancillary data not complete
157 |      *       pmp->header_parsed==1 
158 |      *       pmp->framesize=size of frame           
159 |      *       pmp->fsizeold=size of last frame, or 0 if this is first frame
160 |      *
161 |      * 3. frame fully decoded:  
162 |      *       pmp->header_parsed==0 
163 |      *       pmp->framesize=0           
164 |      *       pmp->fsizeold=size of frame (which is now the last frame)
165 |      *
166 |      */
167 |     if (pmp->header_parsed || pmp->fsizeold > 0 || pmp->framesize > 0) {
168 |         mp3data->header_parsed = 1;
169 |         mp3data->stereo = pmp->fr.stereo;
170 |         mp3data->samplerate = freqs[pmp->fr.sampling_frequency];
171 |         mp3data->mode = pmp->fr.mode;
172 |         mp3data->mode_ext = pmp->fr.mode_ext;
173 |         mp3data->framesize = smpls[pmp->fr.lsf][pmp->fr.lay];
174 | 
175 |         /* free format, we need the entire frame before we can determine
176 |          * the bitrate.  If we haven't gotten the entire frame, bitrate=0 */
177 |         if (pmp->fsizeold > 0) /* works for free format and fixed, no overrun, temporal results are < 400.e6 */
178 |             mp3data->bitrate = 8 * (4 + pmp->fsizeold) * mp3data->samplerate /
179 |                 (1.e3 * mp3data->framesize) + 0.5;
180 |         else if (pmp->framesize > 0)
181 |             mp3data->bitrate = 8 * (4 + pmp->framesize) * mp3data->samplerate /
182 |                 (1.e3 * mp3data->framesize) + 0.5;
183 |         else
184 |             mp3data->bitrate = tabsel_123[pmp->fr.lsf][pmp->fr.lay - 1][pmp->fr.bitrate_index];
185 | 
186 | 
187 | 
188 |         if (pmp->num_frames > 0) {
189 |             /* Xing VBR header found and num_frames was set */
190 |             mp3data->totalframes = pmp->num_frames;
191 |             mp3data->nsamp = mp3data->framesize * pmp->num_frames;
192 |             *enc_delay = pmp->enc_delay;
193 |             *enc_padding = pmp->enc_padding;
194 |         }
195 |     }
196 | 
197 |     switch (ret) {
198 |     case MP3_OK:
199 |         switch (pmp->fr.stereo) {
200 |         case 1:
201 |             processed_samples = processed_bytes / decoded_sample_size;
202 |             if (decoded_sample_size == sizeof(short)) {
203 |                 COPY_MONO(short, short)
204 |             }
205 |             else {
206 |                 COPY_MONO(sample_t, FLOAT)
207 |             }
208 |             break;
209 |         case 2:
210 |             processed_samples = (processed_bytes / decoded_sample_size) >> 1;
211 |             if (decoded_sample_size == sizeof(short)) {
212 |                 COPY_STEREO(short, short)
213 |             }
214 |             else {
215 |                 COPY_STEREO(sample_t, FLOAT)
216 |             }
217 |             break;
218 |         default:
219 |             processed_samples = -1;
220 |             assert(0);
221 |             break;
222 |         }
223 |         break;
224 | 
225 |     case MP3_NEED_MORE:
226 |         processed_samples = 0;
227 |         break;
228 | 
229 |     case MP3_ERR:
230 |         processed_samples = -1;
231 |         break;
232 | 
233 |     default:
234 |         processed_samples = -1;
235 |         assert(0);
236 |         break;
237 |     }
238 | 
239 |     /*fprintf(stderr,"ok, more, err:  %i %i %i\n", MP3_OK, MP3_NEED_MORE, MP3_ERR ); */
240 |     /*fprintf(stderr,"ret = %i out=%i\n", ret, processed_samples ); */
241 |     return processed_samples;
242 | }
243 | 
244 | 
245 | #define OUTSIZE_CLIPPED   (4096*sizeof(short))
246 | 
247 | int
248 | lame_decode1_headersB(unsigned char *buffer,
249 |                       int len,
250 |                       short pcm_l[], short pcm_r[], mp3data_struct * mp3data,
251 |                       int *enc_delay, int *enc_padding)
252 | {
253 |     static char out[OUTSIZE_CLIPPED];
254 | 
255 |     return decode1_headersB_clipchoice(&mp, buffer, len, (char *) pcm_l, (char *) pcm_r, mp3data,
256 |                                        enc_delay, enc_padding, out, OUTSIZE_CLIPPED,
257 |                                        sizeof(short), decodeMP3);
258 | }
259 | 
260 | 
261 | 
262 | 
263 | 
264 | /*
265 |  * For lame_decode:  return code
266 |  *  -1     error
267 |  *   0     ok, but need more data before outputing any samples
268 |  *   n     number of samples output.  Will be at most one frame of
269 |  *         MPEG data.  
270 |  */
271 | 
272 | int
273 | lame_decode1_headers(unsigned char *buffer,
274 |                      int len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
275 | {
276 |     int     enc_delay, enc_padding;
277 |     return lame_decode1_headersB(buffer, len, pcm_l, pcm_r, mp3data, &enc_delay, &enc_padding);
278 | }
279 | 
280 | 
281 | int
282 | lame_decode1(unsigned char *buffer, int len, short pcm_l[], short pcm_r[])
283 | {
284 |     mp3data_struct mp3data;
285 | 
286 |     return lame_decode1_headers(buffer, len, pcm_l, pcm_r, &mp3data);
287 | }
288 | 
289 | 
290 | /*
291 |  * For lame_decode:  return code
292 |  *  -1     error
293 |  *   0     ok, but need more data before outputing any samples
294 |  *   n     number of samples output.  a multiple of 576 or 1152 depending on MP3 file.
295 |  */
296 | 
297 | int
298 | lame_decode_headers(unsigned char *buffer,
299 |                     int len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
300 | {
301 |     int     ret;
302 |     int     totsize = 0;     /* number of decoded samples per channel */
303 | 
304 |     for (;;) {
305 |         switch (ret = lame_decode1_headers(buffer, len, pcm_l + totsize, pcm_r + totsize, mp3data)) {
306 |         case -1:
307 |             return ret;
308 |         case 0:
309 |             return totsize;
310 |         default:
311 |             totsize += ret;
312 |             len = 0;    /* future calls to decodeMP3 are just to flush buffers */
313 |             break;
314 |         }
315 |     }
316 | }
317 | 
318 | 
319 | int
320 | lame_decode(unsigned char *buffer, int len, short pcm_l[], short pcm_r[])
321 | {
322 |     mp3data_struct mp3data;
323 | 
324 |     return lame_decode_headers(buffer, len, pcm_l, pcm_r, &mp3data);
325 | }
326 | 
327 | 
328 | 
329 | 
330 | hip_t hip_decode_init(void)
331 | {
332 |     hip_t hip = calloc(1, sizeof(hip_global_flags));
333 |     InitMP3(hip);
334 |     return hip;
335 | }
336 | 
337 | 
338 | int hip_decode_exit(hip_t hip)
339 | {
340 |     if (hip) {
341 |         ExitMP3(hip);
342 |         free(hip);
343 |     }
344 |     return 0;
345 | }
346 | 
347 | 
348 | /* we forbid input with more than 1152 samples per channel for output in the unclipped mode */
349 | #define OUTSIZE_UNCLIPPED (1152*2*sizeof(FLOAT))
350 | 
351 | int
352 | hip_decode1_unclipped(hip_t hip, unsigned char *buffer, size_t len, sample_t pcm_l[], sample_t pcm_r[])
353 | {
354 |     static char out[OUTSIZE_UNCLIPPED];
355 |     mp3data_struct mp3data;
356 |     int     enc_delay, enc_padding;
357 | 
358 |     if (hip) {
359 |         return decode1_headersB_clipchoice(hip, buffer, len, (char *) pcm_l, (char *) pcm_r, &mp3data,
360 |                                            &enc_delay, &enc_padding, out, OUTSIZE_UNCLIPPED,
361 |                                            sizeof(FLOAT), decodeMP3_unclipped);
362 |     }
363 |     return 0;
364 | }
365 | 
366 | /*
367 |  * For hip_decode:  return code
368 |  *  -1     error
369 |  *   0     ok, but need more data before outputing any samples
370 |  *   n     number of samples output.  Will be at most one frame of
371 |  *         MPEG data.  
372 |  */
373 | 
374 | int
375 | hip_decode1_headers(hip_t hip, unsigned char *buffer,
376 |                      size_t len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
377 | {
378 |     int     enc_delay, enc_padding;
379 |     return hip_decode1_headersB(hip, buffer, len, pcm_l, pcm_r, mp3data, &enc_delay, &enc_padding);
380 | }
381 | 
382 | 
383 | int
384 | hip_decode1(hip_t hip, unsigned char *buffer, size_t len, short pcm_l[], short pcm_r[])
385 | {
386 |     mp3data_struct mp3data;
387 |     return hip_decode1_headers(hip, buffer, len, pcm_l, pcm_r, &mp3data);
388 | }
389 | 
390 | 
391 | /*
392 |  * For hip_decode:  return code
393 |  *  -1     error
394 |  *   0     ok, but need more data before outputing any samples
395 |  *   n     number of samples output.  a multiple of 576 or 1152 depending on MP3 file.
396 |  */
397 | 
398 | int
399 | hip_decode_headers(hip_t hip, unsigned char *buffer,
400 |                     size_t len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
401 | {
402 |     int     ret;
403 |     int     totsize = 0;     /* number of decoded samples per channel */
404 | 
405 |     for (;;) {
406 |         switch (ret = hip_decode1_headers(hip, buffer, len, pcm_l + totsize, pcm_r + totsize, mp3data)) {
407 |         case -1:
408 |             return ret;
409 |         case 0:
410 |             return totsize;
411 |         default:
412 |             totsize += ret;
413 |             len = 0;    /* future calls to decodeMP3 are just to flush buffers */
414 |             break;
415 |         }
416 |     }
417 | }
418 | 
419 | 
420 | int
421 | hip_decode(hip_t hip, unsigned char *buffer, size_t len, short pcm_l[], short pcm_r[])
422 | {
423 |     mp3data_struct mp3data;
424 |     return hip_decode_headers(hip, buffer, len, pcm_l, pcm_r, &mp3data);
425 | }
426 | 
427 | 
428 | int
429 | hip_decode1_headersB(hip_t hip, unsigned char *buffer,
430 |                       size_t len,
431 |                       short pcm_l[], short pcm_r[], mp3data_struct * mp3data,
432 |                       int *enc_delay, int *enc_padding)
433 | {
434 |     static char out[OUTSIZE_CLIPPED];
435 |     if (hip) {
436 |         return decode1_headersB_clipchoice(hip, buffer, len, (char *) pcm_l, (char *) pcm_r, mp3data,
437 |                                            enc_delay, enc_padding, out, OUTSIZE_CLIPPED,
438 |                                            sizeof(short), decodeMP3);
439 |     }
440 |     return -1;
441 | }
442 | 
443 | 
444 | void hip_set_pinfo(hip_t hip, plotting_data* pinfo)
445 | {
446 |     if (hip) {
447 |         hip->pinfo = pinfo;
448 |     }
449 | }
450 | 
451 | 
452 | 
453 | void hip_set_errorf(hip_t hip, lame_report_function func)
454 | {
455 |     if (hip) {
456 |         hip->report_err = func;
457 |     }
458 | }
459 | 
460 | void hip_set_debugf(hip_t hip, lame_report_function func)
461 | {
462 |     if (hip) {
463 |         hip->report_dbg = func;
464 |     }
465 | }
466 | 
467 | void hip_set_msgf  (hip_t hip, lame_report_function func)
468 | {
469 |     if (hip) {
470 |         hip->report_msg = func;
471 |     }
472 | }
473 | 
474 | #endif
475 | 
476 | /* end of mpglib_interface.c */
477 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/presets.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * presets.c -- Apply presets
  3 |  *
  4 |  *	Copyright (c) 2002-2008 Gabriel Bouvigne
  5 |  *	Copyright (c) 2007-2011 Robert Hegemann
  6 |  *
  7 |  * This library is free software; you can redistribute it and/or
  8 |  * modify it under the terms of the GNU Library General Public
  9 |  * License as published by the Free Software Foundation; either
 10 |  * version 2 of the License, or (at your option) any later version.
 11 |  *
 12 |  * This library is distributed in the hope that it will be useful,
 13 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15 |  * Library General Public License for more details.
 16 |  *
 17 |  * You should have received a copy of the GNU Library General Public
 18 |  * License along with this library; if not, write to the Free Software
 19 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 20 |  */
 21 | 
 22 | 
 23 | #ifdef HAVE_CONFIG_H
 24 | # include <config.h>
 25 | #endif
 26 | 
 27 | #include "lame.h"
 28 | #include "machine.h"
 29 | #include "set_get.h"
 30 | #include "encoder.h"
 31 | #include "util.h"
 32 | #include "lame_global_flags.h"
 33 | 
 34 | #define SET_OPTION(opt, val, def) if (enforce) \
 35 |     (void) lame_set_##opt(gfp, val); \
 36 |     else if (!(fabs(lame_get_##opt(gfp) - def) > 0)) \
 37 |     (void) lame_set_##opt(gfp, val);
 38 | 
 39 | #define SET__OPTION(opt, val, def) if (enforce) \
 40 |     lame_set_##opt(gfp, val); \
 41 |     else if (!(fabs(lame_get_##opt(gfp) - def) > 0)) \
 42 |     lame_set_##opt(gfp, val);
 43 | 
 44 | #undef Min
 45 | #undef Max
 46 | 
 47 | static inline int
 48 | min_int(int a, int b)
 49 | {
 50 |     if (a < b) {
 51 |         return a;
 52 |     }
 53 |     return b;
 54 | }
 55 | 
 56 | static inline int
 57 | max_int(int a, int b)
 58 | {
 59 |     if (a > b) {
 60 |         return a;
 61 |     }
 62 |     return b;
 63 | }
 64 | 
 65 | 
 66 | 
 67 | typedef struct {
 68 |     int     vbr_q;
 69 |     int     quant_comp;
 70 |     int     quant_comp_s;
 71 |     int     expY;
 72 |     FLOAT   st_lrm;          /*short threshold */
 73 |     FLOAT   st_s;
 74 |     FLOAT   masking_adj;
 75 |     FLOAT   masking_adj_short;
 76 |     FLOAT   ath_lower;
 77 |     FLOAT   ath_curve;
 78 |     FLOAT   ath_sensitivity;
 79 |     FLOAT   interch;
 80 |     int     safejoint;
 81 |     int     sfb21mod;
 82 |     FLOAT   msfix;
 83 |     FLOAT   minval;
 84 |     FLOAT   ath_fixpoint;
 85 | } vbr_presets_t;
 86 | 
 87 |     /* *INDENT-OFF* */
 88 |     
 89 |     /* Switch mappings for VBR mode VBR_RH */
 90 |     static const vbr_presets_t vbr_old_switch_map[] = {
 91 |     /*vbr_q  qcomp_l  qcomp_s  expY  st_lrm   st_s  mask adj_l  adj_s  ath_lower  ath_curve  ath_sens  interChR  safejoint sfb21mod  msfix */
 92 |         {0,       9,       9,    0,   5.20, 125.0,      -4.2,   -6.3,       4.8,       1,          0,   0,              2,      21,  0.97, 5, 100},
 93 |         {1,       9,       9,    0,   5.30, 125.0,      -3.6,   -5.6,       4.5,       1.5,        0,   0,              2,      21,  1.35, 5, 100},
 94 |         {2,       9,       9,    0,   5.60, 125.0,      -2.2,   -3.5,       2.8,       2,          0,   0,              2,      21,  1.49, 5, 100},
 95 |         {3,       9,       9,    1,   5.80, 130.0,      -1.8,   -2.8,       2.6,       3,         -4,   0,              2,      20,  1.64, 5, 100},
 96 |         {4,       9,       9,    1,   6.00, 135.0,      -0.7,   -1.1,       1.1,       3.5,       -8,   0,              2,       0,  1.79, 5, 100},
 97 |         {5,       9,       9,    1,   6.40, 140.0,       0.5,    0.4,      -7.5,       4,        -12,   0.0002,         0,       0,  1.95, 5, 100},
 98 |         {6,       9,       9,    1,   6.60, 145.0,       0.67,   0.65,    -14.7,       6.5,      -19,   0.0004,         0,       0,  2.30, 5, 100},
 99 |         {7,       9,       9,    1,   6.60, 145.0,       0.8,    0.75,    -19.7,       8,        -22,   0.0006,         0,       0,  2.70, 5, 100},
100 |         {8,       9,       9,    1,   6.60, 145.0,       1.2,    1.15,    -27.5,      10,        -23,   0.0007,         0,       0,  0,    5, 100},
101 |         {9,       9,       9,    1,   6.60, 145.0,       1.6,    1.6,     -36,        11,        -25,   0.0008,         0,       0,  0,    5, 100},
102 |         {10,      9,       9,    1,   6.60, 145.0,       2.0,    2.0,     -36,        12,        -25,   0.0008,         0,       0,  0,    5, 100}
103 |     };
104 |     
105 |     static const vbr_presets_t vbr_mt_psy_switch_map[] = {
106 |     /*vbr_q  qcomp_l  qcomp_s  expY  st_lrm   st_s  mask adj_l  adj_s  ath_lower  ath_curve  ath_sens  ---  safejoint sfb21mod  msfix */
107 |         {0,       9,       9,    0,   4.20,  25.0,      -6.8,   -6.8,       7.1,       1,          0,   0,         2,      31,  1.000,  5, 100},
108 |         {1,       9,       9,    0,   4.20,  25.0,      -4.8,   -4.8,       5.4,       1.4,       -1,   0,         2,      27,  1.122,  5,  98},
109 |         {2,       9,       9,    0,   4.20,  25.0,      -2.6,   -2.6,       3.7,       2.0,       -3,   0,         2,      23,  1.288,  5,  97},
110 |         {3,       9,       9,    1,   4.20,  25.0,      -1.6,   -1.6,       2.0,       2.0,       -5,   0,         2,      18,  1.479,  5,  96},
111 |         {4,       9,       9,    1,   4.20,  25.0,      -0.0,   -0.0,       0.0,       2.0,       -8,   0,         2,      12,  1.698,  5,  95},
112 |         {5,       9,       9,    1,   4.20,  25.0,       1.3,    1.3,      -6,         3.5,      -11,   0,         2,       8,  1.950,  5,  94.2},
113 | #if 0
114 |         {6,       9,       9,    1,   4.50, 100.0,       1.5,    1.5,     -24.0,       6.0,      -14,   0,         2,       4,  2.239,  3,  93.9},
115 |         {7,       9,       9,    1,   4.80, 200.0,       1.7,    1.7,     -28.0,       9.0,      -20,   0,         2,       0,  2.570,  1,  93.6},
116 | #else
117 |         {6,       9,       9,    1,   4.50, 100.0,       2.2,    2.3,     -12.0,       6.0,      -14,   0,         2,       4,  2.239,  3,  93.9},
118 |         {7,       9,       9,    1,   4.80, 200.0,       2.7,    2.7,     -18.0,       9.0,      -17,   0,         2,       0,  2.570,  1,  93.6},
119 | #endif
120 |         {8,       9,       9,    1,   5.30, 300.0,       2.8,    2.8,     -21.0,      10.0,      -23,   0.0002,    0,       0,  2.951,  0,  93.3},
121 |         {9,       9,       9,    1,   6.60, 300.0,       2.8,    2.8,     -23.0,      11.0,      -25,   0.0006,    0,       0,  3.388,  0,  93.3},
122 |         {10,      9,       9,    1,  25.00, 300.0,       2.8,    2.8,     -25.0,      12.0,      -27,   0.0025,    0,       0,  3.500,  0,  93.3}
123 |     };
124 | 
125 |     /* *INDENT-ON* */
126 | 
127 | static vbr_presets_t const*
128 | get_vbr_preset(int v)
129 | {
130 |     switch (v) {
131 |     case vbr_mtrh:
132 |     case vbr_mt:
133 |         return &vbr_mt_psy_switch_map[0];
134 |     default:
135 |         return &vbr_old_switch_map[0];
136 |     }
137 | }
138 | 
139 | #define NOOP(m) (void)p.m
140 | #define LERP(m) (p.m = p.m + x * (q.m - p.m))
141 | 
142 | static void
143 | apply_vbr_preset(lame_global_flags * gfp, int a, int enforce)
144 | {
145 |     vbr_presets_t const *vbr_preset = get_vbr_preset(lame_get_VBR(gfp));
146 |     float   x = gfp->VBR_q_frac;
147 |     vbr_presets_t p = vbr_preset[a];
148 |     vbr_presets_t q = vbr_preset[a + 1];
149 |     vbr_presets_t const *set = &p;
150 | 
151 |     NOOP(vbr_q);
152 |     NOOP(quant_comp);
153 |     NOOP(quant_comp_s);
154 |     NOOP(expY);
155 |     LERP(st_lrm);
156 |     LERP(st_s);
157 |     LERP(masking_adj);
158 |     LERP(masking_adj_short);
159 |     LERP(ath_lower);
160 |     LERP(ath_curve);
161 |     LERP(ath_sensitivity);
162 |     LERP(interch);
163 |     NOOP(safejoint);
164 |     LERP(sfb21mod);
165 |     LERP(msfix);
166 |     LERP(minval);
167 |     LERP(ath_fixpoint);
168 | 
169 |     (void) lame_set_VBR_q(gfp, set->vbr_q);
170 |     SET_OPTION(quant_comp, set->quant_comp, -1);
171 |     SET_OPTION(quant_comp_short, set->quant_comp_s, -1);
172 |     if (set->expY) {
173 |         (void) lame_set_experimentalY(gfp, set->expY);
174 |     }
175 |     SET_OPTION(short_threshold_lrm, set->st_lrm, -1);
176 |     SET_OPTION(short_threshold_s, set->st_s, -1);
177 |     SET_OPTION(maskingadjust, set->masking_adj, 0);
178 |     SET_OPTION(maskingadjust_short, set->masking_adj_short, 0);
179 |     if (lame_get_VBR(gfp) == vbr_mt || lame_get_VBR(gfp) == vbr_mtrh) {
180 |         lame_set_ATHtype(gfp, 5);
181 |     }
182 |     SET_OPTION(ATHlower, set->ath_lower, 0);
183 |     SET_OPTION(ATHcurve, set->ath_curve, -1);
184 |     SET_OPTION(athaa_sensitivity, set->ath_sensitivity, 0);
185 |     if (set->interch > 0) {
186 |         SET_OPTION(interChRatio, set->interch, -1);
187 |     }
188 | 
189 |     /* parameters for which there is no proper set/get interface */
190 |     if (set->safejoint > 0) {
191 |         (void) lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2);
192 |     }
193 |     if (set->sfb21mod > 0) {
194 |         int const nsp = lame_get_exp_nspsytune(gfp);
195 |         int const val = (nsp >> 20) & 63;
196 |         if (val == 0) {
197 |             int const sf21mod = (set->sfb21mod << 20) | nsp;
198 |             (void) lame_set_exp_nspsytune(gfp, sf21mod);
199 |         }
200 |     }
201 |     SET__OPTION(msfix, set->msfix, -1);
202 | 
203 |     if (enforce == 0) {
204 |         gfp->VBR_q = a;
205 |         gfp->VBR_q_frac = x;
206 |     }
207 |     gfp->internal_flags->cfg.minval = set->minval;
208 |     gfp->internal_flags->cfg.ATHfixpoint = set->ath_fixpoint;
209 | }
210 | 
211 | static int
212 | apply_abr_preset(lame_global_flags * gfp, int preset, int enforce)
213 | {
214 |     typedef struct {
215 |         int     abr_kbps;
216 |         int     quant_comp;
217 |         int     quant_comp_s;
218 |         int     safejoint;
219 |         FLOAT   nsmsfix;
220 |         FLOAT   st_lrm;      /*short threshold */
221 |         FLOAT   st_s;
222 |         FLOAT   scale;
223 |         FLOAT   masking_adj;
224 |         FLOAT   ath_lower;
225 |         FLOAT   ath_curve;
226 |         FLOAT   interch;
227 |         int     sfscale;
228 |     } abr_presets_t;
229 | 
230 | 
231 |     /* *INDENT-OFF* */
232 | 
233 |     /* 
234 |      *  Switch mappings for ABR mode
235 |      */
236 |     const abr_presets_t abr_switch_map[] = {        
237 |     /* kbps  quant q_s safejoint nsmsfix st_lrm  st_s  scale   msk ath_lwr ath_curve  interch , sfscale */
238 |       {  8,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -30.0,     11,    0.0012,        1}, /*   8, impossible to use in stereo */
239 |       { 16,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -25.0,     11,    0.0010,        1}, /*  16 */
240 |       { 24,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -20.0,     11,    0.0010,        1}, /*  24 */
241 |       { 32,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -15.0,     11,    0.0010,        1}, /*  32 */
242 |       { 40,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -10.0,     11,    0.0009,        1}, /*  40 */
243 |       { 48,     9,  9,        0,      0,  6.60,  145,  0.95,    0,  -10.0,     11,    0.0009,        1}, /*  48 */
244 |       { 56,     9,  9,        0,      0,  6.60,  145,  0.95,    0,   -6.0,     11,    0.0008,        1}, /*  56 */
245 |       { 64,     9,  9,        0,      0,  6.60,  145,  0.95,    0,   -2.0,     11,    0.0008,        1}, /*  64 */
246 |       { 80,     9,  9,        0,      0,  6.60,  145,  0.95,    0,     .0,      8,    0.0007,        1}, /*  80 */
247 |       { 96,     9,  9,        0,   2.50,  6.60,  145,  0.95,    0,    1.0,      5.5,  0.0006,        1}, /*  96 */
248 |       {112,     9,  9,        0,   2.25,  6.60,  145,  0.95,    0,    2.0,      4.5,  0.0005,        1}, /* 112 */
249 |       {128,     9,  9,        0,   1.95,  6.40,  140,  0.95,    0,    3.0,      4,    0.0002,        1}, /* 128 */
250 |       {160,     9,  9,        1,   1.79,  6.00,  135,  0.95,   -2,    5.0,      3.5,  0,             1}, /* 160 */
251 |       {192,     9,  9,        1,   1.49,  5.60,  125,  0.97,   -4,    7.0,      3,    0,             0}, /* 192 */
252 |       {224,     9,  9,        1,   1.25,  5.20,  125,  0.98,   -6,    9.0,      2,    0,             0}, /* 224 */
253 |       {256,     9,  9,        1,   0.97,  5.20,  125,  1.00,   -8,   10.0,      1,    0,             0}, /* 256 */
254 |       {320,     9,  9,        1,   0.90,  5.20,  125,  1.00,  -10,   12.0,      0,    0,             0}  /* 320 */
255 |     };
256 | 
257 |     /* *INDENT-ON* */
258 | 
259 |     /* Variables for the ABR stuff */
260 |     int     r;
261 |     int     actual_bitrate = preset;
262 | 
263 |     r = nearestBitrateFullIndex(preset);
264 |     
265 |     (void) lame_set_VBR(gfp, vbr_abr);
266 |     (void) lame_set_VBR_mean_bitrate_kbps(gfp, (actual_bitrate));
267 |     (void) lame_set_VBR_mean_bitrate_kbps(gfp, min_int(lame_get_VBR_mean_bitrate_kbps(gfp), 320));
268 |     (void) lame_set_VBR_mean_bitrate_kbps(gfp, max_int(lame_get_VBR_mean_bitrate_kbps(gfp), 8));
269 |     (void) lame_set_brate(gfp, lame_get_VBR_mean_bitrate_kbps(gfp));
270 | 
271 | 
272 |     /* parameters for which there is no proper set/get interface */
273 |     if (abr_switch_map[r].safejoint > 0)
274 |         (void) lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); /* safejoint */
275 | 
276 |     if (abr_switch_map[r].sfscale > 0)
277 |         (void) lame_set_sfscale(gfp, 1);
278 | 
279 | 
280 |     SET_OPTION(quant_comp, abr_switch_map[r].quant_comp, -1);
281 |     SET_OPTION(quant_comp_short, abr_switch_map[r].quant_comp_s, -1);
282 | 
283 |     SET__OPTION(msfix, abr_switch_map[r].nsmsfix, -1);
284 | 
285 |     SET_OPTION(short_threshold_lrm, abr_switch_map[r].st_lrm, -1);
286 |     SET_OPTION(short_threshold_s, abr_switch_map[r].st_s, -1);
287 | 
288 |     /* ABR seems to have big problems with clipping, especially at low bitrates */
289 |     /* so we compensate for that here by using a scale value depending on bitrate */
290 |     lame_set_scale(gfp, lame_get_scale(gfp) * abr_switch_map[r].scale);
291 | 
292 |     SET_OPTION(maskingadjust, abr_switch_map[r].masking_adj, 0);
293 |     if (abr_switch_map[r].masking_adj > 0) {
294 |         SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * .9, 0);
295 |     }
296 |     else {
297 |         SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * 1.1, 0);
298 |     }
299 | 
300 | 
301 |     SET_OPTION(ATHlower, abr_switch_map[r].ath_lower, 0);
302 |     SET_OPTION(ATHcurve, abr_switch_map[r].ath_curve, -1);
303 | 
304 |     SET_OPTION(interChRatio, abr_switch_map[r].interch, -1);
305 | 
306 |     (void) abr_switch_map[r].abr_kbps;
307 | 
308 |     gfp->internal_flags->cfg.minval = 5. * (abr_switch_map[r].abr_kbps / 320.);
309 | 
310 |     return preset;
311 | }
312 | 
313 | 
314 | 
315 | int
316 | apply_preset(lame_global_flags * gfp, int preset, int enforce)
317 | {
318 |     /*translate legacy presets */
319 |     switch (preset) {
320 |     case R3MIX:
321 |         {
322 |             preset = V3;
323 |             (void) lame_set_VBR(gfp, vbr_mtrh);
324 |             break;
325 |         }
326 |     case MEDIUM:
327 |     case MEDIUM_FAST:
328 |         {
329 |             preset = V4;
330 |             (void) lame_set_VBR(gfp, vbr_mtrh);
331 |             break;
332 |         }
333 |     case STANDARD:
334 |     case STANDARD_FAST:
335 |         {
336 |             preset = V2;
337 |             (void) lame_set_VBR(gfp, vbr_mtrh);
338 |             break;
339 |         }
340 |     case EXTREME:
341 |     case EXTREME_FAST:
342 |         {
343 |             preset = V0;
344 |             (void) lame_set_VBR(gfp, vbr_mtrh);
345 |             break;
346 |         }
347 |     case INSANE:
348 |         {
349 |             preset = 320;
350 |             gfp->preset = preset;
351 |             (void) apply_abr_preset(gfp, preset, enforce);
352 |             lame_set_VBR(gfp, vbr_off);
353 |             return preset;
354 |         }
355 |     }
356 | 
357 |     gfp->preset = preset;
358 |     {
359 |         switch (preset) {
360 |         case V9:
361 |             apply_vbr_preset(gfp, 9, enforce);
362 |             return preset;
363 |         case V8:
364 |             apply_vbr_preset(gfp, 8, enforce);
365 |             return preset;
366 |         case V7:
367 |             apply_vbr_preset(gfp, 7, enforce);
368 |             return preset;
369 |         case V6:
370 |             apply_vbr_preset(gfp, 6, enforce);
371 |             return preset;
372 |         case V5:
373 |             apply_vbr_preset(gfp, 5, enforce);
374 |             return preset;
375 |         case V4:
376 |             apply_vbr_preset(gfp, 4, enforce);
377 |             return preset;
378 |         case V3:
379 |             apply_vbr_preset(gfp, 3, enforce);
380 |             return preset;
381 |         case V2:
382 |             apply_vbr_preset(gfp, 2, enforce);
383 |             return preset;
384 |         case V1:
385 |             apply_vbr_preset(gfp, 1, enforce);
386 |             return preset;
387 |         case V0:
388 |             apply_vbr_preset(gfp, 0, enforce);
389 |             return preset;
390 |         default:
391 |             break;
392 |         }
393 |     }
394 |     if (8 <= preset && preset <= 320) {
395 |         return apply_abr_preset(gfp, preset, enforce);
396 |     }
397 | 
398 |     gfp->preset = 0;    /*no corresponding preset found */
399 |     return preset;
400 | }
401 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/vector/Makefile.in:
--------------------------------------------------------------------------------
  1 | # Makefile.in generated by automake 1.11.1 from Makefile.am.
  2 | # @configure_input@
  3 | 
  4 | # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
  5 | # 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
  6 | # Inc.
  7 | # This Makefile.in is free software; the Free Software Foundation
  8 | # gives unlimited permission to copy and/or distribute it,
  9 | # with or without modifications, as long as this notice is preserved.
 10 | 
 11 | # This program is distributed in the hope that it will be useful,
 12 | # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 13 | # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 14 | # PARTICULAR PURPOSE.
 15 | 
 16 | @SET_MAKE@
 17 | 
 18 | # global section for every Makefile.am
 19 | 
 20 | 
 21 | VPATH = @srcdir@
 22 | pkgdatadir = $(datadir)/@PACKAGE@
 23 | pkgincludedir = $(includedir)/@PACKAGE@
 24 | pkglibdir = $(libdir)/@PACKAGE@
 25 | pkglibexecdir = $(libexecdir)/@PACKAGE@
 26 | am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 27 | install_sh_DATA = $(install_sh) -c -m 644
 28 | install_sh_PROGRAM = $(install_sh) -c
 29 | install_sh_SCRIPT = $(install_sh) -c
 30 | INSTALL_HEADER = $(INSTALL_DATA)
 31 | transform = $(program_transform_name)
 32 | NORMAL_INSTALL = :
 33 | PRE_INSTALL = :
 34 | POST_INSTALL = :
 35 | NORMAL_UNINSTALL = :
 36 | PRE_UNINSTALL = :
 37 | POST_UNINSTALL = :
 38 | build_triplet = @build@
 39 | host_triplet = @host@
 40 | ANSI2KNR = $(top_srcdir)/ansi2knr
 41 | DIST_COMMON = $(noinst_HEADERS) $(srcdir)/Makefile.am \
 42 | 	$(srcdir)/Makefile.in $(top_srcdir)/Makefile.am.global
 43 | subdir = libmp3lame/vector
 44 | ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 45 | am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
 46 | 	$(top_srcdir)/configure.in
 47 | am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 48 | 	$(ACLOCAL_M4)
 49 | mkinstalldirs = $(install_sh) -d
 50 | CONFIG_HEADER = $(top_builddir)/config.h
 51 | CONFIG_CLEAN_FILES =
 52 | CONFIG_CLEAN_VPATH_FILES =
 53 | LTLIBRARIES = $(noinst_LTLIBRARIES)
 54 | liblamevectorroutines_la_LIBADD =
 55 | am__liblamevectorroutines_la_SOURCES_DIST = xmm_quantize_sub.c
 56 | am__objects_1 = xmm_quantize_sub$U.lo
 57 | @WITH_XMM_TRUE@am_liblamevectorroutines_la_OBJECTS = $(am__objects_1)
 58 | liblamevectorroutines_la_OBJECTS =  \
 59 | 	$(am_liblamevectorroutines_la_OBJECTS)
 60 | @WITH_XMM_TRUE@am_liblamevectorroutines_la_rpath =
 61 | DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 62 | depcomp = $(SHELL) $(top_srcdir)/depcomp
 63 | am__depfiles_maybe = depfiles
 64 | am__mv = mv -f
 65 | COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 66 | 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
 67 | LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
 68 | 	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
 69 | 	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
 70 | CCLD = $(CC)
 71 | LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
 72 | 	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
 73 | 	$(LDFLAGS) -o $@
 74 | SOURCES = $(liblamevectorroutines_la_SOURCES) \
 75 | 	$(EXTRA_liblamevectorroutines_la_SOURCES)
 76 | DIST_SOURCES = $(am__liblamevectorroutines_la_SOURCES_DIST) \
 77 | 	$(EXTRA_liblamevectorroutines_la_SOURCES)
 78 | HEADERS = $(noinst_HEADERS)
 79 | ETAGS = etags
 80 | CTAGS = ctags
 81 | DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 82 | ACLOCAL = @ACLOCAL@
 83 | ALLOCA = @ALLOCA@
 84 | AMTAR = @AMTAR@
 85 | AR = @AR@
 86 | AUTOCONF = @AUTOCONF@
 87 | AUTOHEADER = @AUTOHEADER@
 88 | AUTOMAKE = @AUTOMAKE@
 89 | AWK = @AWK@
 90 | CC = @CC@
 91 | CCDEPMODE = @CCDEPMODE@
 92 | CFLAGS = @CFLAGS@
 93 | CONFIG_DEFS = @CONFIG_DEFS@
 94 | CONFIG_MATH_LIB = @CONFIG_MATH_LIB@
 95 | CPP = @CPP@
 96 | CPPFLAGS = @CPPFLAGS@
 97 | CPUCCODE = @CPUCCODE@
 98 | CPUTYPE = @CPUTYPE@
 99 | CYGPATH_W = @CYGPATH_W@
100 | DEFS = @DEFS@ @CONFIG_DEFS@
101 | DEPDIR = @DEPDIR@
102 | DSYMUTIL = @DSYMUTIL@
103 | DUMPBIN = @DUMPBIN@
104 | ECHO_C = @ECHO_C@
105 | ECHO_N = @ECHO_N@
106 | ECHO_T = @ECHO_T@
107 | EGREP = @EGREP@
108 | EXEEXT = @EXEEXT@
109 | FGREP = @FGREP@
110 | FRONTEND_CFLAGS = @FRONTEND_CFLAGS@
111 | FRONTEND_LDADD = @FRONTEND_LDADD@
112 | FRONTEND_LDFLAGS = @FRONTEND_LDFLAGS@
113 | GREP = @GREP@
114 | GTK_CFLAGS = @GTK_CFLAGS@
115 | GTK_CONFIG = @GTK_CONFIG@
116 | GTK_LIBS = @GTK_LIBS@
117 | INCLUDES = @INCLUDES@ \
118 | 	-I$(top_srcdir)/libmp3lame \
119 | 	-I$(top_srcdir)/mpglib \
120 | 	-I$(top_builddir)
121 | 
122 | INSTALL = @INSTALL@
123 | INSTALL_DATA = @INSTALL_DATA@
124 | INSTALL_PROGRAM = @INSTALL_PROGRAM@
125 | INSTALL_SCRIPT = @INSTALL_SCRIPT@
126 | INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
127 | LD = @LD@
128 | LDADD = @LDADD@
129 | LDFLAGS = @LDFLAGS@
130 | LIBICONV = @LIBICONV@
131 | LIBOBJS = @LIBOBJS@
132 | LIBS = @LIBS@
133 | LIBTOOL = @LIBTOOL@
134 | LIBTOOL_DEPS = @LIBTOOL_DEPS@
135 | LIB_MAJOR_VERSION = @LIB_MAJOR_VERSION@
136 | LIB_MINOR_VERSION = @LIB_MINOR_VERSION@
137 | LIPO = @LIPO@
138 | LN_S = @LN_S@
139 | LTLIBICONV = @LTLIBICONV@
140 | LTLIBOBJS = @LTLIBOBJS@
141 | MAINT = @MAINT@
142 | MAKEDEP = @MAKEDEP@
143 | MAKEINFO = @MAKEINFO@
144 | MKDIR_P = @MKDIR_P@
145 | NASM = @NASM@
146 | NASM_FORMAT = @NASM_FORMAT@
147 | NM = @NM@
148 | NMEDIT = @NMEDIT@
149 | OBJDUMP = @OBJDUMP@
150 | OBJEXT = @OBJEXT@
151 | OTOOL = @OTOOL@
152 | OTOOL64 = @OTOOL64@
153 | PACKAGE = @PACKAGE@
154 | PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
155 | PACKAGE_NAME = @PACKAGE_NAME@
156 | PACKAGE_STRING = @PACKAGE_STRING@
157 | PACKAGE_TARNAME = @PACKAGE_TARNAME@
158 | PACKAGE_URL = @PACKAGE_URL@
159 | PACKAGE_VERSION = @PACKAGE_VERSION@
160 | PATH_SEPARATOR = @PATH_SEPARATOR@
161 | PKG_CONFIG = @PKG_CONFIG@
162 | PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
163 | PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
164 | RANLIB = @RANLIB@
165 | RM_F = @RM_F@
166 | SED = @SED@
167 | SET_MAKE = @SET_MAKE@
168 | SHELL = @SHELL@
169 | SNDFILE_CFLAGS = @SNDFILE_CFLAGS@
170 | SNDFILE_LIBS = @SNDFILE_LIBS@
171 | STRIP = @STRIP@
172 | U = @U@
173 | VERSION = @VERSION@
174 | WITH_FRONTEND = @WITH_FRONTEND@
175 | WITH_MP3RTP = @WITH_MP3RTP@
176 | WITH_MP3X = @WITH_MP3X@
177 | abs_builddir = @abs_builddir@
178 | abs_srcdir = @abs_srcdir@
179 | abs_top_builddir = @abs_top_builddir@
180 | abs_top_srcdir = @abs_top_srcdir@
181 | ac_ct_CC = @ac_ct_CC@
182 | ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
183 | am__include = @am__include@
184 | am__leading_dot = @am__leading_dot@
185 | am__quote = @am__quote@
186 | am__tar = @am__tar@
187 | am__untar = @am__untar@
188 | bindir = @bindir@
189 | build = @build@
190 | build_alias = @build_alias@
191 | build_cpu = @build_cpu@
192 | build_os = @build_os@
193 | build_vendor = @build_vendor@
194 | builddir = @builddir@
195 | datadir = @datadir@
196 | datarootdir = @datarootdir@
197 | docdir = @docdir@
198 | dvidir = @dvidir@
199 | exec_prefix = @exec_prefix@
200 | host = @host@
201 | host_alias = @host_alias@
202 | host_cpu = @host_cpu@
203 | host_os = @host_os@
204 | host_vendor = @host_vendor@
205 | htmldir = @htmldir@
206 | includedir = @includedir@
207 | infodir = @infodir@
208 | install_sh = @install_sh@
209 | libdir = @libdir@
210 | libexecdir = @libexecdir@
211 | localedir = @localedir@
212 | localstatedir = @localstatedir@
213 | mandir = @mandir@
214 | mkdir_p = @mkdir_p@
215 | oldincludedir = @oldincludedir@
216 | pdfdir = @pdfdir@
217 | prefix = @prefix@
218 | program_transform_name = @program_transform_name@
219 | psdir = @psdir@
220 | sbindir = @sbindir@
221 | sharedstatedir = @sharedstatedir@
222 | srcdir = @srcdir@
223 | sysconfdir = @sysconfdir@
224 | target_alias = @target_alias@
225 | top_build_prefix = @top_build_prefix@
226 | top_builddir = @top_builddir@
227 | top_srcdir = @top_srcdir@
228 | AUTOMAKE_OPTIONS = 1.11 foreign $(top_srcdir)/ansi2knr
229 | @WITH_XMM_TRUE@noinst_LTLIBRARIES = liblamevectorroutines.la
230 | xmm_sources = xmm_quantize_sub.c
231 | @WITH_XMM_TRUE@liblamevectorroutines_la_SOURCES = $(xmm_sources)
232 | noinst_HEADERS = lame_intrin.h
233 | EXTRA_liblamevectorroutines_la_SOURCES = $(xmm_sources)
234 | CLEANFILES = lclint.txt
235 | LCLINTFLAGS = \
236 | 	+posixlib \
237 | 	+showsummary \
238 | 	+showalluses \
239 | 	+whichlib \
240 | 	+forcehints \
241 | 	-fixedformalarray \
242 | 	+matchanyintegral \
243 | 	-Dlint
244 | 
245 | all: all-am
246 | 
247 | .SUFFIXES:
248 | .SUFFIXES: .c .lo .o .obj
249 | $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/Makefile.am.global $(am__configure_deps)
250 | 	@for dep in $?; do \
251 | 	  case '$(am__configure_deps)' in \
252 | 	    *$$dep*) \
253 | 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
254 | 	        && { if test -f $@; then exit 0; else break; fi; }; \
255 | 	      exit 1;; \
256 | 	  esac; \
257 | 	done; \
258 | 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign libmp3lame/vector/Makefile'; \
259 | 	$(am__cd) $(top_srcdir) && \
260 | 	  $(AUTOMAKE) --foreign libmp3lame/vector/Makefile
261 | .PRECIOUS: Makefile
262 | Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
263 | 	@case '$?' in \
264 | 	  *config.status*) \
265 | 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
266 | 	  *) \
267 | 	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
268 | 	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
269 | 	esac;
270 | 
271 | $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
272 | 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
273 | 
274 | $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
275 | 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
276 | $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
277 | 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
278 | $(am__aclocal_m4_deps):
279 | 
280 | clean-noinstLTLIBRARIES:
281 | 	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
282 | 	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
283 | 	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
284 | 	  test "$$dir" != "$$p" || dir=.; \
285 | 	  echo "rm -f \"$${dir}/so_locations\""; \
286 | 	  rm -f "$${dir}/so_locations"; \
287 | 	done
288 | liblamevectorroutines.la: $(liblamevectorroutines_la_OBJECTS) $(liblamevectorroutines_la_DEPENDENCIES) 
289 | 	$(LINK) $(am_liblamevectorroutines_la_rpath) $(liblamevectorroutines_la_OBJECTS) $(liblamevectorroutines_la_LIBADD) $(LIBS)
290 | 
291 | mostlyclean-compile:
292 | 	-rm -f *.$(OBJEXT)
293 | 
294 | distclean-compile:
295 | 	-rm -f *.tab.c
296 | $(top_srcdir)/ansi2knr:
297 | 	$(am__cd) $(top_srcdir) && $(MAKE) $(AM_MAKEFLAGS) ./ansi2knr
298 | 
299 | mostlyclean-kr:
300 | 	-test "$U" = "" || rm -f *_.c
301 | 
302 | @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmm_quantize_sub$U.Plo@am__quote@
303 | 
304 | .c.o:
305 | @am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
306 | @am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
307 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
308 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
309 | @am__fastdepCC_FALSE@	$(COMPILE) -c $<
310 | 
311 | .c.obj:
312 | @am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
313 | @am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
314 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
315 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
316 | @am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
317 | 
318 | .c.lo:
319 | @am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
320 | @am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
321 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
322 | @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
323 | @am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
324 | xmm_quantize_sub_.c: xmm_quantize_sub.c $(ANSI2KNR)
325 | 	$(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) `if test -f $(srcdir)/xmm_quantize_sub.c; then echo $(srcdir)/xmm_quantize_sub.c; else echo xmm_quantize_sub.c; fi` | sed 's/^# \([0-9]\)/#line \1/' | $(ANSI2KNR) > $@ || rm -f $@
326 | xmm_quantize_sub_.$(OBJEXT) xmm_quantize_sub_.lo : $(ANSI2KNR)
327 | 
328 | mostlyclean-libtool:
329 | 	-rm -f *.lo
330 | 
331 | clean-libtool:
332 | 	-rm -rf .libs _libs
333 | 
334 | ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
335 | 	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
336 | 	unique=`for i in $$list; do \
337 | 	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
338 | 	  done | \
339 | 	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
340 | 	      END { if (nonempty) { for (i in files) print i; }; }'`; \
341 | 	mkid -fID $$unique
342 | tags: TAGS
343 | 
344 | TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
345 | 		$(TAGS_FILES) $(LISP)
346 | 	set x; \
347 | 	here=`pwd`; \
348 | 	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
349 | 	unique=`for i in $$list; do \
350 | 	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
351 | 	  done | \
352 | 	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
353 | 	      END { if (nonempty) { for (i in files) print i; }; }'`; \
354 | 	shift; \
355 | 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
356 | 	  test -n "$$unique" || unique=$$empty_fix; \
357 | 	  if test $$# -gt 0; then \
358 | 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
359 | 	      "$$@" $$unique; \
360 | 	  else \
361 | 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
362 | 	      $$unique; \
363 | 	  fi; \
364 | 	fi
365 | ctags: CTAGS
366 | CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
367 | 		$(TAGS_FILES) $(LISP)
368 | 	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
369 | 	unique=`for i in $$list; do \
370 | 	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
371 | 	  done | \
372 | 	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
373 | 	      END { if (nonempty) { for (i in files) print i; }; }'`; \
374 | 	test -z "$(CTAGS_ARGS)$$unique" \
375 | 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
376 | 	     $$unique
377 | 
378 | GTAGS:
379 | 	here=`$(am__cd) $(top_builddir) && pwd` \
380 | 	  && $(am__cd) $(top_srcdir) \
381 | 	  && gtags -i $(GTAGS_ARGS) "$$here"
382 | 
383 | distclean-tags:
384 | 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
385 | 
386 | distdir: $(DISTFILES)
387 | 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
388 | 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
389 | 	list='$(DISTFILES)'; \
390 | 	  dist_files=`for file in $$list; do echo $$file; done | \
391 | 	  sed -e "s|^$$srcdirstrip/||;t" \
392 | 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
393 | 	case $$dist_files in \
394 | 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
395 | 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
396 | 			   sort -u` ;; \
397 | 	esac; \
398 | 	for file in $$dist_files; do \
399 | 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
400 | 	  if test -d $$d/$$file; then \
401 | 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
402 | 	    if test -d "$(distdir)/$$file"; then \
403 | 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
404 | 	    fi; \
405 | 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
406 | 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
407 | 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
408 | 	    fi; \
409 | 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
410 | 	  else \
411 | 	    test -f "$(distdir)/$$file" \
412 | 	    || cp -p $$d/$$file "$(distdir)/$$file" \
413 | 	    || exit 1; \
414 | 	  fi; \
415 | 	done
416 | check-am: all-am
417 | check: check-am
418 | all-am: Makefile $(LTLIBRARIES) $(HEADERS)
419 | installdirs:
420 | install: install-am
421 | install-exec: install-exec-am
422 | install-data: install-data-am
423 | uninstall: uninstall-am
424 | 
425 | install-am: all-am
426 | 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
427 | 
428 | installcheck: installcheck-am
429 | install-strip:
430 | 	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
431 | 	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
432 | 	  `test -z '$(STRIP)' || \
433 | 	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
434 | mostlyclean-generic:
435 | 
436 | clean-generic:
437 | 	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
438 | 
439 | distclean-generic:
440 | 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
441 | 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
442 | 
443 | maintainer-clean-generic:
444 | 	@echo "This command is intended for maintainers to use"
445 | 	@echo "it deletes files that may require special tools to rebuild."
446 | clean: clean-am
447 | 
448 | clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
449 | 	mostlyclean-am
450 | 
451 | distclean: distclean-am
452 | 	-rm -rf ./$(DEPDIR)
453 | 	-rm -f Makefile
454 | distclean-am: clean-am distclean-compile distclean-generic \
455 | 	distclean-tags
456 | 
457 | dvi: dvi-am
458 | 
459 | dvi-am:
460 | 
461 | html: html-am
462 | 
463 | html-am:
464 | 
465 | info: info-am
466 | 
467 | info-am:
468 | 
469 | install-data-am:
470 | 
471 | install-dvi: install-dvi-am
472 | 
473 | install-dvi-am:
474 | 
475 | install-exec-am:
476 | 
477 | install-html: install-html-am
478 | 
479 | install-html-am:
480 | 
481 | install-info: install-info-am
482 | 
483 | install-info-am:
484 | 
485 | install-man:
486 | 
487 | install-pdf: install-pdf-am
488 | 
489 | install-pdf-am:
490 | 
491 | install-ps: install-ps-am
492 | 
493 | install-ps-am:
494 | 
495 | installcheck-am:
496 | 
497 | maintainer-clean: maintainer-clean-am
498 | 	-rm -rf ./$(DEPDIR)
499 | 	-rm -f Makefile
500 | maintainer-clean-am: distclean-am maintainer-clean-generic
501 | 
502 | mostlyclean: mostlyclean-am
503 | 
504 | mostlyclean-am: mostlyclean-compile mostlyclean-generic mostlyclean-kr \
505 | 	mostlyclean-libtool
506 | 
507 | pdf: pdf-am
508 | 
509 | pdf-am:
510 | 
511 | ps: ps-am
512 | 
513 | ps-am:
514 | 
515 | uninstall-am:
516 | 
517 | .MAKE: $(top_srcdir)/ansi2knr install-am install-strip
518 | 
519 | .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
520 | 	clean-libtool clean-noinstLTLIBRARIES ctags distclean \
521 | 	distclean-compile distclean-generic distclean-libtool \
522 | 	distclean-tags distdir dvi dvi-am html html-am info info-am \
523 | 	install install-am install-data install-data-am install-dvi \
524 | 	install-dvi-am install-exec install-exec-am install-html \
525 | 	install-html-am install-info install-info-am install-man \
526 | 	install-pdf install-pdf-am install-ps install-ps-am \
527 | 	install-strip installcheck installcheck-am installdirs \
528 | 	maintainer-clean maintainer-clean-generic mostlyclean \
529 | 	mostlyclean-compile mostlyclean-generic mostlyclean-kr \
530 | 	mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
531 | 	uninstall-am
532 | 
533 | 
534 | # end global section
535 | 
536 | lclint.txt: ${liblamecpuroutines_la_SOURCES} ${noinst_HEADERS}
537 | 	@lclint ${LCLINTFLAGS} ${INCLUDES} ${DEFS} ${liblamecpuroutines_la_SOURCES} 2>&1 >lclint.txt || true
538 | 
539 | lclint: lclint.txt
540 | 	more lclint.txt
541 | 
542 | #$(OBJECTS): libtool
543 | #libtool: $(LIBTOOL_DEPS)
544 | #	$(SHELL) $(top_builddir)/config.status --recheck
545 | 
546 | # Tell versions [3.59,3.63) of GNU make to not export all variables.
547 | # Otherwise a system limit (for SysV at least) may be exceeded.
548 | .NOEXPORT:
549 | 


--------------------------------------------------------------------------------
/SimpleLameLibForAndroid/jni/lame-3.99.5_libmp3lame/encoder.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *      LAME MP3 encoding engine
  3 |  *
  4 |  *      Copyright (c) 1999 Mark Taylor
  5 |  *      Copyright (c) 2000-2002 Takehiro Tominaga
  6 |  *      Copyright (c) 2000-2011 Robert Hegemann
  7 |  *      Copyright (c) 2001 Gabriel Bouvigne
  8 |  *      Copyright (c) 2001 John Dahlstrom
  9 |  *
 10 |  * This library is free software; you can redistribute it and/or
 11 |  * modify it under the terms of the GNU Library General Public
 12 |  * License as published by the Free Software Foundation; either
 13 |  * version 2 of the License, or (at your option) any later version.
 14 |  *
 15 |  * This library is distributed in the hope that it will be useful,
 16 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 18 |  * Library General Public License for more details.
 19 |  *
 20 |  * You should have received a copy of the GNU Library General Public
 21 |  * License along with this library; if not, write to the
 22 |  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 23 |  * Boston, MA 02111-1307, USA.
 24 |  */
 25 | 
 26 | /* $Id: encoder.c,v 1.111 2011/05/07 16:05:17 rbrito Exp $ */
 27 | 
 28 | #ifdef HAVE_CONFIG_H
 29 | #include <config.h>
 30 | #endif
 31 | 
 32 | 
 33 | #include "lame.h"
 34 | #include "machine.h"
 35 | #include "encoder.h"
 36 | #include "util.h"
 37 | #include "lame_global_flags.h"
 38 | #include "newmdct.h"
 39 | #include "psymodel.h"
 40 | #include "lame-analysis.h"
 41 | #include "bitstream.h"
 42 | #include "VbrTag.h"
 43 | #include "quantize_pvt.h"
 44 | 
 45 | 
 46 | 
 47 | /*
 48 |  * auto-adjust of ATH, useful for low volume
 49 |  * Gabriel Bouvigne 3 feb 2001
 50 |  *
 51 |  * modifies some values in
 52 |  *   gfp->internal_flags->ATH
 53 |  *   (gfc->ATH)
 54 |  */
 55 | static void
 56 | adjust_ATH(lame_internal_flags const *const gfc)
 57 | {
 58 |     SessionConfig_t const *const cfg = &gfc->cfg;
 59 |     FLOAT   gr2_max, max_pow;
 60 | 
 61 |     if (gfc->ATH->use_adjust == 0) {
 62 |         gfc->ATH->adjust_factor = 1.0; /* no adjustment */
 63 |         return;
 64 |     }
 65 | 
 66 |     /* jd - 2001 mar 12, 27, jun 30 */
 67 |     /* loudness based on equal loudness curve; */
 68 |     /* use granule with maximum combined loudness */
 69 |     max_pow = gfc->ov_psy.loudness_sq[0][0];
 70 |     gr2_max = gfc->ov_psy.loudness_sq[1][0];
 71 |     if (cfg->channels_out == 2) {
 72 |         max_pow += gfc->ov_psy.loudness_sq[0][1];
 73 |         gr2_max += gfc->ov_psy.loudness_sq[1][1];
 74 |     }
 75 |     else {
 76 |         max_pow += max_pow;
 77 |         gr2_max += gr2_max;
 78 |     }
 79 |     if (cfg->mode_gr == 2) {
 80 |         max_pow = Max(max_pow, gr2_max);
 81 |     }
 82 |     max_pow *= 0.5;     /* max_pow approaches 1.0 for full band noise */
 83 | 
 84 |     /* jd - 2001 mar 31, jun 30 */
 85 |     /* user tuning of ATH adjustment region */
 86 |     max_pow *= gfc->ATH->aa_sensitivity_p;
 87 | 
 88 |     /*  adjust ATH depending on range of maximum value
 89 |      */
 90 | 
 91 |     /* jd - 2001 feb27, mar12,20, jun30, jul22 */
 92 |     /* continuous curves based on approximation */
 93 |     /* to GB's original values. */
 94 |     /* For an increase in approximate loudness, */
 95 |     /* set ATH adjust to adjust_limit immediately */
 96 |     /* after a delay of one frame. */
 97 |     /* For a loudness decrease, reduce ATH adjust */
 98 |     /* towards adjust_limit gradually. */
 99 |     /* max_pow is a loudness squared or a power. */
100 |     if (max_pow > 0.03125) { /* ((1 - 0.000625)/ 31.98) from curve below */
101 |         if (gfc->ATH->adjust_factor >= 1.0) {
102 |             gfc->ATH->adjust_factor = 1.0;
103 |         }
104 |         else {
105 |             /* preceding frame has lower ATH adjust; */
106 |             /* ascend only to the preceding adjust_limit */
107 |             /* in case there is leading low volume */
108 |             if (gfc->ATH->adjust_factor < gfc->ATH->adjust_limit) {
109 |                 gfc->ATH->adjust_factor = gfc->ATH->adjust_limit;
110 |             }
111 |         }
112 |         gfc->ATH->adjust_limit = 1.0;
113 |     }
114 |     else {              /* adjustment curve */
115 |         /* about 32 dB maximum adjust (0.000625) */
116 |         FLOAT const adj_lim_new = 31.98 * max_pow + 0.000625;
117 |         if (gfc->ATH->adjust_factor >= adj_lim_new) { /* descend gradually */
118 |             gfc->ATH->adjust_factor *= adj_lim_new * 0.075 + 0.925;
119 |             if (gfc->ATH->adjust_factor < adj_lim_new) { /* stop descent */
120 |                 gfc->ATH->adjust_factor = adj_lim_new;
121 |             }
122 |         }
123 |         else {          /* ascend */
124 |             if (gfc->ATH->adjust_limit >= adj_lim_new) {
125 |                 gfc->ATH->adjust_factor = adj_lim_new;
126 |             }
127 |             else {      /* preceding frame has lower ATH adjust; */
128 |                 /* ascend only to the preceding adjust_limit */
129 |                 if (gfc->ATH->adjust_factor < gfc->ATH->adjust_limit) {
130 |                     gfc->ATH->adjust_factor = gfc->ATH->adjust_limit;
131 |                 }
132 |             }
133 |         }
134 |         gfc->ATH->adjust_limit = adj_lim_new;
135 |     }
136 | }
137 | 
138 | /***********************************************************************
139 |  *
140 |  *  some simple statistics
141 |  *
142 |  *  bitrate index 0: free bitrate -> not allowed in VBR mode
143 |  *  : bitrates, kbps depending on MPEG version
144 |  *  bitrate index 15: forbidden
145 |  *
146 |  *  mode_ext:
147 |  *  0:  LR
148 |  *  1:  LR-i
149 |  *  2:  MS
150 |  *  3:  MS-i
151 |  *
152 |  ***********************************************************************/
153 | 
154 | static void
155 | updateStats(lame_internal_flags * const gfc)
156 | {
157 |     SessionConfig_t const *const cfg = &gfc->cfg;
158 |     EncResult_t *eov = &gfc->ov_enc;
159 |     int     gr, ch;
160 |     assert(0 <= eov->bitrate_index && eov->bitrate_index < 16);
161 |     assert(0 <= eov->mode_ext && eov->mode_ext < 4);
162 | 
163 |     /* count bitrate indices */
164 |     eov->bitrate_channelmode_hist[eov->bitrate_index][4]++;
165 |     eov->bitrate_channelmode_hist[15][4]++;
166 | 
167 |     /* count 'em for every mode extension in case of 2 channel encoding */
168 |     if (cfg->channels_out == 2) {
169 |         eov->bitrate_channelmode_hist[eov->bitrate_index][eov->mode_ext]++;
170 |         eov->bitrate_channelmode_hist[15][eov->mode_ext]++;
171 |     }
172 |     for (gr = 0; gr < cfg->mode_gr; ++gr) {
173 |         for (ch = 0; ch < cfg->channels_out; ++ch) {
174 |             int     bt = gfc->l3_side.tt[gr][ch].block_type;
175 |             if (gfc->l3_side.tt[gr][ch].mixed_block_flag)
176 |                 bt = 4;
177 |             eov->bitrate_blocktype_hist[eov->bitrate_index][bt]++;
178 |             eov->bitrate_blocktype_hist[eov->bitrate_index][5]++;
179 |             eov->bitrate_blocktype_hist[15][bt]++;
180 |             eov->bitrate_blocktype_hist[15][5]++;
181 |         }
182 |     }
183 | }
184 | 
185 | 
186 | 
187 | 
188 | static void
189 | lame_encode_frame_init(lame_internal_flags * gfc, const sample_t *const inbuf[2])
190 | {
191 |     SessionConfig_t const *const cfg = &gfc->cfg;
192 | 
193 |     int     ch, gr;
194 | 
195 |     if (gfc->lame_encode_frame_init == 0) {
196 |         sample_t primebuff0[286 + 1152 + 576];
197 |         sample_t primebuff1[286 + 1152 + 576];
198 |         int const framesize = 576 * cfg->mode_gr;
199 |         /* prime the MDCT/polyphase filterbank with a short block */
200 |         int     i, j;
201 |         gfc->lame_encode_frame_init = 1;
202 |         memset(primebuff0, 0, sizeof(primebuff0));
203 |         memset(primebuff1, 0, sizeof(primebuff1));
204 |         for (i = 0, j = 0; i < 286 + 576 * (1 + cfg->mode_gr); ++i) {
205 |             if (i < framesize) {
206 |                 primebuff0[i] = 0;
207 |                 if (cfg->channels_out == 2)
208 |                     primebuff1[i] = 0;
209 |             }
210 |             else {
211 |                 primebuff0[i] = inbuf[0][j];
212 |                 if (cfg->channels_out == 2)
213 |                     primebuff1[i] = inbuf[1][j];
214 |                 ++j;
215 |             }
216 |         }
217 |         /* polyphase filtering / mdct */
218 |         for (gr = 0; gr < cfg->mode_gr; gr++) {
219 |             for (ch = 0; ch < cfg->channels_out; ch++) {
220 |                 gfc->l3_side.tt[gr][ch].block_type = SHORT_TYPE;
221 |             }
222 |         }
223 |         mdct_sub48(gfc, primebuff0, primebuff1);
224 | 
225 |         /* check FFT will not use a negative starting offset */
226 | #if 576 < FFTOFFSET
227 | # error FFTOFFSET greater than 576: FFT uses a negative offset
228 | #endif
229 |         /* check if we have enough data for FFT */
230 |         assert(gfc->sv_enc.mf_size >= (BLKSIZE + framesize - FFTOFFSET));
231 |         /* check if we have enough data for polyphase filterbank */
232 |         assert(gfc->sv_enc.mf_size >= (512 + framesize - 32));
233 |     }
234 | 
235 | }
236 | 
237 | 
238 | 
239 | 
240 | 
241 | 
242 | 
243 | /************************************************************************
244 | *
245 | * encodeframe()           Layer 3
246 | *
247 | * encode a single frame
248 | *
249 | ************************************************************************
250 | lame_encode_frame()
251 | 
252 | 
253 |                        gr 0            gr 1
254 | inbuf:           |--------------|--------------|--------------|
255 | 
256 | 
257 | Polyphase (18 windows, each shifted 32)
258 | gr 0:
259 | window1          <----512---->
260 | window18                 <----512---->
261 | 
262 | gr 1:
263 | window1                         <----512---->
264 | window18                                <----512---->
265 | 
266 | 
267 | 
268 | MDCT output:  |--------------|--------------|--------------|
269 | 
270 | FFT's                    <---------1024---------->
271 |                                          <---------1024-------->
272 | 
273 | 
274 | 
275 |     inbuf = buffer of PCM data size=MP3 framesize
276 |     encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY
277 |     so the MDCT coefficints are from inbuf[ch][-MDCTDELAY]
278 | 
279 |     psy-model FFT has a 1 granule delay, so we feed it data for the 
280 |     next granule.
281 |     FFT is centered over granule:  224+576+224
282 |     So FFT starts at:   576-224-MDCTDELAY
283 | 
284 |     MPEG2:  FFT ends at:  BLKSIZE+576-224-MDCTDELAY      (1328)
285 |     MPEG1:  FFT ends at:  BLKSIZE+2*576-224-MDCTDELAY    (1904)
286 | 
287 |     MPEG2:  polyphase first window:  [0..511]
288 |                       18th window:   [544..1055]          (1056)
289 |     MPEG1:            36th window:   [1120..1631]         (1632)
290 |             data needed:  512+framesize-32
291 | 
292 |     A close look newmdct.c shows that the polyphase filterbank
293 |     only uses data from [0..510] for each window.  Perhaps because the window
294 |     used by the filterbank is zero for the last point, so Takehiro's
295 |     code doesn't bother to compute with it.
296 | 
297 |     FFT starts at 576-224-MDCTDELAY (304)  = 576-FFTOFFSET
298 | 
299 | */
300 | 
301 | typedef FLOAT chgrdata[2][2];
302 | 
303 | 
304 | int
305 | lame_encode_mp3_frame(       /* Output */
306 |                          lame_internal_flags * gfc, /* Context */
307 |                          sample_t const *inbuf_l, /* Input */
308 |                          sample_t const *inbuf_r, /* Input */
309 |                          unsigned char *mp3buf, /* Output */
310 |                          int mp3buf_size)
311 | {                       /* Output */
312 |     SessionConfig_t const *const cfg = &gfc->cfg;
313 |     int     mp3count;
314 |     III_psy_ratio masking_LR[2][2]; /*LR masking & energy */
315 |     III_psy_ratio masking_MS[2][2]; /*MS masking & energy */
316 |     const III_psy_ratio (*masking)[2]; /*pointer to selected maskings */
317 |     const sample_t *inbuf[2];
318 | 
319 |     FLOAT   tot_ener[2][4];
320 |     FLOAT   ms_ener_ratio[2] = { .5, .5 };
321 |     FLOAT   pe[2][2] = { {0., 0.}, {0., 0.} }, pe_MS[2][2] = { {
322 |     0., 0.}, {
323 |     0., 0.}};
324 |     FLOAT (*pe_use)[2];
325 | 
326 |     int     ch, gr;
327 | 
328 |     inbuf[0] = inbuf_l;
329 |     inbuf[1] = inbuf_r;
330 | 
331 |     if (gfc->lame_encode_frame_init == 0) {
332 |         /*first run? */
333 |         lame_encode_frame_init(gfc, inbuf);
334 | 
335 |     }
336 | 
337 | 
338 |     /********************** padding *****************************/
339 |     /* padding method as described in 
340 |      * "MPEG-Layer3 / Bitstream Syntax and Decoding"
341 |      * by Martin Sieler, Ralph Sperschneider
342 |      *
343 |      * note: there is no padding for the very first frame
344 |      *
345 |      * Robert Hegemann 2000-06-22
346 |      */
347 |     gfc->ov_enc.padding = FALSE;
348 |     if ((gfc->sv_enc.slot_lag -= gfc->sv_enc.frac_SpF) < 0) {
349 |         gfc->sv_enc.slot_lag += cfg->samplerate_out;
350 |         gfc->ov_enc.padding = TRUE;
351 |     }
352 | 
353 | 
354 | 
355 |     /****************************************
356 |     *   Stage 1: psychoacoustic model       *
357 |     ****************************************/
358 | 
359 |     {
360 |         /* psychoacoustic model
361 |          * psy model has a 1 granule (576) delay that we must compensate for
362 |          * (mt 6/99).
363 |          */
364 |         int     ret;
365 |         const sample_t *bufp[2] = {0, 0}; /* address of beginning of left & right granule */
366 |         int     blocktype[2];
367 | 
368 |         for (gr = 0; gr < cfg->mode_gr; gr++) {
369 | 
370 |             for (ch = 0; ch < cfg->channels_out; ch++) {
371 |                 bufp[ch] = &inbuf[ch][576 + gr * 576 - FFTOFFSET];
372 |             }
373 |             ret = L3psycho_anal_vbr(gfc, bufp, gr,
374 |                                     masking_LR, masking_MS,
375 |                                     pe[gr], pe_MS[gr], tot_ener[gr], blocktype);
376 |             if (ret != 0)
377 |                 return -4;
378 | 
379 |             if (cfg->mode == JOINT_STEREO) {
380 |                 ms_ener_ratio[gr] = tot_ener[gr][2] + tot_ener[gr][3];
381 |                 if (ms_ener_ratio[gr] > 0)
382 |                     ms_ener_ratio[gr] = tot_ener[gr][3] / ms_ener_ratio[gr];
383 |             }
384 | 
385 |             /* block type flags */
386 |             for (ch = 0; ch < cfg->channels_out; ch++) {
387 |                 gr_info *const cod_info = &gfc->l3_side.tt[gr][ch];
388 |                 cod_info->block_type = blocktype[ch];
389 |                 cod_info->mixed_block_flag = 0;
390 |             }
391 |         }
392 |     }
393 | 
394 | 
395 |     /* auto-adjust of ATH, useful for low volume */
396 |     adjust_ATH(gfc);
397 | 
398 | 
399 |     /****************************************
400 |     *   Stage 2: MDCT                       *
401 |     ****************************************/
402 | 
403 |     /* polyphase filtering / mdct */
404 |     mdct_sub48(gfc, inbuf[0], inbuf[1]);
405 | 
406 | 
407 |     /****************************************
408 |     *   Stage 3: MS/LR decision             *
409 |     ****************************************/
410 | 
411 |     /* Here will be selected MS or LR coding of the 2 stereo channels */
412 |     gfc->ov_enc.mode_ext = MPG_MD_LR_LR;
413 | 
414 |     if (cfg->force_ms) {
415 |         gfc->ov_enc.mode_ext = MPG_MD_MS_LR;
416 |     }
417 |     else if (cfg->mode == JOINT_STEREO) {
418 |         /* ms_ratio = is scaled, for historical reasons, to look like
419 |            a ratio of side_channel / total.
420 |            0 = signal is 100% mono
421 |            .5 = L & R uncorrelated
422 |          */
423 | 
424 |         /* [0] and [1] are the results for the two granules in MPEG-1,
425 |          * in MPEG-2 it's only a faked averaging of the same value
426 |          * _prev is the value of the last granule of the previous frame
427 |          * _next is the value of the first granule of the next frame
428 |          */
429 | 
430 |         FLOAT   sum_pe_MS = 0;
431 |         FLOAT   sum_pe_LR = 0;
432 |         for (gr = 0; gr < cfg->mode_gr; gr++) {
433 |             for (ch = 0; ch < cfg->channels_out; ch++) {
434 |                 sum_pe_MS += pe_MS[gr][ch];
435 |                 sum_pe_LR += pe[gr][ch];
436 |             }
437 |         }
438 | 
439 |         /* based on PE: M/S coding would not use much more bits than L/R */
440 |         if (sum_pe_MS <= 1.00 * sum_pe_LR) {
441 | 
442 |             gr_info const *const gi0 = &gfc->l3_side.tt[0][0];
443 |             gr_info const *const gi1 = &gfc->l3_side.tt[cfg->mode_gr - 1][0];
444 | 
445 |             if (gi0[0].block_type == gi0[1].block_type && gi1[0].block_type == gi1[1].block_type) {
446 | 
447 |                 gfc->ov_enc.mode_ext = MPG_MD_MS_LR;
448 |             }
449 |         }
450 |     }
451 | 
452 |     /* bit and noise allocation */
453 |     if (gfc->ov_enc.mode_ext == MPG_MD_MS_LR) {
454 |         masking = (const III_psy_ratio (*)[2])masking_MS; /* use MS masking */
455 |         pe_use = pe_MS;
456 |     }
457 |     else {
458 |         masking = (const III_psy_ratio (*)[2])masking_LR; /* use LR masking */
459 |         pe_use = pe;
460 |     }
461 | 
462 | 
463 |     /* copy data for MP3 frame analyzer */
464 |     if (cfg->analysis && gfc->pinfo != NULL) {
465 |         for (gr = 0; gr < cfg->mode_gr; gr++) {
466 |             for (ch = 0; ch < cfg->channels_out; ch++) {
467 |                 gfc->pinfo->ms_ratio[gr] = 0;
468 |                 gfc->pinfo->ms_ener_ratio[gr] = ms_ener_ratio[gr];
469 |                 gfc->pinfo->blocktype[gr][ch] = gfc->l3_side.tt[gr][ch].block_type;
470 |                 gfc->pinfo->pe[gr][ch] = pe_use[gr][ch];
471 |                 memcpy(gfc->pinfo->xr[gr][ch], &gfc->l3_side.tt[gr][ch].xr[0], sizeof(FLOAT) * 576);
472 |                 /* in psymodel, LR and MS data was stored in pinfo.  
473 |                    switch to MS data: */
474 |                 if (gfc->ov_enc.mode_ext == MPG_MD_MS_LR) {
475 |                     gfc->pinfo->ers[gr][ch] = gfc->pinfo->ers[gr][ch + 2];
476 |                     memcpy(gfc->pinfo->energy[gr][ch], gfc->pinfo->energy[gr][ch + 2],
477 |                            sizeof(gfc->pinfo->energy[gr][ch]));
478 |                 }
479 |             }
480 |         }
481 |     }
482 | 
483 | 
484 |     /****************************************
485 |     *   Stage 4: quantization loop          *
486 |     ****************************************/
487 | 
488 |     if (cfg->vbr == vbr_off || cfg->vbr == vbr_abr) {
489 |         static FLOAT const fircoef[9] = {
490 |             -0.0207887 * 5, -0.0378413 * 5, -0.0432472 * 5, -0.031183 * 5,
491 |             7.79609e-18 * 5, 0.0467745 * 5, 0.10091 * 5, 0.151365 * 5,
492 |             0.187098 * 5
493 |         };
494 | 
495 |         int     i;
496 |         FLOAT   f;
497 | 
498 |         for (i = 0; i < 18; i++)
499 |             gfc->sv_enc.pefirbuf[i] = gfc->sv_enc.pefirbuf[i + 1];
500 | 
501 |         f = 0.0;
502 |         for (gr = 0; gr < cfg->mode_gr; gr++)
503 |             for (ch = 0; ch < cfg->channels_out; ch++)
504 |                 f += pe_use[gr][ch];
505 |         gfc->sv_enc.pefirbuf[18] = f;
506 | 
507 |         f = gfc->sv_enc.pefirbuf[9];
508 |         for (i = 0; i < 9; i++)
509 |             f += (gfc->sv_enc.pefirbuf[i] + gfc->sv_enc.pefirbuf[18 - i]) * fircoef[i];
510 | 
511 |         f = (670 * 5 * cfg->mode_gr * cfg->channels_out) / f;
512 |         for (gr = 0; gr < cfg->mode_gr; gr++) {
513 |             for (ch = 0; ch < cfg->channels_out; ch++) {
514 |                 pe_use[gr][ch] *= f;
515 |             }
516 |         }
517 |     }
518 |     gfc->iteration_loop(gfc, (const FLOAT (*)[2])pe_use, ms_ener_ratio, masking);
519 | 
520 | 
521 |     /****************************************
522 |     *   Stage 5: bitstream formatting       *
523 |     ****************************************/
524 | 
525 | 
526 |     /*  write the frame to the bitstream  */
527 |     (void) format_bitstream(gfc);
528 | 
529 |     /* copy mp3 bit buffer into array */
530 |     mp3count = copy_buffer(gfc, mp3buf, mp3buf_size, 1);
531 | 
532 | 
533 |     if (cfg->write_lame_tag) {
534 |         AddVbrFrame(gfc);
535 |     }
536 | 
537 |     if (cfg->analysis && gfc->pinfo != NULL) {
538 |         int     framesize = 576 * cfg->mode_gr;
539 |         for (ch = 0; ch < cfg->channels_out; ch++) {
540 |             int     j;
541 |             for (j = 0; j < FFTOFFSET; j++)
542 |                 gfc->pinfo->pcmdata[ch][j] = gfc->pinfo->pcmdata[ch][j + framesize];
543 |             for (j = FFTOFFSET; j < 1600; j++) {
544 |                 gfc->pinfo->pcmdata[ch][j] = inbuf[ch][j - FFTOFFSET];
545 |             }
546 |         }
547 |         gfc->sv_qnt.masking_lower = 1.0;
548 | 
549 |         set_frame_pinfo(gfc, masking);
550 |     }
551 | 
552 |     ++gfc->ov_enc.frame_number;
553 | 
554 |     updateStats(gfc);
555 | 
556 |     return mp3count;
557 | }
558 | 


--------------------------------------------------------------------------------