annotate host/host.java @ 31:d8ff8c5ad52a

Add host program, working like a minimal version of vamp-simple-host

import java.util.ArrayList;
import java.util.TreeMap;
import java.util.Map;
import java.util.List;
import java.lang.RuntimeException;

import org.vamp_plugins.PluginLoader;
import org.vamp_plugins.Plugin;
import org.vamp_plugins.ParameterDescriptor;
import org.vamp_plugins.OutputDescriptor;
import org.vamp_plugins.Feature;
import org.vamp_plugins.RealTime;

import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.UnsupportedAudioFileException;

import java.io.File;
import java.io.IOException;

public class host
{
    private static void printFeatures(RealTime frameTime, Integer output,
				      Map<Integer, ArrayList<Feature>> features)
    {
	if (!features.containsKey(output)) return;

	for (Feature f : features.get(output)) {
	    if (f.hasTimestamp) {
		System.out.print(f.timestamp);
	    } else {
		System.out.print(frameTime);
	    }
	    if (f.hasDuration) {
		System.out.print("," + f.duration);
	    }
	    System.out.print(":");
	    for (float v : f.values) {
		System.out.print(" " + v);
	    }
	    System.out.print(" " + f.label);
	    System.out.println("");
	}
    }

    private static void usage() {
	System.err.println("Usage: host pluginlibrary:plugin:output file.wav");
    }

    private static int readBlock(AudioFormat format, AudioInputStream stream,
				 float[][] buffers)
	throws java.io.IOException
    {
	// 16-bit LE signed PCM only
	int channels = format.getChannels();
	byte[] raw = new byte[buffers[0].length * channels * 2];
	int read = stream.read(raw);
	if (read < 0) return read;
	int frames = read / (channels * 2);
	for (int i = 0; i < frames; ++i) {
	    for (int c = 0; c < channels; ++c) {
		int ix = i * channels + c;
		int ival = (raw[ix*2] & 0xff) | (raw[ix*2 + 1] << 8);
		float fval = ival / 32768.0f;
		buffers[c][i] = fval;
	    }
	}
	return frames;
    }

    public static void main(String[] args)
    {
	if (args.length < 2) {
	    usage();
	    return;
	}

	PluginLoader loader = PluginLoader.getInstance();

	String key = args[0];
	String filename = args[1];

	String[] keyparts = key.split(":");
	if (keyparts.length < 3) {
	    usage();
	    return;
	}
	
	String pluginKey = keyparts[0] + ":" + keyparts[1];
	String outputKey = keyparts[2];

	try {
	    File f = new File(filename);
	    AudioInputStream stream = AudioSystem.getAudioInputStream(f);
	    AudioFormat format = stream.getFormat();

	    if (format.getSampleSizeInBits() != 16 ||
		format.getEncoding() != AudioFormat.Encoding.PCM_SIGNED ||
		format.isBigEndian()) {
		System.err.println("Sorry, only 16-bit signed little-endian PCM files supported");
		return;
	    }

	    float rate = format.getFrameRate();
	    int channels = format.getChannels();
	    int bytesPerFrame = format.getFrameSize();
	    int blockSize = 1024; // frames

	    Plugin p = loader.loadPlugin
		(pluginKey, rate, PluginLoader.AdapterFlags.ADAPT_ALL);

	    OutputDescriptor[] outputs = p.getOutputDescriptors();
	    int outputNumber = -1;
	    for (int i = 0; i < outputs.length; ++i) {
		if (outputs[i].identifier.equals(outputKey)) outputNumber = i;
	    }
	    if (outputNumber < 0) {
		System.err.println("Plugin lacks output id: " + outputKey);
		System.err.print("Outputs are:");
		for (int i = 0; i < outputs.length; ++i) {
		    System.err.print(" " + outputs[i].identifier);
		}
		System.err.println("");
		return;
	    }
	    
	    boolean b = p.initialise(channels, blockSize, blockSize);
	    if (!b) {
		System.err.println("Plugin initialise failed");
		return;
	    }
	    
	    float[][] buffers = new float[channels][blockSize];

	    boolean done = false;
	    boolean incomplete = false;
	    int block = 0;

	    while (!done) {

		for (int c = 0; c < channels; ++c) {
		    for (int i = 0; i < blockSize; ++i) {
			buffers[c][i] = 0.0f;
		    }
		}

		int read = readBlock(format, stream, buffers);

		if (read < 0) {
		    done = true;
		} else {

		    if (incomplete) {
			// An incomplete block is only OK if it's the
			// last one -- so if the previous block was
			// incomplete, we have trouble
			System.err.println("Audio file read incomplete! Short buffer detected at " + block * blockSize);
			return;
		    }
		    
		    incomplete = (read < buffers[0].length);

		    RealTime timestamp = RealTime.frame2RealTime
			(block * blockSize, (int)(rate + 0.5));

		    TreeMap<Integer, ArrayList<Feature>>
			features = p.process(buffers, timestamp);

		    printFeatures(timestamp, outputNumber, features);

		    timestamp.dispose();
		}
		
		++block;
	    }

	    TreeMap<Integer, ArrayList<Feature>>
		features = p.getRemainingFeatures();

	    RealTime timestamp = RealTime.frame2RealTime
		(block * blockSize, (int)(rate + 0.5));
	    printFeatures(timestamp, outputNumber, features);
	    timestamp.dispose();

	    p.dispose();

	} catch (java.io.IOException e) {
	    System.err.println("Failed to read audio file: " + e.getMessage());

	} catch (javax.sound.sampled.UnsupportedAudioFileException e) {
	    System.err.println("Unsupported audio file format: " + e.getMessage());

	} catch (PluginLoader.LoadFailedException e) {
	    System.err.println("Plugin load failed (unknown plugin?): key is " +
			       key);
	}
    }
}