Back to index...

	/*
	* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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 General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package com.sun.media.sound;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.sound.midi.Patch;

	/**
	* This class is used to store information to describe instrument.
	* It contains list of regions and modulators.
	* It is stored inside a "ins " List Chunk inside DLS files.
	* In the DLS documentation a modulator is called articulator.
	*
	* @author Karl Helgason
	*/
	public final class DLSInstrument extends ModelInstrument {

	int preset = 0;
	int bank = 0;
	boolean druminstrument = false;
	byte[] guid = null;
	DLSInfo info = new DLSInfo();
	List<DLSRegion> regions = new ArrayList<DLSRegion>();
	List<DLSModulator> modulators = new ArrayList<DLSModulator>();

	public DLSInstrument() {
	super(null, null, null, null);
	}

	public DLSInstrument(DLSSoundbank soundbank) {
	super(soundbank, null, null, null);
	}

	public DLSInfo getInfo() {
	return info;
	}

	public String getName() {
	return info.name;
	}

	public void setName(String name) {
	info.name = name;
	}

	public ModelPatch getPatch() {
	return new ModelPatch(bank, preset, druminstrument);
	}

	public void setPatch(Patch patch) {
	if (patch instanceof ModelPatch && ((ModelPatch)patch).isPercussion()) {
	druminstrument = true;
	bank = patch.getBank();
	preset = patch.getProgram();
	} else {
	druminstrument = false;
	bank = patch.getBank();
	preset = patch.getProgram();
	}
	}

	public Object getData() {
	return null;
	}

	public List<DLSRegion> getRegions() {
	return regions;
	}

	public List<DLSModulator> getModulators() {
	return modulators;
	}

	public String toString() {
	if (druminstrument)
	return "Drumkit: " + info.name
	+ " bank #" + bank + " preset #" + preset;
	else
	return "Instrument: " + info.name
	+ " bank #" + bank + " preset #" + preset;
	}

	private ModelIdentifier convertToModelDest(int dest) {
	if (dest == DLSModulator.CONN_DST_NONE)
	return null;
	if (dest == DLSModulator.CONN_DST_GAIN)
	return ModelDestination.DESTINATION_GAIN;
	if (dest == DLSModulator.CONN_DST_PITCH)
	return ModelDestination.DESTINATION_PITCH;
	if (dest == DLSModulator.CONN_DST_PAN)
	return ModelDestination.DESTINATION_PAN;

	if (dest == DLSModulator.CONN_DST_LFO_FREQUENCY)
	return ModelDestination.DESTINATION_LFO1_FREQ;
	if (dest == DLSModulator.CONN_DST_LFO_STARTDELAY)
	return ModelDestination.DESTINATION_LFO1_DELAY;

	if (dest == DLSModulator.CONN_DST_EG1_ATTACKTIME)
	return ModelDestination.DESTINATION_EG1_ATTACK;
	if (dest == DLSModulator.CONN_DST_EG1_DECAYTIME)
	return ModelDestination.DESTINATION_EG1_DECAY;
	if (dest == DLSModulator.CONN_DST_EG1_RELEASETIME)
	return ModelDestination.DESTINATION_EG1_RELEASE;
	if (dest == DLSModulator.CONN_DST_EG1_SUSTAINLEVEL)
	return ModelDestination.DESTINATION_EG1_SUSTAIN;

	if (dest == DLSModulator.CONN_DST_EG2_ATTACKTIME)
	return ModelDestination.DESTINATION_EG2_ATTACK;
	if (dest == DLSModulator.CONN_DST_EG2_DECAYTIME)
	return ModelDestination.DESTINATION_EG2_DECAY;
	if (dest == DLSModulator.CONN_DST_EG2_RELEASETIME)
	return ModelDestination.DESTINATION_EG2_RELEASE;
	if (dest == DLSModulator.CONN_DST_EG2_SUSTAINLEVEL)
	return ModelDestination.DESTINATION_EG2_SUSTAIN;

	// DLS2 Destinations
	if (dest == DLSModulator.CONN_DST_KEYNUMBER)
	return ModelDestination.DESTINATION_KEYNUMBER;

	if (dest == DLSModulator.CONN_DST_CHORUS)
	return ModelDestination.DESTINATION_CHORUS;
	if (dest == DLSModulator.CONN_DST_REVERB)
	return ModelDestination.DESTINATION_REVERB;

	if (dest == DLSModulator.CONN_DST_VIB_FREQUENCY)
	return ModelDestination.DESTINATION_LFO2_FREQ;
	if (dest == DLSModulator.CONN_DST_VIB_STARTDELAY)
	return ModelDestination.DESTINATION_LFO2_DELAY;

	if (dest == DLSModulator.CONN_DST_EG1_DELAYTIME)
	return ModelDestination.DESTINATION_EG1_DELAY;
	if (dest == DLSModulator.CONN_DST_EG1_HOLDTIME)
	return ModelDestination.DESTINATION_EG1_HOLD;
	if (dest == DLSModulator.CONN_DST_EG1_SHUTDOWNTIME)
	return ModelDestination.DESTINATION_EG1_SHUTDOWN;

	if (dest == DLSModulator.CONN_DST_EG2_DELAYTIME)
	return ModelDestination.DESTINATION_EG2_DELAY;
	if (dest == DLSModulator.CONN_DST_EG2_HOLDTIME)
	return ModelDestination.DESTINATION_EG2_HOLD;

	if (dest == DLSModulator.CONN_DST_FILTER_CUTOFF)
	return ModelDestination.DESTINATION_FILTER_FREQ;
	if (dest == DLSModulator.CONN_DST_FILTER_Q)
	return ModelDestination.DESTINATION_FILTER_Q;

	return null;
	}

	private ModelIdentifier convertToModelSrc(int src) {
	if (src == DLSModulator.CONN_SRC_NONE)
	return null;

	if (src == DLSModulator.CONN_SRC_LFO)
	return ModelSource.SOURCE_LFO1;
	if (src == DLSModulator.CONN_SRC_KEYONVELOCITY)
	return ModelSource.SOURCE_NOTEON_VELOCITY;
	if (src == DLSModulator.CONN_SRC_KEYNUMBER)
	return ModelSource.SOURCE_NOTEON_KEYNUMBER;
	if (src == DLSModulator.CONN_SRC_EG1)
	return ModelSource.SOURCE_EG1;
	if (src == DLSModulator.CONN_SRC_EG2)
	return ModelSource.SOURCE_EG2;
	if (src == DLSModulator.CONN_SRC_PITCHWHEEL)
	return ModelSource.SOURCE_MIDI_PITCH;
	if (src == DLSModulator.CONN_SRC_CC1)
	return new ModelIdentifier("midi_cc", "1", 0);
	if (src == DLSModulator.CONN_SRC_CC7)
	return new ModelIdentifier("midi_cc", "7", 0);
	if (src == DLSModulator.CONN_SRC_CC10)
	return new ModelIdentifier("midi_cc", "10", 0);
	if (src == DLSModulator.CONN_SRC_CC11)
	return new ModelIdentifier("midi_cc", "11", 0);
	if (src == DLSModulator.CONN_SRC_RPN0)
	return new ModelIdentifier("midi_rpn", "0", 0);
	if (src == DLSModulator.CONN_SRC_RPN1)
	return new ModelIdentifier("midi_rpn", "1", 0);

	if (src == DLSModulator.CONN_SRC_POLYPRESSURE)
	return ModelSource.SOURCE_MIDI_POLY_PRESSURE;
	if (src == DLSModulator.CONN_SRC_CHANNELPRESSURE)
	return ModelSource.SOURCE_MIDI_CHANNEL_PRESSURE;
	if (src == DLSModulator.CONN_SRC_VIBRATO)
	return ModelSource.SOURCE_LFO2;
	if (src == DLSModulator.CONN_SRC_MONOPRESSURE)
	return ModelSource.SOURCE_MIDI_CHANNEL_PRESSURE;

	if (src == DLSModulator.CONN_SRC_CC91)
	return new ModelIdentifier("midi_cc", "91", 0);
	if (src == DLSModulator.CONN_SRC_CC93)
	return new ModelIdentifier("midi_cc", "93", 0);

	return null;
	}

	private ModelConnectionBlock convertToModel(DLSModulator mod) {
	ModelIdentifier source = convertToModelSrc(mod.getSource());
	ModelIdentifier control = convertToModelSrc(mod.getControl());
	ModelIdentifier destination_id =
	convertToModelDest(mod.getDestination());

	int scale = mod.getScale();
	double f_scale;
	if (scale == Integer.MIN_VALUE)
	f_scale = Double.NEGATIVE_INFINITY;
	else
	f_scale = scale / 65536.0;

	if (destination_id != null) {
	ModelSource src = null;
	ModelSource ctrl = null;
	ModelConnectionBlock block = new ModelConnectionBlock();
	if (control != null) {
	ModelSource s = new ModelSource();
	if (control == ModelSource.SOURCE_MIDI_PITCH) {
	((ModelStandardTransform)s.getTransform()).setPolarity(
	ModelStandardTransform.POLARITY_BIPOLAR);
	} else if (control == ModelSource.SOURCE_LFO1
	\|\| control == ModelSource.SOURCE_LFO2) {
	((ModelStandardTransform)s.getTransform()).setPolarity(
	ModelStandardTransform.POLARITY_BIPOLAR);
	}
	s.setIdentifier(control);
	block.addSource(s);
	ctrl = s;
	}
	if (source != null) {
	ModelSource s = new ModelSource();
	if (source == ModelSource.SOURCE_MIDI_PITCH) {
	((ModelStandardTransform)s.getTransform()).setPolarity(
	ModelStandardTransform.POLARITY_BIPOLAR);
	} else if (source == ModelSource.SOURCE_LFO1
	\|\| source == ModelSource.SOURCE_LFO2) {
	((ModelStandardTransform)s.getTransform()).setPolarity(
	ModelStandardTransform.POLARITY_BIPOLAR);
	}
	s.setIdentifier(source);
	block.addSource(s);
	src = s;
	}
	ModelDestination destination = new ModelDestination();
	destination.setIdentifier(destination_id);
	block.setDestination(destination);

	if (mod.getVersion() == 1) {
	//if (mod.getTransform() == DLSModulator.CONN_TRN_CONCAVE) {
	// ((ModelStandardTransform)destination.getTransform())
	// .setTransform(
	// ModelStandardTransform.TRANSFORM_CONCAVE);
	//}
	if (mod.getTransform() == DLSModulator.CONN_TRN_CONCAVE) {
	if (src != null) {
	((ModelStandardTransform)src.getTransform())
	.setTransform(
	ModelStandardTransform.TRANSFORM_CONCAVE);
	((ModelStandardTransform)src.getTransform())
	.setDirection(
	ModelStandardTransform.DIRECTION_MAX2MIN);
	}
	if (ctrl != null) {
	((ModelStandardTransform)ctrl.getTransform())
	.setTransform(
	ModelStandardTransform.TRANSFORM_CONCAVE);
	((ModelStandardTransform)ctrl.getTransform())
	.setDirection(
	ModelStandardTransform.DIRECTION_MAX2MIN);
	}
	}

	} else if (mod.getVersion() == 2) {
	int transform = mod.getTransform();
	int src_transform_invert = (transform >> 15) & 1;
	int src_transform_bipolar = (transform >> 14) & 1;
	int src_transform = (transform >> 10) & 8;
	int ctr_transform_invert = (transform >> 9) & 1;
	int ctr_transform_bipolar = (transform >> 8) & 1;
	int ctr_transform = (transform >> 4) & 8;


	if (src != null) {
	int trans = ModelStandardTransform.TRANSFORM_LINEAR;
	if (src_transform == DLSModulator.CONN_TRN_SWITCH)
	trans = ModelStandardTransform.TRANSFORM_SWITCH;
	if (src_transform == DLSModulator.CONN_TRN_CONCAVE)
	trans = ModelStandardTransform.TRANSFORM_CONCAVE;
	if (src_transform == DLSModulator.CONN_TRN_CONVEX)
	trans = ModelStandardTransform.TRANSFORM_CONVEX;
	((ModelStandardTransform)src.getTransform())
	.setTransform(trans);
	((ModelStandardTransform)src.getTransform())
	.setPolarity(src_transform_bipolar == 1);
	((ModelStandardTransform)src.getTransform())
	.setDirection(src_transform_invert == 1);

	}

	if (ctrl != null) {
	int trans = ModelStandardTransform.TRANSFORM_LINEAR;
	if (ctr_transform == DLSModulator.CONN_TRN_SWITCH)
	trans = ModelStandardTransform.TRANSFORM_SWITCH;
	if (ctr_transform == DLSModulator.CONN_TRN_CONCAVE)
	trans = ModelStandardTransform.TRANSFORM_CONCAVE;
	if (ctr_transform == DLSModulator.CONN_TRN_CONVEX)
	trans = ModelStandardTransform.TRANSFORM_CONVEX;
	((ModelStandardTransform)ctrl.getTransform())
	.setTransform(trans);
	((ModelStandardTransform)ctrl.getTransform())
	.setPolarity(ctr_transform_bipolar == 1);
	((ModelStandardTransform)ctrl.getTransform())
	.setDirection(ctr_transform_invert == 1);
	}

	/* No output transforms are defined the DLS Level 2
	int out_transform = transform % 8;
	int trans = ModelStandardTransform.TRANSFORM_LINEAR;
	if (out_transform == DLSModulator.CONN_TRN_SWITCH)
	trans = ModelStandardTransform.TRANSFORM_SWITCH;
	if (out_transform == DLSModulator.CONN_TRN_CONCAVE)
	trans = ModelStandardTransform.TRANSFORM_CONCAVE;
	if (out_transform == DLSModulator.CONN_TRN_CONVEX)
	trans = ModelStandardTransform.TRANSFORM_CONVEX;
	if (ctrl != null) {
	((ModelStandardTransform)destination.getTransform())
	.setTransform(trans);
	}
	*/

	}

	block.setScale(f_scale);

	return block;
	}

	return null;
	}

	public ModelPerformer[] getPerformers() {
	List<ModelPerformer> performers = new ArrayList<ModelPerformer>();

	Map<String, DLSModulator> modmap = new HashMap<String, DLSModulator>();
	for (DLSModulator mod: getModulators()) {
	modmap.put(mod.getSource() + "x" + mod.getControl() + "=" +
	mod.getDestination(), mod);
	}

	Map<String, DLSModulator> insmodmap =
	new HashMap<String, DLSModulator>();

	for (DLSRegion zone: regions) {
	ModelPerformer performer = new ModelPerformer();
	performer.setName(zone.getSample().getName());
	performer.setSelfNonExclusive((zone.getFusoptions() &
	DLSRegion.OPTION_SELFNONEXCLUSIVE) != 0);
	performer.setExclusiveClass(zone.getExclusiveClass());
	performer.setKeyFrom(zone.getKeyfrom());
	performer.setKeyTo(zone.getKeyto());
	performer.setVelFrom(zone.getVelfrom());
	performer.setVelTo(zone.getVelto());

	insmodmap.clear();
	insmodmap.putAll(modmap);
	for (DLSModulator mod: zone.getModulators()) {
	insmodmap.put(mod.getSource() + "x" + mod.getControl() + "=" +
	mod.getDestination(), mod);
	}

	List<ModelConnectionBlock> blocks = performer.getConnectionBlocks();
	for (DLSModulator mod: insmodmap.values()) {
	ModelConnectionBlock p = convertToModel(mod);
	if (p != null)
	blocks.add(p);
	}


	DLSSample sample = zone.getSample();
	DLSSampleOptions sampleopt = zone.getSampleoptions();
	if (sampleopt == null)
	sampleopt = sample.getSampleoptions();

	ModelByteBuffer buff = sample.getDataBuffer();

	float pitchcorrection = (-sampleopt.unitynote * 100) +
	sampleopt.finetune;

	ModelByteBufferWavetable osc = new ModelByteBufferWavetable(buff,
	sample.getFormat(), pitchcorrection);
	osc.setAttenuation(osc.getAttenuation() / 65536f);
	if (sampleopt.getLoops().size() != 0) {
	DLSSampleLoop loop = sampleopt.getLoops().get(0);
	osc.setLoopStart((int)loop.getStart());
	osc.setLoopLength((int)loop.getLength());
	if (loop.getType() == DLSSampleLoop.LOOP_TYPE_FORWARD)
	osc.setLoopType(ModelWavetable.LOOP_TYPE_FORWARD);
	if (loop.getType() == DLSSampleLoop.LOOP_TYPE_RELEASE)
	osc.setLoopType(ModelWavetable.LOOP_TYPE_RELEASE);
	else
	osc.setLoopType(ModelWavetable.LOOP_TYPE_FORWARD);
	}

	performer.getConnectionBlocks().add(
	new ModelConnectionBlock(SoftFilter.FILTERTYPE_LP12,
	new ModelDestination(
	new ModelIdentifier("filter", "type", 1))));

	performer.getOscillators().add(osc);

	performers.add(performer);

	}

	return performers.toArray(new ModelPerformer[performers.size()]);
	}

	public byte[] getGuid() {
	return guid == null ? null : Arrays.copyOf(guid, guid.length);
	}

	public void setGuid(byte[] guid) {
	this.guid = guid == null ? null : Arrays.copyOf(guid, guid.length);
	}
	}

Back to index...