annotate src/org/qmul/eecs/c4dm/sia/midi/MidiParser.java @ 37:cb7f70e10a0c

New

package org.qmul.eecs.c4dm.sia.midi;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.SysexMessage;
import javax.sound.midi.Track;

import org.qmul.eecs.c4dm.sia.model.Datapoint;
import org.qmul.eecs.c4dm.sia.model.DimensionValue;
import org.qmul.eecs.c4dm.sia.rdf.Namespaces;

import com.hp.hpl.jena.ontology.OntClass;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntResource;
import com.hp.hpl.jena.rdf.model.AnonId;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.NodeIterator;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.util.iterator.ExtendedIterator;
import com.hp.hpl.jena.vocabulary.RDF;
import com.sun.media.sound.MidiUtils;

public class MidiParser {
	
	public static final int TIME_DIMENSION = 1;
	public static final int PITCH_DIMENSION = 2;
	public static final int CHANNEL_DIMENSION = 3;

	// The ontology loaded as dataset
	private static final String ontology = "file:src/rdf/siaDatapointOntology.n3";

	// The final output file
	private static final String finalModelFileName = "src/rdf/midiModel";

	public static void main(String[] args)
	{
		// First create a Jena ontology model
		OntModel ontModel = ModelFactory
				.createOntologyModel(); // OntModelSpec.OWL_MEM

		// Then read the data from the file into the ontology model
		ontModel.read(ontology, "N3");
		
		// Set the value of SIA_NS_URI as the namespace for 'sia' found in
		// the ontology. This must be done before we use any of the sia.model classes.
		Namespaces.SIA_NS_URI = ontModel.getNsPrefixURI("sia");
		OntClass datapointClass = ontModel.getOntClass(Datapoint.RESOURCE_URI);
		Resource datapointResource = ontModel.getOntResource(datapointClass);
		Property siaDimValProperty = ontModel.createProperty(DimensionValue.PROPERTY_URI);
		Property siaDimensionProperty = ontModel.createProperty(DimensionValue.DIMENSION_URI);
		Property siaValueProperty = ontModel.createProperty(DimensionValue.VALUE_URI);

		String midiFileName = "/Volumes/USB DISK/portable/ewerts/Cantata_16_no_5-mids/score.mid";

		File midiFile1 = new File(midiFileName);
	
		Sequence sequence = null;
		try {
			sequence = MidiSystem.getSequence(midiFile1);
		} catch (InvalidMidiDataException e) {
			e.printStackTrace();
			System.exit(1);
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
		
		MidiUtils.TempoCache tempoCache = new MidiUtils.TempoCache(sequence);

		Track[] tracks = sequence.getTracks();
		int numTracks = tracks.length;
		float divisionType = sequence.getDivisionType();
	    List<Datapoint> datapoints = new ArrayList<Datapoint>();
		
		HashMap<Integer, Integer> trackDimensionMap = getTrackToDimensionIndexMap(sequence);
		
		if (trackDimensionMap.isEmpty())
		{
			try {
				throw new Exception("Couldn't find any track to dimension mappings");
			} catch (Exception e) {
				e.printStackTrace();
				System.exit(1);
			}
		}
		
		long maxTick = 0;
				
		for (int trackIdx = 0; trackIdx < numTracks; trackIdx++)
		{
			System.out.println("Track " + trackIdx + ":");
			int numEvents = tracks[trackIdx].size();
			for (int eventIdx = 0; eventIdx < numEvents; eventIdx++)
			{
				MidiEvent event = tracks[trackIdx].get(eventIdx);
				long tick = event.getTick();
				MidiMessage midiMessage = event.getMessage();
				
				int midiMessageLength = midiMessage.getLength();
				byte[] messageBytes = midiMessage.getMessage();
				int status = midiMessage.getStatus();
				System.out.println("tick = " + tick + " midiMessageLength = " + midiMessageLength + " status byte = " + status);

				int s = status & 0x80;
				if (s == 0x80)
				{
					System.out.println("STATUS MESSAGE (s = " + s + ")");
				}
				else
				{
					System.out.println("not a status message (s = " + s + ")");
				}
					
				// Determine the type of this message (short, sysex or meta)
				if (midiMessage instanceof ShortMessage)
				{
					System.out.print("ShortMessage ");
										
					// Determine which command is being issued
					ShortMessage shortMessage = (ShortMessage)midiMessage;
					int messageCommand = shortMessage.getCommand();
					int channel = shortMessage.getChannel();
					int data1 = shortMessage.getData1();
					int data2 = shortMessage.getData2();

					if (messageCommand == ShortMessage.ACTIVE_SENSING)
					{
						System.out.print("ignoring ACTIVE_SENSING");
					}
					else if (messageCommand == ShortMessage.CHANNEL_PRESSURE)
					{
						System.out.print("ignoring CHANNEL_PRESSURE");
					}
					else if (messageCommand == ShortMessage.CONTINUE)
					{
						System.out.print("ignoring CONTINUE");
					}
					else if (messageCommand == ShortMessage.CONTROL_CHANGE)
					{
						System.out.print("ignoring CONTROL_CHANGE");
					}
					else if (messageCommand == ShortMessage.END_OF_EXCLUSIVE)
					{
						System.out.print("ignoring END_OF_EXCLUSIVE");
					}
					else if (messageCommand == ShortMessage.MIDI_TIME_CODE)
					{
						System.out.print("ignoring MIDI_TIME_CODE");
					}
					else if (messageCommand == ShortMessage.NOTE_OFF)
					{
						System.out.println("NOTE_OFF");
						long microsecs = MidiUtils.tick2microsecond(sequence, tick, tempoCache);
						System.out.println(" microsecs = " + microsecs);
					}
					else if (messageCommand == ShortMessage.NOTE_ON)
					{
						if (tick > maxTick)
						{
							maxTick = tick;
						}
						System.out.println("NOTE_ON");
						long microsecs = MidiUtils.tick2microsecond(sequence, tick, tempoCache);
						System.out.println(" microsecs = " + microsecs);
						
						DimensionValue timeDimVal = new DimensionValue();
						timeDimVal.setDimension(TIME_DIMENSION);
						timeDimVal.setValue(tick);
						
						DimensionValue dimVal = new DimensionValue();
						dimVal.setDimension(trackDimensionMap.get(trackIdx));
						dimVal.setValue(data1);
						
						Datapoint datapoint = new Datapoint();
						Vector<DimensionValue> dimVals = new Vector<DimensionValue>();
						dimVals.add(timeDimVal);
						dimVals.add(dimVal);
						
						datapoint.setDimensionValues(dimVals);
						datapoints.add(datapoint);
						
						// RDF
						Resource datapointBnode = ontModel.createResource(AnonId.create());
						ontModel.add(datapointBnode, RDF.type, datapointResource);

						Resource timeDimValBnode = ontModel.createResource(AnonId.create());
						Resource pitchDimValBnode = ontModel.createResource(AnonId.create());

						ontModel.add(datapointBnode, siaDimValProperty, timeDimValBnode);
						ontModel.addLiteral(timeDimValBnode, siaDimensionProperty, TIME_DIMENSION);
						ontModel.addLiteral(timeDimValBnode, siaValueProperty, tick);

						ontModel.add(datapointBnode, siaDimValProperty, pitchDimValBnode);
						ontModel.addLiteral(pitchDimValBnode, siaDimensionProperty, trackDimensionMap.get(trackIdx).intValue());
						ontModel.addLiteral(pitchDimValBnode, siaValueProperty, data1);
					}
					else if (messageCommand == ShortMessage.PITCH_BEND)
					{
						System.out.print("ignoring PITCH_BEND");
					}
					else if (messageCommand == ShortMessage.POLY_PRESSURE)
					{
						System.out.print("ignoring POLY_PRESSURE");
					}
					else if (messageCommand == ShortMessage.PROGRAM_CHANGE)
					{
						System.out.print("ignoring PROGRAM_CHANGE");
					}
					else if (messageCommand == ShortMessage.SONG_POSITION_POINTER)
					{
						System.out.print("ignoring SONG_POSITION_POINTER");
					}
					else
					{
						System.out.print("unrecognised midi message command (" + messageCommand + ")");
					}
					System.out.print(", channel " + channel + ", data1 = [" + data1 + "], data2 = [" + data2 + "]");
					System.out.println();
				}
				else if (midiMessage instanceof MetaMessage)
				{
					System.out.println("MetaMessage");
					
					MetaMessage metaMessage = (MetaMessage)midiMessage;
					byte[] metaMessageData = metaMessage.getData();
					int metaMessageLength = metaMessage.getLength();
					int metaMessageType = metaMessage.getType();
					System.out.println("metaMessageType = " + metaMessageType + ", metaMessageLength = " + metaMessageLength);
					
					// Determine message type
					if (metaMessageType == 81)
					{
						if (divisionType == Sequence.PPQ)
						{
							// Do nothing - we've dealt with PPQ tempo data elsewhere
						}
						else
						{
							try {
								throw new Exception("Not yet implemented SMPTE tempo metadata");
							} catch (Exception e) {
								e.printStackTrace();
								System.exit(1);
							}
						}
					}

					for (int dataIdx = 0; dataIdx < metaMessageData.length; dataIdx++)
					{
						System.out.println("\tmetaMessageData[" + dataIdx + "] = " + (metaMessageType == 81 ? metaMessageData[dataIdx] : (char)metaMessageData[dataIdx]));
					}

				}
				else if (midiMessage instanceof SysexMessage)
				{
					// We can safely ignore these messages
					System.out.println("ignoring SysexMessage");
				}
				else
				{
					System.out.println("Unknown MidiMessage type (" + midiMessage.getClass().toString() + ")");
				}
				
				for (int byteIdx = 0; byteIdx < midiMessageLength; byteIdx++)
				{
					byte messageByte = messageBytes[byteIdx];
					System.out.println("\tbyte[" + byteIdx + "] = " + messageByte);
				}
			}
		}

		// Data integrity start - set any 'missing' dimensions to zero value
		// Note the highest dimension for later use
		Collection<Integer> values = trackDimensionMap.values();
		Iterator<Integer> valuesIter = values.iterator();
		int maxDimension = 0;
		while (valuesIter.hasNext())
		{
			Integer value = valuesIter.next();
			if (value > maxDimension)
			{
				maxDimension = value;
			}
		}

		// Iterate over all datapoints
		ExtendedIterator<? extends OntResource> datapointIter = datapointClass.listInstances();
		OntResource datapointIndividual;
		OntModel ontModelTemp = ModelFactory
				.createOntologyModel(); // OntModelSpec.OWL_MEM

		while (datapointIter.hasNext())
		{
			datapointIndividual = datapointIter.next();
		
			// Find all Dimension Values for this datapoint
			NodeIterator dimValIter = datapointIndividual.listPropertyValues(siaDimValProperty);
			
			// Create a hashmap of dimensions for this datapoint
			HashMap<Integer, Boolean> dimensions = new HashMap<>();
			while (dimValIter.hasNext())
			{
				RDFNode dimVal = dimValIter.next();
				NodeIterator dims = ontModel.listObjectsOfProperty(dimVal.asResource(), siaDimensionProperty);
				while (dims.hasNext())
				{
					int dim = dims.next().asLiteral().getInt();
					dimensions.put(dim, true);
					System.out.println(dim);
				}
			}
			
			for (int i = 2; i <= maxDimension; i++)
			{
				if (!dimensions.containsKey(i))
				{
					Resource zeroValDimValBnode = ontModel.createResource(AnonId.create());

					Resource dpResource = datapointIndividual.asResource();
					ontModelTemp.add(dpResource, siaDimValProperty, zeroValDimValBnode);
					ontModelTemp.addLiteral(zeroValDimValBnode, siaDimensionProperty, i);
					ontModelTemp.addLiteral(zeroValDimValBnode, siaValueProperty, 0);					
				}
			}
			
		}
		ontModel.add(ontModelTemp);
		// Data integrity end

		System.out.println("done");
	    	    
		// Print out what we've got now
		System.out.println("------------------");
		StmtIterator stmtIterator = ontModel.listStatements();
		printStmts(stmtIterator);

		// Write rdf to file
		File outFileRdf = new File(finalModelFileName + ".rdf");
		File outFileN3 = new File(finalModelFileName + ".n3");
		FileOutputStream outFileOutputStreamRdf = null;
		FileOutputStream outFileOutputStreamN3 = null;

		// RDF/XML version
		try {
			outFileOutputStreamRdf = new FileOutputStream(outFileRdf);
			ontModel.writeAll(outFileOutputStreamRdf, "RDF/XML", null);
		} catch (FileNotFoundException e) {
			System.out.println("Unable to write to file: "
					+ outFileRdf.getAbsolutePath());
			e.printStackTrace();
			System.exit(1);
		}

		try {
			outFileOutputStreamRdf.close();
		} catch (IOException e1) {
			e1.printStackTrace();
			System.exit(1);
		}

		// N3 version
		try {
			outFileOutputStreamN3 = new FileOutputStream(outFileN3);
			ontModel.writeAll(outFileOutputStreamN3, "N3", null);
		} catch (FileNotFoundException e) {
			System.out.println("Unable to write to file: "
					+ outFileN3.getAbsolutePath());
			e.printStackTrace();
			System.exit(1);
		}

		try {
			outFileOutputStreamN3.close();
		} catch (IOException e1) {
			e1.printStackTrace();
			System.exit(1);
		}

		System.out.println("Model written to files: "
				+ outFileRdf.getAbsolutePath() + " and " + outFileN3.getAbsolutePath());
		
		System.out.println("max tick: " + maxTick);
		
	}

	private static HashMap<Integer, Integer> getTrackToDimensionIndexMap(Sequence sequence) {
		
		int numTracks = sequence.getTracks().length;
		int siaDatapointDimension = 2; // Dimension 1 is reserved for time

		HashMap<Integer, Integer> trackDimensionMap = new HashMap<Integer, Integer>();
		Track[] tracks = sequence.getTracks();
		
		for (int trackIdx = 0; trackIdx < numTracks; trackIdx++)
		{
			boolean trackIsAudible = false;
			int numEvents = tracks[trackIdx].size();

			for (int eventIdx = 0; eventIdx < numEvents; eventIdx++)
			{
				MidiEvent event = tracks[trackIdx].get(eventIdx);
				MidiMessage midiMessage = event.getMessage();
				
				// Determine the type of this message (short, sysex or meta)
				if (midiMessage instanceof ShortMessage)
				{
					// Determine which command is being issued
					ShortMessage shortMessage = (ShortMessage)midiMessage;
					int messageCommand = shortMessage.getCommand();

					if (messageCommand == ShortMessage.NOTE_ON)
					{
						trackIsAudible = true;
						break;
					}
				}
			}

			if (trackIsAudible)
			{
				trackDimensionMap.put(trackIdx, siaDatapointDimension);
				siaDatapointDimension++;
			}
		}

		return trackDimensionMap;
	}

	private static void printStmts(StmtIterator iter) {
		Statement statement;

		while (iter.hasNext()) {
			statement = iter.nextStatement();
			System.out.println(" | <" + statement.getSubject() + "> | <"
					+ statement.getPredicate() + "> | <"
					+ statement.getObject() + "> | ");
		}

		// And an empty line to make it pretty
		System.out.println();
	}
}