toxiclibs 0.4.0 → 0.8.0

data/src/com/toxi/nio/UDPClient.java

@@ -0,0 +1,121 @@
+package com.toxi.nio;
+
+import java.net.*;
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.nio.channels.spi.SelectorProvider;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPClient {
+
+    /**
+     *
+     */
+    public final static int DEFAULT_PORT = 9876;
+
+    int port = DEFAULT_PORT;
+    SocketAddress remote;
+    DatagramChannel channel;
+    Selector selector;
+    ByteBuffer buffer1;
+    ByteBuffer buffer2;
+
+    int clientID;
+
+    /**
+     *
+     * @param clientID
+     */
+    public UDPClient(int clientID) {
+        this.clientID = clientID;
+        System.out.println("new client ID: " + clientID);
+        try {
+            remote = new InetSocketAddress("192.168.1.64", port);
+            channel = DatagramChannel.open();
+            channel.configureBlocking(false);
+            channel.connect(remote);
+            selector = SelectorProvider.provider().openSelector();
+            channel.register(selector, SelectionKey.OP_READ
+                    | SelectionKey.OP_WRITE);
+            buffer1 = ByteBuffer.allocate(4);
+            buffer2 = ByteBuffer.allocate(4);
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+    }
+
+    /**
+     *
+     * @param command
+     */
+    public void send(int command) {
+        try {
+            selector.select(clientID);
+            Set readyKeys = selector.selectedKeys();
+            Iterator iterator = readyKeys.iterator();
+            if (iterator.hasNext()) {
+                SelectionKey key = (SelectionKey) iterator.next();
+                iterator.remove();
+                if (key.isWritable()) {
+                    buffer1.clear();
+                    buffer1.putInt(command);
+                    buffer1.flip();
+                    channel.write(buffer1);
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int receive() {
+        int r = 0;
+        try {
+            selector.select(clientID);
+            Set readyKeys2 = selector.selectedKeys();
+            Iterator iterator2 = readyKeys2.iterator();
+            if (iterator2.hasNext()) {
+                SelectionKey key2 = (SelectionKey) iterator2.next();
+                iterator2.remove();
+                if (key2.isReadable()) {
+                    buffer2.clear();
+                    channel.read(buffer2);
+                    buffer2.flip();
+                    int command = buffer2.getInt();
+                    r = command;
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+        return r;
+    }
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        UDPClient client = new UDPClient(Integer.parseInt(args[0]));
+        client.send(1);
+        while (true) {
+            System.out.println(client.receive());
+            try {
+                Thread.sleep(33);
+            } catch (InterruptedException ex) {
+                Logger.getLogger(UDPClient.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+    }
+}

data/src/com/toxi/nio/UDPClientState.java

@@ -0,0 +1,32 @@
+package com.toxi.nio;
+
+import java.net.SocketAddress;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPClientState {
+    SocketAddress addr;
+    boolean isReady;
+    long lastUpdate;
+
+    /**
+     *
+     * @param a
+     */
+    public UDPClientState(SocketAddress a) {
+        addr = a;
+        isReady = true;
+        lastUpdate = System.currentTimeMillis();
+        System.out.println("new client: " + addr);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public SocketAddress getAddress() {
+        return addr;
+    }
+}

data/src/com/toxi/nio/UDPServer.java

@@ -0,0 +1,129 @@
+package com.toxi.nio;
+
+import java.net.*;
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPServer extends Thread {
+
+    /**
+     *
+     */
+    public final static int DEFAULT_PORT = 9876;
+
+    /**
+     *
+     */
+    public final static int MAX_PACKET_SIZE = 32;
+
+    private int port;
+    private int packetSize;
+    private int numClients;
+
+    ArrayList<UDPClientState> clients;
+    private int frameCount = 0;
+    private int frameDuration;
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        new UDPServer(1, 25).start();
+        try {
+            while (true) {
+                Thread.sleep(1000);
+                // System.out.println("running.");
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     *
+     * @param numClients
+     * @param fps
+     */
+    public UDPServer(int numClients, int fps) {
+        this(DEFAULT_PORT, numClients, MAX_PACKET_SIZE, fps);
+    }
+
+    /**
+     *
+     * @param port
+     * @param numClients
+     * @param maxPacketSize
+     * @param fps
+     */
+    public UDPServer(int port, int numClients, int maxPacketSize, int fps) {
+        this.port = port;
+        this.numClients = numClients;
+        this.packetSize = maxPacketSize;
+        frameDuration = 1000 / fps;
+        clients = new ArrayList<UDPClientState>();
+    }
+
+    /**
+     *
+     */
+    public void run() {
+        DatagramChannel channel = null;
+        DatagramSocket socket = null;
+        ByteBuffer buffer = null;
+        try {
+            channel = DatagramChannel.open();
+            socket = channel.socket();
+            SocketAddress address = new InetSocketAddress(
+                    InetAddress.getLocalHost(), port);
+            socket.bind(address);
+            buffer = ByteBuffer.allocateDirect(packetSize);
+            System.out.println("Server running: " + address);
+            System.out.println("Heartbeat interval: " + frameDuration);
+            System.out.println("waiting for clients...");
+
+            // get the addresses-initialisation phase
+            while (clients.size() < numClients) {
+                clients.add(new UDPClientState(channel.receive(buffer)));
+                buffer.flip();
+                buffer.clear();
+            }
+            // server now knows the clients
+
+            // MAIN LOOP-server is working for the clients
+            while (true) {
+                long beginSynch = System.currentTimeMillis();
+                buffer.clear();
+                buffer.putInt(frameCount++);
+                buffer.flip();
+                Iterator<UDPClientState> iter = clients.iterator();
+                while (iter.hasNext()) {
+                    channel.send(buffer, iter.next().getAddress());
+                }
+                long endSynch = System.currentTimeMillis();
+                if (endSynch - beginSynch < frameDuration) {
+                    int sleep = frameDuration - (int) (endSynch - beginSynch);
+                    // System.out.println("sleeping: " + sleep);
+                    Thread.sleep(sleep);
+                } else {
+                    Thread.sleep(2);
+                }
+            }
+        } catch (Exception ex) {
+            System.err.println(ex);
+        } finally {
+            if (socket != null)
+                socket.close();
+            if (buffer != null)
+                buffer = null;
+            System.out.println("server shutdown.");
+        }
+    }
+}

data/src/toxi/audio/AudioBuffer.java

@@ -0,0 +1,229 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ * Modified and updated by Martin Prout December 2015
+ */
+
+package toxi.audio;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import com.jogamp.openal.AL;
+
+/**
+ * A wrapper for the actual sample data byte buffer in memory. The buffer can be
+ * queried to find out more information about the underlying audio data.
+ */
+public class AudioBuffer {
+
+    /**
+     * Format descriptor
+     */
+    public enum Format {
+        MONO8(AL.AL_FORMAT_MONO8, 8, 1), MONO16(AL.AL_FORMAT_MONO16, 16, 1), STEREO8(
+                AL.AL_FORMAT_STEREO8, 8, 2), STEREO16(AL.AL_FORMAT_STEREO16,
+                16, 2);
+
+        public static Format getForID(int id) {
+            Format format = null;
+            for (Format f : values()) {
+                if (f.id == id) {
+                    format = f;
+                    break;
+                }
+            }
+            return format;
+        }
+
+        private final int id;
+        private final int numBits;
+        private final int numChannels;
+
+        private Format(int id, int bits, int channels) {
+            this.id = id;
+            this.numBits = bits;
+            this.numChannels = channels;
+        }
+
+        public int getID() {
+            return id;
+        }
+
+        /**
+         * @return the numBits
+         */
+        public int getNumBits() {
+            return numBits;
+        }
+
+        /**
+         * @return the numChannels
+         */
+        public int getNumChannels() {
+            return numChannels;
+        }
+    }
+
+    protected final AL al;
+    protected ByteBuffer data;
+
+    protected final int id;
+
+    protected final int[] alResult = new int[1];
+    protected Format format;
+
+    public AudioBuffer(AL al, int bufferID) {
+        this.id = bufferID;
+        this.al = al;
+    }
+
+    public AudioBuffer configure(ByteBuffer data, Format format, int freq) {
+        return configure(data, format.getID(), freq);
+    }
+
+    /**
+     * Configure the audio buffer
+     * 
+     * @param data
+     *            the raw audio data
+     * @param format
+     *            the internal format ID of the audio data
+     * @param freq
+     *            the frequency of the data
+     * @return 
+     */
+    public AudioBuffer configure(ByteBuffer data, int format, int freq) {
+        this.data = data;
+        this.format = Format.getForID(format);
+        al.alBufferData(id, format, data, data.capacity(), freq);
+        return this;
+    }
+
+    public boolean convertUlawToPCM(boolean isAlaw) {
+        byte[] ulaw = new byte[getByteSize()];
+        data.rewind();
+        data.get(ulaw);
+        byte[] pcm = new byte[ulaw.length * 2];
+        ByteArrayInputStream bin = new ByteArrayInputStream(ulaw);
+        try {
+            new DecompressInputStream(bin, isAlaw).read(pcm);
+            configure(ByteBuffer.wrap(pcm), Format.MONO16, getFrequency());
+            return true;
+        } catch (IOException e) {
+        }
+        return false;
+    }
+
+    /**
+     * Deletes this buffer, and frees its resources.
+     * 
+     * @return true, if removed successfully
+     */
+    public boolean delete() {
+        data = null;
+        al.alDeleteBuffers(1, new int[] { id }, 0);
+        return al.alGetError() == AL.AL_NO_ERROR;
+    }
+
+    /**
+     * Get the bit-depth of the data, (8 or 16)
+     * 
+     * @return the bit-depth of the data
+     */
+    public final int getBitDepth() {
+        // al.alGetBufferi(id, AL.AL_BITS, alResult, 0);
+        // return alResult[0];
+        return format.getNumBits();
+    }
+
+    /**
+     * Gets the size (in bytes) of the raw data contained in this buffer.
+     * 
+     * @return the size of the data.
+     */
+    public final int getByteSize() {
+        // al.alGetBufferi(id, AL.AL_SIZE, alResult, 0);
+        // return alResult[0];
+        return data.capacity();
+    }
+
+    /**
+     * Gets the raw data contained in this buffer.
+     * 
+     * @return the raw buffer data.
+     */
+    public final ByteBuffer getData() {
+        return data;
+    }
+
+    /**
+     * Gets the audio frequency of the data contained in this buffer.
+     * 
+     * @return the frequency of the data
+     */
+    public final int getFrequency() {
+        al.alGetBufferi(id, AL.AL_FREQUENCY, alResult, 0);
+        return alResult[0];
+    }
+
+    /**
+     * Returns the OpenAL reference ID for this buffer.
+     * 
+     * @return buffer id
+     */
+    public final int getID() {
+        return id;
+    }
+
+    /**
+     * Get the number of channels of the data (1-Mono, 2-Stereo)
+     * 
+     * @return the number of audio channels.
+     */
+    public final int getNumChannels() {
+        // al.alGetBufferi(id, AL.AL_CHANNELS, alResult, 0);
+        // return alResult[0];
+        return format.getNumChannels();
+    }
+
+    /**
+     * Gets the size (in samples) of the raw data contained in this buffer.
+     * 
+     * @return sample size.
+     */
+    public final int getSampleSize() {
+        return getByteSize() * 8 / getBitDepth() / getNumChannels();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return "AudioBuffer: id=" + id + " format=" + format;
+    }
+}