Implemented Opus audio input support! Fine-tuned Opus audio output.

17 files changed, 1932 insertions, 455 deletions

diff --git a/build.gradle b/build.gradle
index dd7b88d..334083d 100644
--- a/build.gradle
+++ b/build.gradle
@@ -21,7 +21,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:0.5.+'
+        classpath 'com.android.tools.build:gradle:0.6.+'
     }
 }
 apply plugin: 'android-library'
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 799ea00..354b0a8 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -19,4 +19,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.6-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.8-all.zip
diff --git a/src/main/java/com/morlunk/jumble/JumbleService.java b/src/main/java/com/morlunk/jumble/JumbleService.java
index 0526a84..3f9a4cf 100644
--- a/src/main/java/com/morlunk/jumble/JumbleService.java
+++ b/src/main/java/com/morlunk/jumble/JumbleService.java
@@ -24,6 +24,7 @@ import android.os.RemoteCallbackList;
 import android.os.RemoteException;
 import android.util.Log;
 
+import com.morlunk.jumble.audio.AudioInput;
 import com.morlunk.jumble.audio.AudioOutput;
 import com.morlunk.jumble.db.Database;
 import com.morlunk.jumble.model.Channel;
@@ -33,6 +34,7 @@ import com.morlunk.jumble.net.ChannelHandler;
 import com.morlunk.jumble.net.JumbleConnection;
 import com.morlunk.jumble.net.JumbleConnectionException;
 import com.morlunk.jumble.net.JumbleTCPMessageType;
+import com.morlunk.jumble.net.JumbleUDPMessageType;
 import com.morlunk.jumble.net.TextMessageHandler;
 import com.morlunk.jumble.net.UserHandler;
 import com.morlunk.jumble.protobuf.Mumble;
@@ -86,6 +88,14 @@ public class JumbleService extends Service implements JumbleConnection.JumbleCon
     private UserHandler mUserHandler;
     private TextMessageHandler mTextMessageHandler;
     private AudioOutput mAudioOutput;
+    private AudioInput mAudioInput;
+
+    private AudioInput.AudioInputListener mAudioInputListener = new AudioInput.AudioInputListener() {
+        @Override
+        public void onFrameEncoded(byte[] data, int length, JumbleUDPMessageType messageType) {
+            mConnection.sendUDPMessage(data, length, false);
+        }
+    };
 
     // Logging
     private List<String> mLogHistory = new ArrayList<String>();
@@ -179,12 +189,24 @@ public class JumbleService extends Service implements JumbleConnection.JumbleCon
 
         @Override
         public boolean isTalking() throws RemoteException {
-            return false;
+            return mAudioInput.isRecording();
         }
 
         @Override
         public void setTalkingState(boolean talking) throws RemoteException {
+            if(talking)
+                mAudioInput.startRecording();
+            else
+                mAudioInput.stopRecording();
 
+            final User currentUser = getSessionUser();
+            currentUser.setTalkState(talking ? User.TalkState.TALKING : User.TalkState.PASSIVE);
+            notifyObservers(new ObserverRunnable() {
+                @Override
+                public void run(IJumbleObserver observer) throws RemoteException {
+                    observer.onUserTalkStateUpdated(currentUser);
+                }
+            });
         }
 
         @Override
@@ -415,12 +437,14 @@ public class JumbleService extends Service implements JumbleConnection.JumbleCon
         mUserHandler = new UserHandler(this);
         mTextMessageHandler = new TextMessageHandler(this);
         mAudioOutput = new AudioOutput(this);
+        mAudioInput = new AudioInput(JumbleUDPMessageType.UDPVoiceOpus, mAudioInputListener);
 
         // Add message handlers for all managers
         mConnection.addMessageHandler(mChannelHandler);
         mConnection.addMessageHandler(mUserHandler);
         mConnection.addMessageHandler(mTextMessageHandler);
         mConnection.addMessageHandler(mAudioOutput);
+        mConnection.addMessageHandler(mAudioInput);
 
         mConnection.connect();
     }
@@ -430,6 +454,7 @@ public class JumbleService extends Service implements JumbleConnection.JumbleCon
         mConnection.removeMessageHandler(mUserHandler);
         mConnection.removeMessageHandler(mTextMessageHandler);
         mConnection.removeMessageHandler(mAudioOutput);
+        mConnection.removeMessageHandler(mAudioInput);
         mConnection.disconnect();
         mConnection = null;
     }
diff --git a/src/main/java/com/morlunk/jumble/audio/AudioInput.java b/src/main/java/com/morlunk/jumble/audio/AudioInput.java
index aa39099..8a74fc2 100644
--- a/src/main/java/com/morlunk/jumble/audio/AudioInput.java
+++ b/src/main/java/com/morlunk/jumble/audio/AudioInput.java
@@ -19,72 +19,196 @@ package com.morlunk.jumble.audio;
 import android.media.AudioFormat;
 import android.media.AudioRecord;
 import android.media.MediaRecorder;
+import android.util.Log;
 
+import com.googlecode.javacpp.BytePointer;
+import com.googlecode.javacpp.IntPointer;
+import com.googlecode.javacpp.Loader;
+import com.googlecode.javacpp.Pointer;
+import com.googlecode.javacpp.ShortPointer;
+import com.morlunk.jumble.Constants;
+import com.morlunk.jumble.audio.javacpp.Opus;
+import com.morlunk.jumble.net.JumbleMessageHandler;
 import com.morlunk.jumble.net.JumbleUDPMessageType;
+import com.morlunk.jumble.net.PacketDataStream;
+import com.morlunk.jumble.protobuf.Mumble;
+
+import java.nio.ShortBuffer;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 /**
  * Created by andrew on 23/08/13.
  */
-public class AudioInput implements Runnable {
-    private interface JumbleVoiceListener {
-        public void onFrameEncoded(byte[] data, int frameSize);
+public class AudioInput extends JumbleMessageHandler.Stub implements Runnable {
+
+    static {
+        Loader.load(Opus.class); // Do this so we can reference IntPointer and the like earlier.
+    }
+
+    public interface AudioInputListener {
+        public void onFrameEncoded(byte[] data, int length, JumbleUDPMessageType messageType);
     }
 
+    public static final int OPUS_MAX_BYTES = 512; // Opus specifies 4000 bytes as a recommended value for encoding, but the official mumble project uses 512.
+
+    private volatile Pointer mOpusEncoder;;
 //    private SWIGTYPE_p_OpusEncoder mOpusEncoder;
 //    private com.morlunk.jumble.audio.celt11.SWIGTYPE_p_CELTEncoder mCELTBetaEncoder;
 //    private com.morlunk.jumble.audio.celt7.SWIGTYPE_p_CELTMode mCELTAlphaMode;
 //    private com.morlunk.jumble.audio.celt7.SWIGTYPE_p_CELTEncoder mCELTAlphaEncoder;
 
-    private JumbleVoiceListener mListener;
+    private AudioInputListener mListener;
 
     private AudioRecord mAudioRecord;
     private int mMinBufferSize;
-    private int mInputSampleRate = 44100;
+    private int mInputSampleRate = 48000; //44100; FIXME
     private int mFrameSize = Audio.FRAME_SIZE;
+    private int mFramesPerPacket = 2;
 
-    private JumbleUDPMessageType mCodec;
+    // Temporary encoder state
+    private final short[] mOpusBuffer = new short[mFrameSize*mFramesPerPacket];
+    private final byte[] mEncodedBuffer = new byte[OPUS_MAX_BYTES];
+    private int mBufferedFrames = 0;
+    private int mFrameCounter;
 
-    public AudioInput(JumbleUDPMessageType codec, JumbleVoiceListener listener) {
-        mCodec = codec;
+    private JumbleUDPMessageType mCodec = null;
+
+    private Object mRecordLock = new Object(); // Make sure we don't get calls to start and stop recording more than once at a time.
+    private Thread mRecordThread;
+    private boolean mRecording;
+
+    private ExecutorService mEncodingThread = Executors.newSingleThreadExecutor();
+
+    /**
+     * Creates a new audio input manager configured for the specified codec.
+     * @param listener
+     */
+    public AudioInput(JumbleUDPMessageType codec, AudioInputListener listener) {
         mListener = listener;
-        int[] error = new int[1];
-//        switch (codec) {
-//            case UDPVoiceOpus:
-//                mOpusEncoder = Opus.opus_encoder_create(Audio.SAMPLE_RATE, 1, OpusConstants.OPUS_APPLICATION_VOIP, error);
-//                break;
-//            case UDPVoiceCELTBeta:
+        switchCodec(codec);
+
+        // TODO support input resampling. We can't expect 48000hz on all android devices.
+        int reportedMinBufferSize = AudioRecord.getMinBufferSize(Audio.SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
+        mMinBufferSize = Math.max(reportedMinBufferSize, mFrameSize);
+        mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, mInputSampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, mMinBufferSize);
+    }
+
+    /**
+     * Switches to the specified codec, and deallocates old native encoders.
+     * @param codec The codec to switch to.
+     */
+    public void switchCodec(JumbleUDPMessageType codec) {
+        if(codec == mCodec)
+            return;
+        mCodec = codec;
+
+        destroy(); // Deallocate old native objects
+
+        IntPointer error = new IntPointer(1);
+        switch (codec) {
+            case UDPVoiceOpus:
+                mOpusEncoder = Opus.opus_encoder_create(Audio.SAMPLE_RATE, 1, Opus.OPUS_APPLICATION_VOIP, error);
+
+                IntPointer vbr = new IntPointer(1);
+                vbr.put(0);
+                Opus.opus_encoder_ctl(mOpusEncoder, Opus.OPUS_SET_VBR_REQUEST, vbr);
+                break;
+            case UDPVoiceCELTBeta:
 //                mCELTBetaEncoder = CELT11.celt_encoder_create(Audio.SAMPLE_RATE, 1, error);
-//                break;
-//            case UDPVoiceCELTAlpha:
+                break;
+            case UDPVoiceCELTAlpha:
 //                mCELTAlphaMode = CELT7.celt_mode_create(Audio.SAMPLE_RATE, Audio.FRAME_SIZE, error);
 //                mCELTAlphaEncoder = CELT7.celt_encoder_create(mCELTAlphaMode, 1, error);
-//                break;
-//            case UDPVoiceSpeex:
-//                // TODO
-//                break;
-//        }
-
-        mMinBufferSize = AudioRecord.getMinBufferSize(mInputSampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
-        mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, mInputSampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, mMinBufferSize);
+                break;
+            case UDPVoiceSpeex:
+                // TODO
+                break;
+        }
     }
 
+    /**
+     * Starts the recording thread.
+     */
     public void startRecording() {
-        mAudioRecord.startRecording();
+        synchronized (mRecordLock) {
+            if(mRecording) {
+                Log.w(Constants.TAG, "Attempted to start recording while already recording!");
+                return;
+            }
+
+            mRecordThread = new Thread(this);
+            mRecordThread.start();
+        }
     }
 
+    /**
+     * Stops the record loop after the current iteration.
+     */
     public void stopRecording() {
-        mAudioRecord.stop();
+        synchronized (mRecordLock) {
+            mRecording = false;
+            mRecordThread = null;
+        }
+    }
+
+    /**
+     * Stops the record loop and waits on it to finish.
+     * @throws InterruptedException
+     */
+    public void stopRecordingAndWait() throws InterruptedException {
+        stopRecording();
+        synchronized (mRecordLock) {
+            mRecordLock.wait();
+        }
+    }
+
+    public boolean isRecording() {
+        synchronized (mRecordLock) {
+            return mRecording;
+        }
     }
 
     @Override
     public void run() {
-        while(mAudioRecord.getState() == AudioRecord.RECORDSTATE_RECORDING) {
-            short[] audioData = new short[mFrameSize];
-            byte[] encodedData = new byte[512];
-            if(mAudioRecord.read(audioData, 0, mFrameSize) == AudioRecord.SUCCESS) {
+        android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
+
+        mRecording = true;
+        mBufferedFrames = 0;
+        mFrameCounter = 0;
+
+        mAudioRecord.startRecording();
+
+        if(mAudioRecord.getState() != AudioRecord.STATE_INITIALIZED)
+            return;
+        final short[] audioData = new short[mFrameSize];
+
+        // We loop when the 'recording' instance var is true instead of checking audio record state because we want to always cleanly shutdown.
+        while(mRecording) {
+            int shortsRead = mAudioRecord.read(audioData, 0, mFrameSize);
+            if(shortsRead > 0) {
+                int len;
+                boolean encoded = false;
+                mFrameCounter++;
+
                 switch (mCodec) {
                     case UDPVoiceOpus:
-//                        Opus.opus_encode(mOpusEncoder, audioData, mFrameSize, encodedData, 512);
+                        System.arraycopy(audioData, 0, mOpusBuffer, mFrameSize * mBufferedFrames, mFrameSize);
+                        mBufferedFrames++;
+
+                        if(!mRecording || mBufferedFrames >= mFramesPerPacket) {
+                            if(mBufferedFrames < mFramesPerPacket)
+                                mBufferedFrames = mFramesPerPacket; // If recording was stopped early, encode remaining empty frames too.IntPointer sampleRate = new IntPointer(1);
+
+                            len = Opus.opus_encode(mOpusEncoder, mOpusBuffer, mFrameSize*mBufferedFrames, mEncodedBuffer, OPUS_MAX_BYTES);
+
+                            if(len <= 0) {
+                                mBufferedFrames = 0;
+                                continue;
+                            }
+
+                            encoded = true;
+                        }
                         break;
                     case UDPVoiceCELTBeta:
                         break;
@@ -93,7 +217,63 @@ public class AudioInput implements Runnable {
                     case UDPVoiceSpeex:
                         break;
                 }
+
+                if(encoded)
+                    sendFrame(mEncodedBuffer);
+            } else {
+                Log.e(Constants.TAG, "Error fetching audio! AudioRecord error "+shortsRead);
             }
         }
+
+        mAudioRecord.stop();
+
+        synchronized (mRecordLock) {
+            mRecordLock.notify();
+        }
+    }
+
+    /**
+     * Sends the encoded frame to the server.
+     */
+    private void sendFrame(byte[] frame) {
+
+        int frames = mBufferedFrames;
+        mBufferedFrames = 0;
+
+        byte[] packet = new byte[1024];
+        int flags = 0;
+        flags |= mCodec.ordinal() << 5;
+        packet[0] = (byte) (flags & 0xFF);
+
+        PacketDataStream pds = new PacketDataStream(packet, packet.length);
+        pds.skip(1);
+        pds.writeLong(mFrameCounter - frames);
+
+        if(mCodec == JumbleUDPMessageType.UDPVoiceOpus) {
+            long size = frame.length;
+            pds.writeLong(size);
+            pds.append(frame, frame.length);
+        }
+
+        mListener.onFrameEncoded(packet, pds.size(), mCodec);
+    }
+
+    /**
+     * Deallocates native assets. Must be called on disconnect.
+     */
+    public void destroy() {
+        if(mOpusEncoder != null)
+            Opus.opus_encoder_destroy(mOpusEncoder);
+    }
+
+    @Override
+    public void messageCodecVersion(Mumble.CodecVersion msg) {
+//        if(msg.getOpus())
+//            switchCodec(JumbleUDPMessageType.UDPVoiceOpus);
+//        else if(msg.getPreferAlpha())
+//            switchCodec(JumbleUDPMessageType.UDPVoiceCELTAlpha);
+//        else
+//            switchCodec(JumbleUDPMessageType.UDPVoiceCELTBeta);
+
     }
 }
diff --git a/src/main/java/com/morlunk/jumble/audio/AudioOutput.java b/src/main/java/com/morlunk/jumble/audio/AudioOutput.java
index ce76fe0..304abc5 100644
--- a/src/main/java/com/morlunk/jumble/audio/AudioOutput.java
+++ b/src/main/java/com/morlunk/jumble/audio/AudioOutput.java
@@ -65,7 +65,7 @@ public class AudioOutput extends JumbleMessageHandler.Stub implements Runnable,
                 Audio.SAMPLE_RATE,
                 AudioFormat.CHANNEL_OUT_MONO,
                 AudioFormat.ENCODING_PCM_16BIT,
-                bufferSize*2,
+                bufferSize,
                 AudioTrack.MODE_STREAM);
     }
 
diff --git a/src/main/java/com/morlunk/jumble/audio/AudioOutputSpeech.java b/src/main/java/com/morlunk/jumble/audio/AudioOutputSpeech.java
index cbb1b9c..107ef7b 100644
--- a/src/main/java/com/morlunk/jumble/audio/AudioOutputSpeech.java
+++ b/src/main/java/com/morlunk/jumble/audio/AudioOutputSpeech.java
@@ -92,7 +92,7 @@ public class AudioOutputSpeech {
 //                break;
         }
 
-        mBuffer = new float[mAudioBufferSize*2];
+        mBuffer = new float[mAudioBufferSize*2]; // Leave room for an extra frame in the buffer- TODO fix.
         mJitterBuffer = new Speex.JitterBuffer(Audio.FRAME_SIZE);
         IntPointer margin = new IntPointer(1);
         margin.put(10 * Audio.FRAME_SIZE);
@@ -152,7 +152,7 @@ public class AudioOutputSpeech {
 
         while(mBufferFilled < num) {
             int decodedSamples = Audio.FRAME_SIZE;
-            //resizeBuffer(mBufferFilled + mAudioBufferSize);
+            //resizeBuffer(mBufferFilled + mAudioBufferSize); TODO reimplement resize
 
             if(!mLastAlive)
                 out.fill(0);
diff --git a/src/main/java/com/morlunk/jumble/audio/javacpp/CELT11.java b/src/main/java/com/morlunk/jumble/audio/javacpp/CELT11.java
new file mode 100644
index 0000000..bab4cee
--- /dev/null
+++ b/src/main/java/com/morlunk/jumble/audio/javacpp/CELT11.java
@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+package com.morlunk.jumble.audio.javacpp;
+
+import com.googlecode.javacpp.IntPointer;
+import com.googlecode.javacpp.Pointer;
+import com.googlecode.javacpp.annotation.Platform;
+
+/**
+ * Created by andrew on 20/10/13.
+ */
+@Platform(library="celt11", cinclude={"<celt.h>","<celt_types.h>"})
+public class CELT11 {
+
+    public static class Decoder {
+
+        private Pointer mNativeDecoder;
+        private int mError;
+
+        public Decoder(int sampleRate, int channels) {
+            IntPointer error = new IntPointer(1);
+            mNativeDecoder = celt_decoder_init(sampleRate, channels, error);
+            mError = error.get();
+        }
+
+        public int getError() {
+            return mError;
+        }
+    }
+
+    private static native Pointer celt_decoder_init(int sampleRate, int channels, IntPointer error);
+}
diff --git a/src/main/java/com/morlunk/jumble/audio/javacpp/CELT7.java b/src/main/java/com/morlunk/jumble/audio/javacpp/CELT7.java
new file mode 100644
index 0000000..7032cf8
--- /dev/null
+++ b/src/main/java/com/morlunk/jumble/audio/javacpp/CELT7.java
@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+package com.morlunk.jumble.audio.javacpp;
+
+/**
+ * Created by andrew on 20/10/13.
+ */
+public class CELT7 {
+}
diff --git a/src/main/java/com/morlunk/jumble/audio/javacpp/Opus.java b/src/main/java/com/morlunk/jumble/audio/javacpp/Opus.java
index f99119b..b71bddd 100644
--- a/src/main/java/com/morlunk/jumble/audio/javacpp/Opus.java
+++ b/src/main/java/com/morlunk/jumble/audio/javacpp/Opus.java
@@ -23,6 +23,7 @@ import com.googlecode.javacpp.Loader;
 import com.googlecode.javacpp.Pointer;
 import com.googlecode.javacpp.ShortPointer;
 import com.googlecode.javacpp.annotation.Cast;
+import com.googlecode.javacpp.annotation.NoDeallocator;
 import com.googlecode.javacpp.annotation.Platform;
 
 /**
@@ -31,12 +32,29 @@ import com.googlecode.javacpp.annotation.Platform;
 
 @Platform(library="opus", link="opus", cinclude={"<opus.h>","<opus_types.h>"})
 public class Opus {
+
+    public static final int OPUS_APPLICATION_VOIP = 2048;
+
+    public static final int OPUS_SET_BITRATE_REQUEST = 4002;
+    public static final int OPUS_GET_BITRATE_REQUEST = 4003;
+    public static final int OPUS_SET_VBR_REQUEST = 4006;
+
     static {
         Loader.load();
     }
 
+// TODO work on an oo decoder wrapper
+//    public static class Decoder {
+//        private Pointer mNativeDecoder;
+//
+//        public Decoder(int frameSize, int channels) {
+//            IntPointer error = new IntPointer(1);
+//            mNativeDecoder = opus_decoder_create(frameSize, channels, error);
+//        }
+//    }
+
     public static native int opus_decoder_get_size(int channels);
-    public static native Pointer opus_decoder_create(int fs, int channels, IntPointer error);
+    public static native @NoDeallocator Pointer opus_decoder_create(int fs, int channels, IntPointer error);
     public static native int opus_decoder_init(@Cast("OpusDecoder*") Pointer st, int fs, int channels);
     public static native int opus_decode(@Cast("OpusDecoder*") Pointer st, @Cast("const unsigned char*") BytePointer data, int len, ShortPointer out, int frameSize, int decodeFec);
     public static native int opus_decode_float(@Cast("OpusDecoder*") Pointer st, @Cast("const unsigned char*") BytePointer data, int len, FloatPointer out, int frameSize, int decodeFec);
@@ -49,4 +67,12 @@ public class Opus {
     public static native int opus_packet_get_nb_frames(@Cast("const unsigned char*") BytePointer packet, int len);
     public static native int opus_packet_get_nb_samples(@Cast("const unsigned char*") BytePointer packet, int len, int fs);
 
+
+    public static native int opus_encoder_get_size(int channels);
+    public static native @NoDeallocator Pointer opus_encoder_create(int fs, int channels, int application, IntPointer error);
+    public static native int opus_encoder_init(@Cast("OpusEncoder*") Pointer st, int fs, int channels, int application);
+    public static native int opus_encode(@Cast("OpusEncoder*") Pointer st, @Cast("const short*") short[] pcm, int frameSize, @Cast("unsigned char*") byte[] data, int maxDataBytes);
+    public static native int opus_encode_float(@Cast("OpusEncoder*") Pointer st, @Cast("const float*") FloatPointer pcm, int frameSize, @Cast("unsigned char*") BytePointer data, int maxDataBytes);
+    public static native void opus_encoder_destroy(@Cast("OpusEncoder*") Pointer st);
+    public static native int opus_encoder_ctl(@Cast("OpusEncoder*") Pointer st, int request, Pointer value);
 }
diff --git a/src/main/java/com/morlunk/jumble/net/CryptState.java b/src/main/java/com/morlunk/jumble/net/CryptState.java
index 51e2c8f..9271088 100644
--- a/src/main/java/com/morlunk/jumble/net/CryptState.java
+++ b/src/main/java/com/morlunk/jumble/net/CryptState.java
@@ -16,22 +16,27 @@
 
 package com.morlunk.jumble.net;
 
-import javax.crypto.*;
-import javax.crypto.spec.SecretKeySpec;
 import java.nio.ByteBuffer;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
-import java.util.Timer;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.ShortBufferException;
+import javax.crypto.spec.SecretKeySpec;
 
 /**
  * Based off of the official Mumble project's 'CryptState.h' and 'CryptState.cpp' files.
- *
+ * <p/>
  * This code implements the patented OCB-AES128 cipher mode of operation.
  * Until recently, this would've posed a problem- Jumble is licensed under Apache v2, and the patent was only licensed for use with GPL software without authorization.
  * As of January 2013, the author has given a free license for any open source software certified by the OSI (Apache v2 included)
  * http://www.cs.ucdavis.edu/~rogaway/ocb/license.htm
- *
+ * <p/>
  * Created by andrew on 24/06/13.
  */
 public class CryptState {
@@ -43,27 +48,30 @@ public class CryptState {
 
         private static final int SHIFTBITS = 7;
 
-        public static void XOR(final byte[] dst, final byte[] blockA, final byte[] blockB) {
-            for(int i=0;i<AES_BLOCK_SIZE;i++)
-                dst[i] = (byte) (blockA[i] ^ blockB[i]);
+        public static void XOR(final byte[] dst, final byte[] a, final byte[] b) {
+            for (int i = 0; i < AES_BLOCK_SIZE; i++) {
+                dst[i] = (byte) (a[i] ^ b[i]);
+            }
         }
 
         public static void S2(final byte[] block) {
             int carry = (block[0] >> SHIFTBITS) & 0x1;
-            for(int i=0;i<AES_BLOCK_SIZE-1;i++)
-                block[i] = (byte) ((block[i] << 1) | ((block[i+1] >> SHIFTBITS) & 0x1));
-            block[AES_BLOCK_SIZE-1] = (byte) ((block[AES_BLOCK_SIZE-1] << 1) & (carry * 0x87));
+            for (int i = 0; i < AES_BLOCK_SIZE - 1; i++) {
+                block[i] = (byte) ((block[i] << 1) | ((block[i + 1] >> SHIFTBITS) & 0x1));
+            }
+            block[AES_BLOCK_SIZE - 1] = (byte) ((block[AES_BLOCK_SIZE - 1] << 1) ^ (carry * 0x87));
         }
 
         public static void S3(final byte[] block) {
-            int carry = (block[0] >> SHIFTBITS) & 0x1;
-            for(int i=0;i<AES_BLOCK_SIZE-1;i++)
-                block[i] ^= (block[i] << 1) | ((block[i+1] >> SHIFTBITS) & 0x1);
-            block[AES_BLOCK_SIZE-1] ^= (block[AES_BLOCK_SIZE-1] << 1) & (carry * 0x87);
+            final int carry = (block[0] >> SHIFTBITS) & 0x1;
+            for (int i = 0; i < AES_BLOCK_SIZE - 1; i++) {
+                block[i] ^= (block[i] << 1) | ((block[i + 1] >> SHIFTBITS) & 0x1);
+            }
+            block[AES_BLOCK_SIZE - 1] ^= ((block[AES_BLOCK_SIZE - 1] << 1) ^ (carry * 0x87));
         }
 
         public static void ZERO(final byte[] block) {
-            Arrays.fill(block, (byte)0);
+            Arrays.fill(block, (byte) 0);
         }
     }
 
@@ -99,14 +107,14 @@ public class CryptState {
      * @return The time since the last good decrypt in microseconds.
      */
     public long getLastGoodElapsed() {
-        return (System.nanoTime()-mLastGoodStart)/1000;
+        return (System.nanoTime() - mLastGoodStart) / 1000;
     }
 
     /**
      * @return The time since the last request in microseconds.
      */
     public long getLastRequestElapsed() {
-        return (System.nanoTime()-mLastRequestStart)/1000;
+        return (System.nanoTime() - mLastRequestStart) / 1000;
     }
 
     /* No need to create a shared secret, no server implementation.
@@ -115,7 +123,7 @@ public class CryptState {
     }
      */
 
-    public void setKey(byte[] rkey, byte[] eiv, byte[] div) throws InvalidKeyException{
+    public void setKey(byte[] rkey, byte[] eiv, byte[] div) throws InvalidKeyException {
         mRawKey = rkey;
         mEncryptIV = eiv;
         mDecryptIV = div;
@@ -142,7 +150,7 @@ public class CryptState {
         return mDecryptIV;
     }
 
-    public void ocbEncrypt(byte[] plain, byte[] encrypted, int len, byte[] nonce, byte[] tag) throws BadPaddingException, IllegalBlockSizeException, ShortBufferException {
+    public void ocbEncrypt(byte[] plain, byte[] encrypted, int plainLength, byte[] nonce, byte[] tag) throws BadPaddingException, IllegalBlockSizeException, ShortBufferException {
         final byte[] checksum = new byte[AES_BLOCK_SIZE],
                         delta = new byte[AES_BLOCK_SIZE],
                           tmp = new byte[AES_BLOCK_SIZE],
@@ -154,6 +162,7 @@ public class CryptState {
         final byte[] plainRegion = new byte[AES_BLOCK_SIZE];
         final byte[] encryptedRegion = new byte[AES_BLOCK_SIZE];
 
+        int len = plainLength;
         while(len > AES_BLOCK_SIZE) {
             plainBuffer.get(plainRegion);
             encryptedBuffer.get(encryptedRegion);
@@ -168,9 +177,10 @@ public class CryptState {
 
         CryptSupport.S2(delta);
         CryptSupport.ZERO(tmp);
+        tmp[AES_BLOCK_SIZE-1] = (byte) (((len * 8) >> 8) & 0xFF);
         tmp[AES_BLOCK_SIZE-1] = (byte) ((len * 8) & 0xFF);
         CryptSupport.XOR(tmp, tmp, delta);
-        mEncryptKey.doFinal(tmp, 0, AES_BLOCK_SIZE, pad);
+        mEncryptKey.doFinal(tmp, 0, tmp.length, pad);
         System.arraycopy(plain, plainBuffer.position(), tmp, 0, len);
         System.arraycopy(pad, len, tmp, len, AES_BLOCK_SIZE - len);
         CryptSupport.XOR(checksum, checksum, tmp);
@@ -184,9 +194,9 @@ public class CryptState {
 
     public void ocbDecrypt(byte[] encrypted, byte[] plain, int len, byte[] nonce, byte[] tag) throws BadPaddingException, IllegalBlockSizeException, ShortBufferException {
         final byte[] checksum = new byte[AES_BLOCK_SIZE],
-                        delta = new byte[AES_BLOCK_SIZE],
-                          tmp = new byte[AES_BLOCK_SIZE],
-                          pad = new byte[AES_BLOCK_SIZE];
+                delta = new byte[AES_BLOCK_SIZE],
+                tmp = new byte[AES_BLOCK_SIZE],
+                pad = new byte[AES_BLOCK_SIZE];
 
         System.arraycopy(mEncryptKey.doFinal(nonce), 0, delta, 0, AES_BLOCK_SIZE);
 
@@ -195,7 +205,7 @@ public class CryptState {
         final byte[] plainRegion = new byte[AES_BLOCK_SIZE];
         final byte[] encryptedRegion = new byte[AES_BLOCK_SIZE];
 
-        while(len > AES_BLOCK_SIZE) {
+        while (len > AES_BLOCK_SIZE) {
             plainBuffer.get(plainRegion);
             encryptedBuffer.get(encryptedRegion);
 
@@ -209,7 +219,7 @@ public class CryptState {
 
         CryptSupport.S2(delta);
         CryptSupport.ZERO(tmp);
-        tmp[AES_BLOCK_SIZE-1] = (byte) ((len * 8) & 0xFF);
+        tmp[AES_BLOCK_SIZE - 1] = (byte) ((len * 8) & 0xFF);
         CryptSupport.XOR(tmp, tmp, delta);
         mEncryptKey.doFinal(tmp, 0, AES_BLOCK_SIZE, pad);
         System.arraycopy(encrypted, encryptedBuffer.position(), tmp, 0, len);
@@ -224,7 +234,7 @@ public class CryptState {
     }
 
     public boolean decrypt(byte[] source, byte[] dst, int cryptedLength) {
-        if(cryptedLength < 4)
+        if (cryptedLength < 4)
             return false;
 
         int plainLength = cryptedLength - 4;
@@ -244,7 +254,7 @@ public class CryptState {
                 mDecryptIV[0] = ivbyte;
             } else if (ivbyte < mDecryptIV[0]) {
                 mDecryptIV[0] = ivbyte;
-                for (int i=1;i<AES_BLOCK_SIZE;i++)
+                for (int i = 1; i < AES_BLOCK_SIZE; i++)
                     if (++mDecryptIV[i] != 0)
                         break;
             } else {
@@ -255,9 +265,9 @@ public class CryptState {
 
             int diff = ivbyte - mDecryptIV[0];
             if (diff > 128)
-                diff = diff-256;
+                diff = diff - 256;
             else if (diff < -128)
-                diff = diff+256;
+                diff = diff + 256;
 
             if ((ivbyte < mDecryptIV[0]) && (diff > -30) && (diff < 0)) {
                 // Late packet, but no wraparound.
@@ -270,7 +280,7 @@ public class CryptState {
                 late = 1;
                 lost = -1;
                 mDecryptIV[0] = ivbyte;
-                for (int i=1;i<AES_BLOCK_SIZE;i++)
+                for (int i = 1; i < AES_BLOCK_SIZE; i++)
                     if (mDecryptIV[i]-- != 0)
                         break;
                 restore = true;
@@ -282,7 +292,7 @@ public class CryptState {
                 // Lost a few packets, and wrapped around
                 lost = 256 - mDecryptIV[0] + ivbyte - 1;
                 mDecryptIV[0] = ivbyte;
-                for (int i=1;i<AES_BLOCK_SIZE;i++)
+                for (int i = 1; i < AES_BLOCK_SIZE; i++)
                     if (++mDecryptIV[i] != 0)
                         break;
             } else {
@@ -336,8 +346,8 @@ public class CryptState {
         final byte[] tag = new byte[AES_BLOCK_SIZE];
 
         // First, increase our IV.
-        for(int i=0;i<AES_BLOCK_SIZE;i++)
-            if(++mEncryptIV[i] != 0)
+        for (int i = 0; i < AES_BLOCK_SIZE; i++)
+            if ((++mEncryptIV[i]) > 0)
                 break;
 
         try {
@@ -352,6 +362,8 @@ public class CryptState {
             throw new RuntimeException(e);
         }
 
+        // First 4 bytes are header data.
+        System.arraycopy(dst, 0, dst, 4, plainLength);
         dst[0] = mEncryptIV[0];
         dst[1] = tag[0];
         dst[2] = tag[1];
diff --git a/src/main/java/com/morlunk/jumble/net/JumbleConnection.java b/src/main/java/com/morlunk/jumble/net/JumbleConnection.java
index 2bd7b6a..d5365ae 100644
--- a/src/main/java/com/morlunk/jumble/net/JumbleConnection.java
+++ b/src/main/java/com/morlunk/jumble/net/JumbleConnection.java
@@ -210,6 +210,7 @@ public class JumbleConnection {
 
         @Override
         public void messageUDPPing(byte[] data) {
+            Log.v(Constants.TAG, "UDP ping from server");
             byte[] timedata = new byte[8];
             System.arraycopy(data, 1, timedata, 0, 8);
             ByteBuffer buffer = ByteBuffer.allocate(8);
@@ -229,13 +230,15 @@ public class JumbleConnection {
             long t = getElapsed();
 
             if(!mForceTCP) {
-                byte[] buffer = new byte[256];
+                byte[] buffer = new byte[16];
                 buffer[0] = (byte) (JumbleUDPMessageType.UDPPing.ordinal() << 5);
-                byte[] data = new byte[255];
-                PacketDataStream dataStream = new PacketDataStream(data, 255);
+
+                byte[] data = new byte[15];
+                PacketDataStream dataStream = new PacketDataStream(data, 8);
                 dataStream.writeLong(t);
-                System.arraycopy(data, 0, buffer, 1, 255);
-                sendUDPMessage(buffer, JumbleUDPMessageType.UDPPing, true);
+                System.arraycopy(data, 0, buffer, 1, dataStream.size());
+
+                sendUDPMessage(buffer, dataStream.size()+1, true);
             }
 
             Mumble.Ping.Builder pb = Mumble.Ping.newBuilder();
@@ -244,6 +247,7 @@ public class JumbleConnection {
             pb.setLate(mCryptState.mUiLate);
             pb.setLost(mCryptState.mUiLost);
             pb.setResync(mCryptState.mUiResync);
+            // TODO accumulate stats and send with ping
             sendTCPMessage(pb.build(), JumbleTCPMessageType.Ping);
         }
     };
@@ -286,6 +290,7 @@ public class JumbleConnection {
         mPingExecutorService = Executors.newSingleThreadScheduledExecutor();
 
         mTCP = new JumbleTCP();
+        mUDP = new JumbleUDP();
         mNetworkThread = new NetworkSendThread();
         mExecutorService.submit(mNetworkThread);
         mExecutorService.submit(mTCP);
@@ -453,12 +458,12 @@ public class JumbleConnection {
         });
     }
 
-    public void sendUDPMessage(final byte[] data, final JumbleUDPMessageType messageType, final boolean force) {
+    public void sendUDPMessage(final byte[] data, final int length, final boolean force) {
         mNetworkHandler.post(new Runnable() {
             @Override
             public void run() {
                 try {
-                    mUDP.sendMessage(data, data.length, messageType, force);
+                    mUDP.sendMessage(data, length, force);
                 } catch (IOException e) {
                     e.printStackTrace(); // TODO handle me
                 }
@@ -738,7 +743,6 @@ public class JumbleConnection {
             Log.v(Constants.TAG, "Started listening");
 
             if(!mForceTCP) {
-                mUDP = new JumbleUDP();
                 mExecutorService.submit(mUDP);
             }
 
@@ -791,19 +795,16 @@ public class JumbleConnection {
         /**
          * Attempts to send a protobuf message over TCP. Executes on the TCP thread.
          * @param message The data to send.
+         * @param length The length of the byte array.
          * @param messageType The type of the message to send.
          * @throws IOException if we can't write the message to the server.
          */
-        public void sendMessage(byte[] message, JumbleTCPMessageType messageType) throws IOException {
+        public void sendMessage(byte[] message, int length, JumbleTCPMessageType messageType) throws IOException {
             if(!UNLOGGED_MESSAGES.contains(messageType))
                 Log.v(Constants.TAG, "OUT: "+messageType);
             mDataOutput.writeShort(messageType.ordinal());
-            mDataOutput.writeInt(message.length);
-            mDataOutput.write(message);
-        }
-
-        public void sendData(byte[] data) throws  IOException {
-            mDataOutput.write(data);
+            mDataOutput.writeInt(length);
+            mDataOutput.write(message, 0, length);
         }
     }
 
@@ -852,20 +853,15 @@ public class JumbleConnection {
             }
         }
 
-        public void sendMessage(byte[] data, int length, JumbleUDPMessageType messageType, boolean force) throws IOException {
-            if(!mCryptState.isValid())
-                return;
-
+        public void sendMessage(byte[] data, int length, boolean force) throws IOException {
             if(!force && (mForceTCP || !mUsingUDP)) {
-                ByteBuffer bb = ByteBuffer.allocate(length + 6);
-                bb.putShort((short) messageType.ordinal());
-                bb.putInt(length);
-                bb.put(data);
-                mTCP.sendData(bb.array());
+                mTCP.sendMessage(data, length, JumbleTCPMessageType.UDPTunnel);
             } else {
-                byte[] encryptedData = new byte[length];
+                if(!mCryptState.isValid())
+                    return;
+                byte[] encryptedData = new byte[length+4];
                 mCryptState.encrypt(data, encryptedData, length);
-                DatagramPacket packet = new DatagramPacket(encryptedData, length);
+                DatagramPacket packet = new DatagramPacket(encryptedData, encryptedData.length);
                 packet.setAddress(mHost);
                 packet.setPort(mServer.getPort());
                 mUDPSocket.send(packet);
diff --git a/src/main/java/com/morlunk/jumble/net/PacketDataStream.java b/src/main/java/com/morlunk/jumble/net/PacketDataStream.java
index 4c74e6e..2b8c2d7 100644
--- a/src/main/java/com/morlunk/jumble/net/PacketDataStream.java
+++ b/src/main/java/com/morlunk/jumble/net/PacketDataStream.java
@@ -65,7 +65,7 @@ public class PacketDataStream {
         }
     }
 
-    public void append(byte d, int len) {
+    public void append(byte[] d, int len) {
         if(left() >= len) {
             System.arraycopy(d, 0, mData, mOffset, len);
             mOffset += len;
diff --git a/src/main/jni/celt11.cpp b/src/main/jni/celt11.cpp
new file mode 100644
index 0000000..d3e772a
--- /dev/null
+++ b/src/main/jni/celt11.cpp
@@ -0,0 +1,1032 @@
+/* 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_1decoder_1init(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_init(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;
+}
+
+}
+
diff --git a/src/main/jni/opus.cpp b/src/main/jni/opus.cpp
index 5bed8fa..e93fb41 100644
--- a/src/main/jni/opus.cpp
+++ b/src/main/jni/opus.cpp
@@ -274,14 +274,6 @@ JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocato
 
 
 
-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 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) {
@@ -383,8 +375,28 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env
     }
     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 jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+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.");
@@ -392,13 +404,12 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNI
     }
     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);
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
     return rarg;
 }
-JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+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.");
@@ -406,9 +417,10 @@ JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* e
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
-    jbyte rarg = 0;
-    signed char rvalue = ptr[arg0];
-    rarg = (jbyte)rvalue;
+    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) {
@@ -437,19 +449,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNI
     if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
     return rarg;
 }
-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))) {
+
+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;
     }
-    signed char* rptr = new (std::nothrow) signed char[arg0];
+    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_BytePointer_deallocateArray);
+    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) {
@@ -477,7 +489,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JN
     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) {
+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.");
@@ -485,11 +497,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEn
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+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.");
@@ -497,25 +511,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JN
     }
     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);
+    ptr[arg0] = arg1;
     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))) {
+
+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;
     }
-    short* rptr = new (std::nothrow) short[arg0];
+    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_ShortPointer_deallocateArray);
+    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) {
@@ -569,19 +581,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv*
     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))) {
+
+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;
     }
-    int* rptr = new (std::nothrow) int[arg0];
+    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_IntPointer_deallocateArray);
+    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) {
@@ -609,7 +621,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNI
     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) {
+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.");
@@ -617,11 +629,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+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.");
@@ -629,25 +643,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNI
     }
     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);
+    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))) {
+
+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;
     }
-    jlong* rptr = new (std::nothrow) jlong[arg0];
+    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_LongPointer_deallocateArray);
+    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) {
@@ -675,7 +687,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JN
     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) {
+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.");
@@ -683,11 +695,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEn
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+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.");
@@ -695,25 +709,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JN
     }
     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);
+    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))) {
+
+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;
     }
-    float* rptr = new (std::nothrow) float[arg0];
+    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_FloatPointer_deallocateArray);
+    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) {
@@ -741,7 +753,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(J
     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) {
+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.");
@@ -749,11 +761,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIE
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+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.");
@@ -761,25 +775,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(J
     }
     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);
+    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))) {
+
+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;
     }
-    double* rptr = new (std::nothrow) double[arg0];
+    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_DoublePointer_deallocateArray);
+    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) {
@@ -833,19 +845,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv
     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))) {
+
+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;
     }
-    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    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_CharPointer_deallocateArray);
+    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) {
@@ -878,19 +890,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv*
     ptr[arg0] = ptr1;
     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))) {
+
+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;
     }
-    void** rptr = new (std::nothrow) void*[arg0];
+    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_PointerPointer_deallocateArray);
+    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) {
@@ -916,19 +928,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* en
     ptr[arg0] = (bool)arg1;
     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))) {
+
+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;
     }
-    bool* rptr = new (std::nothrow) bool[arg0];
+    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_BoolPointer_deallocateArray);
+    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) {
@@ -954,19 +966,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* e
     ptr[arg0] = (long)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))) {
+
+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;
     }
-    long* rptr = new (std::nothrow) long[arg0];
+    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_CLongPointer_deallocateArray);
+    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) {
@@ -992,28 +1004,14 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* e
     ptr[arg0] = (size_t)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 jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1init(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jint arg2) {
+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;
-    jint rarg = 0;
     jthrowable exc = NULL;
     try {
-        int rvalue = opus_decoder_init((OpusDecoder*)ptr0, arg1, arg2);
-        rarg = (jint)rvalue;
+        opus_decoder_destroy((OpusDecoder*)ptr0);
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
     }
@@ -1021,22 +1019,15 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_
     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, jobject arg1, jint arg2, jobject arg3, jint arg4, jint arg5) {
-    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+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;
-    signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
-    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
-    ptr1 += position1;
-    short* ptr3 = arg3 == NULL ? NULL : (short*)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 = opus_decode((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        int rvalue = opus_packet_get_bandwidth((const unsigned char*)ptr0);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1047,20 +1038,14 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode(J
     }
     return rarg;
 }
-JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode_1float(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2, jobject arg3, jint arg4, jint arg5) {
-    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
+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;
-    signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
-    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
-    ptr1 += position1;
-    float* ptr3 = arg3 == NULL ? NULL : (float*)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 = opus_decode_float((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        int rvalue = opus_packet_get_samples_per_frame((const unsigned char*)ptr0, arg1);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1071,13 +1056,15 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode_1
     }
     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));
+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 {
-        opus_decoder_destroy((OpusDecoder*)ptr0);
+        int rvalue = opus_packet_get_nb_channels((const unsigned char*)ptr0);
+        rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
     }
@@ -1085,15 +1072,16 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_
     if (exc != NULL) {
         env->Throw(exc);
     }
+    return rarg;
 }
-JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1get_1bandwidth(JNIEnv* env, jclass cls, jobject arg0) {
+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_bandwidth((const unsigned char*)ptr0);
+        int rvalue = opus_packet_get_nb_frames((const unsigned char*)ptr0, arg1);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1104,14 +1092,14 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1
     }
     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) {
+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_samples_per_frame((const unsigned char*)ptr0, arg1);
+        int rvalue = opus_packet_get_nb_samples((const unsigned char*)ptr0, arg1, arg2);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1122,14 +1110,11 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1
     }
     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;
+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_packet_get_nb_channels((const unsigned char*)ptr0);
+        int rvalue = opus_encoder_get_size(arg0);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1140,15 +1125,19 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1
     }
     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;
+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 {
-        int rvalue = opus_packet_get_nb_frames((const unsigned char*)ptr0, arg1);
-        rarg = (jint)rvalue;
+        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);
     }
@@ -1158,14 +1147,14 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1
     }
     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));
+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_packet_get_nb_samples((const unsigned char*)ptr0, arg1, arg2);
+        int rvalue = opus_encoder_init((OpusEncoder*)ptr0, arg1, arg2, arg3);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 14);
@@ -1176,16 +1165,23 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1packet_1
     }
     return rarg;
 }
-JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decoder_1get_1size(JNIEnv* env, jclass cls, jint arg0) {
+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_decoder_get_size(arg0);
+        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);
     }
@@ -1213,6 +1209,147 @@ JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decod
     }
     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_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 jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Opus_opus_1decode(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2, jobject 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 : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    short* ptr3 = arg3 == NULL ? NULL : (short*)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 = opus_decode((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        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_1float(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2, jobject 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 : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    float* ptr3 = arg3 == NULL ? NULL : (float*)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 = opus_decode_float((OpusDecoder*)ptr0, (const unsigned char*)ptr1, arg2, ptr3, arg4, arg5);
+        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_1float(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2, jobject 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 : (float*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
+    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
+    ptr1 += position1;
+    signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)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 = opus_encode_float((OpusEncoder*)ptr0, (const float*)ptr1, arg2, (unsigned char*)ptr3, arg4);
+        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_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;
+}
 
 }
 
diff --git a/src/main/jni/speex.cpp b/src/main/jni/speex.cpp
index e2bf402..1560700 100644
--- a/src/main/jni/speex.cpp
+++ b/src/main/jni/speex.cpp
@@ -189,7 +189,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
             { "sizeof" },
             { "sizeof" },
             { "sizeof" },
-            { "sizeof", "len", "timestamp", "data", "sequence", "span" },
+            { "sizeof", "timestamp", "data", "sequence", "span", "len" },
             {  } };
     int offsets[16][6] = {
             {  },
@@ -206,7 +206,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
             { sizeof(bool) },
             { sizeof(long) },
             { sizeof(size_t) },
-            { sizeof(::_JitterBufferPacket), offsetof(::_JitterBufferPacket,len), offsetof(::_JitterBufferPacket,timestamp), offsetof(::_JitterBufferPacket,data), offsetof(::_JitterBufferPacket,sequence), offsetof(::_JitterBufferPacket,span) },
+            { 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");
@@ -279,14 +279,6 @@ JNIEXPORT void JNICALL Java_com_googlecode_javacpp_Pointer_00024NativeDeallocato
 
 
 
-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 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) {
@@ -388,8 +380,28 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_Pointer_memset(JNIEnv* env
     }
     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 jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
+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.");
@@ -397,13 +409,12 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_get___3BII(JNI
     }
     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);
+    jbyte rarg = 0;
+    signed char rvalue = ptr[arg0];
+    rarg = (jbyte)rvalue;
     return rarg;
 }
-JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
+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.");
@@ -411,9 +422,10 @@ JNIEXPORT jbyte JNICALL Java_com_googlecode_javacpp_BytePointer_get__I(JNIEnv* e
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
-    jbyte rarg = 0;
-    signed char rvalue = ptr[arg0];
-    rarg = (jbyte)rvalue;
+    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) {
@@ -442,19 +454,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BytePointer_put___3BII(JNI
     if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
     return rarg;
 }
-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))) {
+
+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;
     }
-    signed char* rptr = new (std::nothrow) signed char[arg0];
+    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_BytePointer_deallocateArray);
+    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) {
@@ -482,7 +494,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_get___3SII(JN
     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) {
+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.");
@@ -490,11 +502,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put__IS(JNIEn
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
+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.");
@@ -502,25 +516,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_ShortPointer_put___3SII(JN
     }
     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);
+    ptr[arg0] = arg1;
     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))) {
+
+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;
     }
-    short* rptr = new (std::nothrow) short[arg0];
+    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_ShortPointer_deallocateArray);
+    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) {
@@ -574,19 +586,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_IntPointer_put__II(JNIEnv*
     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))) {
+
+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;
     }
-    int* rptr = new (std::nothrow) int[arg0];
+    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_IntPointer_deallocateArray);
+    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) {
@@ -614,7 +626,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_get___3JII(JNI
     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) {
+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.");
@@ -622,11 +634,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put__IJ(JNIEnv
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
+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.");
@@ -634,25 +648,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_LongPointer_put___3JII(JNI
     }
     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);
+    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))) {
+
+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;
     }
-    jlong* rptr = new (std::nothrow) jlong[arg0];
+    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_LongPointer_deallocateArray);
+    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) {
@@ -680,7 +692,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_get___3FII(JN
     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) {
+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.");
@@ -688,11 +700,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put__IF(JNIEn
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
+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.");
@@ -700,25 +714,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_FloatPointer_put___3FII(JN
     }
     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);
+    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))) {
+
+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;
     }
-    float* rptr = new (std::nothrow) float[arg0];
+    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_FloatPointer_deallocateArray);
+    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) {
@@ -746,7 +758,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_get___3DII(J
     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) {
+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.");
@@ -754,11 +766,13 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put__ID(JNIE
     }
     jint position = env->GetIntField(obj, JavaCPP_positionFID);
     ptr += position;
+    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
     jobject rarg = obj;
-    ptr[arg0] = arg1;
+    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___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
+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.");
@@ -766,25 +780,23 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_DoublePointer_put___3DII(J
     }
     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);
+    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))) {
+
+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;
     }
-    double* rptr = new (std::nothrow) double[arg0];
+    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_DoublePointer_deallocateArray);
+    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) {
@@ -838,19 +850,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CharPointer_put__IC(JNIEnv
     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))) {
+
+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;
     }
-    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
+    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_CharPointer_deallocateArray);
+    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) {
@@ -883,19 +895,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_PointerPointer_put(JNIEnv*
     ptr[arg0] = ptr1;
     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))) {
+
+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;
     }
-    void** rptr = new (std::nothrow) void*[arg0];
+    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_PointerPointer_deallocateArray);
+    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) {
@@ -921,19 +933,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_BoolPointer_put(JNIEnv* en
     ptr[arg0] = (bool)arg1;
     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))) {
+
+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;
     }
-    bool* rptr = new (std::nothrow) bool[arg0];
+    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_BoolPointer_deallocateArray);
+    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) {
@@ -959,19 +971,19 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_CLongPointer_put(JNIEnv* e
     ptr[arg0] = (long)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))) {
+
+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;
     }
-    long* rptr = new (std::nothrow) long[arg0];
+    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_CLongPointer_deallocateArray);
+    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) {
@@ -997,73 +1009,7 @@ JNIEXPORT jobject JNICALL Java_com_googlecode_javacpp_SizeTPointer_put(JNIEnv* e
     ptr[arg0] = (size_t)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 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 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) {
@@ -1153,16 +1099,68 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_00024JitterBu
     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);
+    }
 
-JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1get_1pointer_1timestamp(JNIEnv* env, jclass cls, jobject arg0) {
+    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_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;
-    jint rarg = 0;
     jthrowable exc = NULL;
     try {
-        int rvalue = jitter_buffer_get_pointer_timestamp((JitterBuffer*)ptr0);
-        rarg = (jint)rvalue;
+        jitter_buffer_reset((JitterBuffer*)ptr0);
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1170,15 +1168,14 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
     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) {
+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_tick((JitterBuffer*)ptr0);
+        jitter_buffer_destroy((JitterBuffer*)ptr0);
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1187,18 +1184,16 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
         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) {
+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;
-    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;
+    ::_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 {
-        int rvalue = jitter_buffer_ctl((JitterBuffer*)ptr0, arg1, (void *)ptr2);
-        rarg = (jint)rvalue;
+        jitter_buffer_put((JitterBuffer*)ptr0, ptr1);
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1206,22 +1201,21 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
     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) {
+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* 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;
+    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_update_delay((JitterBuffer*)ptr0, ptr1, ptr2);
+        int rvalue = jitter_buffer_get((JitterBuffer*)ptr0, ptr1, arg2, ptr3);
         rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
@@ -1232,16 +1226,15 @@ JNIEXPORT jint JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
     }
     return rarg;
 }
-JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1init(JNIEnv* env, jclass cls, jint arg0) {
-    jobject rarg = NULL;
-    void* rptr;
+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 {
-        rptr = jitter_buffer_init(arg0);
-        if (rptr != NULL) {
-            rarg = env->AllocObject(JavaCPP_getClass(env, 1));
-            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
-        }
+        int rvalue = jitter_buffer_get_pointer_timestamp((JitterBuffer*)ptr0);
+        rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1251,13 +1244,13 @@ JNIEXPORT jobject JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1bu
     }
     return rarg;
 }
-JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1reset(JNIEnv* env, jclass cls, jobject arg0) {
+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_reset((JitterBuffer*)ptr0);
+        jitter_buffer_tick((JitterBuffer*)ptr0);
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1266,13 +1259,18 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
         env->Throw(exc);
     }
 }
-JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1destroy(JNIEnv* env, jclass cls, jobject arg0) {
+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 {
-        jitter_buffer_destroy((JitterBuffer*)ptr0);
+        int rvalue = jitter_buffer_ctl((JitterBuffer*)ptr0, arg1, (void *)ptr2);
+        rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1280,17 +1278,23 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
     if (exc != NULL) {
         env->Throw(exc);
     }
+    return rarg;
 }
-JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffer_1put(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
+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 {
-        jitter_buffer_put((JitterBuffer*)ptr0, ptr1);
+        int rvalue = jitter_buffer_update_delay((JitterBuffer*)ptr0, ptr1, ptr2);
+        rarg = (jint)rvalue;
     } catch (...) {
         exc = JavaCPP_handleException(env, 15);
     }
@@ -1298,22 +1302,18 @@ JNIEXPORT void JNICALL Java_com_morlunk_jumble_audio_javacpp_Speex_jitter_1buffe
     if (exc != NULL) {
         env->Throw(exc);
     }
+    return rarg;
 }
-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;
+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 {
-        int rvalue = jitter_buffer_get((JitterBuffer*)ptr0, ptr1, arg2, ptr3);
-        rarg = (jint)rvalue;
+        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);
     }
diff --git a/src/main/libs/armeabi/libopus.so b/src/main/libs/armeabi/libopus.so
index 1df6886..d66004b 100755
--- a/src/main/libs/armeabi/libopus.so
+++ b/src/main/libs/armeabi/libopus.so
diff --git a/src/main/libs/armeabi/libspeex.so b/src/main/libs/armeabi/libspeex.so
index cadf322..b533cd7 100755
--- a/src/main/libs/armeabi/libspeex.so
+++ b/src/main/libs/armeabi/libspeex.so