Updated project structure so native libs compile properly on the latest

gradle plugin.

12 files changed, 5884 insertions, 0 deletions

diff --git a/jni/Android.mk b/jni/Android.mk
new file mode 100644
index 0000000..eda36f8
--- /dev/null
+++ b/jni/Android.mk
@@ -0,0 +1,194 @@
+#
+# Copyright (C) 2013 Andrew Comminos
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ROOT := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_PATH          := $(ROOT)/speex/libspeex
+LOCAL_MODULE        := speex
+LOCAL_C_INCLUDES    := $(ROOT)/speex/include/
+LOCAL_SRC_FILES		:= cb_search.c		exc_10_32_table.c 	exc_8_128_table.c 	filters.c \
+					   gain_table.c 	hexc_table.c 		high_lsp_tables.c 	lsp.c \
+					   ltp.c			speex.c 			stereo.c 			vbr.c \
+					   vq.c bits.c 		exc_10_16_table.c	exc_20_32_table.c 	exc_5_256_table.c \
+					   exc_5_64_table.c	gain_table_lbr.c 	hexc_10_32_table.c	lpc.c \
+					   lsp_tables_nb.c 	modes.c 			modes_wb.c 			nb_celp.c \
+					   quant_lsp.c		sb_celp.c			speex_callbacks.c 	speex_header.c \
+					   window.c			resample.c			jitter.c            preprocess.c \
+					   mdf.c            kiss_fft.c          kiss_fftr.c         fftwrap.c \
+					   filterbank.c     scal.c \
+					   $(ROOT)/speex.cpp
+LOCAL_CFLAGS		:= -D__EMX__ -DUSE_KISS_FFT -DFIXED_POINT -DEXPORT=''
+LOCAL_CPP_FEATURES := exceptions
+LOCAL_LDLIBS := -llog
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_PATH			:= $(ROOT)/celt-0.11.0-src/libcelt
+LOCAL_MODULE		:= libcelt11
+LOCAL_SRC_FILES		:= bands.c celt.c cwrs.c entcode.c entdec.c entenc.c header.c kiss_fft.c laplace.c mathops.c mdct.c modes.c pitch.c plc.c quant_bands.c rate.c vq.c $(ROOT)/celt11.cpp
+LOCAL_C_INCLUDES    := $(ROOT)/celt-0.11.0-src/libcelt/
+LOCAL_CFLAGS		:= -I$(ROOT)/celt-0.11.0-build -DHAVE_CONFIG_H -fvisibility=hidden
+LOCAL_CPP_FEATURES := exceptions
+LOCAL_LDLIBS := -llog
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_PATH			:= $(ROOT)/celt-0.7.0-src/libcelt
+LOCAL_MODULE		:= libcelt7
+LOCAL_SRC_FILES		:= bands.c celt.c cwrs.c entcode.c entdec.c entenc.c header.c kiss_fft.c kiss_fftr.c laplace.c mdct.c modes.c pitch.c psy.c quant_bands.c rangedec.c rangeenc.c rate.c vq.c $(ROOT)/celt7.cpp
+LOCAL_C_INCLUDES    := $(ROOT)/celt-0.7.0-src/libcelt/
+LOCAL_CFLAGS		:= -I$(ROOT)/celt-0.7.0-build -DHAVE_CONFIG_H -fvisibility=hidden
+LOCAL_CPP_FEATURES := exceptions
+LOCAL_LDLIBS := -llog
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_PATH			:= $(ROOT)/opus
+LOCAL_MODULE		:= libopus
+LOCAL_C_INCLUDES	:= $(ROOT)/opus/include $(ROOT)/opus/celt $(ROOT)/opus/silk $(ROOT)/opus/silk/fixed
+LOCAL_SRC_FILES		:= src/opus.c \
+src/opus_decoder.c \
+src/opus_encoder.c \
+src/opus_multistream.c \
+src/opus_multistream_encoder.c \
+src/opus_multistream_decoder.c \
+celt/bands.c \
+celt/celt.c \
+celt/celt_encoder.c \
+celt/celt_decoder.c \
+celt/cwrs.c \
+celt/entcode.c \
+celt/entdec.c \
+celt/entenc.c \
+celt/kiss_fft.c \
+celt/laplace.c \
+celt/mathops.c \
+celt/mdct.c \
+celt/modes.c \
+celt/pitch.c \
+celt/celt_lpc.c \
+celt/quant_bands.c \
+celt/rate.c \
+celt/vq.c \
+silk/CNG.c \
+silk/code_signs.c \
+silk/init_decoder.c \
+silk/decode_core.c \
+silk/decode_frame.c \
+silk/decode_parameters.c \
+silk/decode_indices.c \
+silk/decode_pulses.c \
+silk/decoder_set_fs.c \
+silk/dec_API.c \
+silk/enc_API.c \
+silk/encode_indices.c \
+silk/encode_pulses.c \
+silk/gain_quant.c \
+silk/interpolate.c \
+silk/LP_variable_cutoff.c \
+silk/NLSF_decode.c \
+silk/NSQ.c \
+silk/NSQ_del_dec.c \
+silk/PLC.c \
+silk/shell_coder.c \
+silk/tables_gain.c \
+silk/tables_LTP.c \
+silk/tables_NLSF_CB_NB_MB.c \
+silk/tables_NLSF_CB_WB.c \
+silk/tables_other.c \
+silk/tables_pitch_lag.c \
+silk/tables_pulses_per_block.c \
+silk/VAD.c \
+silk/control_audio_bandwidth.c \
+silk/quant_LTP_gains.c \
+silk/VQ_WMat_EC.c \
+silk/HP_variable_cutoff.c \
+silk/NLSF_encode.c \
+silk/NLSF_VQ.c \
+silk/NLSF_unpack.c \
+silk/NLSF_del_dec_quant.c \
+silk/process_NLSFs.c \
+silk/stereo_LR_to_MS.c \
+silk/stereo_MS_to_LR.c \
+silk/check_control_input.c \
+silk/control_SNR.c \
+silk/init_encoder.c \
+silk/control_codec.c \
+silk/A2NLSF.c \
+silk/ana_filt_bank_1.c \
+silk/biquad_alt.c \
+silk/bwexpander_32.c \
+silk/bwexpander.c \
+silk/debug.c \
+silk/decode_pitch.c \
+silk/inner_prod_aligned.c \
+silk/lin2log.c \
+silk/log2lin.c \
+silk/LPC_analysis_filter.c \
+silk/LPC_inv_pred_gain.c \
+silk/table_LSF_cos.c \
+silk/NLSF2A.c \
+silk/NLSF_stabilize.c \
+silk/NLSF_VQ_weights_laroia.c \
+silk/pitch_est_tables.c \
+silk/resampler.c \
+silk/resampler_down2_3.c \
+silk/resampler_down2.c \
+silk/resampler_private_AR2.c \
+silk/resampler_private_down_FIR.c \
+silk/resampler_private_IIR_FIR.c \
+silk/resampler_private_up2_HQ.c \
+silk/resampler_rom.c \
+silk/sigm_Q15.c \
+silk/sort.c \
+silk/sum_sqr_shift.c \
+silk/stereo_decode_pred.c \
+silk/stereo_encode_pred.c \
+silk/stereo_find_predictor.c \
+silk/stereo_quant_pred.c \
+silk/fixed/LTP_analysis_filter_FIX.c \
+silk/fixed/LTP_scale_ctrl_FIX.c \
+silk/fixed/corrMatrix_FIX.c \
+silk/fixed/encode_frame_FIX.c \
+silk/fixed/find_LPC_FIX.c \
+silk/fixed/find_LTP_FIX.c \
+silk/fixed/find_pitch_lags_FIX.c \
+silk/fixed/find_pred_coefs_FIX.c \
+silk/fixed/noise_shape_analysis_FIX.c \
+silk/fixed/prefilter_FIX.c \
+silk/fixed/process_gains_FIX.c \
+silk/fixed/regularize_correlations_FIX.c \
+silk/fixed/residual_energy16_FIX.c \
+silk/fixed/residual_energy_FIX.c \
+silk/fixed/solve_LS_FIX.c \
+silk/fixed/warped_autocorrelation_FIX.c \
+silk/fixed/apply_sine_window_FIX.c \
+silk/fixed/autocorr_FIX.c \
+silk/fixed/burg_modified_FIX.c \
+silk/fixed/k2a_FIX.c \
+silk/fixed/k2a_Q16_FIX.c \
+silk/fixed/pitch_analysis_core_FIX.c \
+silk/fixed/vector_ops_FIX.c \
+silk/fixed/schur64_FIX.c \
+silk/fixed/schur_FIX.c \
+src/repacketizer.c \
+$(ROOT)/opus.cpp
+LOCAL_CFLAGS		:= -DOPUS_BUILD -DVAR_ARRAYS -Wno-traditional -DFIXED_POINT
+LOCAL_CPP_FEATURES := exceptions
+LOCAL_LDLIBS := -llog
+include $(BUILD_SHARED_LIBRARY)
diff --git a/jni/Application.mk b/jni/Application.mk
new file mode 100644
index 0000000..9e3c749
--- /dev/null
+++ b/jni/Application.mk
@@ -0,0 +1,3 @@
+#APP_OPTIM := debug
+APP_ABI := armeabi #x86
+APP_STL := gnustl_static
\ No newline at end of file
diff --git a/jni/celt-0.11.0-build/config.h b/jni/celt-0.11.0-build/config.h
new file mode 100644
index 0000000..624f041
--- /dev/null
+++ b/jni/celt-0.11.0-build/config.h
@@ -0,0 +1,181 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* This is a build of CELT */
+#define CELT_BUILD /**/
+
+/* Version extra */
+#define CELT_EXTRA_VERSION ""
+
+/* Version major */
+#define CELT_MAJOR_VERSION 0
+
+/* Version micro */
+#define CELT_MICRO_VERSION 0
+
+/* Version minor */
+#define CELT_MINOR_VERSION 11
+
+/* Complete version string */
+#define CELT_VERSION "0.11.0"
+
+/* Compile as fixed-point */
+/* #undef DOUBLE_PRECISION */
+
+/* Assertions */
+/* #undef ENABLE_ASSERTIONS */
+
+/* Postfilter */
+/* #undef ENABLE_POSTFILTER */
+
+/* Debug fixed-point implementation */
+/* #undef FIXED_DEBUG */
+
+/* Compile as fixed-point */
+#define FIXED_POINT
+
+/* Compile as floating-point */
+/* #define FLOATING_POINT */
+
+/* Float approximations */
+/* #undef FLOAT_APPROX */
+
+/* Define to 1 if you have the <alloca.h> header file. */
+#define HAVE_ALLOCA_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getopt_long' function. */
+#define HAVE_GETOPT_LONG 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the `winmm' library (-lwinmm). */
+/* #undef HAVE_LIBWINMM */
+
+/* Define if you have C99's lrint function. */
+#define HAVE_LRINT 1
+
+/* Define if you have C99's lrintf function. */
+#define HAVE_LRINTF 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/audioio.h> header file. */
+/* #undef HAVE_SYS_AUDIOIO_H */
+
+/* Define to 1 if you have the <sys/soundcard.h> header file. */
+#define HAVE_SYS_SOUNDCARD_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+ *    */
+#define LT_OBJDIR ".libs/"
+
+/* Compile as fixed-point */
+/* #undef MIXED_PRECISION */
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* The size of `int', as computed by sizeof. */
+#define SIZEOF_INT 4
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `long long', as computed by sizeof. */
+#define SIZEOF_LONG_LONG 8
+
+/* The size of `short', as computed by sizeof. */
+#define SIZEOF_SHORT 2
+
+/* Custom modes */
+/* #undef CUSTOM_MODES */
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Make use of alloca */
+/* #undef USE_ALLOCA */
+
+/* Use C99 variable-size arrays */
+#define VAR_ARRAYS /**/
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+ *    significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+ *    calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+/* #undef inline */
+#endif
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+ *    nothing if this is not supported.  Do not define if restrict is
+ *       supported directly.  */
+#define restrict __restrict
+/* Work around a bug in Sun C++: it does not support _Restrict, even
+ *    though the corresponding Sun C compiler does, which causes
+ *       "#define restrict _Restrict" in the previous line.  Perhaps some future
+ *          version of Sun C++ will work with _Restrict; if so, it'll probably
+ *             define __RESTRICT, just as Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+#endif
diff --git a/jni/celt-0.11.0-src b/jni/celt-0.11.0-src
new file mode 160000
+Subproject e3d39fec7c44d1841e817d3b1986bfdc4d0863a
diff --git a/jni/celt-0.7.0-build/config.h b/jni/celt-0.7.0-build/config.h
new file mode 100644
index 0000000..16c084b
--- /dev/null
+++ b/jni/celt-0.7.0-build/config.h
@@ -0,0 +1,180 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* This is a build of CELT */
+#define CELT_BUILD /**/
+
+/* Version extra */
+#define CELT_EXTRA_VERSION ""
+
+/* Version major */
+#define CELT_MAJOR_VERSION 0
+
+/* Version micro */
+#define CELT_MICRO_VERSION 0
+
+/* Version minor */
+#define CELT_MINOR_VERSION 7
+
+/* Complete version string */
+#define CELT_VERSION "0.7.0"
+
+/* Compile as fixed-point */
+/* #undef DOUBLE_PRECISION */
+
+/* Assertions */
+/* #undef ENABLE_ASSERTIONS */
+
+/* Debug fixed-point implementation */
+/* #undef FIXED_DEBUG */
+
+/* Compile as fixed-point */
+#define FIXED_POINT
+
+/* Compile as floating-point */
+/* #define FLOATING_POINT */
+
+/* Define to 1 if you have the <alloca.h> header file. */
+#define HAVE_ALLOCA_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getopt_long' function. */
+#define HAVE_GETOPT_LONG 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the `winmm' library (-lwinmm). */
+/* #undef HAVE_LIBWINMM */
+
+/* Define if you have C99's lrint function. */
+#define HAVE_LRINT 1
+
+/* Define if you have C99's lrintf function. */
+#define HAVE_LRINTF 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/audioio.h> header file. */
+/* #undef HAVE_SYS_AUDIOIO_H */
+
+/* Define to 1 if you have the <sys/soundcard.h> header file. */
+#define HAVE_SYS_SOUNDCARD_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled 
+libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Compile as fixed-point */
+/* #undef MIXED_PRECISION */
+
+/* Define to the address where bug reports for this package should be 
+sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* The size of `int', as computed by sizeof. */
+#define SIZEOF_INT 4
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `long long', as computed by sizeof. */
+#define SIZEOF_LONG_LONG 8
+
+/* The size of `short', as computed by sizeof. */
+#define SIZEOF_SHORT 2
+
+/* Static modes */
+/* #undef STATIC_MODES */
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Make use of alloca */
+/* #undef USE_ALLOCA */
+
+/* Use C99 variable-size arrays */
+#define VAR_ARRAYS /**/
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the 
+most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  
+*/
+#ifndef __cplusplus
+/* #undef inline */
+#endif
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#define restrict __restrict
+/* Work around a bug in Sun C++: it does not support _Restrict, even
+   though the corresponding Sun C compiler does, which causes
+   "#define restrict _Restrict" in the previous line.  Perhaps some 
+future
+   version of Sun C++ will work with _Restrict; if so, it'll probably
+   define __RESTRICT, just as Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+#endif
diff --git a/jni/celt-0.7.0-src b/jni/celt-0.7.0-src
new file mode 160000
+Subproject 6c79a9325c328f86fa048bf124ff6a8912a60a3
diff --git a/jni/celt11.cpp b/jni/celt11.cpp
new file mode 100644
index 0000000..a85a138
--- /dev/null
+++ b/jni/celt11.cpp
@@ -0,0 +1,1229 @@
+/* DO NOT EDIT THIS FILE - IT IS MACHINE GENERATED */
+
+
+#ifdef __APPLE__
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __attribute__((visibility("default")))
+    #define JNIIMPORT
+    #define JNICALL
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#ifdef _WIN32
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __declspec(dllexport)
+    #define JNIIMPORT __declspec(dllimport)
+    #define JNICALL __stdcall
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#include <jni.h>
+#ifdef ANDROID
+    #include <android/log.h>
+    #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
+    #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
+#endif
+
+#include <stddef.h>
+#ifndef _WIN32
+    #include <stdint.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <exception>
+#include <new>
+
+#define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
+#define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))
+
+#if defined(_MSC_VER)
+    #define JavaCPP_noinline __declspec(noinline)
+    #define JavaCPP_hidden /* hidden by default */
+#elif defined(__GNUC__)
+    #define JavaCPP_noinline __attribute__((noinline))
+    #define JavaCPP_hidden   __attribute__((visibility("hidden")))
+#else
+    #define JavaCPP_noinline
+    #define JavaCPP_hidden
+#endif
+
+extern "C" {
+#include <celt.h>
+#include <celt_types.h>
+}
+
+static JavaVM* JavaCPP_vm = NULL;
+static const char* JavaCPP_classNames[15] = {
+        "com/googlecode/javacpp/Loader",
+        "com/googlecode/javacpp/Pointer",
+        "java/lang/NullPointerException",
+        "com/googlecode/javacpp/BytePointer",
+        "com/googlecode/javacpp/ShortPointer",
+        "com/googlecode/javacpp/IntPointer",
+        "com/googlecode/javacpp/LongPointer",
+        "com/googlecode/javacpp/FloatPointer",
+        "com/googlecode/javacpp/DoublePointer",
+        "com/googlecode/javacpp/CharPointer",
+        "com/googlecode/javacpp/PointerPointer",
+        "com/googlecode/javacpp/BoolPointer",
+        "com/googlecode/javacpp/CLongPointer",
+        "com/googlecode/javacpp/SizeTPointer",
+        "java/lang/RuntimeException" };
+static jclass JavaCPP_classes[15] = { NULL };
+static jmethodID JavaCPP_initMID = NULL;
+static jfieldID JavaCPP_addressFID = NULL;
+static jfieldID JavaCPP_positionFID = NULL;
+static jfieldID JavaCPP_limitFID = NULL;
+static jfieldID JavaCPP_capacityFID = NULL;
+
+static inline void JavaCPP_log(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+#ifdef ANDROID
+    __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
+#else
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+#endif
+    va_end(ap);
+}
+
+static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
+    if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
+        jclass cls = env->FindClass(JavaCPP_classNames[i]);
+        if (cls == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
+        if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        env->PopLocalFrame(NULL);
+    }
+    return JavaCPP_classes[i];
+}
+
+class JavaCPP_hidden JavaCPP_exception : public std::exception {
+public:
+    JavaCPP_exception(const char* str) throw() {
+        if (str == NULL) {
+            strcpy(msg, "Unknown exception.");
+        } else {
+            strncpy(msg, str, sizeof(msg));
+            msg[sizeof(msg) - 1] = 0;
+        }
+    }
+    virtual const char* what() const throw() { return msg; }
+    char msg[1024];
+};
+
+static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
+    jstring str = NULL;
+    try {
+        throw;
+    } catch (std::exception& e) {
+        str = env->NewStringUTF(e.what());
+    } catch (...) {
+        str = env->NewStringUTF("Unknown exception.");
+    }
+    jclass cls = JavaCPP_getClass(env, i);
+    jmethodID mid = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
+    if (mid == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting constructor ID of %s.", JavaCPP_classNames[i]);
+        return NULL;
+    } else {
+        return (jthrowable)env->NewObject(cls, mid, str);
+    }
+}
+
+
+
+static void JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray(signed char* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray(short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray(int* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray(jlong* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray(float* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray(double* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray(unsigned short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray(void** p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray(bool* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray(long* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray(size_t* p) { delete[] p; }
+
+extern "C" {
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnLoad().");
+        return JNI_ERR;
+    }
+    if (JavaCPP_vm == vm) {
+        return env->GetVersion();
+    }
+    JavaCPP_vm = vm;
+    const char* members[15][1] = {
+            {  },
+            { "sizeof" },
+            {  },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            {  } };
+    int offsets[15][1] = {
+            {  },
+            { sizeof(void*) },
+            {  },
+            { sizeof(signed char) },
+            { sizeof(short) },
+            { sizeof(int) },
+            { sizeof(jlong) },
+            { sizeof(float) },
+            { sizeof(double) },
+            { sizeof(unsigned short) },
+            { sizeof(void*) },
+            { sizeof(bool) },
+            { sizeof(long) },
+            { sizeof(size_t) },
+            {  } };
+    int memberOffsetSizes[15] = { 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
+    jmethodID putMemberOffsetMID = env->GetStaticMethodID(JavaCPP_getClass(env, 0), "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)V");
+    if (putMemberOffsetMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Loader.putMemberOffset().");
+        return JNI_ERR;
+    }
+    for (int i = 0; i < 15 && !env->ExceptionCheck(); i++) {
+        for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
+            if (env->PushLocalFrame(2) == 0) {
+                jvalue args[3];
+                args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
+                args[1].l = env->NewStringUTF(members[i][j]);
+                args[2].i = offsets[i][j];
+                env->CallStaticVoidMethodA(JavaCPP_getClass(env, 0), putMemberOffsetMID, args);
+                env->PopLocalFrame(NULL);
+            }
+        }
+    }
+    JavaCPP_initMID = env->GetMethodID(JavaCPP_getClass(env, 1), "init", "(JIJ)V");
+    if (JavaCPP_initMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Pointer.init().");
+        return JNI_ERR;
+    }
+    JavaCPP_addressFID = env->GetFieldID(JavaCPP_getClass(env, 1), "address", "J");
+    if (JavaCPP_addressFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.address.");
+        return JNI_ERR;
+    }
+    JavaCPP_positionFID = env->GetFieldID(JavaCPP_getClass(env, 1), "position", "I");
+    if (JavaCPP_positionFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.position.");
+        return JNI_ERR;
+    }
+    JavaCPP_limitFID = env->GetFieldID(JavaCPP_getClass(env, 1), "limit", "I");
+    if (JavaCPP_limitFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.limit.");
+        return JNI_ERR;
+    }
+    JavaCPP_capacityFID = env->GetFieldID(JavaCPP_getClass(env, 1), "capacity", "I");
+    if (JavaCPP_capacityFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.capacity.");
+        return JNI_ERR;
+    }
+    return env->GetVersion();
+}
+
+
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnUnLoad().");
+        return;
+    }
+    for (int i = 0; i < 15; i++) {
+        env->DeleteWeakGlobalRef(JavaCPP_classes[i]);
+        JavaCPP_classes[i] = NULL;
+    }
+    JavaCPP_vm = NULL;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
+    void* allocatedAddress = jlong_to_ptr(arg0);
+    void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
+    if (deallocatorAddress != NULL && allocatedAddress != NULL) {
+        (*deallocatorAddress)(allocatedAddress);
+    }
+
+}
+
+
+
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
+    char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint size = env->GetIntField(obj, JavaCPP_limitFID);
+    size -= position;
+    jobject rarg = NULL;
+    char* rptr;
+    rptr = ptr;
+    jint rcapacity = size;
+    if (rptr != NULL) {
+        rarg = env->NewDirectByteBuffer(rptr, rcapacity);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memchr(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jint rarg = 0;
+    int rvalue = memcmp(ptr0, ptr1, arg2);
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memcpy(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memmove(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memset(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
+    void* rptr = ptr0;
+    jint rcapacity = 1;
+    env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    env->SetIntField(obj, JavaCPP_limitFID, rcapacity);
+    env->SetIntField(obj, JavaCPP_capacityFID, rcapacity);
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 3))) {
+        return;
+    }
+    signed char* rptr = new (std::nothrow) signed char[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put__IB(JNIEnv* env, jobject obj, jint arg0, jbyte arg1) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 4))) {
+        return;
+    }
+    short* rptr = new (std::nothrow) short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jshort JNICALL Java_com_googlecode_javacpp_ShortPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jshort rarg = 0;
+    short rvalue = ptr[arg0];
+    rarg = (jshort)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEnv* env, jobject obj, jint arg0, jshort arg1) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 5))) {
+        return;
+    }
+    int* rptr = new (std::nothrow) int[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_IntPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr[arg0];
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv* env, jobject obj, jint arg0, jint arg1) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 6))) {
+        return;
+    }
+    jlong* rptr = new (std::nothrow) jlong[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_LongPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    jlong rvalue = ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 7))) {
+        return;
+    }
+    float* rptr = new (std::nothrow) float[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jfloat JNICALL Java_com_googlecode_javacpp_FloatPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jfloat rarg = 0;
+    float rvalue = ptr[arg0];
+    rarg = (jfloat)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEnv* env, jobject obj, jint arg0, jfloat arg1) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 8))) {
+        return;
+    }
+    double* rptr = new (std::nothrow) double[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jdouble JNICALL Java_com_googlecode_javacpp_DoublePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jdouble rarg = 0;
+    double rvalue = ptr[arg0];
+    rarg = (jdouble)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 9))) {
+        return;
+    }
+    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jchar JNICALL Java_com_googlecode_javacpp_CharPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jchar rarg = 0;
+    unsigned short rvalue = ptr[arg0];
+    rarg = (jchar)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv* env, jobject obj, jint arg0, jchar arg1) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 10))) {
+        return;
+    }
+    void** rptr = new (std::nothrow) void*[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = ptr[arg0];
+    if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jint arg0, jobject arg1) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = obj;
+    ptr[arg0] = ptr1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 11))) {
+        return;
+    }
+    bool* rptr = new (std::nothrow) bool[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jboolean JNICALL Java_com_googlecode_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jboolean rarg = 0;
+    bool rvalue = (bool)ptr[arg0];
+    rarg = (jboolean)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jint arg0, jboolean arg1) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (bool)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 12))) {
+        return;
+    }
+    long* rptr = new (std::nothrow) long[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    long rvalue = (long)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (long)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 13))) {
+        return;
+    }
+    size_t* rptr = new (std::nothrow) size_t[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    size_t rvalue = (size_t)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (size_t)arg1;
+    return rarg;
+}
+
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1mode_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jobject arg2) {
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_mode_create(arg0, arg1, ptr2);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1decoder_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jobject arg2) {
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_decoder_create(arg0, arg1, ptr2);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1decode(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jshortArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    short* ptr3 = arg3 == NULL ? NULL : env->GetShortArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decode((CELTDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseShortArrayElements(arg3, (jshort*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1encode(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1, jint arg2, jbyteArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    signed char* ptr3 = arg3 == NULL ? NULL : env->GetByteArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_encode((CELTEncoder*)ptr0, (const short*)ptr1, arg2, (unsigned char*)ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseByteArrayElements(arg3, (jbyte*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1decode_1float(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jfloatArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    float* ptr3 = arg3 == NULL ? NULL : env->GetFloatArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decode_float((CELTDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseFloatArrayElements(arg3, (jfloat*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1decoder_1ctl(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr2 = arg2 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decoder_ctl((CELTDecoder*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1decoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_decoder_destroy((CELTDecoder*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1encoder_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jobject arg2) {
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_encoder_create(arg0, arg1, ptr2);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1encoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_encoder_destroy((CELTEncoder*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1mode_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_mode_destroy((CELTMode*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT11_celt_1mode_1info(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_mode_info((const CELTMode*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+
+}
+
diff --git a/jni/celt7.cpp b/jni/celt7.cpp
new file mode 100644
index 0000000..6ee7ca5
--- /dev/null
+++ b/jni/celt7.cpp
@@ -0,0 +1,1241 @@
+/* DO NOT EDIT THIS FILE - IT IS MACHINE GENERATED */
+
+
+#ifdef __APPLE__
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __attribute__((visibility("default")))
+    #define JNIIMPORT
+    #define JNICALL
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#ifdef _WIN32
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __declspec(dllexport)
+    #define JNIIMPORT __declspec(dllimport)
+    #define JNICALL __stdcall
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#include <jni.h>
+#ifdef ANDROID
+    #include <android/log.h>
+    #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
+    #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
+#endif
+
+#include <stddef.h>
+#ifndef _WIN32
+    #include <stdint.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <exception>
+#include <new>
+
+#define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
+#define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))
+
+#if defined(_MSC_VER)
+    #define JavaCPP_noinline __declspec(noinline)
+    #define JavaCPP_hidden /* hidden by default */
+#elif defined(__GNUC__)
+    #define JavaCPP_noinline __attribute__((noinline))
+    #define JavaCPP_hidden   __attribute__((visibility("hidden")))
+#else
+    #define JavaCPP_noinline
+    #define JavaCPP_hidden
+#endif
+
+extern "C" {
+#include <celt.h>
+#include <celt_types.h>
+}
+
+static JavaVM* JavaCPP_vm = NULL;
+static const char* JavaCPP_classNames[15] = {
+        "com/googlecode/javacpp/Loader",
+        "com/googlecode/javacpp/Pointer",
+        "java/lang/NullPointerException",
+        "com/googlecode/javacpp/BytePointer",
+        "com/googlecode/javacpp/ShortPointer",
+        "com/googlecode/javacpp/IntPointer",
+        "com/googlecode/javacpp/LongPointer",
+        "com/googlecode/javacpp/FloatPointer",
+        "com/googlecode/javacpp/DoublePointer",
+        "com/googlecode/javacpp/CharPointer",
+        "com/googlecode/javacpp/PointerPointer",
+        "com/googlecode/javacpp/BoolPointer",
+        "com/googlecode/javacpp/CLongPointer",
+        "com/googlecode/javacpp/SizeTPointer",
+        "java/lang/RuntimeException" };
+static jclass JavaCPP_classes[15] = { NULL };
+static jmethodID JavaCPP_initMID = NULL;
+static jfieldID JavaCPP_addressFID = NULL;
+static jfieldID JavaCPP_positionFID = NULL;
+static jfieldID JavaCPP_limitFID = NULL;
+static jfieldID JavaCPP_capacityFID = NULL;
+
+static inline void JavaCPP_log(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+#ifdef ANDROID
+    __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
+#else
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+#endif
+    va_end(ap);
+}
+
+static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
+    if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
+        jclass cls = env->FindClass(JavaCPP_classNames[i]);
+        if (cls == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
+        if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        env->PopLocalFrame(NULL);
+    }
+    return JavaCPP_classes[i];
+}
+
+class JavaCPP_hidden JavaCPP_exception : public std::exception {
+public:
+    JavaCPP_exception(const char* str) throw() {
+        if (str == NULL) {
+            strcpy(msg, "Unknown exception.");
+        } else {
+            strncpy(msg, str, sizeof(msg));
+            msg[sizeof(msg) - 1] = 0;
+        }
+    }
+    virtual const char* what() const throw() { return msg; }
+    char msg[1024];
+};
+
+static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
+    jstring str = NULL;
+    try {
+        throw;
+    } catch (std::exception& e) {
+        str = env->NewStringUTF(e.what());
+    } catch (...) {
+        str = env->NewStringUTF("Unknown exception.");
+    }
+    jclass cls = JavaCPP_getClass(env, i);
+    jmethodID mid = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
+    if (mid == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting constructor ID of %s.", JavaCPP_classNames[i]);
+        return NULL;
+    } else {
+        return (jthrowable)env->NewObject(cls, mid, str);
+    }
+}
+
+
+
+static void JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray(signed char* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray(short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray(int* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray(jlong* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray(float* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray(double* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray(unsigned short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray(void** p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray(bool* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray(long* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray(size_t* p) { delete[] p; }
+
+extern "C" {
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnLoad().");
+        return JNI_ERR;
+    }
+    if (JavaCPP_vm == vm) {
+        return env->GetVersion();
+    }
+    JavaCPP_vm = vm;
+    const char* members[15][1] = {
+            {  },
+            { "sizeof" },
+            {  },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            {  } };
+    int offsets[15][1] = {
+            {  },
+            { sizeof(void*) },
+            {  },
+            { sizeof(signed char) },
+            { sizeof(short) },
+            { sizeof(int) },
+            { sizeof(jlong) },
+            { sizeof(float) },
+            { sizeof(double) },
+            { sizeof(unsigned short) },
+            { sizeof(void*) },
+            { sizeof(bool) },
+            { sizeof(long) },
+            { sizeof(size_t) },
+            {  } };
+    int memberOffsetSizes[15] = { 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
+    jmethodID putMemberOffsetMID = env->GetStaticMethodID(JavaCPP_getClass(env, 0), "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)V");
+    if (putMemberOffsetMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Loader.putMemberOffset().");
+        return JNI_ERR;
+    }
+    for (int i = 0; i < 15 && !env->ExceptionCheck(); i++) {
+        for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
+            if (env->PushLocalFrame(2) == 0) {
+                jvalue args[3];
+                args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
+                args[1].l = env->NewStringUTF(members[i][j]);
+                args[2].i = offsets[i][j];
+                env->CallStaticVoidMethodA(JavaCPP_getClass(env, 0), putMemberOffsetMID, args);
+                env->PopLocalFrame(NULL);
+            }
+        }
+    }
+    JavaCPP_initMID = env->GetMethodID(JavaCPP_getClass(env, 1), "init", "(JIJ)V");
+    if (JavaCPP_initMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Pointer.init().");
+        return JNI_ERR;
+    }
+    JavaCPP_addressFID = env->GetFieldID(JavaCPP_getClass(env, 1), "address", "J");
+    if (JavaCPP_addressFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.address.");
+        return JNI_ERR;
+    }
+    JavaCPP_positionFID = env->GetFieldID(JavaCPP_getClass(env, 1), "position", "I");
+    if (JavaCPP_positionFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.position.");
+        return JNI_ERR;
+    }
+    JavaCPP_limitFID = env->GetFieldID(JavaCPP_getClass(env, 1), "limit", "I");
+    if (JavaCPP_limitFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.limit.");
+        return JNI_ERR;
+    }
+    JavaCPP_capacityFID = env->GetFieldID(JavaCPP_getClass(env, 1), "capacity", "I");
+    if (JavaCPP_capacityFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.capacity.");
+        return JNI_ERR;
+    }
+    return env->GetVersion();
+}
+
+
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnUnLoad().");
+        return;
+    }
+    for (int i = 0; i < 15; i++) {
+        env->DeleteWeakGlobalRef(JavaCPP_classes[i]);
+        JavaCPP_classes[i] = NULL;
+    }
+    JavaCPP_vm = NULL;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
+    void* allocatedAddress = jlong_to_ptr(arg0);
+    void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
+    if (deallocatorAddress != NULL && allocatedAddress != NULL) {
+        (*deallocatorAddress)(allocatedAddress);
+    }
+
+}
+
+
+
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
+    char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint size = env->GetIntField(obj, JavaCPP_limitFID);
+    size -= position;
+    jobject rarg = NULL;
+    char* rptr;
+    rptr = ptr;
+    jint rcapacity = size;
+    if (rptr != NULL) {
+        rarg = env->NewDirectByteBuffer(rptr, rcapacity);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memchr(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jint rarg = 0;
+    int rvalue = memcmp(ptr0, ptr1, arg2);
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memcpy(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memmove(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memset(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
+    void* rptr = ptr0;
+    jint rcapacity = 1;
+    env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    env->SetIntField(obj, JavaCPP_limitFID, rcapacity);
+    env->SetIntField(obj, JavaCPP_capacityFID, rcapacity);
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 3))) {
+        return;
+    }
+    signed char* rptr = new (std::nothrow) signed char[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put__IB(JNIEnv* env, jobject obj, jint arg0, jbyte arg1) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 4))) {
+        return;
+    }
+    short* rptr = new (std::nothrow) short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jshort JNICALL Java_com_googlecode_javacpp_ShortPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jshort rarg = 0;
+    short rvalue = ptr[arg0];
+    rarg = (jshort)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEnv* env, jobject obj, jint arg0, jshort arg1) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 5))) {
+        return;
+    }
+    int* rptr = new (std::nothrow) int[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_IntPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr[arg0];
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv* env, jobject obj, jint arg0, jint arg1) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 6))) {
+        return;
+    }
+    jlong* rptr = new (std::nothrow) jlong[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_LongPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    jlong rvalue = ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 7))) {
+        return;
+    }
+    float* rptr = new (std::nothrow) float[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jfloat JNICALL Java_com_googlecode_javacpp_FloatPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jfloat rarg = 0;
+    float rvalue = ptr[arg0];
+    rarg = (jfloat)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEnv* env, jobject obj, jint arg0, jfloat arg1) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 8))) {
+        return;
+    }
+    double* rptr = new (std::nothrow) double[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jdouble JNICALL Java_com_googlecode_javacpp_DoublePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jdouble rarg = 0;
+    double rvalue = ptr[arg0];
+    rarg = (jdouble)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 9))) {
+        return;
+    }
+    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jchar JNICALL Java_com_googlecode_javacpp_CharPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jchar rarg = 0;
+    unsigned short rvalue = ptr[arg0];
+    rarg = (jchar)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv* env, jobject obj, jint arg0, jchar arg1) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 10))) {
+        return;
+    }
+    void** rptr = new (std::nothrow) void*[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = ptr[arg0];
+    if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jint arg0, jobject arg1) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = obj;
+    ptr[arg0] = ptr1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 11))) {
+        return;
+    }
+    bool* rptr = new (std::nothrow) bool[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jboolean JNICALL Java_com_googlecode_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jboolean rarg = 0;
+    bool rvalue = (bool)ptr[arg0];
+    rarg = (jboolean)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jint arg0, jboolean arg1) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (bool)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 12))) {
+        return;
+    }
+    long* rptr = new (std::nothrow) long[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    long rvalue = (long)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (long)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 13))) {
+        return;
+    }
+    size_t* rptr = new (std::nothrow) size_t[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    size_t rvalue = (size_t)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (size_t)arg1;
+    return rarg;
+}
+
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1mode_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jobject arg2) {
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_mode_create(arg0, arg1, ptr2);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1decoder_1create(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_decoder_create((CELTMode*)ptr0, arg1, ptr2);
+        if (rptr == (CELTMode*)ptr0) {
+            rarg = arg0;
+        } else if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1decode(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jshortArray arg3) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    short* ptr3 = arg3 == NULL ? NULL : env->GetShortArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decode((CELTDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseShortArrayElements(arg3, (jshort*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1encode(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1, jshortArray arg2, jbyteArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    short* ptr2 = arg2 == NULL ? NULL : env->GetShortArrayElements(arg2, NULL);
+    signed char* ptr3 = arg3 == NULL ? NULL : env->GetByteArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_encode((CELTEncoder *)ptr0, (const short *)ptr1, (short *)ptr2, (unsigned char *)ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (arg2 != NULL) env->ReleaseShortArrayElements(arg2, (jshort*)ptr2, 0);
+    if (arg3 != NULL) env->ReleaseByteArrayElements(arg3, (jbyte*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1decode_1float(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jfloatArray arg3) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    float* ptr3 = arg3 == NULL ? NULL : env->GetFloatArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decode_float((CELTDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseFloatArrayElements(arg3, (jfloat*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1decoder_1ctl(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr2 = arg2 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_decoder_ctl((CELTDecoder*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1decoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_decoder_destroy((CELTDecoder*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1encoder_1create(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = celt_encoder_create((const CELTMode *)ptr0, arg1, ptr2);
+        if (rptr == (const CELTMode *)ptr0) {
+            rarg = arg0;
+        } else if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1encoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_encoder_destroy((CELTEncoder *)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1mode_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        celt_mode_destroy((CELTMode*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_CELT7_celt_1mode_1info(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = celt_mode_info((const CELTMode*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+
+}
+
diff --git a/jni/opus b/jni/opus
new file mode 160000
+Subproject ecc81ee6299dfe0f96f0d4fed3d24917c786fce
diff --git a/jni/opus.cpp b/jni/opus.cpp
new file mode 100644
index 0000000..a127e45
--- /dev/null
+++ b/jni/opus.cpp
@@ -0,0 +1,1349 @@
+/* DO NOT EDIT THIS FILE - IT IS MACHINE GENERATED */
+
+
+#ifdef __APPLE__
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __attribute__((visibility("default")))
+    #define JNIIMPORT
+    #define JNICALL
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#ifdef _WIN32
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __declspec(dllexport)
+    #define JNIIMPORT __declspec(dllimport)
+    #define JNICALL __stdcall
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#include <jni.h>
+#ifdef ANDROID
+    #include <android/log.h>
+    #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
+    #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
+#endif
+
+#include <stddef.h>
+#ifndef _WIN32
+    #include <stdint.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <exception>
+#include <new>
+
+#define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
+#define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))
+
+#if defined(_MSC_VER)
+    #define JavaCPP_noinline __declspec(noinline)
+    #define JavaCPP_hidden /* hidden by default */
+#elif defined(__GNUC__)
+    #define JavaCPP_noinline __attribute__((noinline))
+    #define JavaCPP_hidden   __attribute__((visibility("hidden")))
+#else
+    #define JavaCPP_noinline
+    #define JavaCPP_hidden
+#endif
+
+extern "C" {
+#include <opus.h>
+#include <opus_types.h>
+}
+
+static JavaVM* JavaCPP_vm = NULL;
+static const char* JavaCPP_classNames[15] = {
+        "com/googlecode/javacpp/Loader",
+        "com/googlecode/javacpp/Pointer",
+        "java/lang/NullPointerException",
+        "com/googlecode/javacpp/BytePointer",
+        "com/googlecode/javacpp/ShortPointer",
+        "com/googlecode/javacpp/IntPointer",
+        "com/googlecode/javacpp/LongPointer",
+        "com/googlecode/javacpp/FloatPointer",
+        "com/googlecode/javacpp/DoublePointer",
+        "com/googlecode/javacpp/CharPointer",
+        "com/googlecode/javacpp/PointerPointer",
+        "com/googlecode/javacpp/BoolPointer",
+        "com/googlecode/javacpp/CLongPointer",
+        "com/googlecode/javacpp/SizeTPointer",
+        "java/lang/RuntimeException" };
+static jclass JavaCPP_classes[15] = { NULL };
+static jmethodID JavaCPP_initMID = NULL;
+static jfieldID JavaCPP_addressFID = NULL;
+static jfieldID JavaCPP_positionFID = NULL;
+static jfieldID JavaCPP_limitFID = NULL;
+static jfieldID JavaCPP_capacityFID = NULL;
+
+static inline void JavaCPP_log(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+#ifdef ANDROID
+    __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
+#else
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+#endif
+    va_end(ap);
+}
+
+static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
+    if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
+        jclass cls = env->FindClass(JavaCPP_classNames[i]);
+        if (cls == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
+        if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        env->PopLocalFrame(NULL);
+    }
+    return JavaCPP_classes[i];
+}
+
+class JavaCPP_hidden JavaCPP_exception : public std::exception {
+public:
+    JavaCPP_exception(const char* str) throw() {
+        if (str == NULL) {
+            strcpy(msg, "Unknown exception.");
+        } else {
+            strncpy(msg, str, sizeof(msg));
+            msg[sizeof(msg) - 1] = 0;
+        }
+    }
+    virtual const char* what() const throw() { return msg; }
+    char msg[1024];
+};
+
+static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
+    jstring str = NULL;
+    try {
+        throw;
+    } catch (std::exception& e) {
+        str = env->NewStringUTF(e.what());
+    } catch (...) {
+        str = env->NewStringUTF("Unknown exception.");
+    }
+    jclass cls = JavaCPP_getClass(env, i);
+    jmethodID mid = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
+    if (mid == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting constructor ID of %s.", JavaCPP_classNames[i]);
+        return NULL;
+    } else {
+        return (jthrowable)env->NewObject(cls, mid, str);
+    }
+}
+
+
+
+static void JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray(signed char* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray(short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray(int* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray(jlong* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray(float* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray(double* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray(unsigned short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray(void** p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray(bool* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray(long* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray(size_t* p) { delete[] p; }
+
+extern "C" {
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnLoad().");
+        return JNI_ERR;
+    }
+    if (JavaCPP_vm == vm) {
+        return env->GetVersion();
+    }
+    JavaCPP_vm = vm;
+    const char* members[15][1] = {
+            {  },
+            { "sizeof" },
+            {  },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            {  } };
+    int offsets[15][1] = {
+            {  },
+            { sizeof(void*) },
+            {  },
+            { sizeof(signed char) },
+            { sizeof(short) },
+            { sizeof(int) },
+            { sizeof(jlong) },
+            { sizeof(float) },
+            { sizeof(double) },
+            { sizeof(unsigned short) },
+            { sizeof(void*) },
+            { sizeof(bool) },
+            { sizeof(long) },
+            { sizeof(size_t) },
+            {  } };
+    int memberOffsetSizes[15] = { 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
+    jmethodID putMemberOffsetMID = env->GetStaticMethodID(JavaCPP_getClass(env, 0), "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)V");
+    if (putMemberOffsetMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Loader.putMemberOffset().");
+        return JNI_ERR;
+    }
+    for (int i = 0; i < 15 && !env->ExceptionCheck(); i++) {
+        for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
+            if (env->PushLocalFrame(2) == 0) {
+                jvalue args[3];
+                args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
+                args[1].l = env->NewStringUTF(members[i][j]);
+                args[2].i = offsets[i][j];
+                env->CallStaticVoidMethodA(JavaCPP_getClass(env, 0), putMemberOffsetMID, args);
+                env->PopLocalFrame(NULL);
+            }
+        }
+    }
+    JavaCPP_initMID = env->GetMethodID(JavaCPP_getClass(env, 1), "init", "(JIJ)V");
+    if (JavaCPP_initMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Pointer.init().");
+        return JNI_ERR;
+    }
+    JavaCPP_addressFID = env->GetFieldID(JavaCPP_getClass(env, 1), "address", "J");
+    if (JavaCPP_addressFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.address.");
+        return JNI_ERR;
+    }
+    JavaCPP_positionFID = env->GetFieldID(JavaCPP_getClass(env, 1), "position", "I");
+    if (JavaCPP_positionFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.position.");
+        return JNI_ERR;
+    }
+    JavaCPP_limitFID = env->GetFieldID(JavaCPP_getClass(env, 1), "limit", "I");
+    if (JavaCPP_limitFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.limit.");
+        return JNI_ERR;
+    }
+    JavaCPP_capacityFID = env->GetFieldID(JavaCPP_getClass(env, 1), "capacity", "I");
+    if (JavaCPP_capacityFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.capacity.");
+        return JNI_ERR;
+    }
+    return env->GetVersion();
+}
+
+
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnUnLoad().");
+        return;
+    }
+    for (int i = 0; i < 15; i++) {
+        env->DeleteWeakGlobalRef(JavaCPP_classes[i]);
+        JavaCPP_classes[i] = NULL;
+    }
+    JavaCPP_vm = NULL;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
+    void* allocatedAddress = jlong_to_ptr(arg0);
+    void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
+    if (deallocatorAddress != NULL && allocatedAddress != NULL) {
+        (*deallocatorAddress)(allocatedAddress);
+    }
+
+}
+
+
+
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
+    char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint size = env->GetIntField(obj, JavaCPP_limitFID);
+    size -= position;
+    jobject rarg = NULL;
+    char* rptr;
+    rptr = ptr;
+    jint rcapacity = size;
+    if (rptr != NULL) {
+        rarg = env->NewDirectByteBuffer(rptr, rcapacity);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memchr(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jint rarg = 0;
+    int rvalue = memcmp(ptr0, ptr1, arg2);
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memcpy(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memmove(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memset(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
+    void* rptr = ptr0;
+    jint rcapacity = 1;
+    env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    env->SetIntField(obj, JavaCPP_limitFID, rcapacity);
+    env->SetIntField(obj, JavaCPP_capacityFID, rcapacity);
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 3))) {
+        return;
+    }
+    signed char* rptr = new (std::nothrow) signed char[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put__IB(JNIEnv* env, jobject obj, jint arg0, jbyte arg1) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 4))) {
+        return;
+    }
+    short* rptr = new (std::nothrow) short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jshort JNICALL Java_com_googlecode_javacpp_ShortPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jshort rarg = 0;
+    short rvalue = ptr[arg0];
+    rarg = (jshort)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEnv* env, jobject obj, jint arg0, jshort arg1) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 5))) {
+        return;
+    }
+    int* rptr = new (std::nothrow) int[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_IntPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr[arg0];
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv* env, jobject obj, jint arg0, jint arg1) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 6))) {
+        return;
+    }
+    jlong* rptr = new (std::nothrow) jlong[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_LongPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    jlong rvalue = ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 7))) {
+        return;
+    }
+    float* rptr = new (std::nothrow) float[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jfloat JNICALL Java_com_googlecode_javacpp_FloatPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jfloat rarg = 0;
+    float rvalue = ptr[arg0];
+    rarg = (jfloat)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEnv* env, jobject obj, jint arg0, jfloat arg1) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 8))) {
+        return;
+    }
+    double* rptr = new (std::nothrow) double[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jdouble JNICALL Java_com_googlecode_javacpp_DoublePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jdouble rarg = 0;
+    double rvalue = ptr[arg0];
+    rarg = (jdouble)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 9))) {
+        return;
+    }
+    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jchar JNICALL Java_com_googlecode_javacpp_CharPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jchar rarg = 0;
+    unsigned short rvalue = ptr[arg0];
+    rarg = (jchar)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv* env, jobject obj, jint arg0, jchar arg1) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 10))) {
+        return;
+    }
+    void** rptr = new (std::nothrow) void*[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = ptr[arg0];
+    if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jint arg0, jobject arg1) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = obj;
+    ptr[arg0] = ptr1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 11))) {
+        return;
+    }
+    bool* rptr = new (std::nothrow) bool[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jboolean JNICALL Java_com_googlecode_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jboolean rarg = 0;
+    bool rvalue = (bool)ptr[arg0];
+    rarg = (jboolean)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jint arg0, jboolean arg1) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (bool)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 12))) {
+        return;
+    }
+    long* rptr = new (std::nothrow) long[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    long rvalue = (long)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (long)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 13))) {
+        return;
+    }
+    size_t* rptr = new (std::nothrow) size_t[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    size_t rvalue = (size_t)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (size_t)arg1;
+    return rarg;
+}
+
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1nb_1channels(JNIEnv* env, jclass cls, jobject arg0) {
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_packet_get_nb_channels((const unsigned char*)ptr0);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1nb_1frames(JNIEnv* env, jclass cls, jobject arg0, jint arg1) {
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_packet_get_nb_frames((const unsigned char*)ptr0, arg1);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1nb_1samples(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jint arg2) {
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_packet_get_nb_samples((const unsigned char*)ptr0, arg1, arg2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encoder_1get_1size(JNIEnv* env, jclass cls, jint arg0) {
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_encoder_get_size(arg0);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encoder_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jint arg2, jobject arg3) {
+    int* ptr3 = arg3 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
+    jint position3 = arg3 == NULL ? 0 : env->GetIntField(arg3, JavaCPP_positionFID);
+    ptr3 += position3;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = opus_encoder_create(arg0, arg1, arg2, ptr3);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encoder_1init(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jint arg2, jint arg3) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_encoder_init((OpusEncoder*)ptr0, arg1, arg2, arg3);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encode(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1, jint arg2, jbyteArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    signed char* ptr3 = arg3 == NULL ? NULL : env->GetByteArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_encode((OpusEncoder*)ptr0, (const short*)ptr1, arg2, (unsigned char*)ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseByteArrayElements(arg3, (jbyte*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encode_1float(JNIEnv* env, jclass cls, jobject arg0, jfloatArray arg1, jint arg2, jbyteArray arg3, jint arg4) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    float* ptr1 = arg1 == NULL ? NULL : env->GetFloatArrayElements(arg1, NULL);
+    signed char* ptr3 = arg3 == NULL ? NULL : env->GetByteArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_encode_float((OpusEncoder*)ptr0, (const float*)ptr1, arg2, (unsigned char*)ptr3, arg4);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseFloatArrayElements(arg1, (jfloat*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseByteArrayElements(arg3, (jbyte*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        opus_encoder_destroy((OpusEncoder*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1encoder_1ctl(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr2 = arg2 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_encoder_ctl((OpusEncoder*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1get_1size(JNIEnv* env, jclass cls, jint arg0) {
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_decoder_get_size(arg0);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1create(JNIEnv* env, jclass cls, jint arg0, jint arg1, jobject arg2) {
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = opus_decoder_create(arg0, arg1, ptr2);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1init(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jint arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_decoder_init((OpusDecoder*)ptr0, arg1, arg2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jshortArray arg3, jint arg4, jint arg5) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    short* ptr3 = arg3 == NULL ? NULL : env->GetShortArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_decode((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseShortArrayElements(arg3, (jshort*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode_1float(JNIEnv* env, jclass cls, jobject arg0, jbyteArray arg1, jint arg2, jfloatArray arg3, jint arg4, jint arg5) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    signed char* ptr1 = arg1 == NULL ? NULL : env->GetByteArrayElements(arg1, NULL);
+    float* ptr3 = arg3 == NULL ? NULL : env->GetFloatArrayElements(arg3, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_decode_float((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (arg1 != NULL) env->ReleaseByteArrayElements(arg1, (jbyte*)ptr1, 0);
+    if (arg3 != NULL) env->ReleaseFloatArrayElements(arg3, (jfloat*)ptr3, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        opus_decoder_destroy((OpusDecoder*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1bandwidth(JNIEnv* env, jclass cls, jobject arg0) {
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_packet_get_bandwidth((const unsigned char*)ptr0);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1samples_1per_1frame(JNIEnv* env, jclass cls, jobject arg0, jint arg1) {
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = opus_packet_get_samples_per_frame((const unsigned char*)ptr0, arg1);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 14);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+
+}
+
diff --git a/jni/speex b/jni/speex
new file mode 160000
+Subproject a6d05eb5ff9d5062852cdf7df574bec728921ef
diff --git a/jni/speex.cpp b/jni/speex.cpp
new file mode 100644
index 0000000..ae36a1b
--- /dev/null
+++ b/jni/speex.cpp
@@ -0,0 +1,1507 @@
+/* DO NOT EDIT THIS FILE - IT IS MACHINE GENERATED */
+
+
+#ifdef __APPLE__
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __attribute__((visibility("default")))
+    #define JNIIMPORT
+    #define JNICALL
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#ifdef _WIN32
+    #define _JAVASOFT_JNI_MD_H_
+
+    #define JNIEXPORT __declspec(dllexport)
+    #define JNIIMPORT __declspec(dllimport)
+    #define JNICALL __stdcall
+
+    typedef int jint;
+    typedef long long jlong;
+    typedef signed char jbyte;
+#endif
+#include <jni.h>
+#ifdef ANDROID
+    #include <android/log.h>
+    #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
+    #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
+#endif
+
+#include <stddef.h>
+#ifndef _WIN32
+    #include <stdint.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <exception>
+#include <new>
+
+#define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
+#define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))
+
+#if defined(_MSC_VER)
+    #define JavaCPP_noinline __declspec(noinline)
+    #define JavaCPP_hidden /* hidden by default */
+#elif defined(__GNUC__)
+    #define JavaCPP_noinline __attribute__((noinline))
+    #define JavaCPP_hidden   __attribute__((visibility("hidden")))
+#else
+    #define JavaCPP_noinline
+    #define JavaCPP_hidden
+#endif
+
+extern "C" {
+#include <speex/speex.h>
+#include <speex/speex_types.h>
+#include <speex/speex_jitter.h>
+#include <speex/speex_preprocess.h>
+#include <speex/speex_resampler.h>
+}
+
+static JavaVM* JavaCPP_vm = NULL;
+static const char* JavaCPP_classNames[16] = {
+        "com/googlecode/javacpp/Loader",
+        "com/googlecode/javacpp/Pointer",
+        "java/lang/NullPointerException",
+        "com/googlecode/javacpp/BytePointer",
+        "com/googlecode/javacpp/ShortPointer",
+        "com/googlecode/javacpp/IntPointer",
+        "com/googlecode/javacpp/LongPointer",
+        "com/googlecode/javacpp/FloatPointer",
+        "com/googlecode/javacpp/DoublePointer",
+        "com/googlecode/javacpp/CharPointer",
+        "com/googlecode/javacpp/PointerPointer",
+        "com/googlecode/javacpp/BoolPointer",
+        "com/googlecode/javacpp/CLongPointer",
+        "com/googlecode/javacpp/SizeTPointer",
+        "com/morlunk/jumble/audio/javacpp/Speex$JitterBufferPacket",
+        "java/lang/RuntimeException" };
+static jclass JavaCPP_classes[16] = { NULL };
+static jmethodID JavaCPP_initMID = NULL;
+static jfieldID JavaCPP_addressFID = NULL;
+static jfieldID JavaCPP_positionFID = NULL;
+static jfieldID JavaCPP_limitFID = NULL;
+static jfieldID JavaCPP_capacityFID = NULL;
+
+static inline void JavaCPP_log(const char* fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+#ifdef ANDROID
+    __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
+#else
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+#endif
+    va_end(ap);
+}
+
+static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
+    if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
+        jclass cls = env->FindClass(JavaCPP_classNames[i]);
+        if (cls == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
+        if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
+            JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
+            return NULL;
+        }
+        env->PopLocalFrame(NULL);
+    }
+    return JavaCPP_classes[i];
+}
+
+class JavaCPP_hidden JavaCPP_exception : public std::exception {
+public:
+    JavaCPP_exception(const char* str) throw() {
+        if (str == NULL) {
+            strcpy(msg, "Unknown exception.");
+        } else {
+            strncpy(msg, str, sizeof(msg));
+            msg[sizeof(msg) - 1] = 0;
+        }
+    }
+    virtual const char* what() const throw() { return msg; }
+    char msg[1024];
+};
+
+static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
+    jstring str = NULL;
+    try {
+        throw;
+    } catch (std::exception& e) {
+        str = env->NewStringUTF(e.what());
+    } catch (...) {
+        str = env->NewStringUTF("Unknown exception.");
+    }
+    jclass cls = JavaCPP_getClass(env, i);
+    jmethodID mid = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
+    if (mid == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting constructor ID of %s.", JavaCPP_classNames[i]);
+        return NULL;
+    } else {
+        return (jthrowable)env->NewObject(cls, mid, str);
+    }
+}
+
+
+
+static void JavaCPP_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_deallocate(::_JitterBufferPacket* p) { delete p; }
+static void JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray(signed char* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray(short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray(int* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray(jlong* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray(float* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray(double* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray(unsigned short* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray(void** p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray(bool* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray(long* p) { delete[] p; }
+static void JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray(size_t* p) { delete[] p; }
+
+extern "C" {
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnLoad().");
+        return JNI_ERR;
+    }
+    if (JavaCPP_vm == vm) {
+        return env->GetVersion();
+    }
+    JavaCPP_vm = vm;
+    const char* members[16][6] = {
+            {  },
+            { "sizeof" },
+            {  },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof" },
+            { "sizeof", "timestamp", "data", "sequence", "span", "len" },
+            {  } };
+    int offsets[16][6] = {
+            {  },
+            { sizeof(void*) },
+            {  },
+            { sizeof(signed char) },
+            { sizeof(short) },
+            { sizeof(int) },
+            { sizeof(jlong) },
+            { sizeof(float) },
+            { sizeof(double) },
+            { sizeof(unsigned short) },
+            { sizeof(void*) },
+            { sizeof(bool) },
+            { sizeof(long) },
+            { sizeof(size_t) },
+            { sizeof(::_JitterBufferPacket), offsetof(::_JitterBufferPacket,timestamp), offsetof(::_JitterBufferPacket,data), offsetof(::_JitterBufferPacket,sequence), offsetof(::_JitterBufferPacket,span), offsetof(::_JitterBufferPacket,len) },
+            {  } };
+    int memberOffsetSizes[16] = { 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 0 };
+    jmethodID putMemberOffsetMID = env->GetStaticMethodID(JavaCPP_getClass(env, 0), "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)V");
+    if (putMemberOffsetMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Loader.putMemberOffset().");
+        return JNI_ERR;
+    }
+    for (int i = 0; i < 16 && !env->ExceptionCheck(); i++) {
+        for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
+            if (env->PushLocalFrame(2) == 0) {
+                jvalue args[3];
+                args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
+                args[1].l = env->NewStringUTF(members[i][j]);
+                args[2].i = offsets[i][j];
+                env->CallStaticVoidMethodA(JavaCPP_getClass(env, 0), putMemberOffsetMID, args);
+                env->PopLocalFrame(NULL);
+            }
+        }
+    }
+    JavaCPP_initMID = env->GetMethodID(JavaCPP_getClass(env, 1), "init", "(JIJ)V");
+    if (JavaCPP_initMID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting method ID of Pointer.init().");
+        return JNI_ERR;
+    }
+    JavaCPP_addressFID = env->GetFieldID(JavaCPP_getClass(env, 1), "address", "J");
+    if (JavaCPP_addressFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.address.");
+        return JNI_ERR;
+    }
+    JavaCPP_positionFID = env->GetFieldID(JavaCPP_getClass(env, 1), "position", "I");
+    if (JavaCPP_positionFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.position.");
+        return JNI_ERR;
+    }
+    JavaCPP_limitFID = env->GetFieldID(JavaCPP_getClass(env, 1), "limit", "I");
+    if (JavaCPP_limitFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.limit.");
+        return JNI_ERR;
+    }
+    JavaCPP_capacityFID = env->GetFieldID(JavaCPP_getClass(env, 1), "capacity", "I");
+    if (JavaCPP_capacityFID == NULL || env->ExceptionCheck()) {
+        JavaCPP_log("Error getting field ID of Pointer.capacity.");
+        return JNI_ERR;
+    }
+    return env->GetVersion();
+}
+
+
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_6 inside JNI_OnUnLoad().");
+        return;
+    }
+    for (int i = 0; i < 16; i++) {
+        env->DeleteWeakGlobalRef(JavaCPP_classes[i]);
+        JavaCPP_classes[i] = NULL;
+    }
+    JavaCPP_vm = NULL;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
+    void* allocatedAddress = jlong_to_ptr(arg0);
+    void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
+    if (deallocatorAddress != NULL && allocatedAddress != NULL) {
+        (*deallocatorAddress)(allocatedAddress);
+    }
+
+}
+
+
+
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
+    char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint size = env->GetIntField(obj, JavaCPP_limitFID);
+    size -= position;
+    jobject rarg = NULL;
+    char* rptr;
+    rptr = ptr;
+    jint rcapacity = size;
+    if (rptr != NULL) {
+        rarg = env->NewDirectByteBuffer(rptr, rcapacity);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memchr(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jint rarg = 0;
+    int rvalue = memcmp(ptr0, ptr1, arg2);
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memcpy(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memmove(ptr0, ptr1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr == ptr1) {
+        rarg = arg1;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = memset(ptr0, arg1, arg2);
+    if (rptr == ptr0) {
+        rarg = arg0;
+    } else if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
+    void* rptr = ptr0;
+    jint rcapacity = 1;
+    env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    env->SetIntField(obj, JavaCPP_limitFID, rcapacity);
+    env->SetIntField(obj, JavaCPP_capacityFID, rcapacity);
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 3))) {
+        return;
+    }
+    signed char* rptr = new (std::nothrow) signed char[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BytePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put__IB(JNIEnv* env, jobject obj, jint arg0, jbyte arg1) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 4))) {
+        return;
+    }
+    short* rptr = new (std::nothrow) short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_ShortPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jshort JNICALL Java_com_googlecode_javacpp_ShortPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jshort rarg = 0;
+    short rvalue = ptr[arg0];
+    rarg = (jshort)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEnv* env, jobject obj, jint arg0, jshort arg1) {
+    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 5))) {
+        return;
+    }
+    int* rptr = new (std::nothrow) int[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_IntPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jint JNICALL Java_com_googlecode_javacpp_IntPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr[arg0];
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv* env, jobject obj, jint arg0, jint arg1) {
+    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 6))) {
+        return;
+    }
+    jlong* rptr = new (std::nothrow) jlong[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_LongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_LongPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    jlong rvalue = ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 7))) {
+        return;
+    }
+    float* rptr = new (std::nothrow) float[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_FloatPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jfloat JNICALL Java_com_googlecode_javacpp_FloatPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jfloat rarg = 0;
+    float rvalue = ptr[arg0];
+    rarg = (jfloat)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEnv* env, jobject obj, jint arg0, jfloat arg1) {
+    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 8))) {
+        return;
+    }
+    double* rptr = new (std::nothrow) double[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_DoublePointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jdouble JNICALL Java_com_googlecode_javacpp_DoublePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jdouble rarg = 0;
+    double rvalue = ptr[arg0];
+    rarg = (jdouble)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
+    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 9))) {
+        return;
+    }
+    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CharPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jchar JNICALL Java_com_googlecode_javacpp_CharPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jchar rarg = 0;
+    unsigned short rvalue = ptr[arg0];
+    rarg = (jchar)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
+    jobject rarg = obj;
+    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
+    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv* env, jobject obj, jint arg0, jchar arg1) {
+    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 10))) {
+        return;
+    }
+    void** rptr = new (std::nothrow) void*[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_PointerPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = NULL;
+    void* rptr;
+    rptr = ptr[arg0];
+    if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jint arg0, jobject arg1) {
+    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jobject rarg = obj;
+    ptr[arg0] = ptr1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 11))) {
+        return;
+    }
+    bool* rptr = new (std::nothrow) bool[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_BoolPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jboolean JNICALL Java_com_googlecode_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jboolean rarg = 0;
+    bool rvalue = (bool)ptr[arg0];
+    rarg = (jboolean)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jint arg0, jboolean arg1) {
+    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (bool)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 12))) {
+        return;
+    }
+    long* rptr = new (std::nothrow) long[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_CLongPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    long rvalue = (long)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (long)arg1;
+    return rarg;
+}
+
+JNIEXPORT void JNICALL Java_com_googlecode_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 13))) {
+        return;
+    }
+    size_t* rptr = new (std::nothrow) size_t[arg0];
+    jint rcapacity = arg0;
+    jvalue args[3];
+    args[0].j = ptr_to_jlong(rptr);
+    args[1].i = rcapacity;
+    args[2].j = ptr_to_jlong(&JavaCPP_com_googlecode_javacpp_SizeTPointer_deallocateArray);
+    env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+}
+JNIEXPORT jlong JNICALL Java_com_googlecode_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jint arg0) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jlong rarg = 0;
+    size_t rvalue = (size_t)ptr[arg0];
+    rarg = (jlong)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
+    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = obj;
+    ptr[arg0] = (size_t)arg1;
+    return rarg;
+}
+
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_getTimestamp(JNIEnv* env, jobject obj) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr->timestamp;
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_getData(JNIEnv* env, jobject obj) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jobject rarg = NULL;
+    char * rptr;
+    rptr = (char *)ptr->data;
+    if (rptr != NULL) {
+        rarg = env->AllocObject(JavaCPP_getClass(env, 3));
+        env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_sequence(JNIEnv* env, jobject obj) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr->sequence;
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_setData(JNIEnv* env, jobject obj, jobject arg0) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    ptr->data = (char *)ptr0;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_getSpan(JNIEnv* env, jobject obj) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr->span;
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_setSpan(JNIEnv* env, jobject obj, jint arg0) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    ptr->span = arg0;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_setSequence(JNIEnv* env, jobject obj, jint arg0) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    ptr->sequence = arg0;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_getLength(JNIEnv* env, jobject obj) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return 0;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    jint rarg = 0;
+    int rvalue = ptr->len;
+    rarg = (jint)rvalue;
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_setLength(JNIEnv* env, jobject obj, jint arg0) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    ptr->len = arg0;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_allocate(JNIEnv* env, jobject obj) {
+    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 14))) {
+        return;
+    }
+    jthrowable exc = NULL;
+    try {
+        ::_JitterBufferPacket* rptr = new ::_JitterBufferPacket();
+        jint rcapacity = 1;
+        jvalue args[3];
+        args[0].j = ptr_to_jlong(rptr);
+        args[1].i = rcapacity;
+        args[2].j = ptr_to_jlong(&JavaCPP_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_deallocate);
+        env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 1), JavaCPP_initMID, args);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBufferPacket_setTimestamp(JNIEnv* env, jobject obj, jint arg0) {
+    ::_JitterBufferPacket* ptr = (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
+    if (ptr == NULL) {
+        env->ThrowNew(JavaCPP_getClass(env, 2), "This pointer address is NULL.");
+        return;
+    }
+    jint position = env->GetIntField(obj, JavaCPP_positionFID);
+    ptr += position;
+    ptr->timestamp = arg0;
+}
+
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        jitter_buffer_destroy((JitterBuffer*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1put(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    ::_JitterBufferPacket* ptr1 = arg1 == NULL ? NULL : (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    jthrowable exc = NULL;
+    try {
+        jitter_buffer_put((JitterBuffer*)ptr0, ptr1);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1get(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2, jobject arg3) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    ::_JitterBufferPacket* ptr1 = arg1 == NULL ? NULL : (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    int* ptr3 = arg3 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
+    jint position3 = arg3 == NULL ? 0 : env->GetIntField(arg3, JavaCPP_positionFID);
+    ptr3 += position3;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = jitter_buffer_get((JitterBuffer*)ptr0, ptr1, arg2, ptr3);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1get_1pointer_1timestamp(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = jitter_buffer_get_pointer_timestamp((JitterBuffer*)ptr0);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1tick(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        jitter_buffer_tick((JitterBuffer*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1ctl(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr2 = arg2 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = jitter_buffer_ctl((JitterBuffer*)ptr0, arg1, (void *)ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1update_1delay(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    ::_JitterBufferPacket* ptr1 = arg1 == NULL ? NULL : (::_JitterBufferPacket*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = jitter_buffer_update_delay((JitterBuffer*)ptr0, ptr1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess_1state_1init(JNIEnv* env, jclass cls, jint arg0, jint arg1) {
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = speex_preprocess_state_init(arg0, arg1);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess_1state_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        speex_preprocess_state_destroy((SpeexPreprocessState*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess_1run(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = speex_preprocess_run((SpeexPreprocessState*)ptr0, ptr1);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1, jintArray arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    int* ptr2 = arg2 == NULL ? NULL : env->GetIntArrayElements(arg2, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = speex_preprocess((SpeexPreprocessState*)ptr0, ptr1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (arg2 != NULL) env->ReleaseIntArrayElements(arg2, (jint*)ptr2, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess_1estimate_1update(JNIEnv* env, jclass cls, jobject arg0, jshortArray arg1) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr1 = arg1 == NULL ? NULL : env->GetShortArrayElements(arg1, NULL);
+    jthrowable exc = NULL;
+    try {
+        speex_preprocess_estimate_update((SpeexPreprocessState*)ptr0, ptr1);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (arg1 != NULL) env->ReleaseShortArrayElements(arg1, (jshort*)ptr1, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1preprocess_1ctl(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jobject arg2) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    char* ptr2 = arg2 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
+    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
+    ptr2 += position2;
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = speex_preprocess_ctl((SpeexPreprocessState*)ptr0, arg1, ptr2);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1resampler_1init(JNIEnv* env, jclass cls, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4) {
+    int* ptr4 = arg4 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
+    jint position4 = arg4 == NULL ? 0 : env->GetIntField(arg4, JavaCPP_positionFID);
+    ptr4 += position4;
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = speex_resampler_init(arg0, arg1, arg2, arg3, ptr4);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1resampler_1process_1int(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jshortArray arg2, jintArray arg3, jshortArray arg4, jintArray arg5) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    short* ptr2 = arg2 == NULL ? NULL : env->GetShortArrayElements(arg2, NULL);
+    int* ptr3 = arg3 == NULL ? NULL : env->GetIntArrayElements(arg3, NULL);
+    short* ptr4 = arg4 == NULL ? NULL : env->GetShortArrayElements(arg4, NULL);
+    int* ptr5 = arg5 == NULL ? NULL : env->GetIntArrayElements(arg5, NULL);
+    jint rarg = 0;
+    jthrowable exc = NULL;
+    try {
+        int rvalue = speex_resampler_process_int((SpeexResamplerState*)ptr0, arg1, (short*)ptr2, (unsigned int*)ptr3, (short*)ptr4, (unsigned int*)ptr5);
+        rarg = (jint)rvalue;
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (arg2 != NULL) env->ReleaseShortArrayElements(arg2, (jshort*)ptr2, 0);
+    if (arg3 != NULL) env->ReleaseIntArrayElements(arg3, (jint*)ptr3, 0);
+    if (arg4 != NULL) env->ReleaseShortArrayElements(arg4, (jshort*)ptr4, 0);
+    if (arg5 != NULL) env->ReleaseIntArrayElements(arg5, (jint*)ptr5, 0);
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_speex_1resampler_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        speex_resampler_destroy((SpeexResamplerState*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1init(JNIEnv* env, jclass cls, jint arg0) {
+    jobject rarg = NULL;
+    void* rptr;
+    jthrowable exc = NULL;
+    try {
+        rptr = jitter_buffer_init(arg0);
+        if (rptr != NULL) {
+            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
+            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
+        }
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+    return rarg;
+}
+JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1reset(JNIEnv* env, jclass cls, jobject arg0) {
+    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
+    ptr0 += position0;
+    jthrowable exc = NULL;
+    try {
+        jitter_buffer_reset((JitterBuffer*)ptr0);
+    } catch (...) {
+        exc = JavaCPP_handleException(env, 15);
+    }
+
+    if (exc != NULL) {
+        env->Throw(exc);
+    }
+}
+
+}
+