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 implements Parseable {
        private int mapId = -1;
        private MidiInstrumentEntry entry;
        
        private String name = "Untitled";
        private String engine;
        private String instrName = "Untitled";
        private String path = null;
        private int instrumentIndex = 0;
        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 this MIDI instrument.
         * @return The name of this MIDI instrument.
         */
        public String
        getName() { return name; }
        
        /**
         * Sets the name of this MIDI instrument.
         * @param name The new name of this MIDI instrument.
         */
        public void
        setName(String name) { this.name = name; }
        
        /**
         * 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 absolute pathname of the instrument location.
         * @return The absolute pathname of the instrument location.
         */
        public String
        getFileName() { return path; }
        
        /**
         * Sets the absolute pathname of the instrument location.
         * @param path Specifies the absolute pathname of the instrument location.
         */
        public void
        setFileName(String path) { this.path = path; }
        
        /**
         * Returns the index of the instrument in the instrument file.
         * @return The index of the instrument in the instrument file.
         */
        public int
        getInstrumentIndex() { return instrumentIndex; }
        
        /**
         * Sets the index of the instrument in the instrument file.
         * @param idx The index of the instrument in the instrument file.
         */
        public void
        setInstrumentIndex(int idx) { instrumentIndex = idx; }
        
        /**
         * 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(s.substring("NAME: ".length()));
                } else if(s.startsWith("ENGINE_NAME: ")) {
                        setEngine(s.substring("ENGINE_NAME: ".length()));
                } else if(s.startsWith("INSTRUMENT_FILE: ")) {
                        setFileName(s.substring("INSTRUMENT_FILE: ".length()));
                } else if(s.startsWith("INSTRUMENT_NR: ")) {
                        s = s.substring("INSTRUMENT_NR: ".length());
                        setInstrumentIndex(Parser.parseInt(s));
                } 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	iliev	1140	/*
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 implements Parseable {
30			private int mapId = -1;
31			private MidiInstrumentEntry entry;
32
33			private String name = "Untitled";
34			private String engine;
35			private String instrName = "Untitled";
36			private String path = null;
37			private int instrumentIndex = 0;
38			private double volume = 1.0;
39			private LoadMode loadMode = LoadMode.DEFAULT;
40
41			public static enum LoadMode {
42			/** It will be up to the InstrumentManager to decide which mode to use. */
43			DEFAULT ("Default"),
44
45			/**
46			* The instrument will be loaded when when demanded by
47			* at least one sampler channel. It will immediately be freed
48			* from memory when not needed by any sampler channel anymore.
49			*/
50			ON_DEMAND ("On Demand"),
51
52			/**
53			* Same as <code>ON_DEMAND</code> with the difference that the instrument
54			* will be kept in memory even when not needed by any sampler channel.
55			*/
56			ON_DEMAND_HOLD ("On Demand and Hold"),
57
58			/**
59			* The instrument will be immediately loaded into memory
60			* and the instrument will be kept all the time.
61			*/
62			PERSISTENT ("Persistent");
63
64			private final String name;
65
66			LoadMode(String name) { this.name = name; }
67
68			public String
69			toString() { return name; }
70			}
71
72
73			/** Creates a new instance of <code>MidiInstrumentInfo</code> */
74			public MidiInstrumentInfo() {
75
76			}
77
78			/**
79			* Creates a new instance of <code>MidiInstrumentInfo</code>.
80			* @param mapId The ID of the map containing this instrument.
81			* @param entry The instrument position in the map.
82			*/
83			public MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry) {
84			this.mapId = mapId;
85			this.entry = entry;
86			}
87
88			/**
89			* Creates a new instance of <code>MidiInstrumentInfo</code> and parses the
90			* provided information about this instrument.
91			* @param mapId The ID of the map containing this instrument.
92			* @param entry Provides the position of the MIDI instrument in the MIDI instrument map.
93			* @param resultSet An array with information categories about a MIDI instrument.
94			* @throws LscpException If the parse fails.
95			*/
96			public
97			MidiInstrumentInfo(int mapId, MidiInstrumentEntry entry, String[] resultSet)
98			throws LscpException {
99			this.mapId = mapId;
100			this.entry = entry;
101
102			for(String s : resultSet)
103			if(!parse(s)) Client.getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
104			}
105
106			/**
107			* Gets the position of the MIDI instrument in a MIDI instrument map.
108			* @return The position of the MIDI instrument in a MIDI instrument map.
109			*/
110			public MidiInstrumentEntry
111			getEntry() { return entry; }
112
113			/**
114			* Gets the ID of the map containing this instrument.
115			* @return The ID of the map containing this instrument.
116			*/
117			public int
118			getMapId() { return mapId; }
119
120			/**
121			* Gets the index of the MIDI bank, containing this instrument.
122			* @return The index of the MIDI bank, containing this instrument.
123			*/
124			public int
125			getMidiBank() { return entry.getMidiBank(); }
126
127			/**
128			* Gets the MIDI program number of this instrument.
129			* @return The MIDI program number of this instrument.
130			*/
131			public int
132			getMidiProgram() { return entry.getMidiProgram(); }
133
134			/**
135			* Gets the name of this MIDI instrument.
136			* @return The name of this MIDI instrument.
137			*/
138			public String
139			getName() { return name; }
140
141			/**
142			* Sets the name of this MIDI instrument.
143			* @param name The new name of this MIDI instrument.
144			*/
145			public void
146			setName(String name) { this.name = name; }
147
148			/**
149			* Gets the name of the sampler engine to be used to load the instrument.
150			* @return The name of the sampler engine to be used to load the instrument.
151			*/
152			public String
153			getEngine() { return engine; }
154
155			/**
156			* Sets the name of the sampler engine to be used to load the instrument.
157			* @param engine The name of the sampler engine to be used to load the instrument.
158			*/
159			public void
160			setEngine(String engine) { this.engine = engine; }
161
162			/**
163			* Gets the name of the loaded instrument as reflected by its file.
164			* @return The name of the loaded instrument as reflected by its file.
165			*/
166			public String
167			getInstrumentName() { return instrName; }
168
169			/**
170			* Sets the name of this instrument as reflected by its file.
171			* @param name The name of the instrument as reflected by its file.
172			*
173			public void
174			setInstrumentName(String name) { this.instrName = name; }*/
175
176			/**
177			* Returns the absolute pathname of the instrument location.
178			* @return The absolute pathname of the instrument location.
179			*/
180			public String
181			getFileName() { return path; }
182
183			/**
184			* Sets the absolute pathname of the instrument location.
185			* @param path Specifies the absolute pathname of the instrument location.
186			*/
187			public void
188			setFileName(String path) { this.path = path; }
189
190			/**
191			* Returns the index of the instrument in the instrument file.
192			* @return The index of the instrument in the instrument file.
193			*/
194			public int
195			getInstrumentIndex() { return instrumentIndex; }
196
197			/**
198			* Sets the index of the instrument in the instrument file.
199			* @param idx The index of the instrument in the instrument file.
200			*/
201			public void
202			setInstrumentIndex(int idx) { instrumentIndex = idx; }
203
204			/**
205			* Returns the volume, specified for this instrument, where a
206			* value < 1.0 means attenuation and a value > 1.0 means amplification.
207			*/
208			public double
209			getVolume() { return volume; }
210
211			/**
212			* Sets the volume level for this instrument, where a
213			* value < 1.0 means attenuation and a value > 1.0 means amplification.
214			*/
215			public void
216			setVolume(double volume) { this.volume = volume; }
217
218			/**
219			* Gets the load mode of this MIDI instrument.
220			* @return The load mode of this MIDI instrument.
221			*/
222			public LoadMode
223			getLoadMode() { return loadMode; }
224
225			/**
226			* Sets the load mode of this MIDI instrument.
227			* @param loadMode Specifies the load mode for this MIDI instrument.
228			*/
229			public void
230			setLoadMode(LoadMode loadMode) { this.loadMode = loadMode; }
231
232			/**
233			* Parses a line of text.
234			* @param s The string to be parsed.
235			* @return <code>true</code> if the line has been processed, <code>false</code> otherwise.
236			* @throws LscpException If some error occurs.
237			*/
238			public boolean
239			parse(String s) throws LscpException {
240			if(s.startsWith("NAME: ")) {
241			setName(s.substring("NAME: ".length()));
242			} else if(s.startsWith("ENGINE_NAME: ")) {
243			setEngine(s.substring("ENGINE_NAME: ".length()));
244			} else if(s.startsWith("INSTRUMENT_FILE: ")) {
245			setFileName(s.substring("INSTRUMENT_FILE: ".length()));
246			} else if(s.startsWith("INSTRUMENT_NR: ")) {
247			s = s.substring("INSTRUMENT_NR: ".length());
248			setInstrumentIndex(Parser.parseInt(s));
249			} else if(s.startsWith("INSTRUMENT_NAME: ")) {
250			instrName = s.substring("INSTRUMENT_NAME: ".length());
251			} else if(s.startsWith("LOAD_MODE: ")) {
252			s = s.substring("LOAD_MODE: ".length());
253			if(s.length() == 0) setLoadMode(LoadMode.DEFAULT);
254			else setLoadMode(LoadMode.valueOf(s));
255			} else if(s.startsWith("VOLUME: ")) {
256			s = s.substring("VOLUME: ".length());
257			setVolume(Parser.parseFloat(s));
258			} else return false;
259
260			return true;
261			}
262
263			/**
264			* Determines whether the specified object is of type
265			* <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
266			* @param obj The reference object with which to compare.
267			* @return <code>true</code> if the specified object is of type
268			* <code>MidiInstrumentInfo</code> and has equal map ID, MIDI bank and MIDI program.
269			*/
270			public boolean
271			equals(Object obj) {
272			if(obj == null) return false;
273			if(!(obj instanceof MidiInstrumentInfo)) return false;
274			MidiInstrumentInfo i = (MidiInstrumentInfo)obj;
275			if(getMapId() != i.getMapId()) return false;
276			if(getMidiBank() != i.getMidiBank()) return false;
277			if(getMidiProgram() != i.getMidiProgram()) return false;
278
279			return true;
280			}
281			}