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.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Stack;

	import javax.sound.midi.Instrument;
	import javax.sound.midi.Patch;
	import javax.sound.midi.Soundbank;
	import javax.sound.midi.SoundbankResource;
	import javax.sound.sampled.AudioFormat;
	import javax.sound.sampled.AudioInputStream;
	import javax.sound.sampled.AudioSystem;
	import javax.sound.sampled.AudioFormat.Encoding;

	/**
	* A DLS Level 1 and Level 2 soundbank reader (from files/url/streams).
	*
	* @author Karl Helgason
	*/
	public final class DLSSoundbank implements Soundbank {

	static private class DLSID {
	long i1;
	int s1;
	int s2;
	int x1;
	int x2;
	int x3;
	int x4;
	int x5;
	int x6;
	int x7;
	int x8;

	private DLSID() {
	}

	DLSID(long i1, int s1, int s2, int x1, int x2, int x3, int x4,
	int x5, int x6, int x7, int x8) {
	this.i1 = i1;
	this.s1 = s1;
	this.s2 = s2;
	this.x1 = x1;
	this.x2 = x2;
	this.x3 = x3;
	this.x4 = x4;
	this.x5 = x5;
	this.x6 = x6;
	this.x7 = x7;
	this.x8 = x8;
	}

	public static DLSID read(RIFFReader riff) throws IOException {
	DLSID d = new DLSID();
	d.i1 = riff.readUnsignedInt();
	d.s1 = riff.readUnsignedShort();
	d.s2 = riff.readUnsignedShort();
	d.x1 = riff.readUnsignedByte();
	d.x2 = riff.readUnsignedByte();
	d.x3 = riff.readUnsignedByte();
	d.x4 = riff.readUnsignedByte();
	d.x5 = riff.readUnsignedByte();
	d.x6 = riff.readUnsignedByte();
	d.x7 = riff.readUnsignedByte();
	d.x8 = riff.readUnsignedByte();
	return d;
	}

	public int hashCode() {
	return (int)i1;
	}

	public boolean equals(Object obj) {
	if (!(obj instanceof DLSID)) {
	return false;
	}
	DLSID t = (DLSID) obj;
	return i1 == t.i1 && s1 == t.s1 && s2 == t.s2
	&& x1 == t.x1 && x2 == t.x2 && x3 == t.x3 && x4 == t.x4
	&& x5 == t.x5 && x6 == t.x6 && x7 == t.x7 && x8 == t.x8;
	}
	}

	/** X = X & Y */
	private static final int DLS_CDL_AND = 0x0001;
	/** X = X \| Y */
	private static final int DLS_CDL_OR = 0x0002;
	/** X = X ^ Y */
	private static final int DLS_CDL_XOR = 0x0003;
	/** X = X + Y */
	private static final int DLS_CDL_ADD = 0x0004;
	/** X = X - Y */
	private static final int DLS_CDL_SUBTRACT = 0x0005;
	/** X = X * Y */
	private static final int DLS_CDL_MULTIPLY = 0x0006;
	/** X = X / Y */
	private static final int DLS_CDL_DIVIDE = 0x0007;
	/** X = X && Y */
	private static final int DLS_CDL_LOGICAL_AND = 0x0008;
	/** X = X \|\| Y */
	private static final int DLS_CDL_LOGICAL_OR = 0x0009;
	/** X = (X < Y) */
	private static final int DLS_CDL_LT = 0x000A;
	/** X = (X <= Y) */
	private static final int DLS_CDL_LE = 0x000B;
	/** X = (X > Y) */
	private static final int DLS_CDL_GT = 0x000C;
	/** X = (X >= Y) */
	private static final int DLS_CDL_GE = 0x000D;
	/** X = (X == Y) */
	private static final int DLS_CDL_EQ = 0x000E;
	/** X = !X */
	private static final int DLS_CDL_NOT = 0x000F;
	/** 32-bit constant */
	private static final int DLS_CDL_CONST = 0x0010;
	/** 32-bit value returned from query */
	private static final int DLS_CDL_QUERY = 0x0011;
	/** 32-bit value returned from query */
	private static final int DLS_CDL_QUERYSUPPORTED = 0x0012;

	private static final DLSID DLSID_GMInHardware = new DLSID(0x178f2f24,
	0xc364, 0x11d1, 0xa7, 0x60, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12);
	private static final DLSID DLSID_GSInHardware = new DLSID(0x178f2f25,
	0xc364, 0x11d1, 0xa7, 0x60, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12);
	private static final DLSID DLSID_XGInHardware = new DLSID(0x178f2f26,
	0xc364, 0x11d1, 0xa7, 0x60, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12);
	private static final DLSID DLSID_SupportsDLS1 = new DLSID(0x178f2f27,
	0xc364, 0x11d1, 0xa7, 0x60, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12);
	private static final DLSID DLSID_SupportsDLS2 = new DLSID(0xf14599e5,
	0x4689, 0x11d2, 0xaf, 0xa6, 0x0, 0xaa, 0x0, 0x24, 0xd8, 0xb6);
	private static final DLSID DLSID_SampleMemorySize = new DLSID(0x178f2f28,
	0xc364, 0x11d1, 0xa7, 0x60, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12);
	private static final DLSID DLSID_ManufacturersID = new DLSID(0xb03e1181,
	0x8095, 0x11d2, 0xa1, 0xef, 0x0, 0x60, 0x8, 0x33, 0xdb, 0xd8);
	private static final DLSID DLSID_ProductID = new DLSID(0xb03e1182,
	0x8095, 0x11d2, 0xa1, 0xef, 0x0, 0x60, 0x8, 0x33, 0xdb, 0xd8);
	private static final DLSID DLSID_SamplePlaybackRate = new DLSID(0x2a91f713,
	0xa4bf, 0x11d2, 0xbb, 0xdf, 0x0, 0x60, 0x8, 0x33, 0xdb, 0xd8);

	private long major = -1;
	private long minor = -1;

	private final DLSInfo info = new DLSInfo();

	private final List<DLSInstrument> instruments = new ArrayList<DLSInstrument>();
	private final List<DLSSample> samples = new ArrayList<DLSSample>();

	private boolean largeFormat = false;
	private File sampleFile;

	public DLSSoundbank() {
	}

	public DLSSoundbank(URL url) throws IOException {
	InputStream is = url.openStream();
	try {
	readSoundbank(is);
	} finally {
	is.close();
	}
	}

	public DLSSoundbank(File file) throws IOException {
	largeFormat = true;
	sampleFile = file;
	InputStream is = new FileInputStream(file);
	try {
	readSoundbank(is);
	} finally {
	is.close();
	}
	}

	public DLSSoundbank(InputStream inputstream) throws IOException {
	readSoundbank(inputstream);
	}

	private void readSoundbank(InputStream inputstream) throws IOException {
	RIFFReader riff = new RIFFReader(inputstream);
	if (!riff.getFormat().equals("RIFF")) {
	throw new RIFFInvalidFormatException(
	"Input stream is not a valid RIFF stream!");
	}
	if (!riff.getType().equals("DLS ")) {
	throw new RIFFInvalidFormatException(
	"Input stream is not a valid DLS soundbank!");
	}
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	if (chunk.getFormat().equals("LIST")) {
	if (chunk.getType().equals("INFO"))
	readInfoChunk(chunk);
	if (chunk.getType().equals("lins"))
	readLinsChunk(chunk);
	if (chunk.getType().equals("wvpl"))
	readWvplChunk(chunk);
	} else {
	if (chunk.getFormat().equals("cdl ")) {
	if (!readCdlChunk(chunk)) {
	throw new RIFFInvalidFormatException(
	"DLS file isn't supported!");
	}
	}
	if (chunk.getFormat().equals("colh")) {
	// skipped because we will load the entire bank into memory
	// long instrumentcount = chunk.readUnsignedInt();
	// System.out.println("instrumentcount = "+ instrumentcount);
	}
	if (chunk.getFormat().equals("ptbl")) {
	// Pool Table Chunk
	// skipped because we will load the entire bank into memory
	}
	if (chunk.getFormat().equals("vers")) {
	major = chunk.readUnsignedInt();
	minor = chunk.readUnsignedInt();
	}
	}
	}

	for (Map.Entry<DLSRegion, Long> entry : temp_rgnassign.entrySet()) {
	entry.getKey().sample = samples.get((int)entry.getValue().longValue());
	}

	temp_rgnassign = null;
	}

	private boolean cdlIsQuerySupported(DLSID uuid) {
	return uuid.equals(DLSID_GMInHardware)
	\|\| uuid.equals(DLSID_GSInHardware)
	\|\| uuid.equals(DLSID_XGInHardware)
	\|\| uuid.equals(DLSID_SupportsDLS1)
	\|\| uuid.equals(DLSID_SupportsDLS2)
	\|\| uuid.equals(DLSID_SampleMemorySize)
	\|\| uuid.equals(DLSID_ManufacturersID)
	\|\| uuid.equals(DLSID_ProductID)
	\|\| uuid.equals(DLSID_SamplePlaybackRate);
	}

	private long cdlQuery(DLSID uuid) {
	if (uuid.equals(DLSID_GMInHardware))
	return 1;
	if (uuid.equals(DLSID_GSInHardware))
	return 0;
	if (uuid.equals(DLSID_XGInHardware))
	return 0;
	if (uuid.equals(DLSID_SupportsDLS1))
	return 1;
	if (uuid.equals(DLSID_SupportsDLS2))
	return 1;
	if (uuid.equals(DLSID_SampleMemorySize))
	return Runtime.getRuntime().totalMemory();
	if (uuid.equals(DLSID_ManufacturersID))
	return 0;
	if (uuid.equals(DLSID_ProductID))
	return 0;
	if (uuid.equals(DLSID_SamplePlaybackRate))
	return 44100;
	return 0;
	}


	// Reading cdl-ck Chunk
	// "cdl " chunk can only appear inside : DLS,lart,lar2,rgn,rgn2
	private boolean readCdlChunk(RIFFReader riff) throws IOException {

	DLSID uuid;
	long x;
	long y;
	Stack<Long> stack = new Stack<Long>();

	while (riff.available() != 0) {
	int opcode = riff.readUnsignedShort();
	switch (opcode) {
	case DLS_CDL_AND:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(((x != 0) && (y != 0)) ? 1 : 0));
	break;
	case DLS_CDL_OR:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(((x != 0) \|\| (y != 0)) ? 1 : 0));
	break;
	case DLS_CDL_XOR:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(((x != 0) ^ (y != 0)) ? 1 : 0));
	break;
	case DLS_CDL_ADD:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(x + y));
	break;
	case DLS_CDL_SUBTRACT:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(x - y));
	break;
	case DLS_CDL_MULTIPLY:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(x * y));
	break;
	case DLS_CDL_DIVIDE:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(x / y));
	break;
	case DLS_CDL_LOGICAL_AND:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(((x != 0) && (y != 0)) ? 1 : 0));
	break;
	case DLS_CDL_LOGICAL_OR:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf(((x != 0) \|\| (y != 0)) ? 1 : 0));
	break;
	case DLS_CDL_LT:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x < y) ? 1 : 0));
	break;
	case DLS_CDL_LE:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x <= y) ? 1 : 0));
	break;
	case DLS_CDL_GT:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x > y) ? 1 : 0));
	break;
	case DLS_CDL_GE:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x >= y) ? 1 : 0));
	break;
	case DLS_CDL_EQ:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x == y) ? 1 : 0));
	break;
	case DLS_CDL_NOT:
	x = stack.pop();
	y = stack.pop();
	stack.push(Long.valueOf((x == 0) ? 1 : 0));
	break;
	case DLS_CDL_CONST:
	stack.push(Long.valueOf(riff.readUnsignedInt()));
	break;
	case DLS_CDL_QUERY:
	uuid = DLSID.read(riff);
	stack.push(cdlQuery(uuid));
	break;
	case DLS_CDL_QUERYSUPPORTED:
	uuid = DLSID.read(riff);
	stack.push(Long.valueOf(cdlIsQuerySupported(uuid) ? 1 : 0));
	break;
	default:
	break;
	}
	}
	if (stack.isEmpty())
	return false;

	return stack.pop() == 1;
	}

	private void readInfoChunk(RIFFReader riff) throws IOException {
	info.name = null;
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("INAM"))
	info.name = chunk.readString(chunk.available());
	else if (format.equals("ICRD"))
	info.creationDate = chunk.readString(chunk.available());
	else if (format.equals("IENG"))
	info.engineers = chunk.readString(chunk.available());
	else if (format.equals("IPRD"))
	info.product = chunk.readString(chunk.available());
	else if (format.equals("ICOP"))
	info.copyright = chunk.readString(chunk.available());
	else if (format.equals("ICMT"))
	info.comments = chunk.readString(chunk.available());
	else if (format.equals("ISFT"))
	info.tools = chunk.readString(chunk.available());
	else if (format.equals("IARL"))
	info.archival_location = chunk.readString(chunk.available());
	else if (format.equals("IART"))
	info.artist = chunk.readString(chunk.available());
	else if (format.equals("ICMS"))
	info.commissioned = chunk.readString(chunk.available());
	else if (format.equals("IGNR"))
	info.genre = chunk.readString(chunk.available());
	else if (format.equals("IKEY"))
	info.keywords = chunk.readString(chunk.available());
	else if (format.equals("IMED"))
	info.medium = chunk.readString(chunk.available());
	else if (format.equals("ISBJ"))
	info.subject = chunk.readString(chunk.available());
	else if (format.equals("ISRC"))
	info.source = chunk.readString(chunk.available());
	else if (format.equals("ISRF"))
	info.source_form = chunk.readString(chunk.available());
	else if (format.equals("ITCH"))
	info.technician = chunk.readString(chunk.available());
	}
	}

	private void readLinsChunk(RIFFReader riff) throws IOException {
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	if (chunk.getFormat().equals("LIST")) {
	if (chunk.getType().equals("ins "))
	readInsChunk(chunk);
	}
	}
	}

	private void readInsChunk(RIFFReader riff) throws IOException {
	DLSInstrument instrument = new DLSInstrument(this);

	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("LIST")) {
	if (chunk.getType().equals("INFO")) {
	readInsInfoChunk(instrument, chunk);
	}
	if (chunk.getType().equals("lrgn")) {
	while (chunk.hasNextChunk()) {
	RIFFReader subchunk = chunk.nextChunk();
	if (subchunk.getFormat().equals("LIST")) {
	if (subchunk.getType().equals("rgn ")) {
	DLSRegion split = new DLSRegion();
	if (readRgnChunk(split, subchunk))
	instrument.getRegions().add(split);
	}
	if (subchunk.getType().equals("rgn2")) {
	// support for DLS level 2 regions
	DLSRegion split = new DLSRegion();
	if (readRgnChunk(split, subchunk))
	instrument.getRegions().add(split);
	}
	}
	}
	}
	if (chunk.getType().equals("lart")) {
	List<DLSModulator> modlist = new ArrayList<DLSModulator>();
	while (chunk.hasNextChunk()) {
	RIFFReader subchunk = chunk.nextChunk();
	if (chunk.getFormat().equals("cdl ")) {
	if (!readCdlChunk(chunk)) {
	modlist.clear();
	break;
	}
	}
	if (subchunk.getFormat().equals("art1"))
	readArt1Chunk(modlist, subchunk);
	}
	instrument.getModulators().addAll(modlist);
	}
	if (chunk.getType().equals("lar2")) {
	// support for DLS level 2 ART
	List<DLSModulator> modlist = new ArrayList<DLSModulator>();
	while (chunk.hasNextChunk()) {
	RIFFReader subchunk = chunk.nextChunk();
	if (chunk.getFormat().equals("cdl ")) {
	if (!readCdlChunk(chunk)) {
	modlist.clear();
	break;
	}
	}
	if (subchunk.getFormat().equals("art2"))
	readArt2Chunk(modlist, subchunk);
	}
	instrument.getModulators().addAll(modlist);
	}
	} else {
	if (format.equals("dlid")) {
	instrument.guid = new byte[16];
	chunk.readFully(instrument.guid);
	}
	if (format.equals("insh")) {
	chunk.readUnsignedInt(); // Read Region Count - ignored

	int bank = chunk.read(); // LSB
	bank += (chunk.read() & 127) << 7; // MSB
	chunk.read(); // Read Reserved byte
	int drumins = chunk.read(); // Drum Instrument

	int id = chunk.read() & 127; // Read only first 7 bits
	chunk.read(); // Read Reserved byte
	chunk.read(); // Read Reserved byte
	chunk.read(); // Read Reserved byte

	instrument.bank = bank;
	instrument.preset = (int) id;
	instrument.druminstrument = (drumins & 128) > 0;
	//System.out.println("bank="+bank+" drumkit="+drumkit
	// +" id="+id);
	}

	}
	}
	instruments.add(instrument);
	}

	private void readArt1Chunk(List<DLSModulator> modulators, RIFFReader riff)
	throws IOException {
	long size = riff.readUnsignedInt();
	long count = riff.readUnsignedInt();

	if (size - 8 != 0)
	riff.skip(size - 8);

	for (int i = 0; i < count; i++) {
	DLSModulator modulator = new DLSModulator();
	modulator.version = 1;
	modulator.source = riff.readUnsignedShort();
	modulator.control = riff.readUnsignedShort();
	modulator.destination = riff.readUnsignedShort();
	modulator.transform = riff.readUnsignedShort();
	modulator.scale = riff.readInt();
	modulators.add(modulator);
	}
	}

	private void readArt2Chunk(List<DLSModulator> modulators, RIFFReader riff)
	throws IOException {
	long size = riff.readUnsignedInt();
	long count = riff.readUnsignedInt();

	if (size - 8 != 0)
	riff.skip(size - 8);

	for (int i = 0; i < count; i++) {
	DLSModulator modulator = new DLSModulator();
	modulator.version = 2;
	modulator.source = riff.readUnsignedShort();
	modulator.control = riff.readUnsignedShort();
	modulator.destination = riff.readUnsignedShort();
	modulator.transform = riff.readUnsignedShort();
	modulator.scale = riff.readInt();
	modulators.add(modulator);
	}
	}

	private Map<DLSRegion, Long> temp_rgnassign = new HashMap<DLSRegion, Long>();

	private boolean readRgnChunk(DLSRegion split, RIFFReader riff)
	throws IOException {
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("LIST")) {
	if (chunk.getType().equals("lart")) {
	List<DLSModulator> modlist = new ArrayList<DLSModulator>();
	while (chunk.hasNextChunk()) {
	RIFFReader subchunk = chunk.nextChunk();
	if (chunk.getFormat().equals("cdl ")) {
	if (!readCdlChunk(chunk)) {
	modlist.clear();
	break;
	}
	}
	if (subchunk.getFormat().equals("art1"))
	readArt1Chunk(modlist, subchunk);
	}
	split.getModulators().addAll(modlist);
	}
	if (chunk.getType().equals("lar2")) {
	// support for DLS level 2 ART
	List<DLSModulator> modlist = new ArrayList<DLSModulator>();
	while (chunk.hasNextChunk()) {
	RIFFReader subchunk = chunk.nextChunk();
	if (chunk.getFormat().equals("cdl ")) {
	if (!readCdlChunk(chunk)) {
	modlist.clear();
	break;
	}
	}
	if (subchunk.getFormat().equals("art2"))
	readArt2Chunk(modlist, subchunk);
	}
	split.getModulators().addAll(modlist);
	}
	} else {

	if (format.equals("cdl ")) {
	if (!readCdlChunk(chunk))
	return false;
	}
	if (format.equals("rgnh")) {
	split.keyfrom = chunk.readUnsignedShort();
	split.keyto = chunk.readUnsignedShort();
	split.velfrom = chunk.readUnsignedShort();
	split.velto = chunk.readUnsignedShort();
	split.options = chunk.readUnsignedShort();
	split.exclusiveClass = chunk.readUnsignedShort();
	}
	if (format.equals("wlnk")) {
	split.fusoptions = chunk.readUnsignedShort();
	split.phasegroup = chunk.readUnsignedShort();
	split.channel = chunk.readUnsignedInt();
	long sampleid = chunk.readUnsignedInt();
	temp_rgnassign.put(split, sampleid);
	}
	if (format.equals("wsmp")) {
	split.sampleoptions = new DLSSampleOptions();
	readWsmpChunk(split.sampleoptions, chunk);
	}
	}
	}
	return true;
	}

	private void readWsmpChunk(DLSSampleOptions sampleOptions, RIFFReader riff)
	throws IOException {
	long size = riff.readUnsignedInt();
	sampleOptions.unitynote = riff.readUnsignedShort();
	sampleOptions.finetune = riff.readShort();
	sampleOptions.attenuation = riff.readInt();
	sampleOptions.options = riff.readUnsignedInt();
	long loops = riff.readInt();

	if (size > 20)
	riff.skip(size - 20);

	for (int i = 0; i < loops; i++) {
	DLSSampleLoop loop = new DLSSampleLoop();
	long size2 = riff.readUnsignedInt();
	loop.type = riff.readUnsignedInt();
	loop.start = riff.readUnsignedInt();
	loop.length = riff.readUnsignedInt();
	sampleOptions.loops.add(loop);
	if (size2 > 16)
	riff.skip(size2 - 16);
	}
	}

	private void readInsInfoChunk(DLSInstrument dlsinstrument, RIFFReader riff)
	throws IOException {
	dlsinstrument.info.name = null;
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("INAM")) {
	dlsinstrument.info.name = chunk.readString(chunk.available());
	} else if (format.equals("ICRD")) {
	dlsinstrument.info.creationDate =
	chunk.readString(chunk.available());
	} else if (format.equals("IENG")) {
	dlsinstrument.info.engineers =
	chunk.readString(chunk.available());
	} else if (format.equals("IPRD")) {
	dlsinstrument.info.product = chunk.readString(chunk.available());
	} else if (format.equals("ICOP")) {
	dlsinstrument.info.copyright =
	chunk.readString(chunk.available());
	} else if (format.equals("ICMT")) {
	dlsinstrument.info.comments =
	chunk.readString(chunk.available());
	} else if (format.equals("ISFT")) {
	dlsinstrument.info.tools = chunk.readString(chunk.available());
	} else if (format.equals("IARL")) {
	dlsinstrument.info.archival_location =
	chunk.readString(chunk.available());
	} else if (format.equals("IART")) {
	dlsinstrument.info.artist = chunk.readString(chunk.available());
	} else if (format.equals("ICMS")) {
	dlsinstrument.info.commissioned =
	chunk.readString(chunk.available());
	} else if (format.equals("IGNR")) {
	dlsinstrument.info.genre = chunk.readString(chunk.available());
	} else if (format.equals("IKEY")) {
	dlsinstrument.info.keywords =
	chunk.readString(chunk.available());
	} else if (format.equals("IMED")) {
	dlsinstrument.info.medium = chunk.readString(chunk.available());
	} else if (format.equals("ISBJ")) {
	dlsinstrument.info.subject = chunk.readString(chunk.available());
	} else if (format.equals("ISRC")) {
	dlsinstrument.info.source = chunk.readString(chunk.available());
	} else if (format.equals("ISRF")) {
	dlsinstrument.info.source_form =
	chunk.readString(chunk.available());
	} else if (format.equals("ITCH")) {
	dlsinstrument.info.technician =
	chunk.readString(chunk.available());
	}
	}
	}

	private void readWvplChunk(RIFFReader riff) throws IOException {
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	if (chunk.getFormat().equals("LIST")) {
	if (chunk.getType().equals("wave"))
	readWaveChunk(chunk);
	}
	}
	}

	private void readWaveChunk(RIFFReader riff) throws IOException {
	DLSSample sample = new DLSSample(this);

	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("LIST")) {
	if (chunk.getType().equals("INFO")) {
	readWaveInfoChunk(sample, chunk);
	}
	} else {
	if (format.equals("dlid")) {
	sample.guid = new byte[16];
	chunk.readFully(sample.guid);
	}

	if (format.equals("fmt ")) {
	int sampleformat = chunk.readUnsignedShort();
	if (sampleformat != 1 && sampleformat != 3) {
	throw new RIFFInvalidDataException(
	"Only PCM samples are supported!");
	}
	int channels = chunk.readUnsignedShort();
	long samplerate = chunk.readUnsignedInt();
	// bytes per sec
	/* long framerate = */ chunk.readUnsignedInt();
	// block align, framesize
	int framesize = chunk.readUnsignedShort();
	int bits = chunk.readUnsignedShort();
	AudioFormat audioformat = null;
	if (sampleformat == 1) {
	if (bits == 8) {
	audioformat = new AudioFormat(
	Encoding.PCM_UNSIGNED, samplerate, bits,
	channels, framesize, samplerate, false);
	} else {
	audioformat = new AudioFormat(
	Encoding.PCM_SIGNED, samplerate, bits,
	channels, framesize, samplerate, false);
	}
	}
	if (sampleformat == 3) {
	audioformat = new AudioFormat(
	Encoding.PCM_FLOAT, samplerate, bits,
	channels, framesize, samplerate, false);
	}

	sample.format = audioformat;
	}

	if (format.equals("data")) {
	if (largeFormat) {
	sample.setData(new ModelByteBuffer(sampleFile,
	chunk.getFilePointer(), chunk.available()));
	} else {
	byte[] buffer = new byte[chunk.available()];
	// chunk.read(buffer);
	sample.setData(buffer);

	int read = 0;
	int avail = chunk.available();
	while (read != avail) {
	if (avail - read > 65536) {
	chunk.readFully(buffer, read, 65536);
	read += 65536;
	} else {
	chunk.readFully(buffer, read, avail - read);
	read = avail;
	}
	}
	}
	}

	if (format.equals("wsmp")) {
	sample.sampleoptions = new DLSSampleOptions();
	readWsmpChunk(sample.sampleoptions, chunk);
	}
	}
	}

	samples.add(sample);

	}

	private void readWaveInfoChunk(DLSSample dlssample, RIFFReader riff)
	throws IOException {
	dlssample.info.name = null;
	while (riff.hasNextChunk()) {
	RIFFReader chunk = riff.nextChunk();
	String format = chunk.getFormat();
	if (format.equals("INAM")) {
	dlssample.info.name = chunk.readString(chunk.available());
	} else if (format.equals("ICRD")) {
	dlssample.info.creationDate =
	chunk.readString(chunk.available());
	} else if (format.equals("IENG")) {
	dlssample.info.engineers = chunk.readString(chunk.available());
	} else if (format.equals("IPRD")) {
	dlssample.info.product = chunk.readString(chunk.available());
	} else if (format.equals("ICOP")) {
	dlssample.info.copyright = chunk.readString(chunk.available());
	} else if (format.equals("ICMT")) {
	dlssample.info.comments = chunk.readString(chunk.available());
	} else if (format.equals("ISFT")) {
	dlssample.info.tools = chunk.readString(chunk.available());
	} else if (format.equals("IARL")) {
	dlssample.info.archival_location =
	chunk.readString(chunk.available());
	} else if (format.equals("IART")) {
	dlssample.info.artist = chunk.readString(chunk.available());
	} else if (format.equals("ICMS")) {
	dlssample.info.commissioned =
	chunk.readString(chunk.available());
	} else if (format.equals("IGNR")) {
	dlssample.info.genre = chunk.readString(chunk.available());
	} else if (format.equals("IKEY")) {
	dlssample.info.keywords = chunk.readString(chunk.available());
	} else if (format.equals("IMED")) {
	dlssample.info.medium = chunk.readString(chunk.available());
	} else if (format.equals("ISBJ")) {
	dlssample.info.subject = chunk.readString(chunk.available());
	} else if (format.equals("ISRC")) {
	dlssample.info.source = chunk.readString(chunk.available());
	} else if (format.equals("ISRF")) {
	dlssample.info.source_form = chunk.readString(chunk.available());
	} else if (format.equals("ITCH")) {
	dlssample.info.technician = chunk.readString(chunk.available());
	}
	}
	}

	public void save(String name) throws IOException {
	writeSoundbank(new RIFFWriter(name, "DLS "));
	}

	public void save(File file) throws IOException {
	writeSoundbank(new RIFFWriter(file, "DLS "));
	}

	public void save(OutputStream out) throws IOException {
	writeSoundbank(new RIFFWriter(out, "DLS "));
	}

	private void writeSoundbank(RIFFWriter writer) throws IOException {
	RIFFWriter colh_chunk = writer.writeChunk("colh");
	colh_chunk.writeUnsignedInt(instruments.size());

	if (major != -1 && minor != -1) {
	RIFFWriter vers_chunk = writer.writeChunk("vers");
	vers_chunk.writeUnsignedInt(major);
	vers_chunk.writeUnsignedInt(minor);
	}

	writeInstruments(writer.writeList("lins"));

	RIFFWriter ptbl = writer.writeChunk("ptbl");
	ptbl.writeUnsignedInt(8);
	ptbl.writeUnsignedInt(samples.size());
	long ptbl_offset = writer.getFilePointer();
	for (int i = 0; i < samples.size(); i++)
	ptbl.writeUnsignedInt(0);

	RIFFWriter wvpl = writer.writeList("wvpl");
	long off = wvpl.getFilePointer();
	List<Long> offsettable = new ArrayList<Long>();
	for (DLSSample sample : samples) {
	offsettable.add(Long.valueOf(wvpl.getFilePointer() - off));
	writeSample(wvpl.writeList("wave"), sample);
	}

	// small cheat, we are going to rewrite data back in wvpl
	long bak = writer.getFilePointer();
	writer.seek(ptbl_offset);
	writer.setWriteOverride(true);
	for (Long offset : offsettable)
	writer.writeUnsignedInt(offset.longValue());
	writer.setWriteOverride(false);
	writer.seek(bak);

	writeInfo(writer.writeList("INFO"), info);

	writer.close();
	}

	private void writeSample(RIFFWriter writer, DLSSample sample)
	throws IOException {

	AudioFormat audioformat = sample.getFormat();

	Encoding encoding = audioformat.getEncoding();
	float sampleRate = audioformat.getSampleRate();
	int sampleSizeInBits = audioformat.getSampleSizeInBits();
	int channels = audioformat.getChannels();
	int frameSize = audioformat.getFrameSize();
	float frameRate = audioformat.getFrameRate();
	boolean bigEndian = audioformat.isBigEndian();

	boolean convert_needed = false;

	if (audioformat.getSampleSizeInBits() == 8) {
	if (!encoding.equals(Encoding.PCM_UNSIGNED)) {
	encoding = Encoding.PCM_UNSIGNED;
	convert_needed = true;
	}
	} else {
	if (!encoding.equals(Encoding.PCM_SIGNED)) {
	encoding = Encoding.PCM_SIGNED;
	convert_needed = true;
	}
	if (bigEndian) {
	bigEndian = false;
	convert_needed = true;
	}
	}

	if (convert_needed) {
	audioformat = new AudioFormat(encoding, sampleRate,
	sampleSizeInBits, channels, frameSize, frameRate, bigEndian);
	}

	// fmt
	RIFFWriter fmt_chunk = writer.writeChunk("fmt ");
	int sampleformat = 0;
	if (audioformat.getEncoding().equals(Encoding.PCM_UNSIGNED))
	sampleformat = 1;
	else if (audioformat.getEncoding().equals(Encoding.PCM_SIGNED))
	sampleformat = 1;
	else if (audioformat.getEncoding().equals(Encoding.PCM_FLOAT))
	sampleformat = 3;

	fmt_chunk.writeUnsignedShort(sampleformat);
	fmt_chunk.writeUnsignedShort(audioformat.getChannels());
	fmt_chunk.writeUnsignedInt((long) audioformat.getSampleRate());
	long srate = ((long)audioformat.getFrameRate())*audioformat.getFrameSize();
	fmt_chunk.writeUnsignedInt(srate);
	fmt_chunk.writeUnsignedShort(audioformat.getFrameSize());
	fmt_chunk.writeUnsignedShort(audioformat.getSampleSizeInBits());
	fmt_chunk.write(0);
	fmt_chunk.write(0);

	writeSampleOptions(writer.writeChunk("wsmp"), sample.sampleoptions);

	if (convert_needed) {
	RIFFWriter data_chunk = writer.writeChunk("data");
	AudioInputStream stream = AudioSystem.getAudioInputStream(
	audioformat, (AudioInputStream)sample.getData());
	byte[] buff = new byte[1024];
	int ret;
	while ((ret = stream.read(buff)) != -1) {
	data_chunk.write(buff, 0, ret);
	}
	} else {
	RIFFWriter data_chunk = writer.writeChunk("data");
	ModelByteBuffer databuff = sample.getDataBuffer();
	databuff.writeTo(data_chunk);
	/*
	data_chunk.write(databuff.array(),
	databuff.arrayOffset(),
	databuff.capacity());
	*/
	}

	writeInfo(writer.writeList("INFO"), sample.info);
	}

	private void writeInstruments(RIFFWriter writer) throws IOException {
	for (DLSInstrument instrument : instruments) {
	writeInstrument(writer.writeList("ins "), instrument);
	}
	}

	private void writeInstrument(RIFFWriter writer, DLSInstrument instrument)
	throws IOException {

	int art1_count = 0;
	int art2_count = 0;
	for (DLSModulator modulator : instrument.getModulators()) {
	if (modulator.version == 1)
	art1_count++;
	if (modulator.version == 2)
	art2_count++;
	}
	for (DLSRegion region : instrument.regions) {
	for (DLSModulator modulator : region.getModulators()) {
	if (modulator.version == 1)
	art1_count++;
	if (modulator.version == 2)
	art2_count++;
	}
	}

	int version = 1;
	if (art2_count > 0)
	version = 2;

	RIFFWriter insh_chunk = writer.writeChunk("insh");
	insh_chunk.writeUnsignedInt(instrument.getRegions().size());
	insh_chunk.writeUnsignedInt(instrument.bank +
	(instrument.druminstrument ? 2147483648L : 0));
	insh_chunk.writeUnsignedInt(instrument.preset);

	RIFFWriter lrgn = writer.writeList("lrgn");
	for (DLSRegion region: instrument.regions)
	writeRegion(lrgn, region, version);

	writeArticulators(writer, instrument.getModulators());

	writeInfo(writer.writeList("INFO"), instrument.info);

	}

	private void writeArticulators(RIFFWriter writer,
	List<DLSModulator> modulators) throws IOException {
	int art1_count = 0;
	int art2_count = 0;
	for (DLSModulator modulator : modulators) {
	if (modulator.version == 1)
	art1_count++;
	if (modulator.version == 2)
	art2_count++;
	}
	if (art1_count > 0) {
	RIFFWriter lar1 = writer.writeList("lart");
	RIFFWriter art1 = lar1.writeChunk("art1");
	art1.writeUnsignedInt(8);
	art1.writeUnsignedInt(art1_count);
	for (DLSModulator modulator : modulators) {
	if (modulator.version == 1) {
	art1.writeUnsignedShort(modulator.source);
	art1.writeUnsignedShort(modulator.control);
	art1.writeUnsignedShort(modulator.destination);
	art1.writeUnsignedShort(modulator.transform);
	art1.writeInt(modulator.scale);
	}
	}
	}
	if (art2_count > 0) {
	RIFFWriter lar2 = writer.writeList("lar2");
	RIFFWriter art2 = lar2.writeChunk("art2");
	art2.writeUnsignedInt(8);
	art2.writeUnsignedInt(art2_count);
	for (DLSModulator modulator : modulators) {
	if (modulator.version == 2) {
	art2.writeUnsignedShort(modulator.source);
	art2.writeUnsignedShort(modulator.control);
	art2.writeUnsignedShort(modulator.destination);
	art2.writeUnsignedShort(modulator.transform);
	art2.writeInt(modulator.scale);
	}
	}
	}
	}

	private void writeRegion(RIFFWriter writer, DLSRegion region, int version)
	throws IOException {
	RIFFWriter rgns = null;
	if (version == 1)
	rgns = writer.writeList("rgn ");
	if (version == 2)
	rgns = writer.writeList("rgn2");
	if (rgns == null)
	return;

	RIFFWriter rgnh = rgns.writeChunk("rgnh");
	rgnh.writeUnsignedShort(region.keyfrom);
	rgnh.writeUnsignedShort(region.keyto);
	rgnh.writeUnsignedShort(region.velfrom);
	rgnh.writeUnsignedShort(region.velto);
	rgnh.writeUnsignedShort(region.options);
	rgnh.writeUnsignedShort(region.exclusiveClass);

	if (region.sampleoptions != null)
	writeSampleOptions(rgns.writeChunk("wsmp"), region.sampleoptions);

	if (region.sample != null) {
	if (samples.indexOf(region.sample) != -1) {
	RIFFWriter wlnk = rgns.writeChunk("wlnk");
	wlnk.writeUnsignedShort(region.fusoptions);
	wlnk.writeUnsignedShort(region.phasegroup);
	wlnk.writeUnsignedInt(region.channel);
	wlnk.writeUnsignedInt(samples.indexOf(region.sample));
	}
	}
	writeArticulators(rgns, region.getModulators());
	rgns.close();
	}

	private void writeSampleOptions(RIFFWriter wsmp,
	DLSSampleOptions sampleoptions) throws IOException {
	wsmp.writeUnsignedInt(20);
	wsmp.writeUnsignedShort(sampleoptions.unitynote);
	wsmp.writeShort(sampleoptions.finetune);
	wsmp.writeInt(sampleoptions.attenuation);
	wsmp.writeUnsignedInt(sampleoptions.options);
	wsmp.writeInt(sampleoptions.loops.size());

	for (DLSSampleLoop loop : sampleoptions.loops) {
	wsmp.writeUnsignedInt(16);
	wsmp.writeUnsignedInt(loop.type);
	wsmp.writeUnsignedInt(loop.start);
	wsmp.writeUnsignedInt(loop.length);
	}
	}

	private void writeInfoStringChunk(RIFFWriter writer,
	String name, String value) throws IOException {
	if (value == null)
	return;
	RIFFWriter chunk = writer.writeChunk(name);
	chunk.writeString(value);
	int len = value.getBytes("ascii").length;
	chunk.write(0);
	len++;
	if (len % 2 != 0)
	chunk.write(0);
	}

	private void writeInfo(RIFFWriter writer, DLSInfo info) throws IOException {
	writeInfoStringChunk(writer, "INAM", info.name);
	writeInfoStringChunk(writer, "ICRD", info.creationDate);
	writeInfoStringChunk(writer, "IENG", info.engineers);
	writeInfoStringChunk(writer, "IPRD", info.product);
	writeInfoStringChunk(writer, "ICOP", info.copyright);
	writeInfoStringChunk(writer, "ICMT", info.comments);
	writeInfoStringChunk(writer, "ISFT", info.tools);
	writeInfoStringChunk(writer, "IARL", info.archival_location);
	writeInfoStringChunk(writer, "IART", info.artist);
	writeInfoStringChunk(writer, "ICMS", info.commissioned);
	writeInfoStringChunk(writer, "IGNR", info.genre);
	writeInfoStringChunk(writer, "IKEY", info.keywords);
	writeInfoStringChunk(writer, "IMED", info.medium);
	writeInfoStringChunk(writer, "ISBJ", info.subject);
	writeInfoStringChunk(writer, "ISRC", info.source);
	writeInfoStringChunk(writer, "ISRF", info.source_form);
	writeInfoStringChunk(writer, "ITCH", info.technician);
	}

	public DLSInfo getInfo() {
	return info;
	}

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

	public String getVersion() {
	return major + "." + minor;
	}

	public String getVendor() {
	return info.engineers;
	}

	public String getDescription() {
	return info.comments;
	}

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

	public void setVendor(String s) {
	info.engineers = s;
	}

	public void setDescription(String s) {
	info.comments = s;
	}

	public SoundbankResource[] getResources() {
	SoundbankResource[] resources = new SoundbankResource[samples.size()];
	int j = 0;
	for (int i = 0; i < samples.size(); i++)
	resources[j++] = samples.get(i);
	return resources;
	}

	public DLSInstrument[] getInstruments() {
	DLSInstrument[] inslist_array =
	instruments.toArray(new DLSInstrument[instruments.size()]);
	Arrays.sort(inslist_array, new ModelInstrumentComparator());
	return inslist_array;
	}

	public DLSSample[] getSamples() {
	return samples.toArray(new DLSSample[samples.size()]);
	}

	public Instrument getInstrument(Patch patch) {
	int program = patch.getProgram();
	int bank = patch.getBank();
	boolean percussion = false;
	if (patch instanceof ModelPatch)
	percussion = ((ModelPatch) patch).isPercussion();
	for (Instrument instrument : instruments) {
	Patch patch2 = instrument.getPatch();
	int program2 = patch2.getProgram();
	int bank2 = patch2.getBank();
	if (program == program2 && bank == bank2) {
	boolean percussion2 = false;
	if (patch2 instanceof ModelPatch)
	percussion2 = ((ModelPatch) patch2).isPercussion();
	if (percussion == percussion2)
	return instrument;
	}
	}
	return null;
	}

	public void addResource(SoundbankResource resource) {
	if (resource instanceof DLSInstrument)
	instruments.add((DLSInstrument) resource);
	if (resource instanceof DLSSample)
	samples.add((DLSSample) resource);
	}

	public void removeResource(SoundbankResource resource) {
	if (resource instanceof DLSInstrument)
	instruments.remove((DLSInstrument) resource);
	if (resource instanceof DLSSample)
	samples.remove((DLSSample) resource);
	}

	public void addInstrument(DLSInstrument resource) {
	instruments.add(resource);
	}

	public void removeInstrument(DLSInstrument resource) {
	instruments.remove(resource);
	}

	public long getMajor() {
	return major;
	}

	public void setMajor(long major) {
	this.major = major;
	}

	public long getMinor() {
	return minor;
	}

	public void setMinor(long minor) {
	this.minor = minor;
	}
	}

Back to index...