/[svn]/jlscp/trunk/src/org/linuxsampler/lscp/Client.java
ViewVC logotype

Contents of /jlscp/trunk/src/org/linuxsampler/lscp/Client.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1354 - (show annotations) (download)
Mon Sep 17 23:33:50 2007 UTC (16 years, 6 months ago) by iliev
File size: 171634 byte(s)
* Added support for formatting the instruments database

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 java.io.IOException;
26 import java.io.OutputStream;
27
28 import java.net.InetSocketAddress;
29 import java.net.Socket;
30 import java.net.SocketTimeoutException;
31 import java.net.UnknownHostException;
32
33 import java.util.Vector;
34 import java.util.logging.Level;
35 import java.util.logging.Logger;
36
37 import org.linuxsampler.lscp.event.*;
38
39 import static org.linuxsampler.lscp.Parser.*;
40
41
42 /**
43 * This class is the abstraction representing a client endpoint for communication with LinuxSampler
44 * instance. Since it implements all commands specified in the LSCP protocol v1.1, for more
45 * information look at the
46 * <a href=http://www.linuxsampler.org/api/lscp-1.1.html>LSCP</a> specification.
47 *
48 * <p> The following code establishes connection to LinuxSampler instance and gets the
49 * LinuxSampler version:
50 * <pre>
51 * try {
52 * Client client = new Client();
53 * client.connect();
54 *
55 * String version = client.getServerInfo().getVersion();
56 * System.out.println(version);
57 *
58 * client.disconnect();
59 * } catch(Exception x) { x.printStackTrace(); }
60 * </pre>
61 * </p>
62 *
63 * <p>For more examples look at the <code>examples</code> directory
64 * located in the <b>jlscp</b> distribution.</p>
65 *
66 * All methods are thread safe.
67 * @author Grigor Iliev
68 */
69 public class Client {
70 private String address;
71 private int port;
72 private Socket sock = null;
73 private int soTimeout = 20000;
74
75 private LscpInputStream in = null;
76 private LscpOutputStream out = null;
77
78 private EventThread eventThread;
79
80 private boolean printOnlyMode = false;
81
82 class EventThread extends Thread {
83 private Vector<String> queue = new Vector<String>();
84 private boolean terminate = false;
85
86 EventThread() { super("LSCP-Event-Thread"); }
87
88 public void
89 run() {
90 while(!mustTerminate()) {
91 try {
92 processQueue();
93 processNotifications();
94 } catch(Exception x) {
95 getLogger().log(Level.FINE, x.getMessage(), x);
96 }
97 try { synchronized(this) { wait(100); } }
98 catch(Exception x) {
99 getLogger().log(Level.FINE, x.getMessage(), x);
100 }
101 }
102 }
103
104 private synchronized boolean
105 mustTerminate() { return terminate; }
106
107 public synchronized void
108 terminate() {
109 terminate = true;
110 this.notifyAll();
111 }
112
113 public synchronized void
114 scheduleNotification(String s) { queue.add(s); }
115
116 private void
117 processQueue() {
118 String[] notifications = popAllNotifications();
119 for(String n : notifications) fireEvent(n);
120 }
121
122 private synchronized String[]
123 popAllNotifications() {
124 String[] notifications = queue.toArray(new String[queue.size()]);
125 queue.removeAllElements();
126 return notifications;
127 }
128 }
129
130 /**
131 * Creates a new instance of Client with default server address and port.
132 * The default server address and port are 127.0.0.1:8888.
133 */
134 public
135 Client() { this("127.0.0.1"); }
136
137 /**
138 * Creates a new instance of Client with the specified address and default port.
139 * The default port is 8888.
140 * @param address The address of linux sampler server.
141 */
142 public
143 Client(String address) { this(address, 8888); }
144
145 /**
146 * Creates a new instance of Client with the specified address and port.
147 * @param address The address of the Linux Sampler.
148 * @param port The Linux Sampler port number.
149 */
150 public
151 Client(String address, int port) {
152 setServerAddress(address);
153 setServerPort(port);
154
155 eventThread = new EventThread();
156 }
157
158 /**
159 * Creates a new instance of Client.
160 * @param printOnlyMode Determines whether the client will be in print-only mode.
161 */
162 public
163 Client(boolean printOnlyMode) {
164 if(printOnlyMode) setPrintOnlyMode(true);
165 }
166
167 /**
168 * Determines whether the client is in print-only mode.
169 * Print-only mode means that the client will just print all
170 * LSCP commands to the specified output stream or to the standard output stream
171 * (<code>java.lang.System.out</code>) if no output stream is specified,
172 * without taking any further actions. Thus, in print-only mode all returned
173 * values by <code>Client</code>'s methods are meaningless and should be discarded.
174 * @return <code>true</code> if the client is in
175 * print-only mode, <code>false</code> otherwise.
176 * @see #setPrintOnlyModeOutputStream
177 */
178 public synchronized boolean
179 getPrintOnlyMode() { return printOnlyMode; }
180
181 /**
182 * Sets the print-only mode. Note that in print-only mode all returned
183 * values by <code>Client</code>'s methods are meaningless and should be discarded.
184 * The default output stream in print-only mode is <code>java.lang.System.out</code>.
185 * @param b If <code>true</code> all LSCP commands will be sent
186 * to the specified output stream or to the standard output stream
187 * (<code>java.lang.System.out</code>) if no output stream is specified,
188 * and no further actions will be taken.
189 * @throws IllegalStateException If the client is connected.
190 * @see #setPrintOnlyModeOutputStream
191 */
192 public synchronized void
193 setPrintOnlyMode(boolean b) {
194 if(printOnlyMode == b) return;
195 if(isConnected()) throw new IllegalStateException();
196
197 printOnlyMode = b;
198 if(b) out = new LscpOutputStream(System.out);
199 }
200
201 /**
202 * Sets the output stream to be used in print-only mode.
203 * @param out The output stream to be used in print-only mode.
204 * @throws IllegalStateException If the client is not in print-only mode.
205 * @throws IllegalArgumentException if <code>out</code> is <code>null</code>.
206 * @see #setPrintOnlyMode
207 */
208 public synchronized void
209 setPrintOnlyModeOutputStream(OutputStream out) {
210 if(!getPrintOnlyMode()) throw new IllegalStateException("Not in print-only mode");
211 if(out == null) throw new IllegalArgumentException("out must be non-null");
212 this.out = new LscpOutputStream(out);
213 }
214
215 /**
216 * Specifies the jlscp version.
217 * @return The jlscp version.
218 */
219 public static String
220 getClientVersion() {
221 return Package.getPackage("org.linuxsampler.lscp").getImplementationVersion();
222 }
223
224 /**
225 * Gets the Linux Sampler address.
226 * @return The Linux Sampler address.
227 */
228 public synchronized String
229 getServerAddress() { return address; }
230
231 /**
232 * Sets the Linux Sampler address.
233 * @param address The Linux Sampler address.
234 * If <code>address</code> is <code>null</code> sets to default address - 127.0.0.1.
235 */
236 public synchronized void
237 setServerAddress(String address) {
238 this.address = (address == null ? "127.0.0.1" : address);
239 }
240
241 /**
242 * Gets the Linux Sampler port number.
243 * @return The Linux Sampler port number.
244 */
245 public synchronized int
246 getServerPort() { return port; }
247
248 /**
249 * Sets the Linux Sampler port number.
250 * @param port The Linux Sampler port number.
251 */
252 public synchronized void
253 setServerPort(int port) { this.port = port; }
254
255 /**
256 * Connects to the LinuxSampler. If there is already established connection then
257 * the currently available connection is closed berfore connecting.
258 * @throws LscpException If timeout occurs or any other I/O exception.
259 */
260 public synchronized void
261 connect() throws LscpException {
262 if(sock != null) disconnect();
263 if(getPrintOnlyMode()) return;
264
265 // Initializing LSCP event thread
266 if(eventThread.isAlive()) {
267 getLogger().warning("LSCP event thread already running!");
268 eventThread.terminate();
269 }
270
271 if(eventThread.getState() != Thread.State.NEW) eventThread = new EventThread();
272 ///////
273
274 InetSocketAddress sockAddr = null;
275
276 try { sockAddr = new InetSocketAddress(address, port); }
277 catch(IllegalArgumentException x) {
278 String s = String.valueOf(port);
279 throw new LscpException(LscpI18n.getLogMsg("Client.invalidPort!", s), x);
280 }
281
282 if(sockAddr.isUnresolved()) throw new LscpException (
283 LscpI18n.getLogMsg("Client.unknownHost!", address)
284 );
285
286 try {
287 sock = new Socket();
288 sock.bind(null);
289 sock.connect(sockAddr, soTimeout);
290 sock.setSoTimeout(soTimeout);
291 sock.setTcpNoDelay(true);
292
293 in = new LscpInputStream(sock.getInputStream());
294 out = new LscpOutputStream(sock.getOutputStream());
295 } catch(SocketTimeoutException x) {
296 throw new LscpException(LscpI18n.getLogMsg("Client.conTimeout!"), x);
297 } catch(Exception x) {
298 throw new LscpException (
299 LscpI18n.getLogMsg("Client.connectionFailed!"), x
300 );
301 }
302
303 String s = Package.getPackage("org.linuxsampler.lscp").getSpecificationVersion();
304 String s2, sv, sv2;
305
306 try {
307 s2 = s.substring(0, s.indexOf('.'));
308 sv = getServerInfo().getProtocolVersion();
309 sv2 = sv.substring(0, sv.indexOf('.'));
310 } catch(Exception x) {
311 disconnect();
312
313 throw new LscpException (
314 LscpI18n.getLogMsg("Client.connectionFailed!"), x
315 );
316 }
317
318 if(!sv2.equals(s2)) {
319 disconnect();
320
321 throw new LscpException (
322 LscpI18n.getLogMsg("Client.incompatibleLscpVersion!", sv)
323 );
324 }
325
326 s2 = s.substring(s.indexOf('.'));
327 sv2 = sv.substring(sv.indexOf('.'));
328
329 if(sv2.compareToIgnoreCase(s2) < 0) getLogger().info (
330 LscpI18n.getLogMsg("Client.incompatibleLscpMinVersion!", sv)
331 );
332
333 if(hasSubscriptions()) eventThread.start();
334
335 if(!llM.isEmpty()) subscribe("MISCELLANEOUS");
336 if(!llAODC.isEmpty()) subscribe("AUDIO_OUTPUT_DEVICE_COUNT");
337 if(!llAODI.isEmpty()) subscribe("AUDIO_OUTPUT_DEVICE_INFO");
338 if(!llMIDC.isEmpty()) subscribe("MIDI_INPUT_DEVICE_COUNT");
339 if(!llMIDI.isEmpty()) subscribe("MIDI_INPUT_DEVICE_INFO");
340 if(!llBF.isEmpty()) subscribe("BUFFER_FILL");
341 if(!llCC.isEmpty()) subscribe("CHANNEL_COUNT");
342 if(!llCI.isEmpty()) subscribe("CHANNEL_INFO");
343 if(!llFSC.isEmpty()) subscribe("FX_SEND_COUNT");
344 if(!llFSI.isEmpty()) subscribe("FX_SEND_INFO");
345 if(!llSC.isEmpty()) subscribe("STREAM_COUNT");
346 if(!llVC.isEmpty()) subscribe("VOICE_COUNT");
347 if(!llTVC.isEmpty()) subscribe("TOTAL_VOICE_COUNT");
348 if(!llMIMC.isEmpty()) subscribe("MIDI_INSTRUMENT_MAP_COUNT");
349 if(!llMIMI.isEmpty()) subscribe("MIDI_INSTRUMENT_MAP_INFO");
350 if(!llMIC.isEmpty()) subscribe("MIDI_INSTRUMENT_COUNT");
351 if(!llMII.isEmpty()) subscribe("MIDI_INSTRUMENT_INFO");
352 if(!llID.isEmpty()) {
353 subscribe("DB_INSTRUMENT_DIRECTORY_COUNT");
354 subscribe("DB_INSTRUMENT_DIRECTORY_INFO");
355 subscribe("DB_INSTRUMENT_COUNT");
356 subscribe("DB_INSTRUMENT_INFO");
357 }
358 if(!llGI.isEmpty()) subscribe("GLOBAL_INFO");
359 }
360
361 /**
362 * Closes the connection to LinuxSampler.
363 */
364 public synchronized void
365 disconnect() {
366 if(getPrintOnlyMode()) return;
367 try { if(sock != null) sock.close(); }
368 catch(Exception x) { getLogger().log(Level.FINE, x.getMessage(), x); }
369 sock = null;
370
371 if(eventThread.getState() != Thread.State.NEW) {
372 eventThread.terminate();
373 eventThread = new EventThread();
374 }
375 }
376
377 /**
378 * Determines whether the client is connected.
379 * @return <code>true</code> if there is established connection,
380 * <code>false</code> otherwise.
381 */
382 public synchronized boolean
383 isConnected() {
384 if(sock == null) return false;
385 else return sock.isConnected();
386 }
387
388 /**
389 * Verifies that there is established connection.
390 * @throws IOException If the connection is not established.
391 */
392 private void
393 verifyConnection() throws IOException {
394 if(getPrintOnlyMode()) return;
395
396 if(!isConnected())
397 throw new IOException(LscpI18n.getLogMsg("Client.notConnected!"));
398 }
399
400 private String
401 getLine() throws IOException, LscpException {
402 String s;
403 for(;;) {
404 s = in.readLine();
405 if(s.startsWith("NOTIFY:")) {
406 eventThread.scheduleNotification(s.substring("NOTIFY:".length()));
407 }
408 else break;
409 }
410 return s;
411 }
412
413 /** Processes the notifications sent by LinuxSampler */
414 private synchronized void
415 processNotifications() throws IOException, LscpException {
416 while(in.available() > 0) {
417 String s = in.readLine();
418 if(s.startsWith("NOTIFY:")) fireEvent(s.substring("NOTIFY:".length()));
419 else getLogger().severe("Unknown notification format: " + s);
420 }
421 }
422
423 /**
424 * Gets empty result set.
425 * @return <code>ResultSet</code> instance.
426 */
427 private ResultSet
428 getEmptyResultSet() throws IOException, LscpException, LSException {
429 return parseEmptyResultSet(getLine());
430 }
431
432 private ResultSet
433 getSingleLineResultSet() throws IOException, LscpException, LSException {
434 ResultSet rs = new ResultSet();
435 String ln = getLine();
436
437 if(ln.startsWith("WRN")) {
438 parseWarning(ln, rs);
439 getLogger().warning(rs.getMessage());
440 return rs;
441 } else if(ln.startsWith("ERR")) {
442 parseError(ln, rs);
443 throw new LSException(rs.getCode(), rs.getMessage());
444 } else {
445 rs.setResult(ln);
446 return rs;
447 }
448 }
449
450 private ResultSet
451 getMultiLineResultSet() throws IOException, LscpException, LSException {
452 ResultSet rs = new ResultSet();
453 String ln = getLine();
454
455 if(ln.startsWith("WRN")) {
456 parseWarning(ln, rs);
457 getLogger().warning(rs.getMessage());
458 return rs;
459 } else if(ln.startsWith("ERR")) {
460 parseError(ln, rs);
461 throw new LSException(rs.getCode(), rs.getMessage());
462 }
463
464 while(!ln.equals(".")) {
465 rs.addLine(ln);
466 ln = getLine();
467 }
468
469 return rs;
470 }
471
472 /** Audio output device count listeners */
473 private final Vector<ItemCountListener> llAODC = new Vector<ItemCountListener>();
474 /** Audio output device info listeners */
475 private final Vector<ItemInfoListener> llAODI = new Vector<ItemInfoListener>();
476 private final Vector<BufferFillListener> llBF = new Vector<BufferFillListener>();
477 private final Vector<ChannelCountListener> llCC = new Vector<ChannelCountListener>();
478 private final Vector<ChannelInfoListener> llCI = new Vector<ChannelInfoListener>();
479 private final Vector<FxSendCountListener> llFSC = new Vector<FxSendCountListener>();
480 private final Vector<FxSendInfoListener> llFSI = new Vector<FxSendInfoListener>();
481 private final Vector<MiscellaneousListener> llM = new Vector<MiscellaneousListener>();
482 /** MIDI input device count listeners */
483 private final Vector<ItemCountListener> llMIDC = new Vector<ItemCountListener>();
484 /** MIDI input device info listeners */
485 private final Vector<ItemInfoListener> llMIDI = new Vector<ItemInfoListener>();
486 private final Vector<StreamCountListener> llSC = new Vector<StreamCountListener>();
487 private final Vector<VoiceCountListener> llVC = new Vector<VoiceCountListener>();
488 private final Vector<TotalVoiceCountListener> llTVC = new Vector<TotalVoiceCountListener>();
489
490 /** MIDI instrument map count listeners */
491 private final Vector<ItemCountListener> llMIMC = new Vector<ItemCountListener>();
492 /** MIDI instrument map info listeners */
493 private final Vector<ItemInfoListener> llMIMI = new Vector<ItemInfoListener>();
494 /** MIDI instrument count listeners */
495 private final Vector<MidiInstrumentCountListener> llMIC =
496 new Vector<MidiInstrumentCountListener>();
497 /** MIDI instrument info listeners */
498 private final Vector<MidiInstrumentInfoListener> llMII =
499 new Vector<MidiInstrumentInfoListener>();
500 private final Vector<InstrumentsDbListener> llID = new Vector<InstrumentsDbListener>();
501 private final Vector<GlobalInfoListener> llGI = new Vector<GlobalInfoListener>();
502
503
504 /**
505 * Determines whether there is at least one subscription for notification events.
506 * Do not forget to check for additional listeners if the LSCP specification
507 * is extended in the future.
508 * @return <code>true</code> if there is at least one subscription for notification events,
509 * <code>false</code> otherwise.
510 */
511 private boolean
512 hasSubscriptions() {
513 return !llAODC.isEmpty() ||
514 !llAODI.isEmpty() ||
515 !llBF.isEmpty() ||
516 !llCC.isEmpty() ||
517 !llCI.isEmpty() ||
518 !llFSC.isEmpty() ||
519 !llFSI.isEmpty() ||
520 !llM.isEmpty() ||
521 !llMIDC.isEmpty() ||
522 !llMIDI.isEmpty() ||
523 !llSC.isEmpty() ||
524 !llVC.isEmpty() ||
525 !llTVC.isEmpty() ||
526 !llMIMC.isEmpty() ||
527 !llMIMI.isEmpty() ||
528 !llMIC.isEmpty() ||
529 !llMII.isEmpty() ||
530 !llID.isEmpty() ||
531 !llGI.isEmpty();
532 }
533
534 private synchronized void
535 fireEvent(String s) {
536 if(s.startsWith("DB_INSTRUMENT_DIRECTORY_COUNT:")) {
537 s = s.substring("DB_INSTRUMENT_DIRECTORY_COUNT:".length());
538 InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
539 for(InstrumentsDbListener l : llID) l.directoryCountChanged(e);
540 } else if(s.startsWith("DB_INSTRUMENT_DIRECTORY_INFO:")) {
541 InstrumentsDbEvent e;
542 s = s.substring("DB_INSTRUMENT_DIRECTORY_INFO:".length());
543 if(s.startsWith("NAME ")) {
544 String[] list;
545 try {
546 s = s.substring("NAME ".length());
547 list = parseEscapedStringList(s, ' ');
548 if(list.length != 2) throw new LscpException();
549 list[1] = toNonEscapedString(list[1]);
550 e = new InstrumentsDbEvent(this, list[0], list[1]);
551 for(InstrumentsDbListener l : llID) {
552 l.directoryNameChanged(e);
553 }
554 } catch(LscpException x) {
555 getLogger().log (
556 Level.WARNING,
557 LscpI18n.getLogMsg("CommandFailed!"),
558 x
559 );
560 }
561 } else {
562 e = new InstrumentsDbEvent(this, s);
563 for(InstrumentsDbListener l : llID) l.directoryInfoChanged(e);
564 }
565 } else if(s.startsWith("DB_INSTRUMENT_COUNT:")) {
566 s = s.substring("DB_INSTRUMENT_COUNT:".length());
567 InstrumentsDbEvent e = new InstrumentsDbEvent(this, s);
568 for(InstrumentsDbListener l : llID) l.instrumentCountChanged(e);
569 } else if(s.startsWith("DB_INSTRUMENT_INFO:")) {
570 InstrumentsDbEvent e;
571 s = s.substring("DB_INSTRUMENT_INFO:".length());
572 if(s.startsWith("NAME ")) {
573 String[] list;
574 try {
575 s = s.substring("NAME ".length());
576 list = parseEscapedStringList(s, ' ');
577 if(list.length != 2) throw new LscpException();
578 list[1] = toNonEscapedString(list[1]);
579 e = new InstrumentsDbEvent(this, list[0], list[1]);
580 for(InstrumentsDbListener l : llID) {
581 l.instrumentNameChanged(e);
582 }
583 } catch(LscpException x) {
584 getLogger().log (
585 Level.WARNING,
586 LscpI18n.getLogMsg("CommandFailed!"),
587 x
588 );
589 }
590 } else {
591 e = new InstrumentsDbEvent(this, s);
592 for(InstrumentsDbListener l : llID) l.instrumentInfoChanged(e);
593 }
594 } else if(s.startsWith("DB_INSTRUMENTS_JOB_INFO:")) {
595 s = s.substring("DB_INSTRUMENTS_JOB_INFO:".length());
596 try {
597 int i = Integer.parseInt(s);
598 InstrumentsDbEvent e = new InstrumentsDbEvent(this, i);
599 for(InstrumentsDbListener l : llID) l.jobStatusChanged(e);
600 } catch(NumberFormatException x) {
601 s = "Unknown DB_INSTRUMENTS_JOB_INFO format";
602 getLogger().log(Level.WARNING, s, x);
603 }
604
605 } else if(s.startsWith("CHANNEL_COUNT:")) {
606 try {
607 int i = Integer.parseInt(s.substring("CHANNEL_COUNT:".length()));
608 ChannelCountEvent e = new ChannelCountEvent(this, i);
609 for(ChannelCountListener l : llCC) l.channelCountChanged(e);
610 } catch(NumberFormatException x) {
611 getLogger().log (
612 Level.WARNING, LscpI18n.getLogMsg("CommandFailed!"), x
613 );
614 }
615 } else if(s.startsWith("VOICE_COUNT:")) {
616 try {
617 s = s.substring("VOICE_COUNT:".length());
618 Integer[] i = parseIntList(s, ' ');
619 if(i.length != 2) {
620 getLogger().warning("Unknown VOICE_COUNT format");
621 return;
622 }
623 VoiceCountEvent e = new VoiceCountEvent(this, i[0], i[1]);
624 for(VoiceCountListener l : llVC) l.voiceCountChanged(e);
625 } catch(Exception x) {
626 getLogger().log(Level.WARNING, "Unknown VOICE_COUNT format", x);
627 }
628 } else if(s.startsWith("STREAM_COUNT:")) {
629 try {
630 s = s.substring("STREAM_COUNT:".length());
631 Integer[] i = parseIntList(s, ' ');
632 if(i.length != 2) {
633 getLogger().warning("Unknown STREAM_COUNT format");
634 return;
635 }
636 StreamCountEvent e = new StreamCountEvent(this, i[0], i[1]);
637 for(StreamCountListener l : llSC) l.streamCountChanged(e);
638 } catch(Exception x) {
639 getLogger().log(Level.WARNING, "Unknown STREAM_COUNT format", x);
640 }
641 } else if(s.startsWith("BUFFER_FILL:")) {
642 try {
643 s = s.substring("BUFFER_FILL:".length());
644 int i = s.indexOf(' ');
645 if(i == -1) {
646 getLogger().warning("Unknown BUFFER_FILL format");
647 return;
648 }
649 int j = Integer.parseInt(s.substring(0, i));
650 Vector<BufferFill> v =
651 getChannelBufferFillPercentage(s.substring(i + 1));
652 BufferFillEvent e = new BufferFillEvent(this, j, v);
653 for(BufferFillListener l : llBF) l.bufferFillChanged(e);
654 } catch(Exception x) {
655 getLogger().log(Level.WARNING, "Unknown BUFFER_FILL format", x);
656 }
657 } else if(s.startsWith("CHANNEL_INFO:")) {
658 try {
659 int i = Integer.parseInt(s.substring("CHANNEL_INFO:".length()));
660 ChannelInfoEvent e = new ChannelInfoEvent(this, i);
661 for(ChannelInfoListener l : llCI) l.channelInfoChanged(e);
662 } catch(NumberFormatException x) {
663 getLogger().log(Level.WARNING, "Unknown CHANNEL_INFO format", x);
664 }
665 } else if(s.startsWith("TOTAL_VOICE_COUNT:")) {
666 try {
667 s = s.substring("TOTAL_VOICE_COUNT:".length());
668 int i = Integer.parseInt(s);
669 TotalVoiceCountEvent e = new TotalVoiceCountEvent(this, i);
670 for(TotalVoiceCountListener l : llTVC) l.totalVoiceCountChanged(e);
671 } catch(NumberFormatException x) {
672 getLogger().log (
673 Level.WARNING, "Unknown TOTAL_VOICE_COUNT format", x
674 );
675 }
676 } else if(s.startsWith("AUDIO_OUTPUT_DEVICE_COUNT:")) {
677 try {
678 s = s.substring("AUDIO_OUTPUT_DEVICE_COUNT:".length());
679 int i = Integer.parseInt(s);
680 ItemCountEvent e = new ItemCountEvent(this, i);
681 for(ItemCountListener l : llAODC) l.itemCountChanged(e);
682 } catch(NumberFormatException x) {
683 getLogger().log (
684 Level.WARNING, "Unknown AUDIO_OUTPUT_DEVICE_COUNT format", x
685 );
686 }
687 } else if(s.startsWith("AUDIO_OUTPUT_DEVICE_INFO:")) {
688 try {
689 s = s.substring("AUDIO_OUTPUT_DEVICE_INFO:".length());
690 int i = Integer.parseInt(s);
691 ItemInfoEvent e = new ItemInfoEvent(this, i);
692 for(ItemInfoListener l : llAODI) l.itemInfoChanged(e);
693 } catch(NumberFormatException x) {
694 getLogger().log (
695 Level.WARNING, "Unknown AUDIO_OUTPUT_DEVICE_INFO format", x
696 );
697 }
698 } else if(s.startsWith("MIDI_INPUT_DEVICE_COUNT:")) {
699 try {
700 s = s.substring("MIDI_INPUT_DEVICE_COUNT:".length());
701 int i = Integer.parseInt(s);
702 ItemCountEvent e = new ItemCountEvent(this, i);
703 for(ItemCountListener l : llMIDC) l.itemCountChanged(e);
704 } catch(NumberFormatException x) {
705 getLogger().log (
706 Level.WARNING, "Unknown MIDI_INPUT_DEVICE_COUNT format", x
707 );
708 }
709 } else if(s.startsWith("MIDI_INPUT_DEVICE_INFO:")) {
710 try {
711 s = s.substring("MIDI_INPUT_DEVICE_INFO:".length());
712 int i = Integer.parseInt(s);
713 ItemInfoEvent e = new ItemInfoEvent(this, i);
714 for(ItemInfoListener l : llMIDI) l.itemInfoChanged(e);
715 } catch(NumberFormatException x) {
716 getLogger().log (
717 Level.WARNING, "Unknown MIDI_INPUT_DEVICE_INFO format", x
718 );
719 }
720 } else if(s.startsWith("MIDI_INSTRUMENT_MAP_COUNT:")) {
721 try {
722 s = s.substring("MIDI_INSTRUMENT_MAP_COUNT:".length());
723 int i = Integer.parseInt(s);
724 ItemCountEvent e = new ItemCountEvent(this, i);
725 for(ItemCountListener l : llMIMC) l.itemCountChanged(e);
726 } catch(NumberFormatException x) {
727 getLogger().log (
728 Level.WARNING, "Unknown MIDI_INSTRUMENT_MAP_COUNT format", x
729 );
730 }
731 } else if(s.startsWith("MIDI_INSTRUMENT_MAP_INFO:")) {
732 try {
733 s = s.substring("MIDI_INSTRUMENT_MAP_INFO:".length());
734 int i = Integer.parseInt(s);
735 ItemInfoEvent e = new ItemInfoEvent(this, i);
736 for(ItemInfoListener l : llMIMI) l.itemInfoChanged(e);
737 } catch(NumberFormatException x) {
738 getLogger().log (
739 Level.WARNING, "Unknown MIDI_INSTRUMENT_MAP_INFO format", x
740 );
741 }
742 } else if(s.startsWith("MIDI_INSTRUMENT_COUNT:")) {
743 try {
744 s = s.substring("MIDI_INSTRUMENT_COUNT:".length());
745 Integer[] i = parseIntList(s, ' ');
746 if(i.length != 2) {
747 getLogger().warning("Unknown MIDI_INSTRUMENT_COUNT format");
748 return;
749 }
750
751 MidiInstrumentCountEvent e =
752 new MidiInstrumentCountEvent(this, i[0], i[1]);
753
754 for(MidiInstrumentCountListener l : llMIC) {
755 l.instrumentCountChanged(e);
756 }
757 } catch(Exception x) {
758 getLogger().log (
759 Level.WARNING, "Unknown MIDI_INSTRUMENT_COUNT format", x
760 );
761 }
762 } else if(s.startsWith("MIDI_INSTRUMENT_INFO:")) {
763 try {
764 s = s.substring("MIDI_INSTRUMENT_INFO:".length());
765 Integer[] i = parseIntList(s, ' ');
766 if(i.length != 3) {
767 getLogger().warning("Unknown MIDI_INSTRUMENT_INFO format");
768 return;
769 }
770
771 MidiInstrumentInfoEvent e =
772 new MidiInstrumentInfoEvent(this, i[0], i[1], i[2]);
773 for(MidiInstrumentInfoListener l : llMII) {
774 l.instrumentInfoChanged(e);
775 }
776 } catch(Exception x) {
777 getLogger().log (
778 Level.WARNING, "Unknown MIDI_INSTRUMENT_INFO format", x
779 );
780 }
781 } else if(s.startsWith("FX_SEND_COUNT:")) {
782 try {
783 s = s.substring("FX_SEND_COUNT:".length());
784 Integer[] i = parseIntList(s, ' ');
785 if(i.length != 2) {
786 getLogger().warning("Unknown FX_SEND_COUNT format");
787 return;
788 }
789
790 FxSendCountEvent e = new FxSendCountEvent(this, i[0], i[1]);
791
792 for(FxSendCountListener l : llFSC) l.fxSendCountChanged(e);
793 } catch(Exception x) {
794 getLogger().log(Level.WARNING, "Unknown FX_SEND_COUNT format", x);
795 }
796 } else if(s.startsWith("FX_SEND_INFO:")) {
797 try {
798 s = s.substring("FX_SEND_INFO:".length());
799 Integer[] i = parseIntList(s, ' ');
800 if(i.length != 2) {
801 getLogger().warning("Unknown FX_SEND_INFO format");
802 return;
803 }
804
805 FxSendInfoEvent e = new FxSendInfoEvent(this, i[0], i[1]);
806 for(FxSendInfoListener l : llFSI) {
807 l.fxSendInfoChanged(e);
808 }
809 } catch(Exception x) {
810 getLogger().log(Level.WARNING, "Unknown FX_SEND_INFO format", x);
811 }
812 } else if(s.startsWith("GLOBAL_INFO:")) {
813 handleGlobalInfoEvent(s.substring("GLOBAL_INFO:".length()));
814 } else if(s.startsWith("MISCELLANEOUS:")) {
815 s = s.substring("MISCELLANEOUS:".length());
816 MiscellaneousEvent e = new MiscellaneousEvent(this, s);
817 for(MiscellaneousListener l : llM) l.miscEventOccured(e);
818 }
819 }
820
821 private void
822 handleGlobalInfoEvent(String s) {
823 try {
824 if(s.startsWith("VOLUME ")) {
825 float f = Float.parseFloat(s.substring("VOLUME ".length()));
826 GlobalInfoEvent e = new GlobalInfoEvent(this, f);
827 for(GlobalInfoListener l : llGI) l.volumeChanged(e);
828 }
829 } catch(NumberFormatException x) {
830 getLogger().log(Level.WARNING, "Unknown GLOBAL_INFO format", x);
831 }
832 }
833
834 private void
835 subscribe(String event) {
836 if(!getPrintOnlyMode()) {
837 if(!isConnected()) return;
838
839 if(!eventThread.isAlive()) eventThread.start();
840 }
841
842 try {
843 out.writeLine("SUBSCRIBE " + event);
844 if(!getPrintOnlyMode()) getEmptyResultSet();
845 } catch(Exception x) {
846 getLogger().log (
847 Level.WARNING,
848 LscpI18n.getLogMsg("Client.subscriptionFailed!", event),
849 x
850 );
851 }
852 }
853
854 private void
855 unsubscribe(String event) {
856 if(!getPrintOnlyMode() && !isConnected()) return;
857
858 try {
859 out.writeLine("UNSUBSCRIBE " + event);
860 if(!getPrintOnlyMode()) getEmptyResultSet();
861 } catch(Exception x) {
862 getLogger().log (
863 Level.WARNING,
864 LscpI18n.getLogMsg("Client.unsubscriptionFailed!", event),
865 x
866 );
867 }
868 }
869
870 /**
871 * Registers the specified listener for receiving event messages.
872 * Listeners can be registered regardless of the connection state.
873 * @param l The <code>ItemCountListener</code> to register.
874 */
875 public synchronized void
876 addAudioDeviceCountListener(ItemCountListener l) {
877 if(llAODC.isEmpty()) subscribe("AUDIO_OUTPUT_DEVICE_COUNT");
878 llAODC.add(l);
879 }
880
881 /**
882 * Removes the specified listener.
883 * Listeners can be removed regardless of the connection state.
884 * @param l The <code>ItemCountListener</code> to remove.
885 */
886 public synchronized void
887 removeAudioDeviceCountListener(ItemCountListener l) {
888 boolean b = llAODC.remove(l);
889 if(b && llAODC.isEmpty()) unsubscribe("AUDIO_OUTPUT_DEVICE_COUNT");
890 }
891
892 /**
893 * Registers the specified listener for receiving event messages.
894 * Listeners can be registered regardless of the connection state.
895 * @param l The <code>ItemInfoListener</code> to register.
896 */
897 public synchronized void
898 addAudioDeviceInfoListener(ItemInfoListener l) {
899 if(llAODI.isEmpty()) subscribe("AUDIO_OUTPUT_DEVICE_INFO");
900 llAODI.add(l);
901 }
902
903 /**
904 * Removes the specified listener.
905 * Listeners can be removed regardless of the connection state.
906 * @param l The <code>ItemInfoListener</code> to remove.
907 */
908 public synchronized void
909 removeAudioDeviceInfoListener(ItemInfoListener l) {
910 boolean b = llAODI.remove(l);
911 if(b && llAODI.isEmpty()) unsubscribe("AUDIO_OUTPUT_DEVICE_INFO");
912 }
913
914 /**
915 * Registers the specified listener for receiving event messages.
916 * Listeners can be removed regardless of the connection state.
917 * @param l The <code>BufferFillListener</code> to register.
918 */
919 public synchronized void
920 addBufferFillListener(BufferFillListener l) {
921 if(llBF.isEmpty()) subscribe("BUFFER_FILL");
922 llBF.add(l);
923 }
924
925 /**
926 * Removes the specified listener.
927 * Listeners can be removed regardless of the connection state.
928 * @param l The <code>BufferFillListener</code> to remove.
929 */
930 public synchronized void
931 removeBufferFillListener(BufferFillListener l) {
932 boolean b = llBF.remove(l);
933 if(b && llBF.isEmpty()) unsubscribe("BUFFER_FILL");
934 }
935
936 /**
937 * Registers the specified listener for receiving event messages.
938 * Listeners can be registered regardless of the connection state.
939 * @param l The <code>ChannelCountListener</code> to register.
940 */
941 public synchronized void
942 addChannelCountListener(ChannelCountListener l) {
943 if(llCC.isEmpty()) subscribe("CHANNEL_COUNT");
944 llCC.add(l);
945 }
946
947 /**
948 * Removes the specified listener.
949 * Listeners can be removed regardless of the connection state.
950 * @param l The <code>ChannelCountListener</code> to remove.
951 */
952 public synchronized void
953 removeChannelCountListener(ChannelCountListener l) {
954 boolean b = llCC.remove(l);
955 if(b && llCC.isEmpty()) unsubscribe("CHANNEL_COUNT");
956 }
957
958 /**
959 * Registers the specified listener for receiving event messages.
960 * Listeners can be registered regardless of the connection state.
961 * @param l The <code>ChannelInfoListener</code> to register.
962 */
963 public synchronized void
964 addChannelInfoListener(ChannelInfoListener l) {
965 if(llCI.isEmpty()) subscribe("CHANNEL_INFO");
966 llCI.add(l);
967 }
968
969 /**
970 * Removes the specified listener.
971 * Listeners can be removed regardless of the connection state.
972 * @param l The <code>ChannelInfoListener</code> to remove.
973 */
974 public synchronized void
975 removeChannelInfoListener(ChannelInfoListener l) {
976 boolean b = llCI.remove(l);
977 if(b && llCI.isEmpty()) unsubscribe("CHANNEL_INFO");
978 }
979
980 /**
981 * Registers the specified listener for receiving event messages.
982 * Listeners can be registered regardless of the connection state.
983 * @param l The <code>FxSendCountListener</code> to register.
984 */
985 public synchronized void
986 addFxSendCountListener(FxSendCountListener l) {
987 if(llFSC.isEmpty()) subscribe("FX_SEND_COUNT");
988 llFSC.add(l);
989 }
990
991 /**
992 * Removes the specified listener.
993 * Listeners can be removed regardless of the connection state.
994 * @param l The <code>FxSendCountListener</code> to remove.
995 */
996 public synchronized void
997 removeFxSendCountListener(FxSendCountListener l) {
998 boolean b = llFSC.remove(l);
999 if(b && llFSC.isEmpty()) unsubscribe("FX_SEND_COUNT");
1000 }
1001
1002 /**
1003 * Registers the specified listener for receiving event messages.
1004 * Listeners can be registered regardless of the connection state.
1005 * @param l The <code>FxSendInfoListener</code> to register.
1006 */
1007 public synchronized void
1008 addFxSendInfoListener(FxSendInfoListener l) {
1009 if(llFSI.isEmpty()) subscribe("FX_SEND_INFO");
1010 llFSI.add(l);
1011 }
1012
1013 /**
1014 * Removes the specified listener.
1015 * Listeners can be removed regardless of the connection state.
1016 * @param l The <code>FxSendInfoListener</code> to remove.
1017 */
1018 public synchronized void
1019 removeFxSendInfoListener(FxSendInfoListener l) {
1020 boolean b = llFSI.remove(l);
1021 if(b && llFSI.isEmpty()) unsubscribe("FX_SEND_INFO");
1022 }
1023
1024 /**
1025 * Registers the specified listener for receiving event messages.
1026 * Listeners can be registered regardless of the connection state.
1027 * @param l The <code>ItemCountListener</code> to register.
1028 */
1029 public synchronized void
1030 addMidiDeviceCountListener(ItemCountListener l) {
1031 if(llMIDC.isEmpty()) subscribe("MIDI_INPUT_DEVICE_COUNT");
1032 llMIDC.add(l);
1033 }
1034
1035 /**
1036 * Removes the specified listener.
1037 * Listeners can be removed regardless of the connection state.
1038 * @param l The <code>ItemCountListener</code> to remove.
1039 */
1040 public synchronized void
1041 removeMidiDeviceCountListener(ItemCountListener l) {
1042 boolean b = llMIDC.remove(l);
1043 if(b && llMIDC.isEmpty()) unsubscribe("MIDI_INPUT_DEVICE_COUNT");
1044 }
1045
1046 /**
1047 * Registers the specified listener for receiving event messages.
1048 * Listeners can be registered regardless of the connection state.
1049 * @param l The <code>ItemInfoListener</code> to register.
1050 */
1051 public synchronized void
1052 addMidiDeviceInfoListener(ItemInfoListener l) {
1053 if(llMIDI.isEmpty()) subscribe("MIDI_INPUT_DEVICE_INFO");
1054 llMIDI.add(l);
1055 }
1056
1057 /**
1058 * Removes the specified listener.
1059 * Listeners can be removed regardless of the connection state.
1060 * @param l The <code>ItemInfoListener</code> to remove.
1061 */
1062 public synchronized void
1063 removeMidiDeviceInfoListener(ItemInfoListener l) {
1064 boolean b = llMIDI.remove(l);
1065 if(b && llMIDI.isEmpty()) unsubscribe("MIDI_INPUT_DEVICE_INFO");
1066 }
1067
1068 /**
1069 * Registers the specified listener for receiving event messages.
1070 * Listeners can be registered regardless of the connection state.
1071 * @param l The <code>MiscellaneousListener</code> to register.
1072 */
1073 public synchronized void
1074 addMiscellaneousListener(MiscellaneousListener l) {
1075 if(llM.isEmpty()) subscribe("MISCELLANEOUS");
1076 llM.add(l);
1077 }
1078
1079 /**
1080 * Removes the specified listener.
1081 * Listeners can be removed regardless of the connection state.
1082 * @param l The <code>MiscellaneousListener</code> to remove.
1083 */
1084 public synchronized void
1085 removeMiscellaneousListener(MiscellaneousListener l) {
1086 boolean b = llM.remove(l);
1087 if(b && llM.isEmpty()) unsubscribe("MISCELLANEOUS");
1088 }
1089
1090 /**
1091 * Registers the specified listener for receiving event messages.
1092 * Listeners can be registered regardless of the connection state.
1093 * @param l The <code>StreamCountListener</code> to register.
1094 */
1095 public synchronized void
1096 addStreamCountListener(StreamCountListener l) {
1097 if(llSC.isEmpty()) subscribe("STREAM_COUNT");
1098 llSC.add(l);
1099 }
1100
1101 /**
1102 * Removes the specified listener.
1103 * Listeners can be removed regardless of the connection state.
1104 * @param l The <code>StreamCountListener</code> to remove.
1105 */
1106 public synchronized void
1107 removeStreamCountListener(StreamCountListener l) {
1108 boolean b = llSC.remove(l);
1109 if(b && llSC.isEmpty()) unsubscribe("STREAM_COUNT");
1110 }
1111
1112 /**
1113 * Registers the specified listener for receiving event messages.
1114 * Listeners can be registered regardless of the connection state.
1115 * @param l The <code>VoiceCountListener</code> to register.
1116 */
1117 public synchronized void
1118 addVoiceCountListener(VoiceCountListener l) {
1119 if(llVC.isEmpty()) subscribe("VOICE_COUNT");
1120 llVC.add(l);
1121 }
1122
1123 /**
1124 * Removes the specified listener.
1125 * Listeners can be removed regardless of the connection state.
1126 * @param l The <code>VoiceCountListener</code> to remove.
1127 */
1128 public synchronized void
1129 removeVoiceCountListener(VoiceCountListener l) {
1130 boolean b = llVC.remove(l);
1131 if(b && llVC.isEmpty()) unsubscribe("VOICE_COUNT");
1132 }
1133
1134 /**
1135 * Registers the specified listener for receiving event messages.
1136 * Listeners can be registered regardless of the connection state.
1137 * @param l The <code>TotalVoiceCountListener</code> to register.
1138 */
1139 public synchronized void
1140 addTotalVoiceCountListener(TotalVoiceCountListener l) {
1141 if(llTVC.isEmpty()) subscribe("TOTAL_VOICE_COUNT");
1142 llTVC.add(l);
1143 }
1144
1145 /**
1146 * Removes the specified listener.
1147 * Listeners can be removed regardless of the connection state.
1148 * @param l The <code>TotalVoiceCountListener</code> to remove.
1149 */
1150 public synchronized void
1151 removeTotalVoiceCountListener(TotalVoiceCountListener l) {
1152 boolean b = llTVC.remove(l);
1153 if(b && llTVC.isEmpty()) unsubscribe("TOTAL_VOICE_COUNT");
1154 }
1155
1156 /**
1157 * Registers the specified listener for receiving event messages.
1158 * Listeners can be registered regardless of the connection state.
1159 * @param l The <code>ItemCountListener</code> to register.
1160 */
1161 public synchronized void
1162 addMidiInstrumentMapCountListener(ItemCountListener l) {
1163 if(llMIMC.isEmpty()) subscribe("MIDI_INSTRUMENT_MAP_COUNT");
1164 llMIMC.add(l);
1165 }
1166
1167 /**
1168 * Removes the specified listener.
1169 * Listeners can be removed regardless of the connection state.
1170 * @param l The <code>ItemCountListener</code> to remove.
1171 */
1172 public synchronized void
1173 removeMidiInstrumentMapCountListener(ItemCountListener l) {
1174 boolean b = llMIMC.remove(l);
1175 if(b && llMIMC.isEmpty()) unsubscribe("MIDI_INSTRUMENT_MAP_COUNT");
1176 }
1177
1178 /**
1179 * Registers the specified listener for receiving event messages.
1180 * Listeners can be registered regardless of the connection state.
1181 * @param l The <code>ItemInfoListener</code> to register.
1182 */
1183 public synchronized void
1184 addMidiInstrumentMapInfoListener(ItemInfoListener l) {
1185 if(llMIMI.isEmpty()) subscribe("MIDI_INSTRUMENT_MAP_INFO");
1186 llMIMI.add(l);
1187 }
1188
1189 /**
1190 * Removes the specified listener.
1191 * Listeners can be removed regardless of the connection state.
1192 * @param l The <code>ItemInfoListener</code> to remove.
1193 */
1194 public synchronized void
1195 removeMidiInstrumentMapInfoListener(ItemInfoListener l) {
1196 boolean b = llMIMI.remove(l);
1197 if(b && llMIMI.isEmpty()) unsubscribe("MIDI_INSTRUMENT_MAP_INFO");
1198 }
1199
1200 /**
1201 * Registers the specified listener for receiving event messages.
1202 * Listeners can be registered regardless of the connection state.
1203 * @param l The <code>MidiInstrumentCountListener</code> to register.
1204 */
1205 public synchronized void
1206 addMidiInstrumentCountListener(MidiInstrumentCountListener l) {
1207 if(llMIC.isEmpty()) subscribe("MIDI_INSTRUMENT_COUNT");
1208 llMIC.add(l);
1209 }
1210
1211 /**
1212 * Removes the specified listener.
1213 * Listeners can be removed regardless of the connection state.
1214 * @param l The <code>MidiInstrumentCountListener</code> to remove.
1215 */
1216 public synchronized void
1217 removeMidiInstrumentCountListener(MidiInstrumentCountListener l) {
1218 boolean b = llMIC.remove(l);
1219 if(b && llMIC.isEmpty()) unsubscribe("MIDI_INSTRUMENT_COUNT");
1220 }
1221
1222 /**
1223 * Registers the specified listener for receiving event messages.
1224 * Listeners can be registered regardless of the connection state.
1225 * @param l The <code>MidiInstrumentInfoListener</code> to register.
1226 */
1227 public synchronized void
1228 addMidiInstrumentInfoListener(MidiInstrumentInfoListener l) {
1229 if(llMII.isEmpty()) subscribe("MIDI_INSTRUMENT_INFO");
1230 llMII.add(l);
1231 }
1232
1233 /**
1234 * Removes the specified listener.
1235 * Listeners can be removed regardless of the connection state.
1236 * @param l The <code>MidiInstrumentInfoListener</code> to remove.
1237 */
1238 public synchronized void
1239 removeMidiInstrumentInfoListener(MidiInstrumentInfoListener l) {
1240 boolean b = llMII.remove(l);
1241 if(b && llMII.isEmpty()) unsubscribe("MIDI_INSTRUMENT_INFO");
1242 }
1243
1244 /**
1245 * Registers the specified listener for receiving event messages.
1246 * Listeners can be registered regardless of the connection state.
1247 * @param l The <code>InstrumentsDbListener</code> to register.
1248 */
1249 public synchronized void
1250 addInstrumentsDbListener(InstrumentsDbListener l) {
1251 if(llID.isEmpty()) {
1252 subscribe("DB_INSTRUMENT_DIRECTORY_COUNT");
1253 subscribe("DB_INSTRUMENT_DIRECTORY_INFO");
1254 subscribe("DB_INSTRUMENT_COUNT");
1255 subscribe("DB_INSTRUMENT_INFO");
1256 subscribe("DB_INSTRUMENTS_JOB_INFO");
1257 }
1258 llID.add(l);
1259 }
1260
1261 /**
1262 * Removes the specified listener.
1263 * Listeners can be removed regardless of the connection state.
1264 * @param l The <code>InstrumentsDbListener</code> to remove.
1265 */
1266 public synchronized void
1267 removeInstrumentsDbListener(InstrumentsDbListener l) {
1268 boolean b = llID.remove(l);
1269 if(b && llID.isEmpty()) {
1270 unsubscribe("DB_INSTRUMENT_DIRECTORY_COUNT");
1271 unsubscribe("DB_INSTRUMENT_DIRECTORY_INFO");
1272 unsubscribe("DB_INSTRUMENT_COUNT");
1273 unsubscribe("DB_INSTRUMENT_INFO");
1274 unsubscribe("DB_INSTRUMENTS_JOB_INFO");
1275 }
1276 }
1277
1278 /**
1279 * Registers the specified listener for receiving event messages.
1280 * Listeners can be registered regardless of the connection state.
1281 * @param l The <code>GlobalInfoListener</code> to register.
1282 */
1283 public synchronized void
1284 addGlobalInfoListener(GlobalInfoListener l) {
1285 if(llGI.isEmpty()) subscribe("GLOBAL_INFO");
1286 llGI.add(l);
1287 }
1288
1289 /**
1290 * Removes the specified listener.
1291 * Listeners can be removed regardless of the connection state.
1292 * @param l The <code>GlobalInfoListener</code> to remove.
1293 */
1294 public synchronized void
1295 removeGlobalInfoListener(GlobalInfoListener l) {
1296 boolean b = llGI.remove(l);
1297 if(b && llGI.isEmpty()) unsubscribe("GLOBAL_INFO");
1298 }
1299
1300 /**
1301 * Gets the number of all audio output drivers currently
1302 * available for the LinuxSampler instance.
1303 * @return The number of all audio output drivers currently
1304 * available for the LinuxSampler instance.
1305 * @throws IOException If some I/O error occurs.
1306 * @throws LscpException If LSCP protocol corruption occurs.
1307 * @throws LSException If some other error occurs.
1308 */
1309 public synchronized int
1310 getAudioOutputDriverCount() throws IOException, LscpException, LSException {
1311 verifyConnection();
1312 out.writeLine("GET AVAILABLE_AUDIO_OUTPUT_DRIVERS");
1313
1314 if(getPrintOnlyMode()) return -1;
1315
1316 String s = getSingleLineResultSet().getResult();
1317 return parseInt(s);
1318 }
1319
1320 /**
1321 * Gets all audio output drivers currently available for the LinuxSampler instance.
1322 *
1323 * @return <code>AudioOutputDriver</code> array containing all audio output drivers
1324 * currently available for the LinuxSampler instance.
1325 *
1326 * @throws IOException If an I/O error occurs.
1327 * @throws LscpException If LSCP protocol corruption occurs.
1328 * @throws LSException If some other error occurs.
1329 */
1330 public synchronized AudioOutputDriver[]
1331 getAudioOutputDrivers() throws IOException, LscpException, LSException {
1332 String[] drivers = getAudioOutputDriverNames();
1333 if(getPrintOnlyMode()) return null;
1334
1335 AudioOutputDriver[] aod = new AudioOutputDriver[drivers.length];
1336
1337 for(int i = 0; i < aod.length; i++) aod[i] = getAudioOutputDriverInfo(drivers[i]);
1338
1339 return aod;
1340 }
1341
1342 /**
1343 * Gets all audio output drivers currently available for the LinuxSampler instance.
1344 *
1345 * @return <code>String</code> array containing all audio output drivers currently
1346 * available for the LinuxSampler instance.
1347 *
1348 * @throws IOException If an I/O error occurs.
1349 * @throws LscpException If LSCP protocol corruption occurs.
1350 * @throws LSException If some other error occurs.
1351 */
1352 private synchronized String[]
1353 getAudioOutputDriverNames() throws IOException, LscpException, LSException {
1354 verifyConnection();
1355 out.writeLine("LIST AVAILABLE_AUDIO_OUTPUT_DRIVERS");
1356 if(getPrintOnlyMode()) return null;
1357 return parseList(getSingleLineResultSet().getResult());
1358 }
1359
1360 /**
1361 * Gets detailed information about a specific audio output driver.
1362 * @param driverName The name of the audio output driver.
1363 * @param depList An optional list of dependences parameters.
1364 * @return An <code>AudioOutputDriver</code> object containing
1365 * information about the specified audio output driver.
1366 *
1367 * @throws IOException If an I/O error occurs.
1368 * @throws LscpException If LSCP protocol corruption occurs.
1369 * @throws LSException If there is no driver with name <code>driverName</code>.
1370 *
1371 * @see #getAudioOutputDriverNames
1372 */
1373 public synchronized AudioOutputDriver
1374 getAudioOutputDriverInfo(String driverName, Parameter... depList)
1375 throws IOException, LscpException, LSException {
1376
1377 verifyConnection();
1378 out.writeLine("GET AUDIO_OUTPUT_DRIVER INFO " + driverName);
1379 if(getPrintOnlyMode()) return null;
1380
1381 ResultSet rs = getMultiLineResultSet();
1382 AudioOutputDriver aod = new AudioOutputDriver(rs.getMultiLineResult());
1383 aod.setName(driverName);
1384
1385 for(String s : aod.getParameterNames())
1386 aod.addParameter(getAudioOutputDriverParameterInfo(driverName, s, depList));
1387
1388 return aod;
1389 }
1390
1391 /**
1392 * Gets detailed information about a specific audio output driver parameter.
1393 *
1394 * @param driver The name of the audio output driver.
1395 * @param param A specific parameter name for which information should be obtained.
1396 * @param deplist An optional list of parameters on which the sought parameter
1397 * <code>param</code> depends on. <code>Parameter</code> instances can be
1398 * easily created using {@link ParameterFactory} factory.
1399 *
1400 * @return <code>Parameter</code> object containing
1401 * information about the specified audio output driver parameter.
1402 *
1403 * @throws IOException If an I/O error occurs.
1404 * @throws LscpException If LSCP protocol corruption occurs.
1405 * @throws LSException If <code>driver</code> is not a valid driver name
1406 * or <code>param</code> is not a valid parameter for the specified driver.
1407 *
1408 * @see #getAudioOutputDrivers
1409 * @see #getAudioOutputDriverInfo
1410 * @see ParameterFactory
1411 */
1412 public synchronized Parameter
1413 getAudioOutputDriverParameterInfo(String driver, String param, Parameter... deplist)
1414 throws IOException, LscpException, LSException {
1415
1416 verifyConnection();
1417 StringBuffer args = new StringBuffer(driver);
1418 args.append(' ').append(param);
1419
1420 for(Parameter p : deplist) {
1421 if(p.getValue() == null) continue;
1422 args.append(' ').append(p.getName()).append('=').append(p.getStringValue());
1423 }
1424
1425 out.writeLine("GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO " + args.toString());
1426 if(getPrintOnlyMode()) return null;
1427
1428 ResultSet rs = getMultiLineResultSet();
1429
1430 String[] lnS = rs.getMultiLineResult();
1431 ParameterType type = parseType(lnS);
1432 boolean multi = parseMultiplicity(lnS);
1433 Parameter prm;
1434
1435 switch(type) {
1436 case BOOL:
1437 if(!multi) prm = new BoolParameter(lnS);
1438 else prm = new BoolListParameter(lnS);
1439 prm.setName(param);
1440 prm.setValue(prm.getDefault());
1441 return prm;
1442 case INT:
1443 if(!multi) prm = new IntParameter(lnS);
1444 else prm = new IntListParameter(lnS);
1445 prm.setName(param);
1446 prm.setValue(prm.getDefault());
1447 return prm;
1448 case FLOAT:
1449 if(!multi) prm = new FloatParameter(lnS);
1450 else prm = new FloatListParameter(lnS);
1451 prm.setName(param);
1452 prm.setValue(prm.getDefault());
1453 return prm;
1454 case STRING:
1455 if(!multi) prm = new StringParameter(lnS);
1456 else prm = new StringListParameter(lnS);
1457 prm.setName(param);
1458 prm.setValue(prm.getDefault());
1459 return prm;
1460 default: throw new LscpException(LscpI18n.getLogMsg("Client.unknownPrmType!"));
1461 }
1462 }
1463
1464 /**
1465 * Creates a new audio output device for the desired audio output system.
1466 * @param aoDriver The desired audio output system.
1467 * @param paramList An optional list of driver specific parameters. <code>Parameter</code>
1468 * instances can be easily created using {@link ParameterFactory} factory.
1469 * @return The numerical ID of the newly created device.
1470 * @throws IOException If some I/O error occurs.
1471 * @throws LSException If the creation of the new audio output device failed.
1472 * @throws LscpException If LSCP protocol corruption occurs.
1473 * @see #getAudioOutputDrivers
1474 * @see #getAudioOutputDriverInfo
1475 * @see ParameterFactory
1476 */
1477 public synchronized int
1478 createAudioOutputDevice(String aoDriver, Parameter... paramList)
1479 throws IOException, LSException, LscpException {
1480
1481 verifyConnection();
1482 StringBuffer args = new StringBuffer(aoDriver);
1483
1484 for(Parameter p : paramList) {
1485 if(p.getValue() == null) continue;
1486 args.append(' ').append(p.getName()).append('=').append(p.getStringValue());
1487 }
1488
1489 out.writeLine("CREATE AUDIO_OUTPUT_DEVICE " + args.toString());
1490 if(getPrintOnlyMode()) return -1;
1491
1492 ResultSet rs = getEmptyResultSet();
1493
1494 return rs.getIndex();
1495 }
1496
1497 /**
1498 * Destroys already created audio output device.
1499 * @param deviceId The ID of the audio output device to be destroyed.
1500 * @throws IOException If some I/O error occurs.
1501 * @throws LSException If the destroying of the audio output device failed.
1502 * @throws LscpException If LSCP protocol corruption occurs.
1503 * @see #getAudioOutputDevices
1504 */
1505 public synchronized void
1506 destroyAudioOutputDevice(int deviceId) throws IOException, LSException, LscpException {
1507 verifyConnection();
1508 out.writeLine("DESTROY AUDIO_OUTPUT_DEVICE " + deviceId);
1509 if(getPrintOnlyMode()) return;
1510
1511 ResultSet rs = getEmptyResultSet();
1512 }
1513
1514 /**
1515 * Enables/disables the specified audio output device.
1516 * @param deviceId The ID of the audio output device to be enabled/disabled.
1517 * @param enable If <code>true</code> the audio output device is enabled,
1518 * else the device is disabled.
1519 * @throws IOException If some I/O error occurs.
1520 * @throws LSException If there is no audio output
1521 * device with numerical ID <code>deviceId</code>.
1522 * @throws LscpException If LSCP protocol corruption occurs.
1523 */
1524 public void
1525 enableAudioOutputDevice(int deviceId, boolean enable)
1526 throws IOException, LSException, LscpException {
1527
1528 setAudioOutputDeviceParameter(deviceId, new BoolParameter("ACTIVE", enable));
1529 }
1530
1531 /**
1532 * Gets the current number of all created audio output devices.
1533 * @return The current number of all created audio output devices.
1534 * @throws IOException If some I/O error occurs.
1535 * @throws LscpException If LSCP protocol corruption occurs.
1536 * @throws LSException If some other error occurs.
1537 */
1538 public synchronized int
1539 getAudioOutputDeviceCount() throws IOException, LscpException, LSException {
1540 verifyConnection();
1541 out.writeLine("GET AUDIO_OUTPUT_DEVICES");
1542 if(getPrintOnlyMode()) return -1;
1543
1544 String s = getSingleLineResultSet().getResult();
1545 return parseInt(s);
1546 }
1547
1548 /**
1549 * Gets a list of all created audio output devices.
1550 * @return An <code>AudioOutputDevice</code> array
1551 * providing all created audio output devices.
1552 * @throws IOException If some I/O error occurs.
1553 * @throws LscpException If LSCP protocol corruption occurs.
1554 * @throws LSException If some other error occurs.
1555 */
1556 public synchronized AudioOutputDevice[]
1557 getAudioOutputDevices() throws IOException, LscpException, LSException {
1558 Integer[] idS = getAudioOutputDeviceIDs();
1559 if(getPrintOnlyMode()) return null;
1560
1561 AudioOutputDevice[] devices = new AudioOutputDevice[idS.length];
1562
1563 for(int i = 0; i < devices.length; i++)
1564 devices[i] = getAudioOutputDeviceInfo(idS[i]);
1565
1566 return devices;
1567 }
1568
1569 /**
1570 * Gets a list of numerical IDs of all created audio output devices.
1571 * @return An <code>Integer</code> array providing the numerical IDs of
1572 * all created audio output devices.
1573 * @throws IOException If some I/O error occurs.
1574 * @throws LscpException If LSCP protocol corruption occurs.
1575 * @throws LSException If some other error occurs.
1576 */
1577 public synchronized Integer[]
1578 getAudioOutputDeviceIDs() throws IOException, LscpException, LSException {
1579 verifyConnection();
1580 out.writeLine("LIST AUDIO_OUTPUT_DEVICES");
1581 if(getPrintOnlyMode()) return null;
1582
1583 return parseIntList(getSingleLineResultSet().getResult());
1584 }
1585
1586 /**
1587 * Gets the current settings of a specific, already created audio output device.
1588 *
1589 * @param deviceId Specifies the numerical ID of the audio output device.
1590 *
1591 * @return An <code>AudioOutputDevice</code> instance containing information
1592 * about the specified device.
1593 *
1594 * @throws IOException If some I/O error occurs.
1595 * @throws LscpException If LSCP protocol corruption occurs.
1596 * @throws LSException If there is no audio output device
1597 * with device id <code>deviceId</code>.
1598 *
1599 * @see #getAudioOutputDevices
1600 */
1601 public synchronized AudioOutputDevice
1602 getAudioOutputDeviceInfo(int deviceId) throws IOException, LscpException, LSException {
1603 verifyConnection();
1604 out.writeLine("GET AUDIO_OUTPUT_DEVICE INFO " + deviceId);
1605 if(getPrintOnlyMode()) return null;
1606
1607 ResultSet rs = getMultiLineResultSet();
1608
1609 String[] lnS = rs.getMultiLineResult();
1610
1611 AudioOutputDevice aod = new AudioOutputDevice();
1612 aod.setDeviceId(deviceId);
1613 Parameter<Integer> channels;
1614 Parameter<Integer> samplerate;
1615
1616 String drv = getCategoryInfo(lnS, "DRIVER");
1617 aod.setDriverName(drv);
1618
1619 for(String s : lnS) {
1620 if(s.startsWith("CHANNELS: ")) {
1621 channels = (Parameter<Integer>)
1622 getAudioOutputDriverParameterInfo(drv, "CHANNELS");
1623
1624 s = s.substring("CHANNELS: ".length(), s.length());
1625 channels.parseValue(s);
1626 aod.setChannelsParameter(channels);
1627 int count = channels.getValue() > 0 ? channels.getValue() : 0;
1628 AudioOutputChannel[] aoc = new AudioOutputChannel[count];
1629 for(int i = 0; i < count; i++) {
1630 aoc[i] = getAudioOutputChannelInfo(deviceId, i);
1631 }
1632 aod.setAudioChannels(aoc);
1633 } else if(s.startsWith("SAMPLERATE: ")) {
1634 samplerate = (Parameter<Integer>)
1635 getAudioOutputDriverParameterInfo(drv, "SAMPLERATE");
1636
1637 s = s.substring("SAMPLERATE: ".length(), s.length());
1638 samplerate.parseValue(s);
1639 aod.setSampleRateParameter(samplerate);
1640 } else if(s.startsWith("ACTIVE: ")) {
1641 s = s.substring("ACTIVE: ".length(), s.length());
1642 aod.setActive(Boolean.parseBoolean(s));
1643 } else if(s.startsWith("DRIVER: ")) {
1644
1645 } else {
1646 int i = s.indexOf(": ");
1647 if(i == -1) throw new LscpException (
1648 LscpI18n.getLogMsg("CommandFailed!")
1649 );
1650
1651 Parameter prm =
1652 getAudioOutputDriverParameterInfo(drv, s.substring(0, i));
1653
1654 s = s.substring(i + 2);
1655 prm.parseValue(s);
1656
1657 aod.addParameter(prm);
1658 }
1659 }
1660
1661 return aod;
1662 }
1663
1664 /**
1665 * Alters a specific setting of a created audio output device.
1666 *
1667 * @param deviceId The numerical ID of the audio output device.
1668 * @param prm A <code>Parameter</code> instance containing the name of the parameter
1669 * and the new value for this parameter.
1670 *
1671 * @throws IOException If some I/O error occurs.
1672 * @throws LscpException If LSCP protocol corruption occurs.
1673 * @throws LSException If
1674 * <ul>
1675 * <li>There is no audio output device with numerical ID <code>deviceId</code>;
1676 * <li>There is no device parameter with the specified name;
1677 * <li>The device parameter is readonly;
1678 * <li>The device parameter is from different type.
1679 * </ul>
1680 *
1681 * @see #getAudioOutputDevices
1682 * @see #getAudioOutputDeviceInfo
1683 */
1684 public synchronized void
1685 setAudioOutputDeviceParameter(int deviceId, Parameter prm)
1686 throws IOException, LscpException, LSException {
1687
1688 verifyConnection();
1689 String kv = prm.getName() + '=' + prm.getStringValue();
1690 out.writeLine("SET AUDIO_OUTPUT_DEVICE_PARAMETER " + deviceId + ' ' + kv);
1691 if(getPrintOnlyMode()) return;
1692
1693 ResultSet rs = getEmptyResultSet();
1694 }
1695
1696 /**
1697 * Changes the channel number of the speicifed audio output device.
1698 * @param deviceId The numerical ID of the audio output device.
1699 * @param channels The new number of audio output channels.
1700 *
1701 * @throws IOException If an I/O error occurs.
1702 * @throws LscpException If LSCP protocol corruption occurs.
1703 * @throws LSException If there is no device with ID <code>deviceId</code> or
1704 * if <code>channels</code> number is out of range.
1705 *
1706 * @see #getAudioOutputChannelInfo
1707 */
1708 public synchronized void
1709 setAudioOutputChannelCount(int deviceId, int channels)
1710 throws IOException, LscpException, LSException {
1711
1712 setAudioOutputDeviceParameter(deviceId, new IntParameter("CHANNELS", channels));
1713 }
1714
1715 /**
1716 * Gets information about an audio channel.
1717 *
1718 * @param deviceId The numerical ID of the audio output device.
1719 * @param audioChn The audio channel number.
1720 *
1721 * @return An <code>AudioOutputChannel</code> instance containing the
1722 * information about the specified audio output channel.
1723 *
1724 * @throws IOException If some I/O error occurs.
1725 * @throws LscpException If LSCP protocol corruption occurs.
1726 * @throws LSException If
1727 * <ul>
1728 * <li>There is no audio output device with numerical ID <code>deviceId</code>;
1729 * <li><code>audioChn</code> is not a valid channel number;
1730 * </ul>
1731 *
1732 * @see #getAudioOutputDevices
1733 * @see #getAudioOutputDeviceInfo
1734 */
1735 public synchronized AudioOutputChannel
1736 getAudioOutputChannelInfo(int deviceId, int audioChn)
1737 throws IOException, LscpException, LSException {
1738
1739 verifyConnection();
1740 out.writeLine("GET AUDIO_OUTPUT_CHANNEL INFO " + deviceId + ' ' + audioChn);
1741 if(getPrintOnlyMode()) return null;
1742
1743 ResultSet rs = getMultiLineResultSet();
1744
1745 AudioOutputChannel aoc = new AudioOutputChannel();
1746
1747 String[] lnS = rs.getMultiLineResult();
1748 for(String s : lnS) {
1749 if(s.startsWith("NAME: ")) {
1750 s = s.substring("NAME: ".length());
1751 Parameter<String> prm = getAudioOutputChannelParameterInfo (
1752 deviceId, audioChn, "NAME"
1753 );
1754 prm.setValue(removeQuotation(s));
1755 aoc.setNameParameter(prm);
1756 } else if(s.startsWith("IS_MIX_CHANNEL: ")) {
1757 s = s.substring("IS_MIX_CHANNEL: ".length());
1758 Parameter<Boolean> prm = getAudioOutputChannelParameterInfo (
1759 deviceId, audioChn, "IS_MIX_CHANNEL"
1760 );
1761 prm.setValue(Boolean.parseBoolean(s));
1762 aoc.setMixChannelParameter(prm);
1763 } else if(s.startsWith("MIX_CHANNEL_DESTINATION: ")) {
1764 s = s.substring("MIX_CHANNEL_DESTINATION: ".length());
1765 Parameter<Integer> prm = getAudioOutputChannelParameterInfo (
1766 deviceId, audioChn, "MIX_CHANNEL_DESTINATION"
1767 );
1768 prm.setValue(parseInt(s));
1769 aoc.setMixChannelDestParameter(prm);
1770 } else {
1771 int i = s.indexOf(": ");
1772 if(i == -1) throw new LscpException (
1773 LscpI18n.getLogMsg("CommandFailed!")
1774 );
1775
1776 Parameter prm = getAudioOutputChannelParameterInfo (
1777 deviceId, audioChn, s.substring(0, i)
1778 );
1779
1780 s = s.substring(i + 2);
1781 prm.parseValue(s);
1782
1783 aoc.addParameter(prm);
1784 }
1785 }
1786
1787 return aoc;
1788 }
1789
1790 /**
1791 * Gets detailed information about a specific audio output channel parameter.
1792 *
1793 * @param devId The numerical ID of the audio output device.
1794 * @param chan The audio channel number.
1795 * @param param a specific channel parameter name for which information should be obtained.
1796 *
1797 * @return An <code>Parameter</code> instance containing
1798 * information about the specified audio output channel parameter.
1799 *
1800 * @throws IOException If an I/O error occurs.
1801 * @throws LscpException If LSCP protocol corruption occurs.
1802 * @throws LSException If
1803 * <ul>
1804 * <li><code>devId</code> is not a valid device ID;
1805 * <li><code>chan</code> is not a valid channel number;
1806 * <li>There is no channel parameter with the specified name.
1807 * </ul>
1808 *
1809 * @see #getAudioOutputDevices
1810 * @see #getAudioOutputChannelInfo
1811 */
1812 public synchronized Parameter
1813 getAudioOutputChannelParameterInfo(int devId, int chan, String param)
1814 throws IOException, LscpException, LSException {
1815
1816 verifyConnection();
1817 String args = devId + " " + chan + " " + param;
1818 out.writeLine("GET AUDIO_OUTPUT_CHANNEL_PARAMETER INFO " + args);
1819 if(getPrintOnlyMode()) return null;
1820
1821 ResultSet rs = getMultiLineResultSet();
1822
1823 String[] lnS = rs.getMultiLineResult();
1824 ParameterType type = parseType(lnS);
1825 boolean multi = parseMultiplicity(lnS);
1826 Parameter prm;
1827
1828 switch(type) {
1829 case BOOL:
1830 if(!multi) prm = new BoolParameter(lnS);
1831 else prm = new BoolListParameter(lnS);
1832 prm.setName(param);
1833 return prm;
1834 case INT:
1835 if(!multi) prm = new IntParameter(lnS);
1836 else prm = new IntListParameter(lnS);
1837 prm.setName(param);
1838 return prm;
1839 case FLOAT:
1840 if(!multi) prm = new FloatParameter(lnS);
1841 else prm = new FloatListParameter(lnS);
1842 prm.setName(param);
1843 return prm;
1844 case STRING:
1845 if(!multi) prm = new StringParameter(lnS);
1846 else prm = new StringListParameter(lnS);
1847 prm.setName(param);
1848 return prm;
1849 default: throw new LscpException(LscpI18n.getLogMsg("Client.unknownPrmType!"));
1850 }
1851 }
1852
1853 /**
1854 * Alters a specific setting of an audio output channel.
1855 *
1856 * @param devId The numerical ID of the audio device.
1857 * @param chn The audio channel number.
1858 * @param prm A <code>Parameter</code> instance containing the name of the parameter
1859 * and the new value for this parameter.
1860 *
1861 * @throws IOException If some I/O error occurs.
1862 * @throws LscpException If LSCP protocol corruption occurs.
1863 * @throws LSException If
1864 * <ul>
1865 * <li>There is no audio output device with numerical ID <code>devId</code>;
1866 * <li><code>chn</code> is not a valid channel number;
1867 * <li>There is no channel parameter with the specified name;
1868 * <li>The channel parameter is readonly;
1869 * <li>The channel parameter is from different type.
1870 * </ul>
1871 *
1872 * @see #getAudioOutputDevices
1873 * @see #getAudioOutputChannelInfo
1874 */
1875 public synchronized void
1876 setAudioOutputChannelParameter(int devId, int chn, Parameter prm)
1877 throws IOException, LscpException, LSException {
1878
1879 verifyConnection();
1880 String args = devId + " " + chn + " " + prm.getName() + '=' + prm.getStringValue();
1881 out.writeLine("SET AUDIO_OUTPUT_CHANNEL_PARAMETER " + args);
1882 if(getPrintOnlyMode()) return;
1883
1884 ResultSet rs = getEmptyResultSet();
1885 }
1886
1887 /**
1888 * Gets the current number of all MIDI input drivers.
1889 * @return The current number of all MIDI input drivers.
1890 * @throws IOException If some I/O error occurs.
1891 * @throws LscpException If LSCP protocol corruption occurs.
1892 * @throws LSException If some other error occurs.
1893 */
1894 public synchronized int
1895 getMidiInputDriverCount() throws IOException, LscpException, LSException {
1896 verifyConnection();
1897 out.writeLine("GET AVAILABLE_MIDI_INPUT_DRIVERS");
1898 if(getPrintOnlyMode()) return -1;
1899
1900 String s = getSingleLineResultSet().getResult();
1901 return parseInt(s);
1902 }
1903
1904 /**
1905 * Gets all MIDI input drivers currently available for the LinuxSampler instance.
1906 *
1907 * @return <code>MidiInputDriver</code> array containing all MIDI input drivers currently
1908 * available for the LinuxSampler instance.
1909 *
1910 * @throws IOException If an I/O error occurs.
1911 * @throws LscpException If LSCP protocol corruption occurs.
1912 * @throws LSException If some other error occurs.
1913 */
1914 public synchronized MidiInputDriver[]
1915 getMidiInputDrivers() throws IOException, LscpException, LSException {
1916 String[] drivers = getMidiInputDriverNames();
1917 if(getPrintOnlyMode()) return null;
1918
1919 MidiInputDriver[] mid = new MidiInputDriver[drivers.length];
1920
1921 for(int i = 0; i < mid.length; i++) mid[i] = getMidiInputDriverInfo(drivers[i]);
1922
1923 return mid;
1924 }
1925
1926 /**
1927 * Gets all MIDI input drivers currently available for the LinuxSampler instance.
1928 *
1929 * @return <code>String</code> array containing all MIDI input drivers currently available
1930 * for the LinuxSampler instance.
1931 *
1932 * @throws IOException If an I/O error occurs.
1933 * @throws LscpException If LSCP protocol corruption occurs.
1934 * @throws LSException If some other error occurs.
1935 */
1936 private synchronized String[]
1937 getMidiInputDriverNames() throws IOException, LscpException, LSException {
1938 verifyConnection();
1939 out.writeLine("LIST AVAILABLE_MIDI_INPUT_DRIVERS");
1940 if(getPrintOnlyMode()) return null;
1941
1942 return parseList(getSingleLineResultSet().getResult());
1943 }
1944
1945 /**
1946 * Gets detailed information about a specific MIDI input driver.
1947 * @param driverName The name of the MIDI input driver.
1948 * @param depList An optional list of dependences parameters.
1949 * @return A <code>MidiInputDriver</code> object containing
1950 * information about the specified MIDI input driver.
1951 *
1952 * @throws IOException If an I/O error occurs.
1953 * @throws LscpException If LSCP protocol corruption occurs.
1954 * @throws LSException If there is no driver with name <code>driverName</code>.
1955 *
1956 * @see #getMidiInputDriverNames
1957 */
1958 public synchronized MidiInputDriver
1959 getMidiInputDriverInfo(String driverName, Parameter... depList)
1960 throws IOException, LscpException, LSException {
1961
1962 verifyConnection();
1963 out.writeLine("GET MIDI_INPUT_DRIVER INFO " + driverName);
1964 if(getPrintOnlyMode()) return null;
1965
1966 ResultSet rs = getMultiLineResultSet();
1967
1968 MidiInputDriver mid = new MidiInputDriver(rs.getMultiLineResult());
1969 mid.setName(driverName);
1970
1971 for(String s : mid.getParameterNames())
1972 mid.addParameter(getMidiInputDriverParameterInfo(driverName, s, depList));
1973
1974 return mid;
1975 }
1976
1977 /**
1978 * Gets detailed information about a specific MIDI input driver parameter.
1979 *
1980 * @param driver The name of the MIDI input driver.
1981 * @param param a specific parameter name for which information should be obtained.
1982 * @param deplist An optional list of parameters on which the sought parameter
1983 * <code>param</code> depends on. <code>Parameter</code> instances can be
1984 * easily created using {@link ParameterFactory} factory.
1985 *
1986 * @return A <code>Parameter</code> object containing
1987 * information about the specified MIDI input driver parameter.
1988 *
1989 * @throws IOException If an I/O error occurs.
1990 * @throws LscpException If LSCP protocol corruption occurs.
1991 * @throws LSException If <code>driver</code> is not a valid driver name
1992 * or <code>param</code> is not a valid parameter for the specified driver.
1993 *
1994 * @see #getMidiInputDrivers
1995 * @see #getMidiInputDriverInfo
1996 * @see ParameterFactory
1997 */
1998 public synchronized Parameter
1999 getMidiInputDriverParameterInfo(String driver, String param, Parameter... deplist)
2000 throws IOException, LscpException, LSException {
2001
2002 verifyConnection();
2003 StringBuffer args = new StringBuffer(driver);
2004 args.append(' ').append(param);
2005
2006 for(Parameter p : deplist) {
2007 if(p.getValue() == null) continue;
2008 args.append(' ').append(p.getName()).append('=').append(p.getStringValue());
2009 }
2010
2011 out.writeLine("GET MIDI_INPUT_DRIVER_PARAMETER INFO " + args.toString());
2012 if(getPrintOnlyMode()) return null;
2013
2014 ResultSet rs = getMultiLineResultSet();
2015
2016 String[] lnS = rs.getMultiLineResult();
2017 ParameterType type = parseType(lnS);
2018 boolean multi = parseMultiplicity(lnS);
2019 Parameter prm;
2020
2021 switch(type) {
2022 case BOOL:
2023 if(!multi) prm = new BoolParameter(lnS);
2024 else prm = new BoolListParameter(lnS);
2025 prm.setName(param);
2026 prm.setValue(prm.getDefault());
2027 return prm;
2028 case INT:
2029 if(!multi) prm = new IntParameter(lnS);
2030 else prm = new IntListParameter(lnS);
2031 prm.setName(param);
2032 prm.setValue(prm.getDefault());
2033 return prm;
2034 case FLOAT:
2035 if(!multi) prm = new FloatParameter(lnS);
2036 else prm = new FloatListParameter(lnS);
2037 prm.setName(param);
2038 prm.setValue(prm.getDefault());
2039 return prm;
2040 case STRING:
2041 if(!multi) prm = new StringParameter(lnS);
2042 else prm = new StringListParameter(lnS);
2043 prm.setName(param);
2044 prm.setValue(prm.getDefault());
2045 return prm;
2046 default: throw new LscpException(LscpI18n.getLogMsg("Client.unknownPrmType!"));
2047 }
2048 }
2049
2050 /**
2051 * Creates a new MIDI input device.
2052 * @param miDriver The desired MIDI input system.
2053 * @param paramList An optional list of driver specific parameters. <code>Parameter</code>
2054 * instances can be easily created using {@link ParameterFactory} factory.
2055 * @return The numerical ID of the newly created device.
2056 * @throws IOException If some I/O error occurs.
2057 * @throws LSException If the creation of the new MIDI input device failed.
2058 * @throws LscpException If LSCP protocol corruption occurs.
2059 *
2060 * @see #getMidiInputDrivers
2061 * @see #getMidiInputDriverInfo
2062 * @see ParameterFactory
2063 */
2064 public synchronized int
2065 createMidiInputDevice(String miDriver, Parameter... paramList)
2066 throws IOException, LSException, LscpException {
2067
2068 verifyConnection();
2069 StringBuffer args = new StringBuffer(miDriver);
2070
2071 for(Parameter p : paramList) {
2072 if(p.getValue() == null) continue;
2073 args.append(' ').append(p.getName()).append('=').append(p.getStringValue());
2074 }
2075
2076 out.writeLine("CREATE MIDI_INPUT_DEVICE " + args.toString());
2077 if(getPrintOnlyMode()) return -1;
2078
2079 ResultSet rs = getEmptyResultSet();
2080
2081 return rs.getIndex();
2082 }
2083
2084 /**
2085 * Destroys already created MIDI input device.
2086 * @param deviceId The numerical ID of the MIDI input device to be destroyed.
2087 * @throws IOException If some I/O error occurs.
2088 * @throws LSException If the destroying of the MIDI input device failed.
2089 * @throws LscpException If LSCP protocol corruption occurs.
2090 * @see #createMidiInputDevice
2091 * @see #getMidiInputDevices
2092 */
2093 public synchronized void
2094 destroyMidiInputDevice(int deviceId) throws IOException, LSException, LscpException {
2095 verifyConnection();
2096 out.writeLine("DESTROY MIDI_INPUT_DEVICE " + deviceId);
2097 if(getPrintOnlyMode()) return;
2098
2099 ResultSet rs = getEmptyResultSet();
2100 }
2101
2102 /**
2103 * Enables/disables the specified MIDI input device.
2104 * @param deviceId The ID of the MIDI input device to be enabled/disabled.
2105 * @param enable If <code>true</code> the MIDI input device is enabled,
2106 * else the device is disabled.
2107 * @throws IOException If some I/O error occurs.
2108 * @throws LSException If there is no MIDI input
2109 * device with numerical ID <code>deviceId</code>.
2110 * @throws LscpException If LSCP protocol corruption occurs.
2111 */
2112 public void
2113 enableMidiInputDevice(int deviceId, boolean enable)
2114 throws IOException, LSException, LscpException {
2115
2116 setMidiInputDeviceParameter(deviceId, new BoolParameter("ACTIVE", enable));
2117 }
2118
2119 /**
2120 * Gets the current number of all created MIDI input devices.
2121 * @return The current number of all created MIDI input devices.
2122 * @throws IOException If some I/O error occurs.
2123 * @throws LscpException If LSCP protocol corruption occurs.
2124 * @throws LSException If some other error occurs.
2125 */
2126 public synchronized int
2127 getMidiInputDeviceCount() throws IOException, LscpException, LSException {
2128 verifyConnection();
2129 out.writeLine("GET MIDI_INPUT_DEVICES");
2130 if(getPrintOnlyMode()) return -1;
2131
2132 String s = getSingleLineResultSet().getResult();
2133 return parseInt(s);
2134 }
2135
2136 /**
2137 * Gets a list of all created MIDI input devices.
2138 * @return A <code>MidiInputDevice</code> array
2139 * providing all created MIDI input devices.
2140 * @throws IOException If some I/O error occurs.
2141 * @throws LscpException If LSCP protocol corruption occurs.
2142 * @throws LSException If some other error occurs.
2143 *
2144 * @see #createMidiInputDevice
2145 * @see #destroyMidiInputDevice
2146 */
2147 public synchronized MidiInputDevice[]
2148 getMidiInputDevices() throws IOException, LscpException, LSException {
2149 Integer[] idS = getMidiInputDeviceIDs();
2150 if(getPrintOnlyMode()) return null;
2151
2152 MidiInputDevice[] devices = new MidiInputDevice[idS.length];
2153
2154 for(int i = 0; i < devices.length; i++)
2155 devices[i] = getMidiInputDeviceInfo(idS[i]);
2156
2157 return devices;
2158 }
2159
2160 /**
2161 * Gets a list of numerical IDs of all created MIDI input devices.
2162 * @return An <code>Integer</code> array providing the numerical IDs of
2163 * all created MIDI input devices.
2164 * @throws IOException If some I/O error occurs.
2165 * @throws LscpException If LSCP protocol corruption occurs.
2166 * @throws LSException If some other error occurs.
2167 *
2168 * @see #createMidiInputDevice
2169 * @see #destroyMidiInputDevice
2170 */
2171 public synchronized Integer[]
2172 getMidiInputDeviceIDs() throws IOException, LscpException, LSException {
2173 verifyConnection();
2174 out.writeLine("LIST MIDI_INPUT_DEVICES");
2175 if(getPrintOnlyMode()) return null;
2176
2177 return parseIntList(getSingleLineResultSet().getResult());
2178 }
2179
2180 /**
2181 * Gets the current settings of a specific, already created MIDI input device.
2182 *
2183 * @param deviceId Specifies the numerical ID of the MIDI input device.
2184 *
2185 * @return A <code>MidiInputDevice</code> instance containing information
2186 * about the specified device.
2187 *
2188 * @throws IOException If some I/O error occurs.
2189 * @throws LscpException If LSCP protocol corruption occurs.
2190 * @throws LSException If there is no MIDI input device
2191 * with device id <code>deviceId</code>.
2192 *
2193 * @see #getMidiInputDevices
2194 */
2195 public synchronized MidiInputDevice
2196 getMidiInputDeviceInfo(int deviceId) throws IOException, LscpException, LSException {
2197 verifyConnection();
2198 out.writeLine("GET MIDI_INPUT_DEVICE INFO " + deviceId);
2199 if(getPrintOnlyMode()) return null;
2200
2201 ResultSet rs = getMultiLineResultSet();
2202
2203 String[] lnS = rs.getMultiLineResult();
2204
2205 MidiInputDevice mid = new MidiInputDevice();
2206 mid.setDeviceId(deviceId);
2207
2208 String drv = getCategoryInfo(lnS, "DRIVER");
2209 mid.setDriverName(drv);
2210
2211 for(String s : lnS) {
2212 if(s.startsWith("DRIVER: ")) {
2213
2214 } else if(s.startsWith("ACTIVE: ")) {
2215 s = s.substring("ACTIVE: ".length());
2216 mid.setActive(Boolean.parseBoolean(s));
2217 } else if(s.startsWith("PORTS: ")) {
2218 s = s.substring("PORTS: ".length());
2219 int ports = Parser.parseInt(s);
2220 MidiPort[] midiPorts = new MidiPort[ports > 0 ? ports : 0];
2221
2222 for(int i = 0; i < midiPorts.length; i++)
2223 midiPorts[i] = getMidiInputPortInfo(deviceId, i);
2224
2225 mid.setMidiPorts(midiPorts);
2226 } else {
2227 int i = s.indexOf(": ");
2228 if(i == -1) throw new LscpException (
2229 LscpI18n.getLogMsg("CommandFailed!")
2230 );
2231
2232 Parameter prm =
2233 getMidiInputDriverParameterInfo(drv, s.substring(0, i));
2234
2235 s = s.substring(i + 2);
2236 prm.parseValue(s);
2237
2238 mid.addParameter(prm);
2239 }
2240 }
2241
2242 return mid;
2243 }
2244
2245 /**
2246 * Alters a specific setting of a created MIDI input device.
2247 *
2248 * @param deviceId The numerical ID of the MIDI input device.
2249 * @param prm A <code>Parameter</code> instance containing the name of the parameter
2250 * and the new value for this parameter.
2251 *
2252 * @throws IOException If some I/O error occurs.
2253 * @throws LscpException If LSCP protocol corruption occurs.
2254 * @throws LSException If
2255 * <ul>
2256 * <li>There is no MIDI input device with numerical ID <code>deviceId</code>;
2257 * <li>There is no device parameter with the specified name;
2258 * <li>The device parameter is readonly;
2259 * <li>The device parameter is from different type.
2260 * </ul>
2261 *
2262 * @see #getMidiInputDevices
2263 * @see #getMidiInputDeviceInfo
2264 */
2265 public synchronized void
2266 setMidiInputDeviceParameter(int deviceId, Parameter prm)
2267 throws IOException, LscpException, LSException {
2268
2269 verifyConnection();
2270 String kv = prm.getName() + '=' + prm.getStringValue();
2271 out.writeLine("SET MIDI_INPUT_DEVICE_PARAMETER " + deviceId + ' ' + kv);
2272 if(getPrintOnlyMode()) return;
2273
2274 ResultSet rs = getEmptyResultSet();
2275 }
2276
2277
2278 /**
2279 * Changes the port number of the speicified MIDI input device.
2280 * @param deviceId The numerical ID of the MIDI input device.
2281 * @param ports The new number of MIDI input ports.
2282 *
2283 * @throws IOException If an I/O error occurs.
2284 * @throws LscpException If LSCP protocol corruption occurs.
2285 * @throws LSException If there is no device with ID <code>deviceId</code> or
2286 * if <code>ports</code> number is out of range.
2287 *
2288 * @see #getMidiInputPortInfo
2289 */
2290 public synchronized void
2291 setMidiInputPortCount(int deviceId, int ports)
2292 throws IOException, LscpException, LSException {
2293
2294 setMidiInputDeviceParameter(deviceId, new IntParameter("PORTS", ports));
2295 }
2296
2297 /**
2298 * Gets detailed information about a specific MIDI input port.
2299 * @param deviceId The numerical ID of the MIDI input device.
2300 * @param midiPort The MIDI input port number.
2301 *
2302 * @return A <code>MidiPort</code> instance containing
2303 * information about the specified MIDI input port.
2304 *
2305 * @throws IOException If an I/O error occurs.
2306 * @throws LscpException If LSCP protocol corruption occurs.
2307 * @throws LSException If there is no device with ID <code>deviceId</code> or
2308 * if <code>midiPort</code> is not a valid MIDI port number.
2309 *
2310 * @see #getMidiInputDevices
2311 */
2312 public synchronized MidiPort
2313 getMidiInputPortInfo(int deviceId, int midiPort)
2314 throws IOException, LscpException, LSException {
2315
2316 verifyConnection();
2317 out.writeLine("GET MIDI_INPUT_PORT INFO " + deviceId + " " + midiPort);
2318 if(getPrintOnlyMode()) return null;
2319
2320 ResultSet rs = getMultiLineResultSet();
2321
2322 MidiPort mp = new MidiPort();
2323 String[] lnS = rs.getMultiLineResult();
2324
2325 for(String s : lnS) {
2326 if(s.startsWith("NAME: ")) {
2327 s = s.substring("NAME: ".length());
2328 Parameter prm = getMidiInputPortParameterInfo (
2329 deviceId, midiPort, "NAME"
2330 );
2331 prm.setValue(removeQuotation(s));
2332 mp.setNameParameter(prm);
2333 } else {
2334 int i = s.indexOf(": ");
2335 if(i == -1) throw new LscpException (
2336 LscpI18n.getLogMsg("CommandFailed!")
2337 );
2338
2339 Parameter prm = getMidiInputPortParameterInfo (
2340 deviceId, midiPort, s.substring(0, i)
2341 );
2342
2343 s = s.substring(i + 2);
2344 prm.parseValue(s);
2345
2346 mp.addParameter(prm);
2347 }
2348 }
2349
2350 return mp;
2351 }
2352
2353 /**
2354 * Gets detailed information about a specific MIDI input port parameter.
2355 *
2356 * @param deviceId The numerical ID of the MIDI input device.
2357 * @param port The MIDI port number.
2358 * @param param A specific parameter name for which information should be obtained.
2359 *
2360 * @return A <code>Parameter</code> instance containing
2361 * information about the specified MIDI input port parameter.
2362 *
2363 * @throws IOException If an I/O error occurs.
2364 * @throws LscpException If LSCP protocol corruption occurs.
2365 * @throws LSException If
2366 * <ul>
2367 * <li>There is no MIDI input device with numerical ID <code>deviceId</code>;
2368 * <li> <code>port</code> is not a valid MIDI port number;
2369 * <li><code>param</code> is not a valid parameter for the specified MIDI port.
2370 * </ul>
2371 *
2372 * @see #getMidiInputDevices
2373 * @see #getMidiInputPortInfo
2374 */
2375 public synchronized Parameter
2376 getMidiInputPortParameterInfo(int deviceId, int port, String param)
2377 throws IOException, LscpException, LSException {
2378
2379 verifyConnection();
2380 String args = deviceId + " " + port + " " + param;
2381 out.writeLine("GET MIDI_INPUT_PORT_PARAMETER INFO " + args);
2382 if(getPrintOnlyMode()) return null;
2383
2384 ResultSet rs = getMultiLineResultSet();
2385
2386 String[] lnS = rs.getMultiLineResult();
2387 ParameterType type = parseType(lnS);
2388 boolean multi = parseMultiplicity(lnS);
2389 Parameter prm;
2390
2391 switch(type) {
2392 case BOOL:
2393 if(!multi) prm = new BoolParameter(lnS);
2394 else prm = new BoolListParameter(lnS);
2395 prm.setName(param);
2396 return prm;
2397 case INT:
2398 if(!multi) prm = new IntParameter(lnS);
2399 else prm = new IntListParameter(lnS);
2400 prm.setName(param);
2401 return prm;
2402 case FLOAT:
2403 if(!multi) prm = new FloatParameter(lnS);
2404 else prm = new FloatListParameter(lnS);
2405 prm.setName(param);
2406 return prm;
2407 case STRING:
2408 if(!multi) prm = new StringParameter(lnS);
2409 else prm = new StringListParameter(lnS);
2410 prm.setName(param);
2411 return prm;
2412 default: throw new LscpException(LscpI18n.getLogMsg("Client.unknownPrmType!"));
2413 }
2414 }
2415
2416 /**
2417 * Alters a specific setting of a MIDI input port.
2418 *
2419 * @param deviceId The numerical ID of the MIDI device.
2420 * @param port The MIDI port number.
2421 * @param prm A <code>Parameter</code> instance containing the name of the parameter
2422 * and the new value for this parameter.
2423 *
2424 * @throws IOException If some I/O error occurs.
2425 * @throws LscpException If LSCP protocol corruption occurs.
2426 * @throws LSException If
2427 * <ul>
2428 * <li>There is no MIDI device with numerical ID <code>deviceId</code>;
2429 * <li><code>port</code> is not a valid MIDI port number;
2430 * <li><code>prm</code> is not a valid parameter;
2431 * <li>The parameter is readonly;
2432 * <li>The parameter is from different type.
2433 * </ul>
2434 *
2435 * @see #getMidiInputDevices
2436 * @see #getMidiInputPortInfo
2437 */
2438 public synchronized void
2439 setMidiInputPortParameter(int deviceId, int port, Parameter prm)
2440 throws IOException, LscpException, LSException {
2441
2442 verifyConnection();
2443 String args = deviceId + " " + port + " " +
2444 prm.getName() + '=' + prm.getStringValue();
2445 out.writeLine("SET MIDI_INPUT_PORT_PARAMETER " + args);
2446 if(getPrintOnlyMode()) return;
2447
2448 ResultSet rs = getEmptyResultSet();
2449 }
2450
2451 /**
2452 * Adds a new MIDI instrument map.
2453 * @param name The name of this MIDI instrument map.
2454 * @return The number of the newly MIDI instrument map.
2455 * @throws IOException If some I/O error occurs.
2456 * @throws LSException If the creation of the new MIDI instrument map failed.
2457 * @throws LscpException If LSCP protocol corruption occurs.
2458 * @see #removeMidiInstrumentMap
2459 */
2460 public synchronized int
2461 addMidiInstrumentMap(String name) throws IOException, LSException, LscpException {
2462 verifyConnection();
2463 out.writeLine("ADD MIDI_INSTRUMENT_MAP '" + name + "'");
2464 if(getPrintOnlyMode()) return -1;
2465
2466 ResultSet rs = getEmptyResultSet();
2467
2468 return rs.getIndex();
2469 }
2470
2471 /**
2472 * Removes the specified MIDI instrument map.
2473 * @param mapId The numerical ID of the MIDI instrument map to be removed.
2474 * @throws IOException If some I/O error occurs.
2475 * @throws LscpException If LSCP protocol corruption occurs.
2476 * @throws LSException If the removing of the MIDI instrument map failed.
2477 * @see #addMidiInstrumentMap
2478 * @see #getMidiInstrumentMapIDs
2479 */
2480 public synchronized void
2481 removeMidiInstrumentMap(int mapId) throws IOException, LscpException, LSException {
2482 verifyConnection();
2483 out.writeLine("REMOVE MIDI_INSTRUMENT_MAP " + mapId);
2484 if(getPrintOnlyMode()) return;
2485
2486 ResultSet rs = getEmptyResultSet();
2487 }
2488
2489 /**
2490 * Removes the all MIDI instrument maps.
2491 * @throws IOException If some I/O error occurs.
2492 * @throws LscpException If LSCP protocol corruption occurs.
2493 * @throws LSException If the removing of the MIDI instrument maps failed.
2494 */
2495 public synchronized void
2496 removeAllMidiInstrumentMaps() throws IOException, LscpException, LSException {
2497 verifyConnection();
2498 out.writeLine("REMOVE MIDI_INSTRUMENT_MAP ALL");
2499 if(getPrintOnlyMode()) return;
2500
2501 ResultSet rs = getEmptyResultSet();
2502 }
2503
2504 /**
2505 * Gets the current number of all MIDI instrument maps.
2506 * @return The current number of all MIDI instrument maps.
2507 * @throws IOException If some I/O error occurs.
2508 * @throws LscpException If LSCP protocol corruption occurs.
2509 * @throws LSException If some other error occurs.
2510 */
2511 public synchronized int
2512 getMidiInstrumentMapCount() throws IOException, LscpException, LSException {
2513 verifyConnection();
2514 out.writeLine("GET MIDI_INSTRUMENT_MAPS");
2515 if(getPrintOnlyMode()) return -1;
2516
2517 String s = getSingleLineResultSet().getResult();
2518 return parseInt(s);
2519 }
2520
2521 /**
2522 * Gets a list of numerical IDs of all created MIDI instrument maps.
2523 * @return An <code>Integer</code> array providing the numerical IDs of
2524 * all created MIDI instrument maps.
2525 * @throws IOException If some I/O error occurs.
2526 * @throws LscpException If LSCP protocol corruption occurs.
2527 * @throws LSException If some other error occurs.
2528 * @see #addMidiInstrumentMap
2529 * @see #removeMidiInstrumentMap
2530 */
2531 public synchronized Integer[]
2532 getMidiInstrumentMapIDs() throws IOException, LscpException, LSException {
2533 verifyConnection();
2534 out.writeLine("LIST MIDI_INSTRUMENT_MAPS");
2535 if(getPrintOnlyMode()) return null;
2536
2537 return parseIntList(getSingleLineResultSet().getResult());
2538 }
2539
2540 /**
2541 * Gets the current settings of a specific, already created MIDI instrument map.
2542 * @param mapId Specifies the numerical ID of the MIDI instrument map.
2543 * @return A <code>MidiInstrumentMapInfo</code> instance containing information
2544 * about the specified device.
2545 * @throws IOException If some I/O error occurs.
2546 * @throws LscpException If LSCP protocol corruption occurs.
2547 * @throws LSException If there is no MIDI instrument map
2548 * with map id <code>mapId</code>.
2549 * @see #getMidiInstrumentMaps
2550 */
2551 public synchronized MidiInstrumentMapInfo
2552 getMidiInstrumentMapInfo(int mapId) throws IOException, LscpException, LSException {
2553 verifyConnection();
2554 out.writeLine("GET MIDI_INSTRUMENT_MAP INFO " + mapId);
2555 if(getPrintOnlyMode()) return null;
2556
2557 ResultSet rs = getMultiLineResultSet();
2558
2559 String[] lnS = rs.getMultiLineResult();
2560
2561 String name = "";
2562 boolean b = false;
2563
2564 for(String s : lnS) {
2565 if(s.startsWith("NAME: ")) {
2566 name = s.substring("NAME: ".length());
2567 } else if(s.startsWith("DEFAULT: ")) {
2568 b = Boolean.parseBoolean(s.substring("DEFAULT: ".length()));
2569 } else {
2570 getLogger().info(LscpI18n.getLogMsg("unknownLine", s));
2571 }
2572 }
2573
2574 return new MidiInstrumentMapInfo(mapId, name, b);
2575 }
2576
2577 /**
2578 * Gets an information of all created MIDI instrument maps.
2579 * @return A <code>MidiInstrumentMap</code> array
2580 * providing information for all created MIDI instrument maps.
2581 * @throws IOException If some I/O error occurs.
2582 * @throws LscpException If LSCP protocol corruption occurs.
2583 * @throws LSException If some other error occurs.
2584 * @see #addMidiInstrumentMap
2585 * @see #removeMidiInstrumentMap
2586 */
2587 public synchronized MidiInstrumentMapInfo[]
2588 getMidiInstrumentMaps() throws IOException, LscpException, LSException {
2589 Integer[] idS = getMidiInstrumentMapIDs();
2590 if(getPrintOnlyMode()) return null;
2591
2592 MidiInstrumentMapInfo[] maps = new MidiInstrumentMapInfo[idS.length];
2593
2594 for(int i = 0; i < maps.length; i++)
2595 maps[i] = getMidiInstrumentMapInfo(idS[i]);
2596
2597 return maps;
2598 }
2599
2600 /**
2601 * Sets the name of the specified MIDI instrument map.
2602 * @param mapId The numerical ID of the MIDI instrument map.
2603 * @param name The new name for the specified MIDI instrument map.
2604 * @throws IOException If some I/O error occurs.
2605 * @throws LscpException If LSCP protocol corruption occurs.
2606 * @throws LSException If <code>mapId</code> is not a valid MIDI
2607 * instrument map number or <code>name</code> is not a valid name;
2608 */
2609 public synchronized void
2610 setMidiInstrumentMapName(int mapId, String name)
2611 throws IOException, LscpException, LSException {
2612
2613 verifyConnection();
2614 out.writeLine("SET MIDI_INSTRUMENT_MAP NAME " + + mapId + " '" + name + "'");
2615 if(getPrintOnlyMode()) return;
2616
2617 ResultSet rs = getEmptyResultSet();
2618 }
2619
2620
2621
2622 /**
2623 * Creates or replaces a MIDI instrument map entry.
2624 * @param mapId The ID of the map, where this instrument should be mapped.
2625 * @param entry Specifies the position of the MIDI instrument in the MIDI instrument map.
2626 * @param info Provides the needed information of the
2627 * MIDI instrument, which will be mapped to the specified MIDI instrument map.
2628 * @throws IOException If some I/O error occurs.
2629 * @throws LSException If the mapping failed.
2630 * @throws LscpException If LSCP protocol corruption occurs.
2631 * @see #unmapMidiInstrument
2632 */
2633 public synchronized void
2634 mapMidiInstrument(int mapId, MidiInstrumentEntry entry, MidiInstrumentInfo info)
2635 throws IOException, LSException, LscpException {
2636 mapMidiInstrument(mapId, entry, info, false);
2637 }
2638
2639 /**
2640 * Creates or replaces a MIDI instrument map entry.
2641 * @param mapId The ID of the map, where this instrument should be mapped.
2642 * @param entry Specifies the position of the MIDI instrument in the MIDI instrument map.
2643 * @param info Provides the needed information of the
2644 * MIDI instrument, which will be mapped to the specified MIDI instrument map.
2645 * @param nonModal If <code>true</code> the function returns immediately
2646 * and the mapping is established in the background.
2647 * @throws IOException If some I/O error occurs.
2648 * @throws LSException If the mapping failed.
2649 * @throws LscpException If LSCP protocol corruption occurs.
2650 * @see #unmapMidiInstrument
2651 */
2652 public synchronized void
2653 mapMidiInstrument(int mapId, MidiInstrumentEntry entry, MidiInstrumentInfo info, boolean nonModal)
2654 throws IOException, LSException, LscpException {
2655
2656 verifyConnection();
2657 StringBuffer cmd = new StringBuffer("MAP MIDI_INSTRUMENT ");
2658 if(nonModal) cmd.append("NON_MODAL ");
2659 cmd.append(mapId).append(' ');
2660 cmd.append(entry.getMidiBank()).append(' ');
2661 cmd.append(entry.getMidiProgram()).append(' ');
2662 cmd.append(info.getEngine()).append(" '");
2663 cmd.append(info.getFilePath()).append("' ");
2664 cmd.append(info.getInstrumentIndex()).append(' ');
2665 cmd.append(info.getVolume());
2666 if(!info.getLoadMode().name().equals("DEFAULT")) {
2667 cmd.append(' ').append(info.getLoadMode().name());
2668 }
2669 if(info.getName() != null) cmd.append(" '").append(info.getName()).append("'");
2670
2671 out.writeLine(cmd.toString());
2672 if(getPrintOnlyMode()) return;
2673
2674 ResultSet rs = getEmptyResultSet();
2675 }
2676
2677 /**
2678 * Removes an entry MIDI instrument map.
2679 * @param mapId The ID of the map, from which
2680 * the specified MIDI instrument should be removed.
2681 * @param entry The entry to remove from the specified MIDI instrument map.
2682 * @throws IOException If some I/O error occurs.
2683 * @throws LSException If the unmapping failed.
2684 * @throws LscpException If LSCP protocol corruption occurs.
2685 * @see #mapMidiInstrument
2686 */
2687 public synchronized void
2688 unmapMidiInstrument(int mapId, MidiInstrumentEntry entry)
2689 throws IOException, LSException, LscpException {
2690
2691 verifyConnection();
2692 StringBuffer cmd = new StringBuffer("UNMAP MIDI_INSTRUMENT ");
2693 cmd.append(mapId).append(' ');
2694 cmd.append(entry.getMidiBank()).append(' ');
2695 cmd.append(entry.getMidiProgram());
2696
2697 out.writeLine(cmd.toString());
2698 if(getPrintOnlyMode()) return;
2699
2700 ResultSet rs = getEmptyResultSet();
2701 }
2702
2703 /**
2704 * Gets the current number of all MIDI instrument in all maps.
2705 * @return The current number of all MIDI instrument in all maps.
2706 * @throws IOException If some I/O error occurs.
2707 * @throws LscpException If LSCP protocol corruption occurs.
2708 * @throws LSException If some other error occurs.
2709 */
2710 public synchronized int
2711 getMidiInstrumentCount() throws IOException, LscpException, LSException {
2712 verifyConnection();
2713 out.writeLine("GET MIDI_INSTRUMENTS ALL");
2714 if(getPrintOnlyMode()) return -1;
2715
2716 String s = getSingleLineResultSet().getResult();
2717 return parseInt(s);
2718 }
2719
2720 /**
2721 * Gets the current number of MIDI instrument in the specified map.
2722 * @param mapId The ID of the map.
2723 * @return The current number of MIDI instrument in the specified map.
2724 * @throws IOException If some I/O error occurs.
2725 * @throws LscpException If LSCP protocol corruption occurs.
2726 * @throws LSException If some other error occurs.
2727 */
2728 public synchronized int
2729 getMidiInstrumentCount(int mapId) throws IOException, LscpException, LSException {
2730 verifyConnection();
2731 out.writeLine("GET MIDI_INSTRUMENTS " + String.valueOf(mapId));
2732 if(getPrintOnlyMode()) return -1;
2733
2734 String s = getSingleLineResultSet().getResult();
2735 return parseInt(s);
2736 }
2737
2738 /**
2739 * Gets all MIDI instrument from all maps.
2740 * @return A <code>MidiInstrumentInfo</code> array providing
2741 * all MIDI instruments from all MIDI instrument maps.
2742 * @throws IOException If some I/O error occurs.
2743 * @throws LscpException If LSCP protocol corruption occurs.
2744 * @throws LSException If some other error occurs.
2745 */
2746 public synchronized MidiInstrumentInfo[]
2747 getMidiInstruments() throws IOException, LscpException, LSException {
2748 verifyConnection();
2749 out.writeLine("LIST MIDI_INSTRUMENTS ALL");
2750 if(getPrintOnlyMode()) return null;
2751
2752 String[] entries = parseArray(getSingleLineResultSet().getResult());
2753
2754 return getMidiInstruments(entries);
2755 }
2756
2757 /**
2758 * Gets all MIDI instrument contained int the specified MIDI instrument map.
2759 * @param mapId The ID of the map, which instruments should be obtained.
2760 * @return A <code>MidiInstrumentInfo</code> array providing
2761 * all MIDI instruments from all MIDI instrument maps.
2762 * @throws IOException If some I/O error occurs.
2763 * @throws LscpException If LSCP protocol corruption occurs.
2764 * @throws LSException If some other error occurs.
2765 */
2766 public synchronized MidiInstrumentInfo[]
2767 getMidiInstruments(int mapId) throws IOException, LscpException, LSException {
2768 verifyConnection();
2769 out.writeLine("LIST MIDI_INSTRUMENTS " + String.valueOf(mapId));
2770 if(getPrintOnlyMode()) return null;
2771
2772 String[] entries = parseArray(getSingleLineResultSet().getResult());
2773
2774 return getMidiInstruments(entries);
2775 }
2776
2777 private MidiInstrumentInfo[]
2778 getMidiInstruments(String[] entries) throws IOException, LscpException, LSException {
2779 Vector<MidiInstrumentInfo> v = new Vector<MidiInstrumentInfo>();
2780
2781 for(String s : entries) {
2782 Integer[] vals = parseIntList(s);
2783 if(vals.length != 3) {
2784 throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
2785 }
2786
2787 v.add(getMidiInstrumentInfo(vals[0], vals[1], vals[2]));
2788 }
2789
2790 return v.toArray(new MidiInstrumentInfo[v.size()]);
2791 }
2792
2793 /**
2794 * Gets the current settings of the specified MIDI instrument.
2795 * @param mapId The ID of the map.
2796 * @param bank The index of the MIDI bank.
2797 * @param program The MIDI program number of the instrument.
2798 * @return <code>MidiInstrumentInfo</code> instance containing
2799 * the current settings of the specified MIDI instrument.
2800 * @throws IOException If an I/O error occurs.
2801 * @throws LscpException If LSCP protocol corruption occurs.
2802 * @throws LSException If the specified MIDI instrument is missing.
2803 */
2804 public synchronized MidiInstrumentInfo
2805 getMidiInstrumentInfo(int mapId, int bank, int program)
2806 throws IOException, LscpException, LSException {
2807
2808 verifyConnection();
2809 StringBuffer cmd = new StringBuffer("GET MIDI_INSTRUMENT INFO ");
2810 cmd.append(mapId).append(' ');
2811 cmd.append(bank).append(' ');
2812 cmd.append(program);
2813
2814 out.writeLine(cmd.toString());
2815 if(getPrintOnlyMode()) return null;
2816
2817 ResultSet rs = getMultiLineResultSet();
2818 MidiInstrumentEntry entry = new MidiInstrumentEntry(bank, program);
2819 return new MidiInstrumentInfo(mapId, entry, rs.getMultiLineResult());
2820 }
2821
2822 /**
2823 * Loads and assigns an instrument to a sampler channel. Notice that this function will
2824 * return after the instrument is fully loaded and the channel is ready to be used.
2825 * @param filename The name of the instrument file
2826 * on the LinuxSampler instance's host system.
2827 * @param instrIdx The index of the instrument in the instrument file.
2828 * @param samplerChn The number of the sampler channel the instrument should be assigned to.
2829 * @throws IOException If some I/O error occurs.
2830 * @throws LscpException If LSCP protocol corruption occurs.
2831 * @throws LSException If the loading of the instrument failed.
2832 * @see #loadInstrument(String, int, int, boolean)
2833 * @see #getSamplerChannels
2834 */
2835 public synchronized void
2836 loadInstrument(String filename, int instrIdx, int samplerChn)
2837 throws IOException, LscpException, LSException {
2838
2839 verifyConnection();
2840 loadInstrument(filename, instrIdx, samplerChn, false);
2841 }
2842
2843 /**
2844 * Loads and assigns an instrument to a sampler channel.
2845 *
2846 * @param filename The name of the instrument file
2847 * on the LinuxSampler instance's host system.
2848 * @param instrIdx The index of the instrument in the instrument file.
2849 * @param samplerChn The number of the sampler channel the instrument should be assigned to.
2850 * @param nonModal If <code>false</code> the function will return after the instrument
2851 * has been fully loaded and the channel is ready to be used. If <code>true</code>
2852 * the function returns immediately.
2853 *
2854 * @throws IOException If some I/O error occurs.
2855 * @throws LscpException If LSCP protocol corruption occurs.
2856 * @throws LSException If the loading of the instrument failed.
2857 *
2858 * @see #loadInstrument(String, int, int)
2859 * @see #getSamplerChannels
2860 */
2861 public synchronized void
2862 loadInstrument(String filename, int instrIdx, int samplerChn, boolean nonModal)
2863 throws IOException, LscpException, LSException {
2864
2865 String cmd = nonModal ? "LOAD INSTRUMENT NON_MODAL " : "LOAD INSTRUMENT ";
2866 String args = '\'' + filename + "' " + instrIdx + ' ' + samplerChn;
2867
2868 out.writeLine(cmd + args);
2869 if(getPrintOnlyMode()) return;
2870
2871 ResultSet rs = getEmptyResultSet();
2872 }
2873
2874 /**
2875 * Loads a sampler engine to a specific sampler channel.
2876 * @param engineName The name of the engine.
2877 * @param samplerChn The number of the sampler channel
2878 * the deployed engine should be assigned to.
2879 *
2880 * @throws IOException If some I/O error occurs.
2881 * @throws LscpException If LSCP protocol corruption occurs.
2882 * @throws LSException If the loading of the sampler engine failed.
2883 * @see #getEngines
2884 * @see #getSamplerChannels
2885 */
2886 public synchronized void
2887 loadSamplerEngine(String engineName, int samplerChn)
2888 throws IOException, LscpException, LSException {
2889
2890 verifyConnection();
2891 out.writeLine("LOAD ENGINE " + engineName + ' ' + samplerChn);
2892 if(getPrintOnlyMode()) return;
2893
2894 ResultSet rs = getEmptyResultSet();
2895 }
2896
2897 /**
2898 * Gets the current number of all created sampler channels.
2899 * @return The current number of all created sampler channels.
2900 * @throws IOException If some I/O error occurs.
2901 * @throws LscpException If LSCP protocol corruption occurs.
2902 * @throws LSException If some other error occurs.
2903 */
2904 public synchronized int
2905 getSamplerChannelCount() throws IOException, LscpException, LSException {
2906 verifyConnection();
2907 out.writeLine("GET CHANNELS");
2908 if(getPrintOnlyMode()) return -1;
2909
2910 String s = getSingleLineResultSet().getResult();
2911 return parseInt(s);
2912 }
2913
2914 /**
2915 * Gets a list of all created sampler channels.
2916 * @return A <code>SamplerChannel</code> array providing all created sampler channels.
2917 * @throws IOException If some I/O error occurs.
2918 * @throws LscpException If LSCP protocol corruption occurs.
2919 * @throws LSException If some other error occurs.
2920 * @see #addSamplerChannel
2921 * @see #removeSamplerChannel
2922 */
2923 public synchronized SamplerChannel[]
2924 getSamplerChannels() throws IOException, LscpException, LSException {
2925 Integer[] idS = getSamplerChannelIDs();
2926 if(getPrintOnlyMode()) return null;
2927
2928 SamplerChannel[] channels = new SamplerChannel[idS.length];
2929
2930 for(int i = 0; i < channels.length; i++)
2931 channels[i] = getSamplerChannelInfo(idS[i]);
2932
2933 return channels;
2934 }
2935
2936 /**
2937 * Gets a list with numerical IDs of all created sampler channels.
2938 * @return An <code>Integer</code> array providing
2939 * the numerical IDs of all created sampler channels.
2940 * @throws IOException If some I/O error occurs.
2941 * @throws LscpException If LSCP protocol corruption occurs.
2942 * @throws LSException If some other error occurs.
2943 * @see #addSamplerChannel
2944 * @see #removeSamplerChannel
2945 */
2946 public synchronized Integer[]
2947 getSamplerChannelIDs() throws IOException, LscpException, LSException {
2948 verifyConnection();
2949 out.writeLine("LIST CHANNELS");
2950 if(getPrintOnlyMode()) return null;
2951
2952 return parseIntList(getSingleLineResultSet().getResult());
2953 }
2954
2955 /**
2956 * Adds a new sampler channel. This method will increment the sampler channel count by one
2957 * and the new sampler channel will be appended to the end of the sampler channel list.
2958 *
2959 * @return The number of the newly created sampler channel.
2960 * @throws IOException If some I/O error occurs.
2961 * @throws LSException If the creation of the new sampler channel failed.
2962 * @throws LscpException If LSCP protocol corruption occurs.
2963 * @see #removeSamplerChannel
2964 */
2965 public synchronized int
2966 addSamplerChannel() throws IOException, LSException, LscpException {
2967 verifyConnection();
2968 out.writeLine("ADD CHANNEL");
2969 if(getPrintOnlyMode()) return -1;
2970
2971 ResultSet rs = getEmptyResultSet();
2972
2973 return rs.getIndex();
2974 }
2975
2976 /**
2977 * Removes the specified sampler channel.
2978 *
2979 * @param samplerChn The numerical ID of the sampler channel to be removed.
2980 *
2981 * @throws IOException If some I/O error occurs.
2982 * @throws LscpException If LSCP protocol corruption occurs.
2983 * @throws LSException If the removing of the sampler channel failed.
2984 * @see #addSamplerChannel
2985 * @see #getSamplerChannels
2986 */
2987 public synchronized void
2988 removeSamplerChannel(int samplerChn) throws IOException, LscpException, LSException {
2989 verifyConnection();
2990 out.writeLine("REMOVE CHANNEL " + samplerChn);
2991 if(getPrintOnlyMode()) return;
2992
2993 ResultSet rs = getEmptyResultSet();
2994 }
2995
2996 /**
2997 * Gets the number of all available engines.
2998 * @return The number of all available engines.
2999 * @throws IOException If some I/O error occurs.
3000 * @throws LscpException If LSCP protocol corruption occurs.
3001 * @throws LSException If some other error occurs.
3002 */
3003 public synchronized int
3004 getEngineCount() throws IOException, LscpException, LSException {
3005 verifyConnection();
3006 out.writeLine("GET AVAILABLE_ENGINES");
3007 if(getPrintOnlyMode()) return -1;
3008
3009 String s = getSingleLineResultSet().getResult();
3010 return parseInt(s);
3011 }
3012
3013 /**
3014 * Gets a list of all available engines.
3015 *
3016 * @return <code>SamplerEngine</code> array containing all available engines.
3017 * @throws IOException If some I/O error occurs.
3018 * @throws LscpException If LSCP protocol corruption occurs.
3019 * @throws LSException If some other error occurs.
3020 */
3021 public synchronized SamplerEngine[]
3022 getEngines() throws IOException, LscpException, LSException {
3023 String[] engines = getEngineNames();
3024 if(getPrintOnlyMode()) return null;
3025
3026 SamplerEngine[] se = new SamplerEngine[engines.length];
3027
3028 for(int i = 0; i < engines.length; i++) se[i] = getEngineInfo(engines[i]);
3029
3030 return se;
3031 }
3032
3033 /**
3034 * Gets a list of all available engines' names.
3035 *
3036 * @return <code>String</code> array with all available engines' names.
3037 * @throws IOException If some I/O error occurs.
3038 * @throws LscpException If LSCP protocol corruption occurs.
3039 * @throws LSException If some other error occurs.
3040 */
3041 private synchronized String[]
3042 getEngineNames() throws IOException, LscpException, LSException {
3043 verifyConnection();
3044 out.writeLine("LIST AVAILABLE_ENGINES");
3045 if(getPrintOnlyMode()) return null;
3046
3047 return parseQuotedStringList(getSingleLineResultSet().getResult());
3048 }
3049
3050 /**
3051 * Gets information about a specific sampler engine.
3052 * @param engineName The name of the sampler engine.
3053 *
3054 * @return <code>SamplerEngine</code> instance containing
3055 * information about the specified sampler engine.
3056 *
3057 * @throws IOException If an I/O error occurs.
3058 * @throws LscpException If LSCP protocol corruption occurs.
3059 * @throws LSException If there is no sampler engine with name <code>engineName</code>.
3060 * @see #getEngineNames
3061 */
3062 private synchronized SamplerEngine
3063 getEngineInfo(String engineName) throws IOException, LscpException, LSException {
3064 verifyConnection();
3065 out.writeLine("GET ENGINE INFO " + engineName);
3066 if(getPrintOnlyMode()) return null;
3067
3068 ResultSet rs = getMultiLineResultSet();
3069 SamplerEngine se = new SamplerEngine(rs.getMultiLineResult());
3070 se.setName(engineName);
3071 return se;
3072 }
3073
3074 /**
3075 * Gets the current settings of the specified sampler channel.
3076 * @param samplerChn The sampler channel number.
3077 *
3078 * @return <code>SamplerChannel</code> instance containing
3079 * the current settings of the specified sampler channel.
3080 *
3081 * @throws IOException If an I/O error occurs.
3082 * @throws LscpException If LSCP protocol corruption occurs.
3083 * @throws LSException If there is no sampler channel with <code>samplerChn</code> number.
3084 * @see #getSamplerChannels
3085 */
3086 public synchronized SamplerChannel
3087 getSamplerChannelInfo(int samplerChn) throws IOException, LscpException, LSException {
3088 verifyConnection();
3089 out.writeLine("GET CHANNEL INFO " + samplerChn);
3090 if(getPrintOnlyMode()) return null;
3091
3092 ResultSet rs = getMultiLineResultSet();
3093 SamplerChannel sc = new SamplerChannel(rs.getMultiLineResult());
3094 sc.setChannelId(samplerChn);
3095 if(sc.getEngine() != null) sc.setEngine(getEngineInfo(sc.getEngine().getName()));
3096
3097 return sc;
3098 }
3099
3100 /**
3101 * Gets the current number of active voices on the specified sampler channel.
3102 *
3103 * @param samplerChn The sampler channel number.
3104 * @return The current number of active voices on the specified sampler channel.
3105 * @throws IOException If some I/O error occurs.
3106 * @throws LscpException If LSCP protocol corruption occurs.
3107 * @throws LSException If there is no sampler channel with number <code>samplerChn</code>.
3108 * @see #getSamplerChannels
3109 */
3110 public synchronized int
3111 getChannelVoiceCount(int samplerChn) throws IOException, LscpException, LSException {
3112 verifyConnection();
3113 out.writeLine("GET CHANNEL VOICE_COUNT " + samplerChn);
3114 if(getPrintOnlyMode()) return -1;
3115
3116 ResultSet rs = getSingleLineResultSet();
3117
3118 return parseInt(rs.getResult());
3119 }
3120
3121 /**
3122 * Gets the current number of active disk streams on the specified sampler channel.
3123 *
3124 * @param samplerChn The sampler channel number.
3125 * @return The current number of active disk streams on the specified sampler channel
3126 * or -1 if the engine doesn't support disk streaming.
3127 * @throws IOException If some I/O error occurs.
3128 * @throws LscpException If LSCP protocol corruption occurs.
3129 * @throws LSException If there is no sampler channel with number <code>samplerChn</code>.
3130 * @see #getSamplerChannels
3131 */
3132 public synchronized int
3133 getChannelStreamCount(int samplerChn) throws IOException, LscpException, LSException {
3134 verifyConnection();
3135 out.writeLine("GET CHANNEL STREAM_COUNT " + samplerChn);
3136 if(getPrintOnlyMode()) return -1;
3137
3138 ResultSet rs = getSingleLineResultSet();
3139
3140 if(rs.getResult().equals("NA")) return -1;
3141
3142 return parseInt(rs.getResult());
3143 }
3144
3145 /**
3146 * Gets the current fill state of all disk streams on the specified sampler channel
3147 * in bytes.
3148 *
3149 * @param samplerChn The sampler channel number.
3150 * @return The current fill state of all disk streams on the specified sampler channel
3151 * or <code>null</code> if the engine which is deployed doesn't support disk streaming.
3152 * @throws IOException If some I/O error occurs.
3153 * @throws LscpException If LSCP protocol corruption occurs.
3154 * @throws LSException If there is no sampler channel with number <code>samplerChn</code>.
3155 * @see #getChannelBufferFillPercentage
3156 * @see #getSamplerChannels
3157 */
3158 public synchronized Vector<BufferFill>
3159 getChannelBufferFillBytes(int samplerChn) throws IOException, LscpException, LSException {
3160 verifyConnection();
3161 out.writeLine("GET CHANNEL BUFFER_FILL BYTES " + samplerChn);
3162 if(getPrintOnlyMode()) return null;
3163
3164 ResultSet rs = getSingleLineResultSet();
3165
3166 if(rs.getResult().equals("NA")) return null;
3167
3168 Vector<BufferFill> v = new Vector<BufferFill>();
3169 String[] args = parseList(rs.getResult());
3170
3171 for(String s : args) {
3172 if(s.charAt(0) != '[')
3173 throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
3174
3175 int i = s.indexOf(']');
3176 if(i == -1) throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
3177
3178 BufferFill bf = new BufferFill();
3179 bf.setStreamId(parseInt(s.substring(1, i)));
3180 bf.setValue(parseInt(s.substring(i + 1)));
3181 v.add(bf);
3182 }
3183
3184 return v;
3185 }
3186
3187 /**
3188 * Gets the current fill state of all disk streams on the specified sampler channel
3189 * in percent.
3190 *
3191 * @param samplerChn The sampler channel number.
3192 * @return The current fill state of all disk streams on the specified sampler channel
3193 * or <code>null</code> if the engine which is deployed doesn't support disk streaming.
3194 * @throws IOException If some I/O error occurs.
3195 * @throws LscpException If LSCP protocol corruption occurs.
3196 * @throws LSException If there is no sampler channel with number <code>samplerChn</code>.
3197 * @see #getChannelBufferFillBytes
3198 * @see #getSamplerChannels
3199 */
3200 public synchronized Vector<BufferFill>
3201 getChannelBufferFillPercentage(int samplerChn)
3202 throws IOException, LscpException, LSException {
3203
3204 verifyConnection();
3205 out.writeLine("GET CHANNEL BUFFER_FILL PERCENTAGE " + samplerChn);
3206 if(getPrintOnlyMode()) return null;
3207
3208 ResultSet rs = getSingleLineResultSet();
3209
3210 return getChannelBufferFillPercentage(rs.getResult());
3211 }
3212
3213 private Vector<BufferFill>
3214 getChannelBufferFillPercentage(String ln) throws LscpException {
3215 if(ln.equals("NA")) return null;
3216
3217 Vector<BufferFill> v = new Vector<BufferFill>();
3218 String[] args = parseList(ln);
3219
3220 for(String s : args) {
3221 if(s.charAt(0) != '[')
3222 throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
3223
3224 int i = s.indexOf(']');
3225 if(i == -1) throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
3226
3227 if(s.charAt(s.length() - 1) != '%')
3228 throw new LscpException(LscpI18n.getLogMsg("CommandFailed!"));
3229
3230 BufferFill bf = new BufferFill();
3231 bf.setStreamId(parseInt(s.substring(1, i)));
3232 bf.setValue(parseInt(s.substring(i + 1, s.length() - 1)));
3233 v.add(bf);
3234 }
3235
3236 return v;
3237 }
3238
3239 /**
3240 * Sets the audio output device on the specified sampler channel.
3241 *
3242 * @param samplerChn The sampler channel number.
3243 * @param devId The numerical ID of the audio output device.
3244 *
3245 * @throws IOException If some I/O error occurs.
3246 * @throws LscpException If LSCP protocol corruption occurs.
3247 * @throws LSException If
3248 * <ul>
3249 * <li><code>samplerChn</code> is not a valid channel number;
3250 * <li><code>devId</code> is not a valid audio output device ID;
3251 * </ul>
3252 *
3253 * @see #getSamplerChannels
3254 * @see #getAudioOutputDevices
3255 */
3256 public synchronized void
3257 setChannelAudioOutputDevice(int samplerChn, int devId)
3258 throws IOException, LscpException, LSException {
3259
3260 verifyConnection();
3261 out.writeLine("SET CHANNEL AUDIO_OUTPUT_DEVICE " + samplerChn + ' ' + devId);
3262 if(getPrintOnlyMode()) return;
3263
3264 ResultSet rs = getEmptyResultSet();
3265 }
3266
3267 /**
3268 * Sets the audio output channel on the specified sampler channel.
3269 *
3270 * @param samplerChn The sampler channel number.
3271 * @param audioOut The sampler channel's audio output channel which should be rerouted.
3272 * @param audioIn The audio channel of the selected audio output device
3273 * where <code>audioOut</code> should be routed to.
3274 *
3275 * @throws IOException If some I/O error occurs.
3276 * @throws LscpException If LSCP protocol corruption occurs.
3277 * @throws LSException If
3278 * <ul>
3279 * <li><code>samplerChn</code> is not a valid channel number;
3280 * <li>There is no engine assigned yet to the specified sampler channel.
3281 * <li> There is no audio output device connected to the specified sampler channel.
3282 * </ul>
3283 *
3284 * @see #getSamplerChannels
3285 */
3286 public synchronized void
3287 setChannelAudioOutputChannel(int samplerChn, int audioOut, int audioIn)
3288 throws IOException, LscpException, LSException {
3289
3290 verifyConnection();
3291 String args = " " + samplerChn + ' ' + audioOut + ' ' + audioIn;
3292 out.writeLine("SET CHANNEL AUDIO_OUTPUT_CHANNEL" + args);
3293 if(getPrintOnlyMode()) return;
3294
3295 ResultSet rs = getEmptyResultSet();
3296 }
3297
3298 /**
3299 * Sets the MIDI input device on the specified sampler channel.
3300 *
3301 * @param samplerChn The sampler channel number.
3302 * @param devId The numerical ID of the MIDI input device.
3303 *
3304 * @throws IOException If some I/O error occurs.
3305 * @throws LscpException If LSCP protocol corruption occurs.
3306 * @throws LSException If
3307 * <ul>
3308 * <li><code>samplerChn</code> is not a valid channel number;
3309 * <li><code>devId</code> is not a valid MIDI input device ID;
3310 * </ul>
3311 *
3312 * @see #getSamplerChannels
3313 * @see #getMidiInputDevices
3314 */
3315 public synchronized void
3316 setChannelMidiInputDevice(int samplerChn, int devId)
3317 throws IOException, LscpException, LSException {
3318
3319 verifyConnection();
3320 out.writeLine("SET CHANNEL MIDI_INPUT_DEVICE " + samplerChn + ' ' + devId);
3321 if(getPrintOnlyMode()) return;
3322
3323 ResultSet rs = getEmptyResultSet();
3324 }
3325
3326 /**
3327 * Sets the MIDI input port on the specified sampler channel.
3328 *
3329 * @param samplerChn The sampler channel number.
3330 * @param port The MIDI input port number of
3331 * the MIDI input device connected to the specified sampler channel.
3332 *
3333 * @throws IOException If some I/O error occurs.
3334 * @throws LscpException If LSCP protocol corruption occurs.
3335 * @throws LSException If <code>samplerChn</code> is not a valid channel number.
3336 * @see #getSamplerChannels
3337 */
3338 public synchronized void
3339 setChannelMidiInputPort(int samplerChn, int port)
3340 throws IOException, LscpException, LSException {
3341
3342 verifyConnection();
3343 out.writeLine("SET CHANNEL MIDI_INPUT_PORT " + samplerChn + ' ' + port);
3344 if(getPrintOnlyMode()) return;
3345
3346 ResultSet rs = getEmptyResultSet();
3347 }
3348
3349 /**
3350 * Sets the MIDI input channel the specified sampler channel should listen to.
3351 *
3352 * @param samplerChn The sampler channel number.
3353 * @param midiChn The number of the new MIDI input channel where
3354 * <code>samplerChn</code> should listen to or -1 to listen on all 16 MIDI channels.
3355 *
3356 * @throws IOException If some I/O error occurs.
3357 * @throws LscpException If LSCP protocol corruption occurs.
3358 * @throws LSException If <code>samplerChn</code> is not a valid channel number.
3359 * @see #getSamplerChannels
3360 */
3361 public synchronized void
3362 setChannelMidiInputChannel(int samplerChn, int midiChn)
3363 throws IOException, LscpException, LSException {
3364
3365 verifyConnection();
3366 String args = String.valueOf(samplerChn) + ' ';
3367 args += (midiChn == -1 ? "ALL" : String.valueOf(midiChn));
3368 out.writeLine("SET CHANNEL MIDI_INPUT_CHANNEL " + args);
3369 if(getPrintOnlyMode()) return;
3370
3371 ResultSet rs = getEmptyResultSet();
3372 }
3373
3374 /**
3375 * Sets the MIDI instrument map to be used on the specified sampler channel.
3376 *
3377 * @param samplerChn The sampler channel number.
3378 * @param mapId Specifies the numerical ID of the MIDI instrument
3379 * map to assign. To remove the current map binding use <code>-1</code>.
3380 * To set the current map to be the default map use <code>-2</code>.
3381 *
3382 * @throws IOException If some I/O error occurs.
3383 * @throws LscpException If LSCP protocol corruption occurs.
3384 * @throws LSException If
3385 * <ul>
3386 * <li><code>samplerChn</code> is not a valid channel number;
3387 * <li><code>mapId</code> is not a valid MIDI instrument map ID;
3388 * </ul>
3389 *
3390 * @see #getSamplerChannels
3391 * @see #getMidiInstrumentMaps
3392 */
3393 public synchronized void
3394 setChannelMidiInstrumentMap(int samplerChn, int mapId)
3395 throws IOException, LscpException, LSException {
3396
3397 verifyConnection();
3398 String s;
3399 if(mapId == -1) {
3400 s = " NONE";
3401 } else if(mapId == -2) {
3402 s = " DEFAULT";
3403 } else {
3404 s = " " + String.valueOf(mapId);
3405 }
3406 out.writeLine("SET CHANNEL MIDI_INSTRUMENT_MAP " + samplerChn + s);
3407 if(getPrintOnlyMode()) return;
3408
3409 ResultSet rs = getEmptyResultSet();
3410 }
3411
3412 /**
3413 * Sets the volume of the specified sampler channel.
3414 *
3415 * @param samplerChn The sampler channel number.
3416 * @param volume The new volume value.
3417 *
3418 * @throws IOException If some I/O error occurs.
3419 * @throws LscpException If LSCP protocol corruption occurs.
3420 * @throws LSException If <code>samplerChn</code> is not a valid channel number or if
3421 * there is no engine assigned yet to the specified sampler channel.
3422 * @see #getSamplerChannels
3423 */
3424 public synchronized void
3425 setChannelVolume(int samplerChn, float volume)
3426 throws IOException, LscpException, LSException {
3427
3428 verifyConnection();
3429 out.writeLine("SET CHANNEL VOLUME " + samplerChn + ' ' + volume);
3430 if(getPrintOnlyMode()) return;
3431
3432 ResultSet rs = getEmptyResultSet();
3433 }
3434
3435 /**
3436 * Mute/unmute the specified sampler channel.
3437 *
3438 * @param samplerChn The sampler channel number.
3439 * @param mute If <code>true</code> the specified channel is muted, else the channel
3440 * is unmuted.
3441 *
3442 * @throws IOException If some I/O error occurs.
3443 * @throws LscpException If LSCP protocol corruption occurs.
3444 * @throws LSException If <code>samplerChn</code> is not a valid channel number or if
3445 * there is no engine assigned yet to the specified sampler channel.
3446 * @see #getSamplerChannels
3447 */
3448 public synchronized void
3449 setChannelMute(int samplerChn, boolean mute)
3450 throws IOException, LscpException, LSException {
3451
3452 verifyConnection();
3453 out.writeLine("SET CHANNEL MUTE " + samplerChn + ' ' + (mute ? 1 : 0));
3454 if(getPrintOnlyMode()) return;
3455
3456 ResultSet rs = getEmptyResultSet();
3457 }
3458
3459 /**
3460 * Solo/unsolo the specified sampler channel.
3461 *
3462 * @param samplerChn The sampler channel number.
3463 * @param solo <code>true</code> to solo the specified channel, <code>false</code>
3464 * otherwise.
3465 *
3466 * @throws IOException If some I/O error occurs.
3467 * @throws LscpException If LSCP protocol corruption occurs.
3468 * @throws LSException If <code>samplerChn</code> is not a valid channel number or if
3469 * there is no engine assigned yet to the specified sampler channel.
3470 * @see #getSamplerChannels
3471 */
3472 public synchronized void
3473 setChannelSolo(int samplerChn, boolean solo)
3474 throws IOException, LscpException, LSException {
3475
3476 verifyConnection();
3477 out.writeLine("SET CHANNEL SOLO " + samplerChn + ' ' + (solo ? 1 : 0));
3478 if(getPrintOnlyMode()) return;
3479
3480 ResultSet rs = getEmptyResultSet();
3481 }
3482
3483 /**
3484 * Creates an additional effect send on the specified sampler channel.
3485 * @param channel The sampler channel, on which a new effect send should be added.
3486 * @param midiCtrl Defines the MIDI controller, which
3487 * will be able alter the effect send level.
3488 * @return The unique ID of the newly created effect send entity.
3489 * @throws IOException If some I/O error occurs.
3490 * @throws LSException If the creation of the effect send failed.
3491 * @throws LscpException If LSCP protocol corruption occurs.
3492 * @see #destroyFxSend
3493 */
3494 public synchronized int
3495 createFxSend(int channel, int midiCtrl)
3496 throws IOException, LSException, LscpException {
3497
3498 return createFxSend(channel, midiCtrl, null);
3499 }
3500
3501 /**
3502 * Creates an additional effect send on the specified sampler channel.
3503 * @param channel The sampler channel, on which the effect send should be created on.
3504 * @param midiCtrl Defines the MIDI controller, which can alter the effect send level.
3505 * @param name The name of the effect send entity. The name does not have to be unique.
3506 * @return The unique ID of the newly created effect send entity.
3507 * @throws IOException If some I/O error occurs.
3508 * @throws LSException If the creation of the effect send failed.
3509 * @throws LscpException If LSCP protocol corruption occurs.
3510 * @see #destroyFxSend
3511 */
3512 public synchronized int
3513 createFxSend(int channel, int midiCtrl, String name)
3514 throws IOException, LSException, LscpException {
3515
3516 verifyConnection();
3517 String s = String.valueOf(channel) + " " + String.valueOf(midiCtrl);
3518 if(name != null) s += " '" + name + "'";
3519 out.writeLine("CREATE FX_SEND " + s);
3520 if(getPrintOnlyMode()) return -1;
3521
3522 ResultSet rs = getEmptyResultSet();
3523
3524 return rs.getIndex();
3525 }
3526
3527 /**
3528 * Destroys the specified effect send on the specified sampler channel.
3529 * @param channel The sampler channel, from which
3530 * the specified effect send should be removed.
3531 * @param fxSend The ID of the effect send that should be removed.
3532 * @throws LSException If some other error occurs.
3533 * @throws LscpException If LSCP protocol corruption occurs.
3534 * @see #createFxSend
3535 */
3536 public synchronized void
3537 destroyFxSend(int channel, int fxSend)
3538 throws IOException, LSException, LscpException {
3539
3540 verifyConnection();
3541 String s = String.valueOf(channel) + " " + String.valueOf(fxSend);
3542 out.writeLine("DESTROY FX_SEND " + s);
3543 if(getPrintOnlyMode()) return;
3544
3545 ResultSet rs = getEmptyResultSet();
3546 }
3547
3548 /**
3549 * Gets the current number of effect sends on the specified sampler channel.
3550 * @param channel The ID of the sampler channel.
3551 * @return The current number of effect sends on the specified sampler channels.
3552 * @throws IOException If some I/O error occurs.
3553 * @throws LscpException If LSCP protocol corruption occurs.
3554 * @throws LSException If some other error occurs.
3555 */
3556 public synchronized int
3557 getFxSoundCount(int channel) throws IOException, LscpException, LSException {
3558 verifyConnection();
3559 out.writeLine("GET FX_SENDS " + String.valueOf(channel));
3560 if(getPrintOnlyMode()) return -1;
3561
3562 String s = getSingleLineResultSet().getResult();
3563 return parseInt(s);
3564 }
3565
3566 /**
3567 * Gets a list of all created effect sends on the specified sampler channel.
3568 * @param channel The sampler channel number.
3569 * @return A <code>FxSend</code> array providing all created
3570 * effect sends on the specified sampler channel.
3571 * @throws IOException If some I/O error occurs.
3572 * @throws LscpException If LSCP protocol corruption occurs.
3573 * @throws LSException If <code>channel</code> is not a valid sampler channel ID.
3574 * @see #createFxSend
3575 * @see #destroyFxSend
3576 */
3577 public synchronized FxSend[]
3578 getFxSends(int channel) throws IOException, LscpException, LSException {
3579 Integer[] idS = getFxSendIDs(channel);
3580 if(getPrintOnlyMode()) return null;
3581
3582 FxSend[] fxSends = new FxSend[idS.length];
3583
3584 for(int i = 0; i < fxSends.length; i++)
3585 fxSends[i] = getFxSendInfo(channel, idS[i]);
3586
3587 return fxSends;
3588 }
3589
3590 /**
3591 * Gets a list of effect sends on the specified sampler channel.
3592 * @param channel The sampler channel number.
3593 * @return An <code>Integer</code> array providing
3594 * the numerical IDs of all effect sends on the specified sampler channel.
3595 * @throws IOException If some I/O error occurs.
3596 * @throws LscpException If LSCP protocol corruption occurs.
3597 * @throws LSException If <code>channel</code> is not a valid sampler channel ID.
3598 * @see #createFxSend
3599 * @see #destroyFxSend
3600 */
3601 public synchronized Integer[]
3602 getFxSendIDs(int channel) throws IOException, LscpException, LSException {
3603 verifyConnection();
3604 out.writeLine("LIST FX_SENDS " + channel);
3605 if(getPrintOnlyMode()) return null;
3606
3607 return parseIntList(getSingleLineResultSet().getResult());
3608 }
3609
3610 /**
3611 * Gets the current settings of the specified effect send entity.
3612 * @param channel The sampler channel number.
3613 * @param fxSend The numerical ID of the effect send entity.
3614 * @return <code>FxSend</code> instance containing
3615 * the current settings of the specified effect send entity.
3616 * @throws IOException If an I/O error occurs.
3617 * @throws LscpException If LSCP protocol corruption occurs.
3618 * @throws LSException If the sampler channel and/or the effect send number are invalid.
3619 */
3620 public synchronized FxSend
3621 getFxSendInfo(int channel, int fxSend) throws IOException, LscpException, LSException {
3622 verifyConnection();
3623 String s = String.valueOf(channel) + " " + String.valueOf(fxSend);
3624 out.writeLine("GET FX_SEND INFO " + s);
3625 if(getPrintOnlyMode()) return null;
3626
3627 ResultSet rs = getMultiLineResultSet();
3628 FxSend fxs = new FxSend(rs.getMultiLineResult());
3629 fxs.setFxSendId(fxSend);
3630
3631 return fxs;
3632 }
3633
3634 /**
3635 * Sets the name of the specified effect send.
3636 * @param channel The sampler channel number.
3637 * @param fxSend The numerical ID of the effect send entity.
3638 * @param name The new name for the specified effect send.
3639 * @throws IOException If some I/O error occurs.
3640 * @throws LscpException If LSCP protocol corruption occurs.
3641 * @throws LSException If <code>channel</code> is not a valid channel
3642 * number or <code>fxSend</code> is not a valid effect send ID;
3643 */
3644 public synchronized void
3645 setFxSendName(int channel, int fxSend, String name)
3646 throws IOException, LscpException, LSException {
3647
3648 verifyConnection();
3649 String args = " " + channel + " " + fxSend + " '" + name + "'";
3650 out.writeLine("SET FX_SEND NAME" + args);
3651 if(getPrintOnlyMode()) return;
3652
3653 ResultSet rs = getEmptyResultSet();
3654 }
3655
3656 /**
3657 * Sets the destination of an effect send's audio channel in the specified sampler channel.
3658 * @param channel The sampler channel number.
3659 * @param fxSend The numerical ID of the effect send entity to be rerouted.
3660 * @param audioSrc The numerical ID of the effect send's audio output channel,
3661 * which should be rerouted.
3662 * @param audioDst The audio channel of the selected audio output device
3663 * where <code>audioSrc</code> should be routed to.
3664 * @throws IOException If some I/O error occurs.
3665 * @throws LscpException If LSCP protocol corruption occurs.
3666 * @throws LSException If
3667 * <ul>
3668 * <li><code>channel</code> is not a valid channel number;
3669 * <li><code>fxSend</code> is not a valid effect send ID;
3670 * <li>There is no engine assigned yet to the specified sampler channel;
3671 * <li>There is no audio output device connected to the specified sampler channel.
3672 * </ul>
3673 */
3674 public synchronized void
3675 setFxSendAudioOutputChannel(int channel, int fxSend, int audioSrc, int audioDst)
3676 throws IOException, LscpException, LSException {
3677
3678 verifyConnection();
3679 String args = " " + channel + " " + fxSend + " " + audioSrc + " " + audioDst;
3680 out.writeLine("SET FX_SEND AUDIO_OUTPUT_CHANNEL" + args);
3681 if(getPrintOnlyMode()) return;
3682
3683 ResultSet rs = getEmptyResultSet();
3684 }
3685
3686 /**
3687 * Sets the MIDI controller, which will be able to modify
3688 * the send level of the specified effect send in the specified sampler channel.
3689 * @param channel The sampler channel number.
3690 * @param fxSend The numerical ID of the effect send entity.
3691 * @param midiCtrl The MIDI controller which shall be
3692 * able to modify the effect send's send level.
3693 * @throws IOException If some I/O error occurs.
3694 * @throws LscpException If LSCP protocol corruption occurs.
3695 * @throws LSException If
3696 * <ul>
3697 * <li><code>channel</code> is not a valid channel number;
3698 * <li><code>fxSend</code> is not a valid effect send ID;
3699 * <li><code>midiCtrl</code> is not a valid controller;
3700 * </ul>
3701 */
3702 public synchronized void
3703 setFxSendMidiController(int channel, int fxSend, int midiCtrl)
3704 throws IOException, LscpException, LSException {
3705
3706 verifyConnection();
3707 String args = " " + channel + " " + fxSend + " " + midiCtrl;
3708 out.writeLine("SET FX_SEND MIDI_CONTROLLER" + args);
3709 if(getPrintOnlyMode()) return;
3710
3711 ResultSet rs = getEmptyResultSet();
3712 }
3713
3714 /**
3715 * Sets the current send level of the specified
3716 * effect send entity in the specified sampler channel.
3717 * @param channel The sampler channel number.
3718 * @param fxSend The numerical ID of the effect send entity.
3719 * @param volume The new volume value (a value smaller than 1.0 means
3720 * attenuation, whereas a value greater than 1.0 means amplification).
3721 * @throws IOException If some I/O error occurs.
3722 * @throws LscpException If LSCP protocol corruption occurs.
3723 * @throws LSException If some other error occurs.
3724 */
3725 public synchronized void
3726 setFxSendLevel(int channel, int fxSend, float volume)
3727 throws IOException, LscpException, LSException {
3728
3729 verifyConnection();
3730 String args = " " + channel + " " + fxSend + " " + String.valueOf(volume);
3731 out.writeLine("SET FX_SEND LEVEL" + args);
3732 if(getPrintOnlyMode()) return;
3733
3734 ResultSet rs = getEmptyResultSet();
3735 }
3736
3737 /**
3738 * Starts an instrument editor for editing the loaded instrument
3739 * on the specified sampler channel.
3740 * @param samplerChn The sampler channel number.
3741 * @throws IOException If some I/O error occurs.
3742 * @throws LscpException If LSCP protocol corruption occurs.
3743 * @throws LSException If <code>samplerChn</code> is not a valid channel number or if
3744 * there is no instrument loaded on the specified sampler channel.
3745 * @see #getSamplerChannels
3746 */
3747 public synchronized void
3748 editInstrument(int samplerChn) throws IOException, LscpException, LSException {
3749 verifyConnection();
3750 out.writeLine("EDIT INSTRUMENT " + samplerChn);
3751 if(getPrintOnlyMode()) return;
3752
3753 ResultSet rs = getEmptyResultSet();
3754 }
3755
3756
3757
3758 /**
3759 * Adds the specified directory to the instruments database.
3760 * @param dir The absolute (escaped) path name of the directory to add.
3761 * @throws IOException If some I/O error occurs.
3762 * @throws LSException If the creation of the directory failed.
3763 * @throws LscpException If LSCP protocol corruption occurs.
3764 */
3765 public synchronized void
3766 addDbDirectory(String dir) throws IOException, LSException, LscpException {
3767 verifyConnection();
3768 out.writeLine("ADD DB_INSTRUMENT_DIRECTORY '" + dir + "'");
3769 if(getPrintOnlyMode()) return;
3770
3771 ResultSet rs = getEmptyResultSet();
3772 }
3773
3774 /**
3775 * Removes the specified directory from the instruments database.
3776 * @param dir The absolute (escaped) path name of the directory to remove.
3777 * @throws IOException If some I/O error occurs.
3778 * @throws LscpException If LSCP protocol corruption occurs.
3779 * @throws LSException If the specified directory is not
3780 * empty or if the removal of the directory failed.
3781 */
3782 public synchronized void
3783 removeDbDirectory(String dir) throws IOException, LscpException, LSException {
3784 removeDbDirectory(dir, false);
3785 }
3786
3787 /**
3788 * Removes the specified directory from the instruments database.
3789 * @param dir The absolute path name of the directory to remove.
3790 * @param force If <code>true</code> forces the removal of non-empty
3791 * directory and all its content.
3792 * @throws IOException If some I/O error occurs.
3793 * @throws LscpException If LSCP protocol corruption occurs.
3794 * @throws LSException If the removing of the directory failed.
3795 */
3796 public synchronized void
3797 removeDbDirectory(String dir, boolean force)
3798 throws IOException, LscpException, LSException {
3799
3800 verifyConnection();
3801 String s = "REMOVE DB_INSTRUMENT_DIRECTORY ";
3802 if(force) s += "FORCE ";
3803 out.writeLine(s + "'" + dir + "'");
3804 if(getPrintOnlyMode()) return;
3805
3806 ResultSet rs = getEmptyResultSet();
3807 }
3808
3809 /**
3810 * Removes the specified directories from the instruments database.
3811 * @param dirs The absolute (escaped) path names of the directories to remove.
3812 * @param force If <code>true</code> forces the removal of non-empty
3813 * directories.
3814 * @throws IOException If some I/O error occurs.
3815 * @throws LscpException If LSCP protocol corruption occurs.
3816 * @throws LSException If the removing of the directores failed.
3817 */
3818 public synchronized void
3819 removeDbDirectories(String[] dirs, boolean force)
3820 throws IOException, LscpException, LSException {
3821
3822 verifyConnection();
3823 String cmd = "REMOVE DB_INSTRUMENT_DIRECTORY ";
3824 if(force) cmd += "FORCE ";
3825
3826 for(String s : dirs) out.writeLine(cmd + "'" + s + "'");
3827
3828 if(getPrintOnlyMode()) return;
3829
3830 getEmptyResultSets(dirs.length, "Client.dirDeletionFailed!");
3831 }
3832
3833 /**
3834 * Gets the number of directories in the specified directory.
3835 * @return The current number of directories in the specified directory.
3836 * @param dir The absolute path name of the directory.
3837 * @throws IOException If some I/O error occurs.
3838 * @throws LscpException If LSCP protocol corruption occurs.
3839 * @throws LSException If some other error occurs.
3840 */
3841 public synchronized int
3842 getDbDirectoryCount(String dir) throws IOException, LscpException, LSException {
3843 return getDbDirectoryCount(dir, false);
3844 }
3845
3846 /**
3847 * Gets the number of directories in the specified directory.
3848 * @return The current number of directories in the specified directory.
3849 * @param dir The absolute path name of the directory.
3850 * @param recursive If <code>true</code>, the number of all directories
3851 * in the specified subtree will be returned.
3852 * @throws IOException If some I/O error occurs.
3853 * @throws LscpException If LSCP protocol corruption occurs.
3854 * @throws LSException If some other error occurs.
3855 */
3856 public synchronized int
3857 getDbDirectoryCount(String dir, boolean recursive)
3858 throws IOException, LscpException, LSException {
3859
3860 verifyConnection();
3861 String s;
3862 if(recursive) s = "GET DB_INSTRUMENT_DIRECTORIES RECURSIVE '";
3863 else s = "GET DB_INSTRUMENT_DIRECTORIES '";
3864 out.writeLine(s + dir + "'");
3865 if(getPrintOnlyMode()) return -1;
3866
3867 s = getSingleLineResultSet().getResult();
3868 return parseInt(s);
3869 }
3870
3871 /**
3872 * Gets the list of directories in the specified directory.
3873 * @param dir The absolute path name of the directory.
3874 * @return A <code>String</code> array providing the names of
3875 * all directories in the specified directory.
3876 * @throws IOException If some I/O error occurs.
3877 * @throws LscpException If LSCP protocol corruption occurs.
3878 * @throws LSException If the specified path name is invalid.
3879 */
3880 public synchronized String[]
3881 getDbDirectoryNames(String dir) throws IOException, LscpException, LSException {
3882 verifyConnection();
3883 out.writeLine("LIST DB_INSTRUMENT_DIRECTORIES '" + dir + "'");
3884 if(getPrintOnlyMode()) return null;
3885
3886 String[] names = parseEscapedStringList(getSingleLineResultSet().getResult());
3887 for(int i = 0; i < names.length; i++) {
3888 names[i] = toNonEscapedString(names[i]);
3889 }
3890 return names;
3891 }
3892
3893 /**
3894 * Gets information about the specified directory.
3895 * @param dir The absolute path name of the directory.
3896 * @return A <code>DbDirectoryInfo</code> instance providing information
3897 * about the specified directory.
3898 * @throws IOException If some I/O error occurs.
3899 * @throws LscpException If LSCP protocol corruption occurs.
3900 * @throws LSException If the specified directory is not found.
3901 */
3902 public synchronized DbDirectoryInfo
3903 getDbDirectoryInfo(String dir) throws IOException, LscpException, LSException {
3904 verifyConnection();
3905 out.writeLine("GET DB_INSTRUMENT_DIRECTORY INFO '" + dir + "'");
3906 if(getPrintOnlyMode()) return null;
3907
3908 ResultSet rs = getMultiLineResultSet();
3909 DbDirectoryInfo info = new DbDirectoryInfo(rs.getMultiLineResult());
3910 if(dir.equals("/")) {
3911 info.setName("/");
3912 } else {
3913 dir = removeEndingFileSeparator(dir);
3914 }
3915 String s = getFileName(dir);
3916 if(s != null) info.setName(toNonEscapedFileName(s));
3917 s = getParentDirectory(dir);
3918 if(s != null) info.setParentDirectoryPath(s);
3919
3920 return info;
3921 }
3922
3923 /**
3924 * Gets the list of directories in the specified directory.
3925 * @param dir The absolute path name of the directory.
3926 * @return A <code>DbDirectoryInfo</code> array providing
3927 * information about all directories in the specified directory.
3928 * @throws IOException If some I/O error occurs.
3929 * @throws LscpException If LSCP protocol corruption occurs.
3930 * @throws LSException If the specified path name is invalid.
3931 */
3932 public synchronized DbDirectoryInfo[]
3933 getDbDirectories(String dir) throws IOException, LscpException, LSException {
3934 String[] dirS = getDbDirectoryNames(dir);
3935 if(!hasEndingFileSeparator(dir)) dir += "/";
3936 DbDirectoryInfo[] infoS = new DbDirectoryInfo[dirS.length];
3937 for(int i = 0; i < dirS.length; i++) {
3938 infoS[i] = getDbDirectoryInfo(dir + toEscapedFileName(dirS[i]));
3939 }
3940 return infoS;
3941 }
3942
3943 /**
3944 * Gets the list of directories in the specified directory.
3945 * @param dir The absolute path name of the directory.
3946 * @return A <code>DbDirectoryInfo</code> array providing
3947 * information about all directories in the specified directory.
3948 * @throws IOException If some I/O error occurs.
3949 * @throws LscpException If LSCP protocol corruption occurs.
3950 * @throws LSException If the specified path name is invalid.
3951 *
3952 public synchronized DbDirectoryInfo[]
3953 getDbDirectories(String dir) throws IOException, LscpException, LSException {
3954 String[] dirS = getDbDirectoryNames(dir);
3955 if(dirS.length == 0) return new DbDirectoryInfo[0];
3956
3957 if(dir.charAt(dir.length() - 1) != '/') dir += "/";
3958
3959 for(int i = 0; i < dirS.length; i++) {
3960 out.writeLine("GET DB_INSTRUMENT_DIRECTORY INFO '" + dir + dirS[i] + "'");
3961 }
3962
3963 if(getPrintOnlyMode()) return null;
3964
3965 if(dir.length() > 1) dir = dir.substring(0, dir.length() - 1);
3966 StringBuffer sb = new StringBuffer();
3967 DbDirectoryInfo[] infoS = new DbDirectoryInfo[dirS.length];
3968 for(int i = 0; i < dirS.length; i++) {
3969 try {
3970 ResultSet rs = getMultiLineResultSet();
3971 infoS[i] = new DbDirectoryInfo(rs.getMultiLineResult());
3972 infoS[i].setName(dirS[i]);
3973 infoS[i].setParentDirectoryPath(dir);
3974 } catch (SocketTimeoutException e) {
3975 getLogger().log(Level.FINE, e.getMessage(), e);
3976 sb.append(e.getMessage()).append("\n");
3977 break;
3978 } catch (Exception e) {
3979 getLogger().log(Level.FINE, e.getMessage(), e);
3980 sb.append(e.getMessage()).append("\n");
3981 }
3982 }
3983
3984 String details = sb.toString();
3985 if(details.length() > 0) {
3986 String err = LscpI18n.getLogMsg("Client.getInstrsInfoFailed!");
3987 throw new LSException(0, err, details);
3988 }
3989
3990 return infoS;
3991 }*/
3992
3993 /**
3994 * Renames the specified directory.
3995 * @param dir The absolute path name of the directory to rename.
3996 * @param name The new name for the directory.
3997 * @throws IOException If some I/O error occurs.
3998 * @throws LSException If the renaming of the directory failed.
3999 * @throws LscpException If LSCP protocol corruption occurs.
4000 */
4001 public synchronized void
4002 renameDbDirectory(String dir, String name) throws IOException, LSException, LscpException {
4003 verifyConnection();
4004 name = toEscapedString(name);
4005 out.writeLine("SET DB_INSTRUMENT_DIRECTORY NAME '" + dir + "' '" + name + "'");
4006 if(getPrintOnlyMode()) return;
4007
4008 ResultSet rs = getEmptyResultSet();
4009 }
4010
4011 /**
4012 * Moves the specified directory into the specified location.
4013 * @param dir The absolute path name of the directory to move.
4014 * @param dst The location where the directory will be moved to.
4015 * @throws IOException If some I/O error occurs.
4016 * @throws LSException If the operation failed.
4017 * @throws LscpException If LSCP protocol corruption occurs.
4018 */
4019 public synchronized void
4020 moveDbDirectory(String dir, String dst) throws IOException, LSException, LscpException {
4021 verifyConnection();
4022 out.writeLine("MOVE DB_INSTRUMENT_DIRECTORY '" + dir + "' '" + dst + "'");
4023 if(getPrintOnlyMode()) return;
4024
4025 ResultSet rs = getEmptyResultSet();
4026 }
4027
4028 /**
4029 * Moves the specified directories into the specified location.
4030 * @param dirs The absolute path names of the directories to move.
4031 * @param dst The location where the directories will be moved to.
4032 * @throws IOException If some I/O error occurs.
4033 * @throws LSException If the operation failed.
4034 * @throws LscpException If LSCP protocol corruption occurs.
4035 */
4036 public synchronized void
4037 moveDbDirectories(String dirs[], String dst) throws IOException, LSException, LscpException {
4038 verifyConnection();
4039 for(String s : dirs) {
4040 out.writeLine("MOVE DB_INSTRUMENT_DIRECTORY '" + s + "' '" + dst + "'");
4041 }
4042 if(getPrintOnlyMode()) return;
4043
4044 getEmptyResultSets(dirs.length, "Client.dirMovingFailed!");
4045 }
4046
4047 /**
4048 * Copies the specified directory into the specified location.
4049 * @param dir The absolute path name of the directory to copy.
4050 * @param dst The location where the directory will be copied to.
4051 * @throws IOException If some I/O error occurs.
4052 * @throws LSException If the operation failed.
4053 * @throws LscpException If LSCP protocol corruption occurs.
4054 */
4055 public synchronized void
4056 copyDbDirectory(String dir, String dst) throws IOException, LSException, LscpException {
4057 verifyConnection();
4058 out.writeLine("COPY DB_INSTRUMENT_DIRECTORY '" + dir + "' '" + dst + "'");
4059 if(getPrintOnlyMode()) return;
4060
4061 ResultSet rs = getEmptyResultSet();
4062 }
4063
4064 /**
4065 * Copies the specified directories into the specified location.
4066 * @param dirs The absolute path names of the directories to copy.
4067 * @param dst The location where the directories will be copied to.
4068 * @throws IOException If some I/O error occurs.
4069 * @throws LSException If the operation failed.
4070 * @throws LscpException If LSCP protocol corruption occurs.
4071 */
4072 public synchronized void
4073 copyDbDirectories(String[] dirs, String dst) throws IOException, LSException, LscpException {
4074 verifyConnection();
4075 for(String s : dirs) {
4076 out.writeLine("COPY DB_INSTRUMENT_DIRECTORY '" + s + "' '" + dst + "'");
4077 }
4078 if(getPrintOnlyMode()) return;
4079
4080 getEmptyResultSets(dirs.length, "Client.dirCopyingFailed!");
4081 }
4082
4083 /**
4084 * Changes the description of the specified directory.
4085 * @param dir The absolute path name of the directory.
4086 * @param desc The new description for the directory.
4087 * @throws IOException If some I/O error occurs.
4088 * @throws LSException If failed to change the description.
4089 * @throws LscpException If LSCP protocol corruption occurs.
4090 */
4091 public synchronized void
4092 setDbDirectoryDescription(String dir, String desc)
4093 throws IOException, LSException, LscpException {
4094
4095 verifyConnection();
4096 String s = "SET DB_INSTRUMENT_DIRECTORY DESCRIPTION '";
4097 out.writeLine(s + dir + "' '" + toEscapedString(desc) + "'");
4098 if(getPrintOnlyMode()) return;
4099
4100 ResultSet rs = getEmptyResultSet();
4101 }
4102
4103 public static enum ScanMode {
4104 RECURSIVE, NON_RECURSIVE, FLAT
4105 }
4106
4107 /**
4108 * Adds the specified instrument to the specified instruments database directory.
4109 * @param dbDir The absolute path name of the database directory in which the
4110 * specified instrument will be added.
4111 * @param filePath The absolute path name of the instrument file.
4112 * @param instrIndex The index of the instrument (in the given instrument file) to add.
4113 * @throws IOException If some I/O error occurs.
4114 * @throws LSException If the operation failed.
4115 * @throws LscpException If LSCP protocol corruption occurs.
4116 */
4117 public synchronized void
4118 addDbInstrument(String dbDir, String filePath, int instrIndex)
4119 throws IOException, LSException, LscpException {
4120
4121 addDbInstrument(dbDir, filePath, instrIndex, false);
4122 }
4123
4124 /**
4125 * Adds the specified instrument to the specified instruments database directory.
4126 * @param dbDir The absolute path name of the database directory in which the
4127 * specified instrument will be added.
4128 * @param filePath The absolute path name of the instrument file.
4129 * @param instrIndex The index of the instrument (in the given instrument file) to add.
4130 * @param background If <code>true</code>, the scan will be done
4131 * in background and this method may return before the job is finished.
4132 * @return If <code>background</code> is <code>true</code>, the ID
4133 * of the scan job.
4134 * @throws IOException If some I/O error occurs.
4135 * @throws LSException If the operation failed.
4136 * @throws LscpException If LSCP protocol corruption occurs.
4137 * @see #addInstrumentsDbListener
4138 */
4139 public synchronized int
4140 addDbInstrument(String dbDir, String filePath, int instrIndex, boolean background)
4141 throws IOException, LSException, LscpException {
4142
4143 verifyConnection();
4144 String s = "ADD DB_INSTRUMENTS";
4145 if(background) s += " NON_MODAL";
4146 s += " '" + dbDir + "' '" + filePath + "' ";
4147 out.writeLine(s + String.valueOf(instrIndex));
4148 if(getPrintOnlyMode()) return -1;
4149
4150 ResultSet rs = getEmptyResultSet();
4151 return rs.getIndex();
4152 }
4153
4154 /**
4155 * Adds the instruments in the specified file to the specified
4156 * instruments database directory.
4157 * @param dbDir The absolute path name of the database directory
4158 * in which the the supported instruments will be added.
4159 * @param filePath The absolute path name of the file to scan for instruments.
4160 * @throws IOException If some I/O error occurs.
4161 * @throws LSException If the operation failed.
4162 * @throws LscpException If LSCP protocol corruption occurs.
4163 */
4164 public synchronized void
4165 addDbInstruments(String dbDir, String filePath)
4166 throws IOException, LSException, LscpException {
4167
4168 addDbInstruments(dbDir, filePath, false);
4169 }
4170
4171 /**
4172 * Adds the instruments in the specified file to the specified
4173 * instruments database directory.
4174 * @param dbDir The absolute path name of the database directory
4175 * in which the the supported instruments will be added.
4176 * @param filePath The absolute path name of the file to scan for instruments.
4177 * @param background If <code>true</code>, the scan will be done
4178 * in background and this method may return before the job is finished.
4179 * @return If <code>background</code> is <code>true</code>, the ID
4180 * of the scan job.
4181 * @throws IOException If some I/O error occurs.
4182 * @throws LSException If the operation failed.
4183 * @throws LscpException If LSCP protocol corruption occurs.
4184 * @see #addInstrumentsDbListener
4185 */
4186 public synchronized int
4187 addDbInstruments(String dbDir, String filePath, boolean background)
4188 throws IOException, LSException, LscpException {
4189
4190 verifyConnection();
4191 String s = "ADD DB_INSTRUMENTS";
4192 if(background) s += " NON_MODAL";
4193 out.writeLine(s + " '" + dbDir + "' '" + filePath + "'");
4194 if(getPrintOnlyMode()) return -1;
4195
4196 ResultSet rs = getEmptyResultSet();
4197 return rs.getIndex();
4198 }
4199
4200 /**
4201 * Adds the instruments in the specified file system directory
4202 * to the specified instruments database directory.
4203 * @param mode Determines the scanning mode. If RECURSIVE is
4204 * specified, all supported instruments in the specified file system
4205 * direcotry will be added to the specified instruments database
4206 * directory, including the instruments in subdirectories
4207 * of the supplied directory. If NON_RECURSIVE is specified,
4208 * the instruments in the subdirectories will not be processed.
4209 * If FLAT is specified, all supported instruments in the specified
4210 * file system direcotry will be added, including the instruments in
4211 * subdirectories of the supplied directory, but the respective
4212 * subdirectory structure will not be recreated in the instruments
4213 * database and all instruments will be added directly in the
4214 * specified database directory.
4215 * @param dbDir The absolute path name of the database directory
4216 * in which the supported instruments will be added.
4217 * @param fsDir The absolute path name of the file system directory.
4218 * @throws IOException If some I/O error occurs.
4219 * @throws LSException If the operation failed.
4220 * @throws LscpException If LSCP protocol corruption occurs.
4221 */
4222 public synchronized void
4223 addDbInstruments(ScanMode mode, String dbDir, String fsDir)
4224 throws IOException, LSException, LscpException {
4225
4226 addDbInstruments(mode, dbDir, fsDir, false);
4227 }
4228
4229 /**
4230 * Adds the instruments in the specified file system directory
4231 * to the specified instruments database directory.
4232 * @param mode Determines the scanning mode. If RECURSIVE is
4233 * specified, all supported instruments in the specified file system
4234 * direcotry will be added to the specified instruments database
4235 * directory, including the instruments in subdirectories
4236 * of the supplied directory. If NON_RECURSIVE is specified,
4237 * the instruments in the subdirectories will not be processed.
4238 * If FLAT is specified, all supported instruments in the specified
4239 * file system direcotry will be added, including the instruments in
4240 * subdirectories of the supplied directory, but the respective
4241 * subdirectory structure will not be recreated in the instruments
4242 * database and all instruments will be added directly in the
4243 * specified database directory.
4244 * @param dbDir The absolute path name of the database directory
4245 * in which the supported instruments will be added.
4246 * @param fsDir The absolute path name of the file system directory.
4247 * @param background If <code>true</code>, the scan will be done
4248 * in background and this method may return before the job is finished.
4249 * @return If <code>background</code> is <code>true</code>, the ID
4250 * of the scan job.
4251 * @throws IOException If some I/O error occurs.
4252 * @throws LSException If the operation failed.
4253 * @throws LscpException If LSCP protocol corruption occurs.
4254 * @see #addInstrumentsDbListener
4255 */
4256 public synchronized int
4257 addDbInstruments(ScanMode mode, String dbDir, String fsDir, boolean background)
4258 throws IOException, LSException, LscpException {
4259
4260 verifyConnection();
4261 StringBuffer sb = new StringBuffer("ADD DB_INSTRUMENTS");
4262 if(background) sb.append(" NON_MODAL");
4263
4264 switch(mode) {
4265 case RECURSIVE:
4266 sb.append(" RECURSIVE");
4267 break;
4268 case NON_RECURSIVE:
4269 sb.append(" NON_RECURSIVE");
4270 break;
4271 case FLAT:
4272 sb.append(" FLAT");
4273 break;
4274 }
4275
4276 sb.append(" '").append(dbDir).append("' '");
4277 sb.append(fsDir).append("'");
4278 out.writeLine(sb.toString());
4279 if(getPrintOnlyMode()) return -1;
4280
4281 ResultSet rs = getEmptyResultSet();
4282 return rs.getIndex();
4283 }
4284
4285 /**
4286 * Removes the specified instrument from the instruments database.
4287 * @param instr The absolute path name of the instrument to remove.
4288 * @throws IOException If some I/O error occurs.
4289 * @throws LscpException If LSCP protocol corruption occurs.
4290 * @throws LSException If the removing of the instrument failed.
4291 */
4292 public synchronized void
4293 removeDbInstrument(String instr) throws IOException, LscpException, LSException {
4294
4295 verifyConnection();
4296 out.writeLine("REMOVE DB_INSTRUMENT '" + instr + "'");
4297 if(getPrintOnlyMode()) return;
4298
4299 ResultSet rs = getEmptyResultSet();
4300 }
4301
4302 /**
4303 * Removes the specified instruments from the instruments database.
4304 * @param instrs The absolute path names of the instruments to remove.
4305 * @throws IOException If some I/O error occurs.
4306 * @throws LscpException If LSCP protocol corruption occurs.
4307 * @throws LSException If the removing of the instruments failed.
4308 */
4309 public synchronized void
4310 removeDbInstruments(String[] instrs) throws IOException, LscpException, LSException {
4311 verifyConnection();
4312 for(String s : instrs) {
4313 out.writeLine("REMOVE DB_INSTRUMENT '" + s + "'");
4314 }
4315 if(getPrintOnlyMode()) return;
4316
4317 getEmptyResultSets(instrs.length, "Client.instrDeletionFailed!");
4318 }
4319
4320 /**
4321 * Gets the number of instruments in the specified directory.
4322 * @return The current number of instruments in the specified directory.
4323 * @param dir The absolute path name of the directory.
4324 * @throws IOException If some I/O error occurs.
4325 * @throws LscpException If LSCP protocol corruption occurs.
4326 * @throws LSException If some other error occurs.
4327 */
4328 public synchronized int
4329 getDbInstrumentCount(String dir) throws IOException, LscpException, LSException {
4330 return getDbInstrumentCount(dir, false);
4331 }
4332
4333 /**
4334 * Gets the number of instruments in the specified directory.
4335 * @return The current number of instruments in the specified directory.
4336 * @param dir The absolute path name of the directory.
4337 * @param recursive If <code>true</code>, the number of all instruments
4338 * in the specified subtree will be returned.
4339 * @throws IOException If some I/O error occurs.
4340 * @throws LscpException If LSCP protocol corruption occurs.
4341 * @throws LSException If some other error occurs.
4342 */
4343 public synchronized int
4344 getDbInstrumentCount(String dir, boolean recursive)
4345 throws IOException, LscpException, LSException {
4346
4347 verifyConnection();
4348 String s;
4349 if(recursive) s = "GET DB_INSTRUMENTS RECURSIVE '";
4350 else s = "GET DB_INSTRUMENTS '";
4351 out.writeLine(s + dir + "'");
4352 if(getPrintOnlyMode()) return -1;
4353
4354 s = getSingleLineResultSet().getResult();
4355 return parseInt(s);
4356 }
4357
4358 /**
4359 * Gets the list of instruments in the specified directory.
4360 * @param dir The absolute path name of the directory.
4361 * @return A <code>String</code> array providing the names of
4362 * all instruments in the specified directory.
4363 * @throws IOException If some I/O error occurs.
4364 * @throws LscpException If LSCP protocol corruption occurs.
4365 * @throws LSException If the specified path name is invalid.
4366 */
4367 public synchronized String[]
4368 getDbInstrumentNames(String dir) throws IOException, LscpException, LSException {
4369 verifyConnection();
4370 out.writeLine("LIST DB_INSTRUMENTS '" + dir + "'");
4371 if(getPrintOnlyMode()) return null;
4372
4373 String[] names = parseEscapedStringList(getSingleLineResultSet().getResult());
4374 for(int i = 0; i < names.length; i++) {
4375 names[i] = toNonEscapedString(names[i]);
4376 }
4377 return names;
4378 }
4379
4380 /**
4381 * Gets information about the specified instrument.
4382 * @param instr The absolute path name of the instrument.
4383 * @return A <code>DbInstrumentInfo</code> instance providing information
4384 * about the specified instrument.
4385 * @throws IOException If some I/O error occurs.
4386 * @throws LscpException If LSCP protocol corruption occurs.
4387 * @throws LSException If the specified instrument is not found.
4388 */
4389 public synchronized DbInstrumentInfo
4390 getDbInstrumentInfo(String instr) throws IOException, LscpException, LSException {
4391 verifyConnection();
4392 out.writeLine("GET DB_INSTRUMENT INFO '" + instr + "'");
4393 if(getPrintOnlyMode()) return null;
4394
4395 ResultSet rs = getMultiLineResultSet();
4396 DbInstrumentInfo info = new DbInstrumentInfo(rs.getMultiLineResult());
4397 String s = getParentDirectory(instr);
4398 if(s != null) info.setDirectoryPath(s);
4399 s = getFileName(instr);
4400 if(s != null) info.setName(toNonEscapedFileName(s));
4401
4402 return info;
4403 }
4404
4405 /**
4406 * Gets the list of instruments in the specified directory.
4407 * @param dir The absolute path name of the directory.
4408 * @return A <code>DbInstrumentInfo</code> array providing
4409 * information about all instruments in the specified directory.
4410 * @throws IOException If some I/O error occurs.
4411 * @throws LscpException If LSCP protocol corruption occurs.
4412 * @throws LSException If the specified path name is invalid.
4413 */
4414 public synchronized DbInstrumentInfo[]
4415 getDbInstruments(String dir) throws IOException, LscpException, LSException {
4416 String[] instrS = getDbInstrumentNames(dir);
4417 if(!hasEndingFileSeparator(dir)) dir += "/";
4418
4419 DbInstrumentInfo[] infoS = new DbInstrumentInfo[instrS.length];
4420 for(int i = 0; i < instrS.length; i++) {
4421 infoS[i] = getDbInstrumentInfo(dir + toEscapedFileName(instrS[i]));
4422 }
4423 return infoS;
4424 }
4425
4426 /**
4427 * Gets the list of instruments in the specified directory.
4428 * @param dir The absolute path name of the directory.
4429 * @return A <code>DbInstrumentInfo</code> array providing
4430 * information about all instruments in the specified directory.
4431 * @throws IOException If some I/O error occurs.
4432 * @throws LscpException If LSCP protocol corruption occurs.
4433 * @throws LSException If the specified path name is invalid.
4434 *
4435 public synchronized DbInstrumentInfo[]
4436 getDbInstruments(String dir) throws IOException, LscpException, LSException {
4437 String[] instrS = getDbInstrumentNames(dir);
4438 if(instrS.length == 0) return new DbInstrumentInfo[0];
4439
4440 if(dir.charAt(dir.length() - 1) != '/') dir += "/";
4441
4442 for(int i = 0; i < instrS.length; i++) {
4443 out.writeLine("GET DB_INSTRUMENT INFO '" + dir + instrS[i] + "'");
4444 }
4445
4446 if(getPrintOnlyMode()) return null;
4447
4448 if(dir.length() > 1) dir = dir.substring(0, dir.length() - 1);
4449 StringBuffer sb = new StringBuffer();
4450 DbInstrumentInfo[] infoS = new DbInstrumentInfo[instrS.length];
4451 for(int i = 0; i < instrS.length; i++) {
4452 try {
4453 ResultSet rs = getMultiLineResultSet();
4454 infoS[i] = new DbInstrumentInfo(rs.getMultiLineResult());
4455 infoS[i].setName(instrS[i]);
4456 infoS[i].setDirectoryPath(dir);
4457 } catch (SocketTimeoutException e) {
4458 getLogger().log(Level.FINE, e.getMessage(), e);
4459 sb.append(e.getMessage()).append("\n");
4460 break;
4461 } catch (Exception e) {
4462 getLogger().log(Level.FINE, e.getMessage(), e);
4463 sb.append(e.getMessage()).append("\n");
4464 }
4465 }
4466
4467 String details = sb.toString();
4468 if(details.length() > 0) {
4469 String err = LscpI18n.getLogMsg("Client.getInstrsInfoFailed!");
4470 throw new LSException(0, err, details);
4471 }
4472
4473 return infoS;
4474 }*/
4475
4476 /**
4477 * Renames the specified instrument.
4478 * @param instr The absolute path name of the instrument to rename.
4479 * @param name The new name for the instrument.
4480 * @throws IOException If some I/O error occurs.
4481 * @throws LSException If the renaming of the instrument failed.
4482 * @throws LscpException If LSCP protocol corruption occurs.
4483 */
4484 public synchronized void
4485 renameDbInstrument(String instr, String name)
4486 throws IOException, LSException, LscpException {
4487
4488 verifyConnection();
4489 name = toEscapedString(name);
4490 out.writeLine("SET DB_INSTRUMENT NAME '" + instr + "' '" + name + "'");
4491 if(getPrintOnlyMode()) return;
4492
4493 ResultSet rs = getEmptyResultSet();
4494 }
4495
4496 /**
4497 * Moves the specified instrument into the specified location.
4498 * @param instr The absolute path name of the instrument to move.
4499 * @param dst The directory where the specified instrument will be moved to.
4500 * @throws IOException If some I/O error occurs.
4501 * @throws LSException If the operation failed.
4502 * @throws LscpException If LSCP protocol corruption occurs.
4503 */
4504 public synchronized void
4505 moveDbInstrument(String instr, String dst) throws IOException, LSException, LscpException {
4506 verifyConnection();
4507 out.writeLine("MOVE DB_INSTRUMENT '" + instr + "' '" + dst + "'");
4508 if(getPrintOnlyMode()) return;
4509
4510 ResultSet rs = getEmptyResultSet();
4511 }
4512
4513 /**
4514 * Moves the specified instruments into the specified location.
4515 * @param instrs The absolute path names of the instruments to move.
4516 * @param dst The directory where the specified instruments will be moved to.
4517 * @throws IOException If some I/O error occurs.
4518 * @throws LSException If the operation failed.
4519 * @throws LscpException If LSCP protocol corruption occurs.
4520 */
4521 public synchronized void
4522 moveDbInstruments(String[] instrs, String dst) throws IOException, LSException, LscpException {
4523 verifyConnection();
4524 for(String s : instrs) {
4525 out.writeLine("MOVE DB_INSTRUMENT '" + s + "' '" + dst + "'");
4526 }
4527 if(getPrintOnlyMode()) return;
4528
4529 getEmptyResultSets(instrs.length, "Client.instrMovingFailed!");
4530 }
4531
4532 /**
4533 * Copies the specified instrument into the specified location.
4534 * @param instr The absolute path name of the instrument to copy.
4535 * @param dst The directory where the specified instrument will be copied to.
4536 * @throws IOException If some I/O error occurs.
4537 * @throws LSException If the operation failed.
4538 * @throws LscpException If LSCP protocol corruption occurs.
4539 */
4540 public synchronized void
4541 copyDbInstrument(String instr, String dst) throws IOException, LSException, LscpException {
4542 verifyConnection();
4543 out.writeLine("COPY DB_INSTRUMENT '" + instr + "' '" + dst + "'");
4544 if(getPrintOnlyMode()) return;
4545
4546 ResultSet rs = getEmptyResultSet();
4547 }
4548
4549 /**
4550 * Copies the specified instruments into the specified location.
4551 * @param instrs The absolute path name of the instruments to copy.
4552 * @param dst The directory where the specified instruments will be copied to.
4553 * @throws IOException If some I/O error occurs.
4554 * @throws LSException If the operation failed.
4555 * @throws LscpException If LSCP protocol corruption occurs.
4556 */
4557 public synchronized void
4558 copyDbInstruments(String[] instrs, String dst) throws IOException, LSException, LscpException {
4559 verifyConnection();
4560 for(String s : instrs) {
4561 out.writeLine("COPY DB_INSTRUMENT '" + s + "' '" + dst + "'");
4562 }
4563 if(getPrintOnlyMode()) return;
4564
4565 getEmptyResultSets(instrs.length, "Client.instrCopyingFailed!");
4566 }
4567
4568 /**
4569 * Changes the description of the specified instrument.
4570 * @param instr The absolute path name of the instrument.
4571 * @param desc The new description for the instrument.
4572 * @throws IOException If some I/O error occurs.
4573 * @throws LSException If failed to change the description.
4574 * @throws LscpException If LSCP protocol corruption occurs.
4575 */
4576 public synchronized void
4577 setDbInstrumentDescription(String instr, String desc)
4578 throws IOException, LSException, LscpException {
4579
4580 verifyConnection();
4581 desc = toEscapedString(desc);
4582 out.writeLine("SET DB_INSTRUMENT DESCRIPTION '" + instr + "' '" + desc + "'");
4583 if(getPrintOnlyMode()) return;
4584
4585 ResultSet rs = getEmptyResultSet();
4586 }
4587
4588 /**
4589 * Finds all directories in the specified directory
4590 * that corresponds to the specified search criterias.
4591 * @param dir The absolute path name of the directory to search.
4592 * @param query Provides the search criterias.
4593 * @return A <code>DbDirectoryInfo</code> array providing
4594 * information about all directories that are found in the specified directory.
4595 * @throws IOException If some I/O error occurs.
4596 * @throws LscpException If LSCP protocol corruption occurs.
4597 * @throws LSException If the specified path name is invalid.
4598 */
4599 public synchronized DbDirectoryInfo[]
4600 findDbDirectories(String dir, DbSearchQuery query)
4601 throws IOException, LscpException, LSException {
4602
4603 return findDbDirectories(dir, query, false);
4604 }
4605
4606 /**
4607 * Finds all directories in the specified directory
4608 * that corresponds to the specified search criterias.
4609 * @param dir The absolute path name of the directory to search.
4610 * @param query Provides the search criterias.
4611 * @param nonRecursive If <code>true</code>, the search will be non-recursive.
4612 * @return A <code>DbDirectoryInfo</code> array providing
4613 * information about all directories that are found in the specified directory.
4614 * @throws IOException If some I/O error occurs.
4615 * @throws LscpException If LSCP protocol corruption occurs.
4616 * @throws LSException If the specified path name is invalid.
4617 */
4618 public synchronized DbDirectoryInfo[]
4619 findDbDirectories(String dir, DbSearchQuery query, boolean nonRecursive)
4620 throws IOException, LscpException, LSException {
4621
4622 verifyConnection();
4623 StringBuffer sb = new StringBuffer();
4624 sb.append("FIND DB_INSTRUMENT_DIRECTORIES");
4625 if(nonRecursive) sb.append(" NON_RECURSIVE");
4626 sb.append(" '").append(dir).append("'");
4627
4628 if(query.name != null && query.name.length() > 0) {
4629 sb.append(" NAME='").append(toEscapedString(query.name)).append("'");
4630 }
4631
4632 String s = query.getCreatedAfter();
4633 String s2 = query.getCreatedBefore();
4634 if(s != null || s2 != null) {
4635 sb.append(" CREATED='");
4636 if(s != null) sb.append(s);
4637 sb.append("..");
4638 if(s2 != null) sb.append(s2);
4639 sb.append("'");
4640 }
4641
4642 s = query.getModifiedAfter();
4643 s2 = query.getModifiedBefore();
4644 if(s != null || s2 != null) {
4645 sb.append(" MODIFIED='");
4646 if(s != null) sb.append(s);
4647 sb.append("..");
4648 if(s2 != null) sb.append(s2);
4649 sb.append("'");
4650 }
4651
4652 if(query.description != null && query.description.length() > 0) {
4653 sb.append(" DESCRIPTION='");
4654 sb.append(toEscapedString(query.description)).append("'");
4655 }
4656
4657 out.writeLine(sb.toString());
4658 if(getPrintOnlyMode()) return null;
4659
4660 String[] dirS = parseEscapedStringList(getSingleLineResultSet().getResult());
4661
4662 DbDirectoryInfo[] infoS = new DbDirectoryInfo[dirS.length];
4663 for(int i = 0; i < dirS.length; i++) {
4664 infoS[i] = getDbDirectoryInfo(dirS[i]);
4665 }
4666 return infoS;
4667 }
4668
4669 /**
4670 * Finds all instruments in the specified directory
4671 * that corresponds to the specified search criterias.
4672 * @param dir The absolute path name of the directory to search.
4673 * @param query Provides the search criterias.
4674 * @return A <code>DbInstrumentInfo</code> array providing
4675 * information about all instruments that are found in the specified directory.
4676 * @throws IOException If some I/O error occurs.
4677 * @throws LscpException If LSCP protocol corruption occurs.
4678 * @throws LSException If the specified path name is invalid.
4679 */
4680 public synchronized DbInstrumentInfo[]
4681 findDbInstruments(String dir, DbSearchQuery query)
4682 throws IOException, LscpException, LSException {
4683
4684 return findDbInstruments(dir, query, false);
4685 }
4686
4687 /**
4688 * Finds all instruments in the specified directory
4689 * that corresponds to the specified search criterias.
4690 * @param dir The absolute path name of the directory to search.
4691 * @param query Provides the search criterias.
4692 * @param nonRecursive If <code>true</code>, the search will be non-recursive.
4693 * @return A <code>DbInstrumentInfo</code> array providing
4694 * information about all instruments that are found in the specified directory.
4695 * @throws IOException If some I/O error occurs.
4696 * @throws LscpException If LSCP protocol corruption occurs.
4697 * @throws LSException If the specified path name is invalid.
4698 */
4699 public synchronized DbInstrumentInfo[]
4700 findDbInstruments(String dir, DbSearchQuery query, boolean nonRecursive)
4701 throws IOException, LscpException, LSException {
4702
4703 verifyConnection();
4704 StringBuffer sb = new StringBuffer();
4705 sb.append("FIND DB_INSTRUMENTS");
4706 if(nonRecursive) sb.append(" NON_RECURSIVE");
4707 sb.append(" '").append(dir).append("'");
4708
4709 if(query.name != null && query.name.length() > 0) {
4710 sb.append(" NAME='").append(toEscapedString(query.name)).append("'");
4711 }
4712
4713 if(query.formatFamilies.size() > 0) {
4714 sb.append(" FORMAT_FAMILIES='").append(query.formatFamilies.get(0));
4715 for(int i = 1; i < query.formatFamilies.size(); i++) {
4716 sb.append(',').append(query.formatFamilies.get(i));
4717 }
4718 sb.append("'");
4719 }
4720
4721 if(query.minSize != -1 || query.maxSize != -1) {
4722 sb.append(" SIZE='");
4723 if(query.minSize != -1) sb.append(query.minSize);
4724 sb.append("..");
4725 if(query.maxSize != -1) sb.append(query.maxSize);
4726 sb.append("'");
4727 }
4728
4729 String s = query.getCreatedAfter();
4730 String s2 = query.getCreatedBefore();
4731 if(s != null || s2 != null) {
4732 sb.append(" CREATED='");
4733 if(s != null) sb.append(s);
4734 sb.append("..");
4735 if(s2 != null) sb.append(s2);
4736 sb.append("'");
4737 }
4738
4739 s = query.getModifiedAfter();
4740 s2 = query.getModifiedBefore();
4741 if(s != null || s2 != null) {
4742 sb.append(" MODIFIED='");
4743 if(s != null) sb.append(s);
4744 sb.append("..");
4745 if(s2 != null) sb.append(s2);
4746 sb.append("'");
4747 }
4748
4749 if(query.description != null && query.description.length() > 0) {
4750 sb.append(" DESCRIPTION='");
4751 sb.append(toEscapedString(query.description)).append("'");
4752 }
4753
4754 if(query.instrumentType != DbSearchQuery.InstrumentType.BOTH) {
4755 sb.append(" IS_DRUM=");
4756 if(query.instrumentType == DbSearchQuery.InstrumentType.DRUM) {
4757 sb.append("'true'");
4758 } else {
4759 sb.append("'false'");
4760 }
4761 }
4762
4763 if(query.product != null && query.product.length() > 0) {
4764 sb.append(" PRODUCT='").append(toEscapedString(query.product)).append("'");
4765 }
4766
4767 if(query.artists != null && query.artists.length() > 0) {
4768 sb.append(" ARTISTS='").append(toEscapedString(query.artists)).append("'");
4769 }
4770
4771 if(query.keywords != null && query.keywords.length() > 0) {
4772 sb.append(" KEYWORDS='");
4773 sb.append(toEscapedString(query.keywords)).append("'");
4774 }
4775
4776 out.writeLine(sb.toString());
4777 if(getPrintOnlyMode()) return null;
4778
4779 String[] instrS = parseEscapedStringList(getSingleLineResultSet().getResult());
4780
4781 DbInstrumentInfo[] infoS = new DbInstrumentInfo[instrS.length];
4782 for(int i = 0; i < instrS.length; i++) {
4783 infoS[i] = getDbInstrumentInfo(instrS[i]);
4784 }
4785 return infoS;
4786 }
4787
4788 /**
4789 * Gets status information about the specified job.
4790 * @param jobId The ID of the job.
4791 * @return A <code>ScanJobInfo</code> instance providing information
4792 * about the specified job.
4793 * @throws IOException If some I/O error occurs.
4794 * @throws LscpException If LSCP protocol corruption occurs.
4795 * @throws LSException If the specified job is not found.
4796 */
4797 public synchronized ScanJobInfo
4798 getDbInstrumentsJobInfo(int jobId) throws IOException, LscpException, LSException {
4799 verifyConnection();
4800 out.writeLine("GET DB_INSTRUMENTS_JOB INFO " + String.valueOf(jobId));
4801 if(getPrintOnlyMode()) return null;
4802
4803 ResultSet rs = getMultiLineResultSet();
4804 ScanJobInfo info = new ScanJobInfo(rs.getMultiLineResult());
4805
4806 return info;
4807 }
4808
4809 /**
4810 * Removes all instruments and directories and re-creates
4811 * the instruments database structure.
4812 * @throws IOException If some I/O error occurs.
4813 * @throws LscpException If LSCP protocol corruption occurs.
4814 * @throws LSException If the formatting of the instruments database failed.
4815 */
4816 public synchronized void
4817 formatInstrumentsDb() throws IOException, LscpException, LSException {
4818 verifyConnection();
4819 out.writeLine("FORMAT INSTRUMENTS_DB");
4820 if(getPrintOnlyMode()) return;
4821
4822 ResultSet rs = getEmptyResultSet();
4823 }
4824
4825 /**
4826 * Resets the specified sampler channel.
4827 *
4828 * @param samplerChn The sampler channel number.
4829 *
4830 * @throws IOException If some I/O error occurs.
4831 * @throws LscpException If LSCP protocol corruption occurs.
4832 * @throws LSException If <code>samplerChn</code> is not a valid channel number or if
4833 * there is no engine assigned yet to the specified sampler channel.
4834 * @see #getSamplerChannels
4835 */
4836 public synchronized void
4837 resetChannel(int samplerChn) throws IOException, LscpException, LSException {
4838 verifyConnection();
4839 out.writeLine("RESET CHANNEL " + samplerChn);
4840 if(getPrintOnlyMode()) return;
4841
4842 ResultSet rs = getEmptyResultSet();
4843 }
4844
4845 /**
4846 * Resets the whole sampler.
4847 *
4848 * @throws IOException If some I/O error occurs.
4849 * @throws LscpException If LSCP protocol corruption occurs.
4850 */
4851 public synchronized void
4852 resetSampler() throws IOException, LscpException {
4853 verifyConnection();
4854 out.writeLine("RESET");
4855 if(getPrintOnlyMode()) return;
4856
4857 try { ResultSet rs = getEmptyResultSet(); }
4858 catch(LSException x) { getLogger().warning(x.getMessage()); }
4859 }
4860
4861 /**
4862 * Gets the current number of all active voices.
4863 * @return The current number of all active voices.
4864 * @throws IOException If some I/O error occurs.
4865 * @throws LscpException If LSCP protocol corruption occurs.
4866 * @throws LSException If some other error occurs.
4867 */
4868 public synchronized int
4869 getTotalVoiceCount() throws IOException, LscpException, LSException {
4870 verifyConnection();
4871 out.writeLine("GET TOTAL_VOICE_COUNT");
4872 if(getPrintOnlyMode()) return -1;
4873
4874 String s = getSingleLineResultSet().getResult();
4875 return parseInt(s);
4876 }
4877
4878 /**
4879 * Gets the maximum number of active voices.
4880 * @return The maximum number of active voices.
4881 * @throws IOException If some I/O error occurs.
4882 * @throws LscpException If LSCP protocol corruption occurs.
4883 * @throws LSException If some other error occurs.
4884 */
4885 public synchronized int
4886 getTotalVoiceCountMax() throws IOException, LscpException, LSException {
4887 verifyConnection();
4888 out.writeLine("GET TOTAL_VOICE_COUNT_MAX");
4889 if(getPrintOnlyMode()) return -1;
4890
4891 String s = getSingleLineResultSet().getResult();
4892 return parseInt(s);
4893 }
4894
4895 /**
4896 * Gets information about the LinuxSampler instance.
4897 *
4898 * @return <code>ServerInfo</code> instance containing
4899 * information about the LinuxSampler instance.
4900 *
4901 * @throws IOException If an I/O error occurs.
4902 * @throws LscpException If LSCP protocol corruption occurs.
4903 * @throws LSException If some other error occurs.
4904 */
4905 public synchronized ServerInfo
4906 getServerInfo() throws IOException, LscpException, LSException {
4907 verifyConnection();
4908 out.writeLine("GET SERVER INFO");
4909 if(getPrintOnlyMode()) return null;
4910
4911 ResultSet rs = getMultiLineResultSet();
4912 return new ServerInfo(rs.getMultiLineResult());
4913 }
4914
4915 /**
4916 * Gets the golobal volume of the sampler.
4917 * @return The golobal volume of the sampler.
4918 * @throws IOException If some I/O error occurs.
4919 * @throws LscpException If LSCP protocol corruption occurs.
4920 * @throws LSException If some other error occurs.
4921 */
4922 public synchronized float
4923 getVolume() throws IOException, LscpException, LSException {
4924 verifyConnection();
4925 out.writeLine("GET VOLUME");
4926 if(getPrintOnlyMode()) return -1;
4927
4928 String s = getSingleLineResultSet().getResult();
4929 return parseFloat(s);
4930 }
4931
4932 /**
4933 * Sets the global volume of the sampler.
4934 * @param volume The new volume value.
4935 * @throws IOException If some I/O error occurs.
4936 * @throws LscpException If LSCP protocol corruption occurs.
4937 * @throws LSException If some other error occurs.
4938 * @see #getVolume
4939 */
4940 public synchronized void
4941 setVolume(float volume) throws IOException, LscpException, LSException {
4942
4943 verifyConnection();
4944 out.writeLine("SET VOLUME " + volume);
4945 if(getPrintOnlyMode()) return;
4946
4947 ResultSet rs = getEmptyResultSet();
4948 }
4949
4950 private void
4951 getEmptyResultSets(int count, String err) throws LSException {
4952 StringBuffer sb = new StringBuffer();
4953 for(int i = 0; i < count; i++) {
4954 try { getEmptyResultSet(); }
4955 catch (SocketTimeoutException e) {
4956 getLogger().log(Level.FINE, e.getMessage(), e);
4957 sb.append(e.getMessage()).append("\n");
4958 break;
4959 } catch (Exception e) {
4960 getLogger().log(Level.FINE, e.getMessage(), e);
4961 sb.append(e.getMessage()).append("\n");
4962 }
4963 }
4964
4965 String details = sb.toString();
4966 if(details.length() > 0) {
4967 String s = LscpI18n.getLogMsg(err);
4968 throw new LSException(0, s, details);
4969 }
4970 }
4971
4972 /**
4973 * Returns the logger for this library.
4974 * @return The logger for this library.
4975 */
4976 protected static Logger
4977 getLogger() { return Logger.getLogger("org.linuxsampler.lscp"); }
4978 }

  ViewVC Help
Powered by ViewVC