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;

/**
 * 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 (super.parse(s)) return true;
                
                if(s.startsWith("NAME: ")) {
                        setName(s.substring("NAME: ".length()));
                } else if(s.startsWith("ENGINE_NAME: ")) {
                        setEngine(s.substring("ENGINE_NAME: ".length()));
                } else if(s.startsWith("INSTRUMENT_NAME: ")) {
                        instrName = 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 false;
                
                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	/**
26	* Provides information about a MIDI instrument.
27	* @author Grigor Iliev
28	*/
29	public class MidiInstrumentInfo extends AbstractInstrument implements Parseable {
30	private int mapId = -1;
31	private MidiInstrumentEntry entry;
32
33	private String engine;
34	private String instrName = "Untitled";
35	private double volume = 1.0;
36	private LoadMode loadMode = LoadMode.DEFAULT;
37
38	public static enum LoadMode {
39	/** It will be up to the InstrumentManager to decide which mode to use. */
40	DEFAULT ("Default"),
41
42	/**
43	* The instrument will be loaded when when demanded by
44	* at least one sampler channel. It will immediately be freed
45	* from memory when not needed by any sampler channel anymore.
46	*/
47	ON_DEMAND ("On Demand"),
48
49	/**
50	* Same as <code>ON_DEMAND</code> with the difference that the instrument
51	* will be kept in memory even when not needed by any sampler channel.
52	*/
53	ON_DEMAND_HOLD ("On Demand and Hold"),
54
55	/**
56	* The instrument will be immediately loaded into memory
57	* and the instrument will be kept all the time.
58	*/
59	PERSISTENT ("Persistent");
60
61	private final String name;
62
63	LoadMode(String name) { this.name = name; }
64
65	public String
66	toString() { return name; }
67	}
68
69
70	/** Creates a new instance of <code>MidiInstrumentInfo</code> */
71	public MidiInstrumentInfo() {
72
73	}
74
75	/**
76	* Creates a new instance of <code>MidiInstrumentInfo</code>.
77	* @param mapId The ID of the map containing this instrument.
78	* @param entry The instrument position in the map.
79	*/
80	public MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry) {
81	this.mapId = mapId;
82	this.entry = entry;
83	}
84
85	/**
86	* Creates a new instance of <code>MidiInstrumentInfo</code> and parses the
87	* provided information about this instrument.
88	* @param mapId The ID of the map containing this instrument.
89	* @param entry Provides the position of the MIDI instrument in the MIDI instrument map.
90	* @param resultSet An array with information categories about a MIDI instrument.
91	* @throws LscpException If the parse fails.
92	*/
93	public
94	MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry, String[] resultSet)
95	throws LscpException {
96	this.mapId = mapId;
97	this.entry = entry;
98
99	for(String s : resultSet)
100	if(!parse(s)) Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
101	}
102
103	/**
104	* Gets the position of the MIDI instrument in a MIDI instrument map.
105	* @return The position of the MIDI instrument in a MIDI instrument map.
106	*/
107	public MidiInstrumentEntry
108	getEntry() { return entry; }
109
110	/**
111	* Gets the ID of the map containing this instrument.
112	* @return The ID of the map containing this instrument.
113	*/
114	public int
115	getMapId() { return mapId; }
116
117	/**
118	* Gets the index of the MIDI bank, containing this instrument.
119	* @return The index of the MIDI bank, containing this instrument.
120	*/
121	public int
122	getMidiBank() { return entry.getMidiBank(); }
123
124	/**
125	* Gets the MIDI program number of this instrument.
126	* @return The MIDI program number of this instrument.
127	*/
128	public int
129	getMidiProgram() { return entry.getMidiProgram(); }
130
131	/**
132	* Gets the name of the sampler engine to be used to load the instrument.
133	* @return The name of the sampler engine to be used to load the instrument.
134	*/
135	public String
136	getEngine() { return engine; }
137
138	/**
139	* Sets the name of the sampler engine to be used to load the instrument.
140	* @param engine The name of the sampler engine to be used to load the instrument.
141	*/
142	public void
143	setEngine(String engine) { this.engine = engine; }
144
145	/**
146	* Gets the name of the loaded instrument as reflected by its file.
147	* @return The name of the loaded instrument as reflected by its file.
148	*/
149	public String
150	getInstrumentName() { return instrName; }
151
152	/**
153	* Sets the name of this instrument as reflected by its file.
154	* @param name The name of the instrument as reflected by its file.
155	*
156	public void
157	setInstrumentName(String name) { this.instrName = name; }*/
158
159	/**
160	* Returns the volume, specified for this instrument, where a
161	* value < 1.0 means attenuation and a value > 1.0 means amplification.
162	*/
163	public double
164	getVolume() { return volume; }
165
166	/**
167	* Sets the volume level for this instrument, where a
168	* value < 1.0 means attenuation and a value > 1.0 means amplification.
169	*/
170	public void
171	setVolume(double volume) { this.volume = volume; }
172
173	/**
174	* Gets the load mode of this MIDI instrument.
175	* @return The load mode of this MIDI instrument.
176	*/
177	public LoadMode
178	getLoadMode() { return loadMode; }
179
180	/**
181	* Sets the load mode of this MIDI instrument.
182	* @param loadMode Specifies the load mode for this MIDI instrument.
183	*/
184	public void
185	setLoadMode(LoadMode loadMode) { this.loadMode = loadMode; }
186
187	/**
188	* Parses a line of text.
189	* @param s The string to be parsed.
190	* @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
191	* @throws LscpException If some error occurs.
192	*/
193	public boolean
194	parse(String s) throws LscpException {
195	if (super.parse(s)) return true;
196
197	if(s.startsWith("NAME: ")) {
198	setName(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 = 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 false;
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	}