linuxsampler/lscp/MidiInstrumentInfo.java

/*
 *   jlscp - a java LinuxSampler control protocol API
 *
 *   Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of jlscp.
 *
 *   jlscp is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   jlscp 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 for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with jlscp; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.linuxsampler.lscp;

import static org.linuxsampler.lscp.Parser.*;

/**
 * Provides information about a MIDI instrument.
 * @author Grigor Iliev
 */
public class MidiInstrumentInfo extends AbstractInstrument implements Parseable {
        private int mapId = -1;
        private MidiInstrumentEntry entry;
        
        private String engine;
        private String instrName = "Untitled";
        private double volume = 1.0;
        private LoadMode loadMode = LoadMode.DEFAULT;
        
        public static enum LoadMode {
                /** It will be up to the InstrumentManager to decide which mode to use. */
                DEFAULT ("Default"),
                
                /**
                 * The instrument will be loaded when when demanded by
                 * at least one sampler channel. It will immediately be freed
                 * from memory when not needed by any sampler channel anymore.
                 */
                ON_DEMAND ("On Demand"),
                
                /**
                 * Same as <code>ON_DEMAND</code> with the difference that the instrument
                 * will be kept in memory even when not needed by any sampler channel.
                 */
                ON_DEMAND_HOLD ("On Demand and Hold"),
                
                /**
                 * The instrument will be immediately loaded into memory
                 * and the instrument will be kept all the time.
                 */
                PERSISTENT ("Persistent");
                
                private final String name;
                
                LoadMode(String name) { this.name = name; }
                
                public String
                toString() { return name; }
        }
        
        
        /** Creates a new instance of <code>MidiInstrumentInfo</code> */
        public MidiInstrumentInfo() {
                
        }
        
        /**
         * Creates a new instance of <code>MidiInstrumentInfo</code>.
         * @param mapId The ID of the map containing this instrument.
         * @param entry The instrument position in the map.
         */
        public MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry) {
                this.mapId = mapId;
                this.entry = entry;
        }
        
        /**
         * Creates a new instance of <code>MidiInstrumentInfo</code> and parses the
         * provided information about this instrument.
         * @param mapId The ID of the map containing this instrument.
         * @param entry Provides the position of the MIDI instrument in the MIDI instrument map.
         * @param resultSet An array with information categories about a MIDI instrument.
         * @throws LscpException If the parse fails.
         */
        public
        MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry, String[] resultSet)
                                                                        throws LscpException {
                this.mapId = mapId;
                this.entry = entry;
                
                for(String s : resultSet)
                        if(!parse(s)) Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
        }
        
        /**
         * Gets the position of the MIDI instrument in a MIDI instrument map.
         * @return The position of the MIDI instrument in a MIDI instrument map.
         */
        public MidiInstrumentEntry
        getEntry() { return entry; }
        
        /**
         * Gets the ID of the map containing this instrument.
         * @return The ID of the map containing this instrument.
         */
        public int
        getMapId() { return mapId; }
        
        /**
         * Gets the index of the MIDI bank, containing this instrument.
         * @return The index of the MIDI bank, containing this instrument.
         */
        public int
        getMidiBank() { return entry.getMidiBank(); }
        
        /**
         * Gets the MIDI program number of this instrument.
         * @return The MIDI program number of this instrument.
         */
        public int
        getMidiProgram() { return entry.getMidiProgram(); }
        
        /**
         * Gets the name of the sampler engine to be used to load the instrument.
         * @return The name of the sampler engine to be used to load the instrument.
         */
        public String
        getEngine() { return engine; }
        
        /**
         * Sets the name of the sampler engine to be used to load the instrument.
         * @param engine The name of the sampler engine to be used to load the instrument.
         */
        public void
        setEngine(String engine) { this.engine = engine; }
        
        /**
         * Gets the name of the loaded instrument as reflected by its file.
         * @return The name of the loaded instrument as reflected by its file.
         */
        public String
        getInstrumentName() { return instrName; }
        
        /**
         * Sets the name of this instrument as reflected by its file.
         * @param name The  name of the instrument as reflected by its file.
         *
        public void
        setInstrumentName(String name) { this.instrName = name; }*/
        
        /**
         * Returns the volume, specified for this instrument, where a
         * value < 1.0 means attenuation and a value > 1.0 means amplification.
         */
        public double
        getVolume() { return volume; }
        
        /**
         * Sets the volume level for this instrument,  where a
         * value < 1.0 means attenuation and a value > 1.0 means amplification.
         */
        public void
        setVolume(double volume) { this.volume = volume; }
        
        /**
         * Gets the load mode of this MIDI instrument.
         * @return The load mode of this MIDI instrument.
         */
        public LoadMode
        getLoadMode() { return loadMode; }
        
        /**
         * Sets the load mode of this MIDI instrument.
         * @param loadMode Specifies the load mode for this MIDI instrument.
         */
        public void
        setLoadMode(LoadMode loadMode) { this.loadMode = loadMode; }
        
        /**
         * Parses a line of text.
         * @param s The string to be parsed.
         * @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
         * @throws LscpException If some error occurs.
         */
        public boolean
        parse(String s) throws LscpException {
                if(s.startsWith("NAME: ")) {
                        setName(toNonEscapedString(s.substring("NAME: ".length())));
                } else if(s.startsWith("ENGINE_NAME: ")) {
                        setEngine(s.substring("ENGINE_NAME: ".length()));
                } else if(s.startsWith("INSTRUMENT_NAME: ")) {
                        instrName = toNonEscapedString(s.substring("INSTRUMENT_NAME: ".length()));
                } else if(s.startsWith("LOAD_MODE: ")) {
                        s = s.substring("LOAD_MODE: ".length());
                        if(s.length() == 0) setLoadMode(LoadMode.DEFAULT);
                        else setLoadMode(LoadMode.valueOf(s));
                } else if(s.startsWith("VOLUME: ")) {
                        s = s.substring("VOLUME: ".length());
                        setVolume(Parser.parseFloat(s));
                } else return super.parse(s);
                
                return true;
        }
        
        /**
         * Determines whether the specified object is of type
         * <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
         * @param obj The reference object with which to compare.
         * @return <code>true</code> if the specified object is of type
         * <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
         */
        public boolean
        equals(Object obj) {
                if(obj == null) return false;
                if(!(obj instanceof MidiInstrumentInfo)) return false;
                MidiInstrumentInfo i = (MidiInstrumentInfo)obj;
                if(getMapId() != i.getMapId()) return false;
                if(getMidiBank() != i.getMidiBank()) return false;
                if(getMidiProgram() != i.getMidiProgram()) return false;
                
                return true;
        }
}
1	/*
2	* jlscp - a java LinuxSampler control protocol API
3	*
4	* Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of jlscp.
7	*
8	* jlscp is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* jlscp is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with jlscp; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.linuxsampler.lscp;
24
25	import static org.linuxsampler.lscp.Parser.*;
26
27	/**
28	* Provides information about a MIDI instrument.
29	* @author Grigor Iliev
30	*/
31	public class MidiInstrumentInfo extends AbstractInstrument implements Parseable {
32	private int mapId = -1;
33	private MidiInstrumentEntry entry;
34
35	private String engine;
36	private String instrName = "Untitled";
37	private double volume = 1.0;
38	private LoadMode loadMode = LoadMode.DEFAULT;
39
40	public static enum LoadMode {
41	/** It will be up to the InstrumentManager to decide which mode to use. */
42	DEFAULT ("Default"),
43
44	/**
45	* The instrument will be loaded when when demanded by
46	* at least one sampler channel. It will immediately be freed
47	* from memory when not needed by any sampler channel anymore.
48	*/
49	ON_DEMAND ("On Demand"),
50
51	/**
52	* Same as <code>ON_DEMAND</code> with the difference that the instrument
53	* will be kept in memory even when not needed by any sampler channel.
54	*/
55	ON_DEMAND_HOLD ("On Demand and Hold"),
56
57	/**
58	* The instrument will be immediately loaded into memory
59	* and the instrument will be kept all the time.
60	*/
61	PERSISTENT ("Persistent");
62
63	private final String name;
64
65	LoadMode(String name) { this.name = name; }
66
67	public String
68	toString() { return name; }
69	}
70
71
72	/** Creates a new instance of <code>MidiInstrumentInfo</code> */
73	public MidiInstrumentInfo() {
74
75	}
76
77	/**
78	* Creates a new instance of <code>MidiInstrumentInfo</code>.
79	* @param mapId The ID of the map containing this instrument.
80	* @param entry The instrument position in the map.
81	*/
82	public MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry) {
83	this.mapId = mapId;
84	this.entry = entry;
85	}
86
87	/**
88	* Creates a new instance of <code>MidiInstrumentInfo</code> and parses the
89	* provided information about this instrument.
90	* @param mapId The ID of the map containing this instrument.
91	* @param entry Provides the position of the MIDI instrument in the MIDI instrument map.
92	* @param resultSet An array with information categories about a MIDI instrument.
93	* @throws LscpException If the parse fails.
94	*/
95	public
96	MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry, String[] resultSet)
97	throws LscpException {
98	this.mapId = mapId;
99	this.entry = entry;
100
101	for(String s : resultSet)
102	if(!parse(s)) Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
103	}
104
105	/**
106	* Gets the position of the MIDI instrument in a MIDI instrument map.
107	* @return The position of the MIDI instrument in a MIDI instrument map.
108	*/
109	public MidiInstrumentEntry
110	getEntry() { return entry; }
111
112	/**
113	* Gets the ID of the map containing this instrument.
114	* @return The ID of the map containing this instrument.
115	*/
116	public int
117	getMapId() { return mapId; }
118
119	/**
120	* Gets the index of the MIDI bank, containing this instrument.
121	* @return The index of the MIDI bank, containing this instrument.
122	*/
123	public int
124	getMidiBank() { return entry.getMidiBank(); }
125
126	/**
127	* Gets the MIDI program number of this instrument.
128	* @return The MIDI program number of this instrument.
129	*/
130	public int
131	getMidiProgram() { return entry.getMidiProgram(); }
132
133	/**
134	* Gets the name of the sampler engine to be used to load the instrument.
135	* @return The name of the sampler engine to be used to load the instrument.
136	*/
137	public String
138	getEngine() { return engine; }
139
140	/**
141	* Sets the name of the sampler engine to be used to load the instrument.
142	* @param engine The name of the sampler engine to be used to load the instrument.
143	*/
144	public void
145	setEngine(String engine) { this.engine = engine; }
146
147	/**
148	* Gets the name of the loaded instrument as reflected by its file.
149	* @return The name of the loaded instrument as reflected by its file.
150	*/
151	public String
152	getInstrumentName() { return instrName; }
153
154	/**
155	* Sets the name of this instrument as reflected by its file.
156	* @param name The name of the instrument as reflected by its file.
157	*
158	public void
159	setInstrumentName(String name) { this.instrName = name; }*/
160
161	/**
162	* Returns the volume, specified for this instrument, where a
163	* value < 1.0 means attenuation and a value > 1.0 means amplification.
164	*/
165	public double
166	getVolume() { return volume; }
167
168	/**
169	* Sets the volume level for this instrument, where a
170	* value < 1.0 means attenuation and a value > 1.0 means amplification.
171	*/
172	public void
173	setVolume(double volume) { this.volume = volume; }
174
175	/**
176	* Gets the load mode of this MIDI instrument.
177	* @return The load mode of this MIDI instrument.
178	*/
179	public LoadMode
180	getLoadMode() { return loadMode; }
181
182	/**
183	* Sets the load mode of this MIDI instrument.
184	* @param loadMode Specifies the load mode for this MIDI instrument.
185	*/
186	public void
187	setLoadMode(LoadMode loadMode) { this.loadMode = loadMode; }
188
189	/**
190	* Parses a line of text.
191	* @param s The string to be parsed.
192	* @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
193	* @throws LscpException If some error occurs.
194	*/
195	public boolean
196	parse(String s) throws LscpException {
197	if(s.startsWith("NAME: ")) {
198	setName(toNonEscapedString(s.substring("NAME: ".length())));
199	} else if(s.startsWith("ENGINE_NAME: ")) {
200	setEngine(s.substring("ENGINE_NAME: ".length()));
201	} else if(s.startsWith("INSTRUMENT_NAME: ")) {
202	instrName = toNonEscapedString(s.substring("INSTRUMENT_NAME: ".length()));
203	} else if(s.startsWith("LOAD_MODE: ")) {
204	s = s.substring("LOAD_MODE: ".length());
205	if(s.length() == 0) setLoadMode(LoadMode.DEFAULT);
206	else setLoadMode(LoadMode.valueOf(s));
207	} else if(s.startsWith("VOLUME: ")) {
208	s = s.substring("VOLUME: ".length());
209	setVolume(Parser.parseFloat(s));
210	} else return super.parse(s);
211
212	return true;
213	}
214
215	/**
216	* Determines whether the specified object is of type
217	* <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
218	* @param obj The reference object with which to compare.
219	* @return <code>true</code> if the specified object is of type
220	* <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
221	*/
222	public boolean
223	equals(Object obj) {
224	if(obj == null) return false;
225	if(!(obj instanceof MidiInstrumentInfo)) return false;
226	MidiInstrumentInfo i = (MidiInstrumentInfo)obj;
227	if(getMapId() != i.getMapId()) return false;
228	if(getMidiBank() != i.getMidiBank()) return false;
229	if(getMidiProgram() != i.getMidiProgram()) return false;
230
231	return true;
232	}
233	}