/[svn]/liblscp/trunk/src/client.c
ViewVC logotype

Annotation of /liblscp/trunk/src/client.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1020 - (hide annotations) (download)
Thu Jan 11 15:25:04 2007 UTC (15 years, 7 months ago) by capela
File MIME type: text/plain
File size: 77362 byte(s)
* Audio routing representation changed to integer array.

1 capela 107 // client.c
2     //
3     /****************************************************************************
4     liblscp - LinuxSampler Control Protocol API
5 capela 1019 Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
6 capela 107
7     This library is free software; you can redistribute it and/or
8     modify it under the terms of the GNU Lesser General Public
9     License as published by the Free Software Foundation; either
10     version 2.1 of the License, or (at your option) any later version.
11    
12     This library 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 GNU
15     Lesser General Public License for more details.
16    
17 capela 921 You should have received a copy of the GNU General Public License along
18     with this program; if not, write to the Free Software Foundation, Inc.,
19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 capela 107
21     *****************************************************************************/
22    
23     #include "common.h"
24    
25     // Default timeout value (in milliseconds).
26     #define LSCP_TIMEOUT_MSECS 500
27    
28    
29     // Local prototypes.
30    
31 capela 144 static void _lscp_client_evt_proc (void *pvClient);
32 capela 107
33 capela 144 static lscp_status_t _lscp_client_evt_connect (lscp_client_t *pClient);
34     static lscp_status_t _lscp_client_evt_request (lscp_client_t *pClient, int iSubscribe, lscp_event_t event);
35 capela 107
36 capela 144
37 capela 107 //-------------------------------------------------------------------------
38 capela 132 // Event service (datagram oriented).
39 capela 107
40 capela 132 static void _lscp_client_evt_proc ( void *pvClient )
41 capela 107 {
42 capela 952 lscp_client_t *pClient = (lscp_client_t *) pvClient;
43 capela 562
44 capela 952 fd_set fds; // File descriptor list for select().
45     int fd, fdmax; // Maximum file descriptor number.
46     struct timeval tv; // For specifying a timeout value.
47     int iSelect; // Holds select return status.
48     int iTimeout;
49 capela 562
50 capela 952 char achBuffer[LSCP_BUFSIZ];
51     int cchBuffer;
52     const char *pszSeps = ":\r\n";
53     char * pszToken;
54     char * pch;
55     int cchToken;
56     lscp_event_t event;
57 capela 107
58     #ifdef DEBUG
59 capela 952 fprintf(stderr, "_lscp_client_evt_proc: Client waiting for events.\n");
60 capela 107 #endif
61    
62 capela 952 while (pClient->evt.iState) {
63 capela 177
64 capela 952 // Prepare for waiting on select...
65     fd = (int) pClient->evt.sock;
66     FD_ZERO(&fds);
67     FD_SET((unsigned int) fd, &fds);
68     fdmax = fd;
69 capela 177
70 capela 952 // Use the timeout (x10) select feature ...
71     iTimeout = 10 * pClient->iTimeout;
72     if (iTimeout >= 1000) {
73     tv.tv_sec = iTimeout / 1000;
74     iTimeout -= tv.tv_sec * 1000;
75     }
76     else tv.tv_sec = 0;
77     tv.tv_usec = iTimeout * 1000;
78 capela 177
79 capela 952 // Wait for event...
80     iSelect = select(fdmax + 1, &fds, NULL, NULL, &tv);
81     if (iSelect > 0 && FD_ISSET(fd, &fds)) {
82     // May recv now...
83     cchBuffer = recv(pClient->evt.sock, achBuffer, sizeof(achBuffer), 0);
84     if (cchBuffer > 0) {
85     // Make sure received buffer it's null terminated.
86     achBuffer[cchBuffer] = (char) 0;
87     // Parse for the notification event message...
88     pszToken = lscp_strtok(achBuffer, pszSeps, &(pch)); // Have "NOTIFY".
89     if (strcasecmp(pszToken, "NOTIFY") == 0) {
90     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
91     event = lscp_event_from_text(pszToken);
92     // And pick the rest of data...
93     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
94     cchToken = (pszToken == NULL ? 0 : strlen(pszToken));
95     // Double-check if we're really up to it...
96     if (pClient->events & event) {
97     // Invoke the client event callback...
98     if ((*pClient->pfnCallback)(
99     pClient,
100     event,
101     pszToken,
102     cchToken,
103     pClient->pvData) != LSCP_OK) {
104     pClient->evt.iState = 0;
105     }
106     }
107     }
108     } else {
109     lscp_socket_perror("_lscp_client_evt_proc: recv");
110     pClient->evt.iState = 0;
111     }
112     } // Check if select has in error.
113     else if (iSelect < 0) {
114     lscp_socket_perror("_lscp_client_evt_proc: select");
115     pClient->evt.iState = 0;
116     }
117 capela 562
118 capela 952 // Finally, always signal the event.
119     lscp_cond_signal(pClient->cond);
120     }
121 capela 107
122     #ifdef DEBUG
123 capela 952 fprintf(stderr, "_lscp_client_evt_proc: Client closing.\n");
124 capela 107 #endif
125     }
126    
127    
128     //-------------------------------------------------------------------------
129 capela 144 // Event subscription helpers.
130    
131     // Open the event service socket connection.
132     static lscp_status_t _lscp_client_evt_connect ( lscp_client_t *pClient )
133     {
134 capela 952 lscp_socket_t sock;
135     struct sockaddr_in addr;
136     int cAddr;
137 capela 144 #if defined(WIN32)
138 capela 952 int iSockOpt = (-1);
139 capela 144 #endif
140    
141 capela 952 // Prepare the event connection socket...
142     sock = socket(AF_INET, SOCK_STREAM, 0);
143     if (sock == INVALID_SOCKET) {
144     lscp_socket_perror("_lscp_client_evt_connect: socket");
145     return LSCP_FAILED;
146     }
147 capela 144
148     #if defined(WIN32)
149 capela 952 if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
150     lscp_socket_perror("lscp_client_evt_connect: setsockopt(SO_DONTLINGER)");
151 capela 144 #endif
152    
153     #ifdef DEBUG
154 capela 952 lscp_socket_getopts("_lscp_client_evt_connect:", sock);
155 capela 144 #endif
156    
157 capela 952 // Use same address of the command connection.
158     cAddr = sizeof(struct sockaddr_in);
159     memmove((char *) &addr, &(pClient->cmd.addr), cAddr);
160 capela 144
161 capela 952 // Start the connection...
162     if (connect(sock, (struct sockaddr *) &addr, cAddr) == SOCKET_ERROR) {
163     lscp_socket_perror("_lscp_client_evt_connect: connect");
164     closesocket(sock);
165     return LSCP_FAILED;
166     }
167 capela 562
168 capela 952 // Set our socket agent struct...
169     lscp_socket_agent_init(&(pClient->evt), sock, &addr, cAddr);
170 capela 562
171 capela 952 // And finally the service thread...
172     return lscp_socket_agent_start(&(pClient->evt), _lscp_client_evt_proc, pClient, 0);
173 capela 144 }
174    
175    
176     // Subscribe to a single event.
177     static lscp_status_t _lscp_client_evt_request ( lscp_client_t *pClient, int iSubscribe, lscp_event_t event )
178     {
179 capela 952 const char *pszEvent;
180     char szQuery[LSCP_BUFSIZ];
181     int cchQuery;
182 capela 144
183 capela 952 if (pClient == NULL)
184     return LSCP_FAILED;
185 capela 144
186 capela 952 // Which (single) event?
187     pszEvent = lscp_event_to_text(event);
188     if (pszEvent == NULL)
189     return LSCP_FAILED;
190 capela 146
191 capela 952 // Build the query string...
192     cchQuery = sprintf(szQuery, "%sSUBSCRIBE %s\n\n", (iSubscribe == 0 ? "UN" : ""), pszEvent);
193     // Just send data, forget result...
194     if (send(pClient->evt.sock, szQuery, cchQuery, 0) < cchQuery) {
195     lscp_socket_perror("_lscp_client_evt_request: send");
196     return LSCP_FAILED;
197     }
198 capela 144
199 capela 952 // Wait on response.
200     lscp_cond_wait(pClient->cond, pClient->mutex);
201 capela 562
202 capela 952 // Update as naively as we can...
203     if (iSubscribe)
204     pClient->events |= event;
205     else
206     pClient->events &= ~event;
207 capela 144
208 capela 952 return LSCP_OK;
209 capela 144 }
210    
211    
212     //-------------------------------------------------------------------------
213 capela 107 // Client versioning teller fuunction.
214    
215    
216     /** Retrieve the current client library version string. */
217     const char* lscp_client_package (void) { return LSCP_PACKAGE; }
218    
219     /** Retrieve the current client library version string. */
220     const char* lscp_client_version (void) { return LSCP_VERSION; }
221    
222     /** Retrieve the current client library build timestamp string. */
223     const char* lscp_client_build (void) { return __DATE__ " " __TIME__; }
224    
225    
226     //-------------------------------------------------------------------------
227     // Client socket functions.
228    
229     /**
230     * Create a client instance, estabilishing a connection to a server hostname,
231     * which must be listening on the given port. A client callback function is
232     * also supplied for server notification event handling.
233     *
234     * @param pszHost Hostname of the linuxsampler listening server.
235     * @param iPort Port number of the linuxsampler listening server.
236     * @param pfnCallback Callback function to receive event notifications.
237     * @param pvData User context opaque data, that will be passed
238     * to the callback function.
239     *
240     * @returns The new client instance pointer if successfull, which shall be
241     * used on all subsequent client calls, NULL otherwise.
242     */
243     lscp_client_t* lscp_client_create ( const char *pszHost, int iPort, lscp_client_proc_t pfnCallback, void *pvData )
244     {
245 capela 952 lscp_client_t *pClient;
246     struct hostent *pHost;
247     lscp_socket_t sock;
248     struct sockaddr_in addr;
249     int cAddr;
250 capela 144 #if defined(WIN32)
251 capela 952 int iSockOpt = (-1);
252 capela 144 #endif
253 capela 107
254 capela 952 if (pfnCallback == NULL) {
255     fprintf(stderr, "lscp_client_create: Invalid client callback function.\n");
256     return NULL;
257     }
258 capela 107
259 capela 952 pHost = gethostbyname(pszHost);
260     if (pHost == NULL) {
261     lscp_socket_herror("lscp_client_create: gethostbyname");
262     return NULL;
263     }
264 capela 107
265 capela 952 // Allocate client descriptor...
266 capela 107
267 capela 952 pClient = (lscp_client_t *) malloc(sizeof(lscp_client_t));
268     if (pClient == NULL) {
269     fprintf(stderr, "lscp_client_create: Out of memory.\n");
270     return NULL;
271     }
272     memset(pClient, 0, sizeof(lscp_client_t));
273 capela 107
274 capela 952 pClient->pfnCallback = pfnCallback;
275     pClient->pvData = pvData;
276 capela 107
277     #ifdef DEBUG
278 capela 952 fprintf(stderr, "lscp_client_create: pClient=%p: pszHost=%s iPort=%d.\n", pClient, pszHost, iPort);
279 capela 107 #endif
280    
281 capela 952 // Prepare the command connection socket...
282 capela 107
283 capela 952 sock = socket(AF_INET, SOCK_STREAM, 0);
284     if (sock == INVALID_SOCKET) {
285     lscp_socket_perror("lscp_client_create: cmd: socket");
286     free(pClient);
287     return NULL;
288     }
289 capela 107
290     #if defined(WIN32)
291 capela 952 if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
292     lscp_socket_perror("lscp_client_create: cmd: setsockopt(SO_DONTLINGER)");
293 capela 107 #endif
294    
295     #ifdef DEBUG
296 capela 952 lscp_socket_getopts("lscp_client_create: cmd", sock);
297 capela 107 #endif
298    
299 capela 952 cAddr = sizeof(struct sockaddr_in);
300     memset((char *) &addr, 0, cAddr);
301     addr.sin_family = pHost->h_addrtype;
302     memmove((char *) &(addr.sin_addr), pHost->h_addr, pHost->h_length);
303     addr.sin_port = htons((short) iPort);
304 capela 107
305 capela 952 if (connect(sock, (struct sockaddr *) &addr, cAddr) == SOCKET_ERROR) {
306     lscp_socket_perror("lscp_client_create: cmd: connect");
307     closesocket(sock);
308     free(pClient);
309     return NULL;
310     }
311 capela 107
312 capela 952 // Initialize the command socket agent struct...
313     lscp_socket_agent_init(&(pClient->cmd), sock, &addr, cAddr);
314 capela 107
315     #ifdef DEBUG
316 capela 952 fprintf(stderr, "lscp_client_create: cmd: pClient=%p: sock=%d addr=%s port=%d.\n", pClient, pClient->cmd.sock, inet_ntoa(pClient->cmd.addr.sin_addr), ntohs(pClient->cmd.addr.sin_port));
317 capela 107 #endif
318    
319 capela 952 // Initialize the event service socket struct...
320     lscp_socket_agent_init(&(pClient->evt), INVALID_SOCKET, NULL, 0);
321     // No events subscribed, yet.
322     pClient->events = LSCP_EVENT_NONE;
323     // Initialize cached members.
324     pClient->audio_drivers = NULL;
325     pClient->midi_drivers = NULL;
326     pClient->audio_devices = NULL;
327     pClient->midi_devices = NULL;
328     pClient->engines = NULL;
329     pClient->channels = NULL;
330 capela 1019 pClient->fxsends = NULL;
331 capela 952 pClient->midi_instruments = NULL;
332 capela 975 pClient->midi_maps = NULL;
333     pClient->midi_map_name = NULL;
334 capela 952 lscp_driver_info_init(&(pClient->audio_driver_info));
335     lscp_driver_info_init(&(pClient->midi_driver_info));
336     lscp_device_info_init(&(pClient->audio_device_info));
337     lscp_device_info_init(&(pClient->midi_device_info));
338     lscp_param_info_init(&(pClient->audio_param_info));
339     lscp_param_info_init(&(pClient->midi_param_info));
340     lscp_device_port_info_init(&(pClient->audio_channel_info));
341     lscp_device_port_info_init(&(pClient->midi_port_info));
342     lscp_param_info_init(&(pClient->audio_channel_param_info));
343     lscp_param_info_init(&(pClient->midi_port_param_info));
344     lscp_server_info_init(&(pClient->server_info));
345     lscp_engine_info_init(&(pClient->engine_info));
346     lscp_channel_info_init(&(pClient->channel_info));
347 capela 1019 lscp_fxsend_info_init(&(pClient->fxsend_info));
348 capela 952 lscp_midi_instrument_info_init(&(pClient->midi_instrument_info));
349     // Initialize error stuff.
350     pClient->pszResult = NULL;
351     pClient->iErrno = -1;
352     // Stream usage stuff.
353     pClient->buffer_fill = NULL;
354     pClient->iStreamCount = 0;
355     // Default timeout value.
356     pClient->iTimeout = LSCP_TIMEOUT_MSECS;
357 capela 626 pClient->iTimeoutCount = 0;
358 capela 107
359 capela 952 // Initialize the transaction mutex.
360     lscp_mutex_init(pClient->mutex);
361     lscp_cond_init(pClient->cond);
362 capela 107
363 capela 952 // Finally we've some success...
364     return pClient;
365 capela 107 }
366    
367    
368     /**
369     * Wait for a client instance to terminate graciously.
370     *
371     * @param pClient Pointer to client instance structure.
372     */
373     lscp_status_t lscp_client_join ( lscp_client_t *pClient )
374     {
375 capela 952 if (pClient == NULL)
376     return LSCP_FAILED;
377 capela 107
378     #ifdef DEBUG
379 capela 952 fprintf(stderr, "lscp_client_join: pClient=%p.\n", pClient);
380 capela 107 #endif
381    
382 capela 132 // lscp_socket_agent_join(&(pClient->evt));
383 capela 952 lscp_socket_agent_join(&(pClient->cmd));
384 capela 107
385 capela 952 return LSCP_OK;
386 capela 107 }
387    
388    
389     /**
390     * Terminate and destroy a client instance.
391     *
392     * @param pClient Pointer to client instance structure.
393     *
394     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
395     */
396     lscp_status_t lscp_client_destroy ( lscp_client_t *pClient )
397     {
398 capela 952 if (pClient == NULL)
399     return LSCP_FAILED;
400 capela 107
401     #ifdef DEBUG
402 capela 952 fprintf(stderr, "lscp_client_destroy: pClient=%p.\n", pClient);
403 capela 107 #endif
404    
405 capela 952 // Lock this section up.
406     lscp_mutex_lock(pClient->mutex);
407 capela 562
408 capela 952 // Free up all cached members.
409     lscp_midi_instrument_info_free(&(pClient->midi_instrument_info));
410 capela 1019 lscp_fxsend_info_free(&(pClient->fxsend_info));
411 capela 952 lscp_channel_info_free(&(pClient->channel_info));
412     lscp_engine_info_free(&(pClient->engine_info));
413     lscp_server_info_free(&(pClient->server_info));
414     lscp_param_info_free(&(pClient->midi_port_param_info));
415     lscp_param_info_free(&(pClient->audio_channel_param_info));
416     lscp_device_port_info_free(&(pClient->midi_port_info));
417     lscp_device_port_info_free(&(pClient->audio_channel_info));
418     lscp_param_info_free(&(pClient->midi_param_info));
419     lscp_param_info_free(&(pClient->audio_param_info));
420     lscp_device_info_free(&(pClient->midi_device_info));
421     lscp_device_info_free(&(pClient->audio_device_info));
422     lscp_driver_info_free(&(pClient->midi_driver_info));
423     lscp_driver_info_free(&(pClient->audio_driver_info));
424     // Free available engine table.
425     lscp_szsplit_destroy(pClient->audio_drivers);
426     lscp_szsplit_destroy(pClient->midi_drivers);
427     lscp_isplit_destroy(pClient->audio_devices);
428     lscp_isplit_destroy(pClient->midi_devices);
429     lscp_szsplit_destroy(pClient->engines);
430     lscp_isplit_destroy(pClient->channels);
431 capela 1019 lscp_isplit_destroy(pClient->fxsends);
432 capela 952 lscp_midi_instruments_destroy(pClient->midi_instruments);
433 capela 975 lscp_isplit_destroy(pClient->midi_maps);
434     if (pClient->midi_map_name)
435     free(pClient->midi_map_name);
436 capela 952 // Make them null.
437     pClient->audio_drivers = NULL;
438     pClient->midi_drivers = NULL;
439     pClient->audio_devices = NULL;
440     pClient->midi_devices = NULL;
441     pClient->engines = NULL;
442     pClient->channels = NULL;
443 capela 1019 pClient->fxsends = NULL;
444 capela 952 pClient->midi_instruments = NULL;
445 capela 975 pClient->midi_maps = NULL;
446     pClient->midi_map_name = NULL;
447 capela 952 // Free result error stuff.
448     lscp_client_set_result(pClient, NULL, 0);
449     // Free stream usage stuff.
450     if (pClient->buffer_fill)
451     free(pClient->buffer_fill);
452     pClient->buffer_fill = NULL;
453     pClient->iStreamCount = 0;
454     pClient->iTimeout = 0;
455 capela 107
456 capela 952 // Free socket agents.
457     lscp_socket_agent_free(&(pClient->evt));
458     lscp_socket_agent_free(&(pClient->cmd));
459 capela 107
460 capela 952 // Last but not least, free good ol'transaction mutex.
461     lscp_mutex_unlock(pClient->mutex);
462     lscp_mutex_destroy(pClient->mutex);
463     lscp_cond_destroy(pClient->cond);
464 capela 107
465 capela 952 free(pClient);
466 capela 107
467 capela 952 return LSCP_OK;
468 capela 107 }
469    
470    
471     /**
472     * Set the client transaction timeout interval.
473     *
474     * @param pClient Pointer to client instance structure.
475     * @param iTimeout Transaction timeout in milliseconds.
476     *
477     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
478     */
479     lscp_status_t lscp_client_set_timeout ( lscp_client_t *pClient, int iTimeout )
480     {
481 capela 952 if (pClient == NULL)
482     return LSCP_FAILED;
483     if (iTimeout < 0)
484     return LSCP_FAILED;
485 capela 107
486 capela 952 pClient->iTimeout = iTimeout;
487     return LSCP_OK;
488 capela 107 }
489    
490    
491     /**
492     * Get the client transaction timeout interval.
493     *
494     * @param pClient Pointer to client instance structure.
495     *
496     * @returns The current timeout value milliseconds, -1 in case of failure.
497     */
498     int lscp_client_get_timeout ( lscp_client_t *pClient )
499     {
500 capela 952 if (pClient == NULL)
501     return -1;
502 capela 107
503 capela 952 return pClient->iTimeout;
504 capela 107 }
505    
506    
507     //-------------------------------------------------------------------------
508     // Client common protocol functions.
509    
510     /**
511     * Submit a command query line string to the server. The query string
512     * must be cr/lf and null terminated. Besides the return code, the
513     * specific server response to the command request is made available
514     * by the @ref lscp_client_get_result and @ref lscp_client_get_errno
515     * function calls.
516     *
517     * @param pClient Pointer to client instance structure.
518     * @param pszQuery Command request line to be sent to server,
519     * must be cr/lf and null terminated.
520     *
521     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
522     */
523     lscp_status_t lscp_client_query ( lscp_client_t *pClient, const char *pszQuery )
524     {
525 capela 952 lscp_status_t ret;
526 capela 562
527 capela 975 if (pClient == NULL)
528     return LSCP_FAILED;
529    
530 capela 952 // Lock this section up.
531     lscp_mutex_lock(pClient->mutex);
532 capela 107
533 capela 952 // Just make the now guarded call.
534     ret = lscp_client_call(pClient, pszQuery, 0);
535 capela 562
536 capela 952 // Unlock this section down.
537     lscp_mutex_unlock(pClient->mutex);
538 capela 562
539 capela 952 return ret;
540 capela 107 }
541    
542     /**
543     * Get the last received result string. In case of error or warning,
544     * this is the text of the error or warning message issued.
545     *
546     * @param pClient Pointer to client instance structure.
547     *
548     * @returns A pointer to the literal null-terminated result string as
549     * of the last command request.
550     */
551     const char *lscp_client_get_result ( lscp_client_t *pClient )
552     {
553 capela 952 if (pClient == NULL)
554     return NULL;
555 capela 107
556 capela 952 return pClient->pszResult;
557 capela 107 }
558    
559    
560     /**
561     * Get the last error/warning number received.
562     *
563     * @param pClient Pointer to client instance structure.
564     *
565     * @returns The numerical value of the last error or warning
566     * response code received.
567     */
568     int lscp_client_get_errno ( lscp_client_t *pClient )
569     {
570 capela 952 if (pClient == NULL)
571     return -1;
572 capela 107
573 capela 952 return pClient->iErrno;
574 capela 107 }
575    
576    
577     //-------------------------------------------------------------------------
578     // Client registration protocol functions.
579    
580     /**
581 capela 144 * Register frontend for receiving event messages:
582 capela 994 * SUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT
583     * | BUFFER_FILL | CHANNEL_INFO | TOTAL_VOICE_COUNT
584     * | AUDIO_OUTPUT_DEVICE_COUNT | AUDIO_OUTPUT_DEVICE_INFO
585     * | MIDI_INPUT_DEVICE_COUNT | MIDI_INPUT_DEVICE_INFO
586     * | MIDI_INSTRUMENT_MAP_COUNT | MIDI_INSTRUMENT_MAP_INFO
587     * | MIDI_INSTRUMENT_COUNT | MIDI_INSTRUMENT_INFO
588     * | MISCELLANEOUS
589 capela 107 *
590     * @param pClient Pointer to client instance structure.
591 capela 144 * @param events Bit-wise OR'ed event flags to subscribe.
592 capela 107 *
593     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
594     */
595 capela 144 lscp_status_t lscp_client_subscribe ( lscp_client_t *pClient, lscp_event_t events )
596 capela 107 {
597 capela 952 lscp_status_t ret = LSCP_FAILED;
598 capela 107
599 capela 952 if (pClient == NULL)
600     return LSCP_FAILED;
601 capela 107
602 capela 952 // Lock this section up.
603     lscp_mutex_lock(pClient->mutex);
604 capela 144
605 capela 952 // If applicable, start the alternate connection...
606     if (pClient->events == LSCP_EVENT_NONE)
607     ret = _lscp_client_evt_connect(pClient);
608 capela 562
609 capela 952 // Send the subscription commands.
610     if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_COUNT))
611     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_CHANNEL_COUNT);
612     if (ret == LSCP_OK && (events & LSCP_EVENT_VOICE_COUNT))
613     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_VOICE_COUNT);
614     if (ret == LSCP_OK && (events & LSCP_EVENT_STREAM_COUNT))
615     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_STREAM_COUNT);
616     if (ret == LSCP_OK && (events & LSCP_EVENT_BUFFER_FILL))
617     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_BUFFER_FILL);
618     if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_INFO))
619     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_CHANNEL_INFO);
620 capela 994 if (ret == LSCP_OK && (events & LSCP_EVENT_TOTAL_VOICE_COUNT))
621     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_TOTAL_VOICE_COUNT);
622     if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT))
623     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT);
624     if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO))
625     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO);
626     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT))
627     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT);
628     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_INFO))
629     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO);
630     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT))
631     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT);
632     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO))
633     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO);
634     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_COUNT))
635     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_COUNT);
636     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_INFO))
637     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_INFO);
638 capela 952 if (ret == LSCP_OK && (events & LSCP_EVENT_MISCELLANEOUS))
639     ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MISCELLANEOUS);
640 capela 107
641 capela 952 // Unlock this section down.
642     lscp_mutex_unlock(pClient->mutex);
643 capela 132
644 capela 952 return ret;
645 capela 107 }
646    
647    
648     /**
649 capela 144 * Deregister frontend from receiving UDP event messages anymore:
650 capela 994 * UNSUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT
651     * | BUFFER_FILL | CHANNEL_INFO | TOTAL_VOICE_COUNT
652     * | AUDIO_OUTPUT_DEVICE_COUNT | AUDIO_OUTPUT_DEVICE_INFO
653     * | MIDI_INPUT_DEVICE_COUNT | MIDI_INPUT_DEVICE_INFO
654     * | MIDI_INSTRUMENT_MAP_COUNT | MIDI_INSTRUMENT_MAP_INFO
655     * | MIDI_INSTRUMENT_COUNT | MIDI_INSTRUMENT_INFO
656     * | MISCELLANEOUS
657 capela 107 *
658     * @param pClient Pointer to client instance structure.
659 capela 144 * @param events Bit-wise OR'ed event flags to unsubscribe.
660 capela 107 *
661     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
662     */
663 capela 144 lscp_status_t lscp_client_unsubscribe ( lscp_client_t *pClient, lscp_event_t events )
664 capela 107 {
665 capela 952 lscp_status_t ret = LSCP_OK;
666 capela 107
667 capela 952 if (pClient == NULL)
668     return LSCP_FAILED;
669 capela 107
670 capela 952 // Lock this section up.
671     lscp_mutex_lock(pClient->mutex);
672 capela 132
673 capela 952 // Send the unsubscription commands.
674     if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_COUNT))
675     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_CHANNEL_COUNT);
676     if (ret == LSCP_OK && (events & LSCP_EVENT_VOICE_COUNT))
677     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_VOICE_COUNT);
678     if (ret == LSCP_OK && (events & LSCP_EVENT_STREAM_COUNT))
679     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_STREAM_COUNT);
680     if (ret == LSCP_OK && (events & LSCP_EVENT_BUFFER_FILL))
681     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_BUFFER_FILL);
682     if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_INFO))
683     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_CHANNEL_INFO);
684 capela 994 if (ret == LSCP_OK && (events & LSCP_EVENT_TOTAL_VOICE_COUNT))
685     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_TOTAL_VOICE_COUNT);
686     if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT))
687     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT);
688     if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO))
689     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO);
690     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT))
691     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT);
692     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_INFO))
693     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO);
694     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT))
695     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT);
696     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO))
697     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO);
698     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_COUNT))
699     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_COUNT);
700     if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_INFO))
701     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_INFO);
702 capela 952 if (ret == LSCP_OK && (events & LSCP_EVENT_MISCELLANEOUS))
703     ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MISCELLANEOUS);
704 capela 107
705 capela 952 // If necessary, close the alternate connection...
706     if (pClient->events == LSCP_EVENT_NONE)
707     lscp_socket_agent_free(&(pClient->evt));
708 capela 144
709 capela 952 // Unlock this section down.
710     lscp_mutex_unlock(pClient->mutex);
711 capela 132
712 capela 952 return ret;
713 capela 107 }
714    
715    
716 capela 213 /**
717     * Getting current subscribed events.
718     *
719     * @param pClient Pointer to client instance structure.
720     *
721     * @returns The current subscrived bit-wise OR'ed event flags.
722     */
723     lscp_event_t lscp_client_get_events ( lscp_client_t *pClient )
724     {
725 capela 952 if (pClient == NULL)
726     return LSCP_EVENT_NONE;
727 capela 213
728 capela 952 return pClient->events;
729 capela 213 }
730    
731    
732 capela 107 //-------------------------------------------------------------------------
733     // Client command protocol functions.
734    
735     /**
736     * Loading an instrument:
737     * LOAD INSTRUMENT <filename> <instr-index> <sampler-channel>
738     *
739     * @param pClient Pointer to client instance structure.
740     * @param pszFileName Instrument file name.
741     * @param iInstrIndex Instrument index number.
742     * @param iSamplerChannel Sampler Channel.
743     *
744     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
745     */
746     lscp_status_t lscp_load_instrument ( lscp_client_t *pClient, const char *pszFileName, int iInstrIndex, int iSamplerChannel )
747     {
748 capela 952 char szQuery[LSCP_BUFSIZ];
749 capela 107
750 capela 952 if (pszFileName == NULL || iSamplerChannel < 0)
751     return LSCP_FAILED;
752 capela 107
753 capela 952 sprintf(szQuery, "LOAD INSTRUMENT '%s' %d %d\r\n", pszFileName, iInstrIndex, iSamplerChannel);
754     return lscp_client_query(pClient, szQuery);
755 capela 107 }
756    
757    
758     /**
759 capela 144 * Loading an instrument in the background (non modal):
760     * LOAD INSTRUMENT NON_MODAL <filename> <instr-index> <sampler-channel>
761     *
762     * @param pClient Pointer to client instance structure.
763     * @param pszFileName Instrument file name.
764     * @param iInstrIndex Instrument index number.
765     * @param iSamplerChannel Sampler Channel.
766     *
767     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
768     */
769     lscp_status_t lscp_load_instrument_non_modal ( lscp_client_t *pClient, const char *pszFileName, int iInstrIndex, int iSamplerChannel )
770     {
771 capela 952 char szQuery[LSCP_BUFSIZ];
772 capela 144
773 capela 952 if (pszFileName == NULL || iSamplerChannel < 0)
774     return LSCP_FAILED;
775 capela 144
776 capela 952 sprintf(szQuery, "LOAD INSTRUMENT NON_MODAL '%s' %d %d\r\n", pszFileName, iInstrIndex, iSamplerChannel);
777     return lscp_client_query(pClient, szQuery);
778 capela 144 }
779    
780    
781     /**
782 capela 107 * Loading a sampler engine:
783     * LOAD ENGINE <engine-name> <sampler-channel>
784     *
785     * @param pClient Pointer to client instance structure.
786     * @param pszEngineName Engine name.
787     * @param iSamplerChannel Sampler channel number.
788     *
789     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
790     */
791     lscp_status_t lscp_load_engine ( lscp_client_t *pClient, const char *pszEngineName, int iSamplerChannel )
792     {
793 capela 952 char szQuery[LSCP_BUFSIZ];
794 capela 107
795 capela 952 if (pszEngineName == NULL || iSamplerChannel < 0)
796     return LSCP_FAILED;
797 capela 107
798 capela 952 sprintf(szQuery, "LOAD ENGINE %s %d\r\n", pszEngineName, iSamplerChannel);
799     return lscp_client_query(pClient, szQuery);
800 capela 107 }
801    
802    
803     /**
804     * Current number of sampler channels:
805     * GET CHANNELS
806     *
807     * @param pClient Pointer to client instance structure.
808     *
809     * @returns The current total number of sampler channels on success,
810     * -1 otherwise.
811     */
812     int lscp_get_channels ( lscp_client_t *pClient )
813     {
814 capela 952 int iChannels = -1;
815 capela 132
816 capela 975 if (pClient == NULL)
817     return -1;
818    
819 capela 952 // Lock this section up.
820     lscp_mutex_lock(pClient->mutex);
821 capela 132
822 capela 952 if (lscp_client_call(pClient, "GET CHANNELS\r\n", 0) == LSCP_OK)
823     iChannels = atoi(lscp_client_get_result(pClient));
824 capela 132
825 capela 952 // Unlock this section doen.
826     lscp_mutex_unlock(pClient->mutex);
827 capela 132
828 capela 952 return iChannels;
829 capela 107 }
830    
831    
832     /**
833 capela 125 * List current sampler channels number identifiers:
834     * LIST CHANNELS
835     *
836     * @param pClient Pointer to client instance structure.
837     *
838     * @returns An array of the sampler channels identifiers as positive integers,
839     * terminated with -1 on success, NULL otherwise.
840     */
841     int *lscp_list_channels ( lscp_client_t *pClient )
842     {
843 capela 952 const char *pszSeps = ",";
844 capela 125
845 capela 952 if (pClient == NULL)
846     return NULL;
847 capela 562
848 capela 952 // Lock this section up.
849     lscp_mutex_lock(pClient->mutex);
850 capela 132
851 capela 952 if (pClient->channels) {
852     lscp_isplit_destroy(pClient->channels);
853     pClient->channels = NULL;
854     }
855 capela 125
856 capela 952 if (lscp_client_call(pClient, "LIST CHANNELS\r\n", 0) == LSCP_OK)
857     pClient->channels = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
858 capela 125
859 capela 952 // Unlock this section down.
860     lscp_mutex_unlock(pClient->mutex);
861 capela 132
862 capela 952 return pClient->channels;
863 capela 125 }
864    
865    
866     /**
867 capela 107 * Adding a new sampler channel:
868     * ADD CHANNEL
869     *
870     * @param pClient Pointer to client instance structure.
871     *
872     * @returns The new sampler channel number identifier,
873     * or -1 in case of failure.
874     */
875     int lscp_add_channel ( lscp_client_t *pClient )
876     {
877 capela 952 int iSamplerChannel = -1;
878 capela 132
879 capela 975 if (pClient == NULL)
880     return -1;
881    
882 capela 952 // Lock this section up.
883     lscp_mutex_lock(pClient->mutex);
884 capela 132
885 capela 952 if (lscp_client_call(pClient, "ADD CHANNEL\r\n", 0) == LSCP_OK)
886     iSamplerChannel = atoi(lscp_client_get_result(pClient));
887 capela 562
888 capela 952 // Unlock this section down.
889     lscp_mutex_unlock(pClient->mutex);
890 capela 132
891 capela 952 return iSamplerChannel;
892 capela 107 }
893    
894    
895     /**
896     * Removing a sampler channel:
897     * REMOVE CHANNEL <sampler-channel>
898     *
899     * @param pClient Pointer to client instance structure.
900     * @param iSamplerChannel Sampler channel number.
901     *
902     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
903     */
904     lscp_status_t lscp_remove_channel ( lscp_client_t *pClient, int iSamplerChannel )
905     {
906 capela 952 char szQuery[LSCP_BUFSIZ];
907 capela 107
908 capela 952 if (iSamplerChannel < 0)
909     return LSCP_FAILED;
910 capela 107
911 capela 952 sprintf(szQuery, "REMOVE CHANNEL %d\r\n", iSamplerChannel);
912     return lscp_client_query(pClient, szQuery);
913 capela 107 }
914    
915    
916     /**
917 capela 523 * Getting all available engines count:
918 capela 107 * GET AVAILABLE_ENGINES
919     *
920     * @param pClient Pointer to client instance structure.
921     *
922 capela 523 * @returns The current total number of sampler engines on success,
923     * -1 otherwise.
924     */
925     int lscp_get_available_engines ( lscp_client_t *pClient )
926     {
927 capela 952 int iAvailableEngines = -1;
928 capela 523
929 capela 975 if (pClient == NULL)
930     return -1;
931    
932 capela 952 // Lock this section up.
933     lscp_mutex_lock(pClient->mutex);
934 capela 523
935 capela 952 if (lscp_client_call(pClient, "GET AVAILABLE_ENGINES\r\n", 0) == LSCP_OK)
936     iAvailableEngines = atoi(lscp_client_get_result(pClient));
937 capela 523
938 capela 952 // Unlock this section down.
939     lscp_mutex_unlock(pClient->mutex);
940 capela 523
941 capela 952 return iAvailableEngines;
942 capela 523 }
943    
944    
945     /**
946     * Getting all available engines:
947     * LIST AVAILABLE_ENGINES
948     *
949     * @param pClient Pointer to client instance structure.
950     *
951 capela 107 * @returns A NULL terminated array of engine name strings,
952     * or NULL in case of failure.
953     */
954 capela 523 const char **lscp_list_available_engines ( lscp_client_t *pClient )
955 capela 107 {
956 capela 952 const char *pszSeps = ",";
957 capela 107
958 capela 975 if (pClient == NULL)
959     return NULL;
960    
961 capela 952 // Lock this section up.
962     lscp_mutex_lock(pClient->mutex);
963 capela 132
964 capela 952 if (pClient->engines) {
965     lscp_szsplit_destroy(pClient->engines);
966     pClient->engines = NULL;
967     }
968 capela 107
969 capela 952 if (lscp_client_call(pClient, "LIST AVAILABLE_ENGINES\r\n", 0) == LSCP_OK)
970     pClient->engines = lscp_szsplit_create(lscp_client_get_result(pClient), pszSeps);
971 capela 107
972 capela 952 // Unlock this section down.
973     lscp_mutex_unlock(pClient->mutex);
974 capela 132
975 capela 952 return (const char **) pClient->engines;
976 capela 107 }
977    
978    
979     /**
980     * Getting information about an engine.
981     * GET ENGINE INFO <engine-name>
982     *
983     * @param pClient Pointer to client instance structure.
984     * @param pszEngineName Engine name.
985     *
986     * @returns A pointer to a @ref lscp_engine_info_t structure, with all the
987     * information of the given sampler engine, or NULL in case of failure.
988     */
989     lscp_engine_info_t *lscp_get_engine_info ( lscp_client_t *pClient, const char *pszEngineName )
990     {
991 capela 952 lscp_engine_info_t *pEngineInfo;
992     char szQuery[LSCP_BUFSIZ];
993     const char *pszResult;
994     const char *pszSeps = ":";
995     const char *pszCrlf = "\r\n";
996     char *pszToken;
997     char *pch;
998 capela 107
999 capela 975 if (pClient == NULL)
1000     return NULL;
1001 capela 952 if (pszEngineName == NULL)
1002     return NULL;
1003 capela 107
1004 capela 952 // Lock this section up.
1005     lscp_mutex_lock(pClient->mutex);
1006 capela 132
1007 capela 952 pEngineInfo = &(pClient->engine_info);
1008     lscp_engine_info_reset(pEngineInfo);
1009 capela 107
1010 capela 952 sprintf(szQuery, "GET ENGINE INFO %s\r\n", pszEngineName);
1011     if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
1012     pszResult = lscp_client_get_result(pClient);
1013     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
1014     while (pszToken) {
1015     if (strcasecmp(pszToken, "DESCRIPTION") == 0) {
1016     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1017     if (pszToken)
1018     lscp_unquote_dup(&(pEngineInfo->description), &pszToken);
1019     }
1020     else if (strcasecmp(pszToken, "VERSION") == 0) {
1021     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1022     if (pszToken)
1023     lscp_unquote_dup(&(pEngineInfo->version), &pszToken);
1024     }
1025     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1026     }
1027     }
1028     else pEngineInfo = NULL;
1029 capela 562
1030 capela 952 // Unlock this section down.
1031     lscp_mutex_unlock(pClient->mutex);
1032 capela 107
1033 capela 952 return pEngineInfo;
1034 capela 107 }
1035    
1036    
1037     /**
1038     * Getting sampler channel informations:
1039     * GET CHANNEL INFO <sampler-channel>
1040     *
1041     * @param pClient Pointer to client instance structure.
1042     * @param iSamplerChannel Sampler channel number.
1043     *
1044     * @returns A pointer to a @ref lscp_channel_info_t structure, with all the
1045     * information of the given sampler channel, or NULL in case of failure.
1046     */
1047     lscp_channel_info_t *lscp_get_channel_info ( lscp_client_t *pClient, int iSamplerChannel )
1048     {
1049 capela 952 lscp_channel_info_t *pChannelInfo;
1050     char szQuery[LSCP_BUFSIZ];
1051     const char *pszResult;
1052     const char *pszSeps = ":";
1053     const char *pszCrlf = "\r\n";
1054     char *pszToken;
1055     char *pch;
1056 capela 107
1057 capela 975 if (pClient == NULL)
1058     return NULL;
1059 capela 952 if (iSamplerChannel < 0)
1060     return NULL;
1061 capela 107
1062 capela 952 // Lock this section up.
1063     lscp_mutex_lock(pClient->mutex);
1064 capela 562
1065 capela 952 pChannelInfo = &(pClient->channel_info);
1066     lscp_channel_info_reset(pChannelInfo);
1067 capela 107
1068 capela 952 sprintf(szQuery, "GET CHANNEL INFO %d\r\n", iSamplerChannel);
1069     if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
1070     pszResult = lscp_client_get_result(pClient);
1071     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
1072     while (pszToken) {
1073     if (strcasecmp(pszToken, "ENGINE_NAME") == 0) {
1074     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1075     if (pszToken)
1076     lscp_unquote_dup(&(pChannelInfo->engine_name), &pszToken);
1077     }
1078     else if (strcasecmp(pszToken, "AUDIO_OUTPUT_DEVICE") == 0) {
1079     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1080     if (pszToken)
1081     pChannelInfo->audio_device = atoi(lscp_ltrim(pszToken));
1082     }
1083     else if (strcasecmp(pszToken, "AUDIO_OUTPUT_CHANNELS") == 0) {
1084     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1085     if (pszToken)
1086     pChannelInfo->audio_channels = atoi(lscp_ltrim(pszToken));
1087     }
1088     else if (strcasecmp(pszToken, "AUDIO_OUTPUT_ROUTING") == 0) {
1089     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1090     if (pszToken) {
1091     if (pChannelInfo->audio_routing)
1092 capela 1020 lscp_isplit_destroy(pChannelInfo->audio_routing);
1093     pChannelInfo->audio_routing = lscp_isplit_create(pszToken, ",");
1094 capela 952 }
1095     }
1096     else if (strcasecmp(pszToken, "INSTRUMENT_FILE") == 0) {
1097     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1098     if (pszToken)
1099     lscp_unquote_dup(&(pChannelInfo->instrument_file), &pszToken);
1100     }
1101     else if (strcasecmp(pszToken, "INSTRUMENT_NR") == 0) {
1102     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1103     if (pszToken)
1104     pChannelInfo->instrument_nr = atoi(lscp_ltrim(pszToken));
1105     }
1106     else if (strcasecmp(pszToken, "INSTRUMENT_NAME") == 0) {
1107     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1108     if (pszToken)
1109     lscp_unquote_dup(&(pChannelInfo->instrument_name), &pszToken);
1110     }
1111     else if (strcasecmp(pszToken, "INSTRUMENT_STATUS") == 0) {
1112     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1113     if (pszToken)
1114     pChannelInfo->instrument_status = atoi(lscp_ltrim(pszToken));
1115     }
1116     else if (strcasecmp(pszToken, "MIDI_INPUT_DEVICE") == 0) {
1117     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1118     if (pszToken)
1119     pChannelInfo->midi_device = atoi(lscp_ltrim(pszToken));
1120     }
1121     else if (strcasecmp(pszToken, "MIDI_INPUT_PORT") == 0) {
1122     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1123     if (pszToken)
1124     pChannelInfo->midi_port = atoi(lscp_ltrim(pszToken));
1125     }
1126     else if (strcasecmp(pszToken, "MIDI_INPUT_CHANNEL") == 0) {
1127     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1128     if (pszToken) {
1129     pszToken = lscp_ltrim(pszToken);
1130     if (strcasecmp(pszToken, "ALL") == 0)
1131     pChannelInfo->midi_channel = LSCP_MIDI_CHANNEL_ALL;
1132     else
1133     pChannelInfo->midi_channel = atoi(pszToken);
1134     }
1135     }
1136 capela 975 else if (strcasecmp(pszToken, "MIDI_INSTRUMENT_MAP") == 0) {
1137     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1138     if (pszToken) {
1139     pszToken = lscp_ltrim(pszToken);
1140     if (strcasecmp(pszToken, "NONE") == 0)
1141     pChannelInfo->midi_map = LSCP_MIDI_MAP_NONE;
1142     else
1143     if (strcasecmp(pszToken, "DEFAULT") == 0)
1144     pChannelInfo->midi_map = LSCP_MIDI_MAP_DEFAULT;
1145     else
1146     pChannelInfo->midi_map = atoi(pszToken);
1147     }
1148     }
1149 capela 952 else if (strcasecmp(pszToken, "VOLUME") == 0) {
1150     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1151     if (pszToken)
1152     pChannelInfo->volume = (float) atof(lscp_ltrim(pszToken));
1153     }
1154     else if (strcasecmp(pszToken, "MUTE") == 0) {
1155     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1156     if (pszToken)
1157     pChannelInfo->mute = (strcasecmp(lscp_unquote(&pszToken, 0), "TRUE") == 0);
1158     }
1159     else if (strcasecmp(pszToken, "SOLO") == 0) {
1160     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1161     if (pszToken)
1162     pChannelInfo->solo = (strcasecmp(lscp_unquote(&pszToken, 0), "TRUE") == 0);
1163     }
1164     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1165     }
1166     }
1167     else pChannelInfo = NULL;
1168 capela 562
1169 capela 952 // Unlock this section up.
1170     lscp_mutex_unlock(pClient->mutex);
1171 capela 107
1172 capela 952 return pChannelInfo;
1173 capela 107 }
1174    
1175    
1176     /**
1177     * Current number of active voices:
1178     * GET CHANNEL VOICE_COUNT <sampler-channel>
1179     *
1180     * @param pClient Pointer to client instance structure.
1181     * @param iSamplerChannel Sampler channel number.
1182     *
1183     * @returns The number of voices currently active, -1 in case of failure.
1184     */
1185     int lscp_get_channel_voice_count ( lscp_client_t *pClient, int iSamplerChannel )
1186     {
1187 capela 952 char szQuery[LSCP_BUFSIZ];
1188     int iVoiceCount = -1;
1189 capela 107
1190 capela 975 if (pClient == NULL)
1191     return -1;
1192 capela 952 if (iSamplerChannel < 0)
1193 capela 975 return -1;
1194 capela 107
1195 capela 952 // Lock this section up.
1196     lscp_mutex_lock(pClient->mutex);
1197 capela 132
1198 capela 952 sprintf(szQuery, "GET CHANNEL VOICE_COUNT %d\r\n", iSamplerChannel);
1199     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
1200     iVoiceCount = atoi(lscp_client_get_result(pClient));
1201 capela 107
1202 capela 952 // Unlock this section down.
1203     lscp_mutex_unlock(pClient->mutex);
1204 capela 132
1205 capela 952 return iVoiceCount;
1206 capela 107 }
1207    
1208    
1209     /**
1210     * Current number of active disk streams:
1211     * GET CHANNEL STREAM_COUNT <sampler-channel>
1212     *
1213 capela 167 * @param pClient Pointer to client instance structure.
1214     * @param iSamplerChannel Sampler channel number.
1215     *
1216 capela 107 * @returns The number of active disk streams on success, -1 otherwise.
1217     */
1218     int lscp_get_channel_stream_count ( lscp_client_t *pClient, int iSamplerChannel )
1219     {
1220 capela 952 char szQuery[LSCP_BUFSIZ];
1221     int iStreamCount = -1;
1222 capela 107
1223 capela 975 if (pClient == NULL)
1224     return -1;
1225 capela 952 if (iSamplerChannel < 0)
1226 capela 975 return -1;
1227 capela 107
1228 capela 952 // Lock this section up.
1229     lscp_mutex_lock(pClient->mutex);
1230 capela 132
1231 capela 952 sprintf(szQuery, "GET CHANNEL STREAM_COUNT %d\r\n", iSamplerChannel);
1232     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
1233     iStreamCount = atoi(lscp_client_get_result(pClient));
1234 capela 107
1235 capela 952 // Unlock this section down.
1236     lscp_mutex_unlock(pClient->mutex);
1237 capela 132
1238 capela 952 return iStreamCount;
1239 capela 107 }
1240    
1241    
1242     /**
1243 capela 167 * Current least usage of active disk streams.
1244     *
1245     * @param pClient Pointer to client instance structure.
1246     * @param iSamplerChannel Sampler channel number.
1247     *
1248     * @returns The usage percentage of the least filled active disk stream
1249     * on success, -1 otherwise.
1250     */
1251     int lscp_get_channel_stream_usage ( lscp_client_t *pClient, int iSamplerChannel )
1252     {
1253 capela 952 char szQuery[LSCP_BUFSIZ];
1254     int iStreamUsage = -1;
1255     const char *pszResult;
1256     const char *pszSeps = "[]%,";
1257     char *pszToken;
1258     char *pch;
1259     int iStream;
1260     int iPercent;
1261 capela 167
1262 capela 975 if (pClient == NULL)
1263     return -1;
1264 capela 952 if (iSamplerChannel < 0)
1265 capela 975 return -1;
1266 capela 167
1267 capela 952 // Lock this section up.
1268     lscp_mutex_lock(pClient->mutex);
1269 capela 167
1270 capela 952 iStream = 0;
1271     sprintf(szQuery, "GET CHANNEL BUFFER_FILL PERCENTAGE %d\r\n", iSamplerChannel);
1272     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK) {
1273     pszResult = lscp_client_get_result(pClient);
1274     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
1275     while (pszToken) {
1276     if (*pszToken) {
1277     // Skip stream id.
1278     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1279     if (pszToken == NULL)
1280     break;
1281     // Get least buffer fill percentage.
1282     iPercent = atol(pszToken);
1283     if (iStreamUsage > iPercent || iStream == 0)
1284     iStreamUsage = iPercent;
1285     iStream++;
1286     }
1287     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1288     }
1289     }
1290 capela 167
1291 capela 952 // Unlock this section down.
1292     lscp_mutex_unlock(pClient->mutex);
1293 capela 167
1294 capela 952 return iStreamUsage;
1295 capela 167 }
1296    
1297    
1298     /**
1299 capela 107 * Current fill state of disk stream buffers:
1300     * GET CHANNEL BUFFER_FILL {BYTES|PERCENTAGE} <sampler-channel>
1301     *
1302     * @param pClient Pointer to client instance structure.
1303     * @param usage_type Usage type to be returned, either
1304     * @ref LSCP_USAGE_BYTES, or
1305     * @ref LSCP_USAGE_PERCENTAGE.
1306     * @param iSamplerChannel Sampler channel number.
1307     *
1308     * @returns A pointer to a @ref lscp_buffer_fill_t structure, with the
1309     * information of the current disk stream buffer fill usage, for the given
1310     * sampler channel, or NULL in case of failure.
1311     */
1312     lscp_buffer_fill_t *lscp_get_channel_buffer_fill ( lscp_client_t *pClient, lscp_usage_t usage_type, int iSamplerChannel )
1313     {
1314 capela 952 lscp_buffer_fill_t *pBufferFill;
1315     char szQuery[LSCP_BUFSIZ];
1316     int iStreamCount;
1317     const char *pszUsageType = (usage_type == LSCP_USAGE_BYTES ? "BYTES" : "PERCENTAGE");
1318     const char *pszResult;
1319     const char *pszSeps = "[]%,";
1320     char *pszToken;
1321     char *pch;
1322     int iStream;
1323 capela 107
1324 capela 952 // Retrieve a channel stream estimation.
1325     iStreamCount = lscp_get_channel_stream_count(pClient, iSamplerChannel);
1326 capela 975 if (iStreamCount < 0)
1327 capela 952 return NULL;
1328 capela 132
1329 capela 952 // Lock this section up.
1330     lscp_mutex_lock(pClient->mutex);
1331 capela 132
1332 capela 952 // Check if we need to reallocate the stream usage array.
1333     if (pClient->iStreamCount != iStreamCount) {
1334     if (pClient->buffer_fill)
1335     free(pClient->buffer_fill);
1336     if (iStreamCount > 0)
1337     pClient->buffer_fill = (lscp_buffer_fill_t *) malloc(iStreamCount * sizeof(lscp_buffer_fill_t));
1338     else
1339     pClient->buffer_fill = NULL;
1340     pClient->iStreamCount = iStreamCount;
1341     }
1342 capela 107
1343 capela 952 // Get buffer fill usage...
1344     pBufferFill = pClient->buffer_fill;
1345     if (pBufferFill && iStreamCount > 0) {
1346     iStream = 0;
1347     pBufferFill = pClient->buffer_fill;
1348     sprintf(szQuery, "GET CHANNEL BUFFER_FILL %s %d\r\n", pszUsageType, iSamplerChannel);
1349     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK) {
1350     pszResult = lscp_client_get_result(pClient);
1351     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
1352     while (pszToken && iStream < pClient->iStreamCount) {
1353     if (*pszToken) {
1354     pBufferFill[iStream].stream_id = atol(pszToken);
1355     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1356     if (pszToken == NULL)
1357     break;
1358     pBufferFill[iStream].stream_usage = atol(pszToken);
1359     iStream++;
1360     }
1361     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1362     }
1363     } // Reset the usage, whatever it was before.
1364     else while (iStream < pClient->iStreamCount)
1365     pBufferFill[iStream++].stream_usage = 0;
1366     }
1367 capela 562
1368 capela 952 // Unlock this section down.
1369     lscp_mutex_unlock(pClient->mutex);
1370 capela 107
1371 capela 952 return pBufferFill;
1372 capela 107 }
1373    
1374    
1375     /**
1376     * Setting audio output type:
1377     * SET CHANNEL AUDIO_OUTPUT_TYPE <sampler-channel> <audio-output-type>
1378     *
1379     * @param pClient Pointer to client instance structure.
1380     * @param iSamplerChannel Sampler channel number.
1381     * @param pszAudioDriver Audio output driver type (e.g. "ALSA" or "JACK").
1382 capela 946 *
1383     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1384 capela 107 */
1385     lscp_status_t lscp_set_channel_audio_type ( lscp_client_t *pClient, int iSamplerChannel, const char *pszAudioDriver )
1386     {
1387 capela 952 char szQuery[LSCP_BUFSIZ];
1388 capela 107
1389 capela 952 if (iSamplerChannel < 0 || pszAudioDriver == NULL)
1390     return LSCP_FAILED;
1391 capela 107
1392 capela 952 sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_TYPE %d %s\r\n", iSamplerChannel, pszAudioDriver);
1393     return lscp_client_query(pClient, szQuery);
1394 capela 107 }
1395    
1396    
1397     /**
1398 capela 144 * Setting audio output device:
1399     * SET CHANNEL AUDIO_OUTPUT_DEVICE <sampler-channel> <device-id>
1400     *
1401     * @param pClient Pointer to client instance structure.
1402     * @param iSamplerChannel Sampler channel number.
1403     * @param iAudioDevice Audio output device number identifier.
1404 capela 946 *
1405     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1406 capela 144 */
1407     lscp_status_t lscp_set_channel_audio_device ( lscp_client_t *pClient, int iSamplerChannel, int iAudioDevice )
1408     {
1409 capela 952 char szQuery[LSCP_BUFSIZ];
1410 capela 144
1411 capela 952 if (iSamplerChannel < 0 || iAudioDevice < 0)
1412     return LSCP_FAILED;
1413 capela 144
1414 capela 952 sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_DEVICE %d %d\r\n", iSamplerChannel, iAudioDevice);
1415     return lscp_client_query(pClient, szQuery);
1416 capela 144 }
1417    
1418    
1419     /**
1420 capela 107 * Setting audio output channel:
1421     * SET CHANNEL AUDIO_OUTPUT_CHANNEL <sampler-channel> <audio-output-chan> <audio-input-chan>
1422     *
1423     * @param pClient Pointer to client instance structure.
1424     * @param iSamplerChannel Sampler channel number.
1425     * @param iAudioOut Audio output device channel to be routed from.
1426     * @param iAudioIn Audio output device channel to be routed into.
1427     *
1428     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1429     */
1430     lscp_status_t lscp_set_channel_audio_channel ( lscp_client_t *pClient, int iSamplerChannel, int iAudioOut, int iAudioIn )
1431     {
1432 capela 952 char szQuery[LSCP_BUFSIZ];
1433 capela 107
1434 capela 952 if (iSamplerChannel < 0 || iAudioOut < 0 || iAudioIn < 0)
1435     return LSCP_FAILED;
1436 capela 107
1437 capela 952 sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_CHANNEL %d %d %d\r\n", iSamplerChannel, iAudioOut, iAudioIn);
1438     return lscp_client_query(pClient, szQuery);
1439 capela 107 }
1440    
1441    
1442     /**
1443     * Setting MIDI input type:
1444     * SET CHANNEL MIDI_INPUT_TYPE <sampler-channel> <midi-input-type>
1445     *
1446     * @param pClient Pointer to client instance structure.
1447     * @param iSamplerChannel Sampler channel number.
1448     * @param pszMidiDriver MIDI input driver type (e.g. "ALSA").
1449     *
1450     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1451     */
1452     lscp_status_t lscp_set_channel_midi_type ( lscp_client_t *pClient, int iSamplerChannel, const char *pszMidiDriver )
1453     {
1454 capela 952 char szQuery[LSCP_BUFSIZ];
1455 capela 107
1456 capela 952 if (iSamplerChannel < 0 || pszMidiDriver == NULL)
1457     return LSCP_FAILED;
1458 capela 107
1459 capela 952 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_TYPE %d %s\r\n", iSamplerChannel, pszMidiDriver);
1460     return lscp_client_query(pClient, szQuery);
1461 capela 107 }
1462    
1463    
1464     /**
1465 capela 144 * Setting MIDI input device:
1466     * SET CHANNEL MIDI_INPUT_DEVICE <sampler-channel> <device-id>
1467     *
1468     * @param pClient Pointer to client instance structure.
1469     * @param iSamplerChannel Sampler channel number.
1470     * @param iMidiDevice MIDI input device number identifier.
1471 capela 946 *
1472     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1473 capela 144 */
1474     lscp_status_t lscp_set_channel_midi_device ( lscp_client_t *pClient, int iSamplerChannel, int iMidiDevice )
1475     {
1476 capela 952 char szQuery[LSCP_BUFSIZ];
1477 capela 144
1478 capela 952 if (iSamplerChannel < 0 || iMidiDevice < 0)
1479     return LSCP_FAILED;
1480 capela 144
1481 capela 952 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_DEVICE %d %d\r\n", iSamplerChannel, iMidiDevice);
1482     return lscp_client_query(pClient, szQuery);
1483 capela 144 }
1484    
1485    
1486     /**
1487 capela 107 * Setting MIDI input port:
1488     * SET CHANNEL MIDI_INPUT_PORT <sampler-channel> <midi-input-port>
1489     *
1490     * @param pClient Pointer to client instance structure.
1491     * @param iSamplerChannel Sampler channel number.
1492     * @param iMidiPort MIDI input driver virtual port number.
1493     *
1494     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1495     */
1496     lscp_status_t lscp_set_channel_midi_port ( lscp_client_t *pClient, int iSamplerChannel, int iMidiPort )
1497     {
1498 capela 952 char szQuery[LSCP_BUFSIZ];
1499 capela 107
1500 capela 952 if (iSamplerChannel < 0 || iMidiPort < 0)
1501     return LSCP_FAILED;
1502 capela 107
1503 capela 952 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_PORT %d %d\r\n", iSamplerChannel, iMidiPort);
1504     return lscp_client_query(pClient, szQuery);
1505 capela 107 }
1506    
1507    
1508     /**
1509     * Setting MIDI input channel:
1510     * SET CHANNEL MIDI_INPUT_CHANNEL <sampler-channel> <midi-input-chan>
1511     *
1512     * @param pClient Pointer to client instance structure.
1513     * @param iSamplerChannel Sampler channel number.
1514 capela 278 * @param iMidiChannel MIDI channel address number to listen (0-15) or
1515 capela 975 * @ref LSCP_MIDI_CHANNEL_ALL (16) to listen on all channels.
1516 capela 107 *
1517     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1518     */
1519     lscp_status_t lscp_set_channel_midi_channel ( lscp_client_t *pClient, int iSamplerChannel, int iMidiChannel )
1520     {
1521 capela 952 char szQuery[LSCP_BUFSIZ];
1522 capela 107
1523 capela 952 if (iSamplerChannel < 0 || iMidiChannel < 0 || iMidiChannel > 16)
1524     return LSCP_FAILED;
1525 capela 107
1526 capela 952 if (iMidiChannel == LSCP_MIDI_CHANNEL_ALL)
1527     sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d ALL\r\n", iSamplerChannel);
1528     else
1529     sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d %d\r\n", iSamplerChannel, iMidiChannel);
1530     return lscp_client_query(pClient, szQuery);
1531 capela 107 }
1532    
1533    
1534     /**
1535 capela 975 * Setting MIDI instrument map:
1536     * SET CHANNEL MIDI_INSTRUMENT_MAP <sampler-channel> <midi-map>
1537     *
1538     * @param pClient Pointer to client instance structure.
1539     * @param iSamplerChannel Sampler channel number.
1540     * @param iMidiMap MIDI instrument map number, or either
1541     * @ref LSCP_MIDI_MAP_NONE or
1542     * @ref LSCP_MIDI_MAP_DEFAULT .
1543     *
1544     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1545     */
1546     lscp_status_t lscp_set_channel_midi_map ( lscp_client_t *pClient, int iSamplerChannel, int iMidiMap )
1547     {
1548     char szQuery[LSCP_BUFSIZ];
1549    
1550     if (iSamplerChannel < 0)
1551     return LSCP_FAILED;
1552    
1553     sprintf(szQuery, "SET CHANNEL MIDI_INSTRUMENT_MAP %d ", iSamplerChannel);
1554     if (iMidiMap == LSCP_MIDI_MAP_NONE)
1555     strcat(szQuery , "NONE");
1556     else
1557     if (iMidiMap == LSCP_MIDI_MAP_DEFAULT)
1558     strcat(szQuery , "DEFAULT");
1559     else
1560     sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
1561    
1562     strcat(szQuery, "\r\n");
1563    
1564     return lscp_client_query(pClient, szQuery);
1565     }
1566    
1567    
1568     /**
1569 capela 107 * Setting channel volume:
1570     * SET CHANNEL VOLUME <sampler-channel> <volume>
1571     *
1572     * @param pClient Pointer to client instance structure.
1573     * @param iSamplerChannel Sampler channel number.
1574     * @param fVolume Sampler channel volume as a positive floating point
1575     * number, where a value less than 1.0 for attenuation,
1576     * and greater than 1.0 for amplification.
1577     *
1578     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1579     */
1580     lscp_status_t lscp_set_channel_volume ( lscp_client_t *pClient, int iSamplerChannel, float fVolume )
1581     {
1582 capela 952 char szQuery[LSCP_BUFSIZ];
1583 capela 107
1584 capela 1019 if (iSamplerChannel < 0 || fVolume < 0.0f)
1585 capela 952 return LSCP_FAILED;
1586 capela 107
1587 capela 952 sprintf(szQuery, "SET CHANNEL VOLUME %d %g\r\n", iSamplerChannel, fVolume);
1588     return lscp_client_query(pClient, szQuery);
1589 capela 107 }
1590    
1591    
1592     /**
1593 capela 735 * Muting a sampler channel:
1594     * SET CHANNEL MUTE <sampler-channel> <mute>
1595     *
1596     * @param pClient Pointer to client instance structure.
1597     * @param iSamplerChannel Sampler channel number.
1598     * @param iMute Sampler channel mute state as a boolean value,
1599     * either 1 (one) to mute the channel or 0 (zero)
1600     * to unmute the channel.
1601     *
1602     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1603     */
1604     lscp_status_t lscp_set_channel_mute ( lscp_client_t *pClient, int iSamplerChannel, int iMute )
1605     {
1606 capela 952 char szQuery[LSCP_BUFSIZ];
1607 capela 735
1608 capela 952 if (iSamplerChannel < 0 || iMute < 0 || iMute > 1)
1609     return LSCP_FAILED;
1610 capela 735
1611 capela 952 sprintf(szQuery, "SET CHANNEL MUTE %d %d\r\n", iSamplerChannel, iMute);
1612     return lscp_client_query(pClient, szQuery);
1613 capela 735 }
1614    
1615    
1616     /**
1617     * Soloing a sampler channel:
1618     * SET CHANNEL SOLO <sampler-channel> <solo>
1619     *
1620     * @param pClient Pointer to client instance structure.
1621     * @param iSamplerChannel Sampler channel number.
1622     * @param iSolo Sampler channel solo state as a boolean value,
1623     * either 1 (one) to solo the channel or 0 (zero)
1624     * to unsolo the channel.
1625     *
1626     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1627     */
1628     lscp_status_t lscp_set_channel_solo ( lscp_client_t *pClient, int iSamplerChannel, int iSolo )
1629     {
1630 capela 952 char szQuery[LSCP_BUFSIZ];
1631 capela 735
1632 capela 952 if (iSamplerChannel < 0 || iSolo < 0 || iSolo > 1)
1633     return LSCP_FAILED;
1634 capela 735
1635 capela 952 sprintf(szQuery, "SET CHANNEL SOLO %d %d\r\n", iSamplerChannel, iSolo);
1636     return lscp_client_query(pClient, szQuery);
1637 capela 735 }
1638    
1639    
1640     /**
1641 capela 107 * Resetting a sampler channel:
1642     * RESET CHANNEL <sampler-channel>
1643     *
1644     * @param pClient Pointer to client instance structure.
1645     * @param iSamplerChannel Sampler channel number.
1646     *
1647     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1648     */
1649     lscp_status_t lscp_reset_channel ( lscp_client_t *pClient, int iSamplerChannel )
1650     {
1651 capela 952 char szQuery[LSCP_BUFSIZ];
1652 capela 107
1653 capela 952 if (iSamplerChannel < 0)
1654     return LSCP_FAILED;
1655 capela 107
1656 capela 952 sprintf(szQuery, "RESET CHANNEL %d\r\n", iSamplerChannel);
1657     return lscp_client_query(pClient, szQuery);
1658 capela 107 }
1659    
1660    
1661 capela 213 /**
1662     * Resetting the sampler:
1663     * RESET
1664     *
1665     * @param pClient Pointer to client instance structure.
1666     *
1667     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1668     */
1669     lscp_status_t lscp_reset_sampler ( lscp_client_t *pClient )
1670     {
1671 capela 994 // Do actual whole sampler reset...
1672 capela 952 return lscp_client_query(pClient, "RESET\r\n");
1673 capela 213 }
1674    
1675    
1676 capela 564 /**
1677     * Getting information about the server.
1678     * GET SERVER INFO
1679     *
1680     * @param pClient Pointer to client instance structure.
1681     *
1682     * @returns A pointer to a @ref lscp_server_info_t structure, with all the
1683     * information of the current connected server, or NULL in case of failure.
1684     */
1685     lscp_server_info_t *lscp_get_server_info ( lscp_client_t *pClient )
1686     {
1687 capela 952 lscp_server_info_t *pServerInfo;
1688     const char *pszResult;
1689     const char *pszSeps = ":";
1690     const char *pszCrlf = "\r\n";
1691     char *pszToken;
1692     char *pch;
1693 capela 564
1694 capela 975 if (pClient == NULL)
1695     return NULL;
1696    
1697 capela 952 // Lock this section up.
1698     lscp_mutex_lock(pClient->mutex);
1699 capela 564
1700 capela 952 pServerInfo = &(pClient->server_info);
1701     lscp_server_info_reset(pServerInfo);
1702 capela 564
1703 capela 952 if (lscp_client_call(pClient, "GET SERVER INFO\r\n", 1) == LSCP_OK) {
1704     pszResult = lscp_client_get_result(pClient);
1705     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
1706     while (pszToken) {
1707     if (strcasecmp(pszToken, "DESCRIPTION") == 0) {
1708     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1709     if (pszToken)
1710     lscp_unquote_dup(&(pServerInfo->description), &pszToken);
1711     }
1712     else if (strcasecmp(pszToken, "VERSION") == 0) {
1713     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1714     if (pszToken)
1715     lscp_unquote_dup(&(pServerInfo->version), &pszToken);
1716     }
1717 capela 977 else if (strcasecmp(pszToken, "PROTOCOL_VERSION") == 0) {
1718     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
1719     if (pszToken)
1720     lscp_unquote_dup(&(pServerInfo->protocol_version), &pszToken);
1721     }
1722 capela 952 pszToken = lscp_strtok(NULL, pszSeps, &(pch));
1723     }
1724     }
1725     else pServerInfo = NULL;
1726 capela 564
1727 capela 952 // Unlock this section down.
1728     lscp_mutex_unlock(pClient->mutex);
1729 capela 564
1730 capela 952 return pServerInfo;
1731 capela 564 }
1732    
1733    
1734 capela 946 /**
1735     * Current total number of active voices:
1736     * GET TOTAL_VOICE_COUNT
1737     *
1738     * @param pClient Pointer to client instance structure.
1739     *
1740     * @returns The total number of voices currently active,
1741     * -1 in case of failure.
1742     */
1743     int lscp_get_total_voice_count ( lscp_client_t *pClient )
1744     {
1745 capela 952 int iVoiceCount = -1;
1746 capela 946
1747 capela 975 if (pClient == NULL)
1748     return -1;
1749    
1750 capela 952 // Lock this section up.
1751     lscp_mutex_lock(pClient->mutex);
1752 capela 946
1753 capela 952 if (lscp_client_call(pClient, "GET TOTAL_VOICE_COUNT\r\n", 0) == LSCP_OK)
1754     iVoiceCount = atoi(lscp_client_get_result(pClient));
1755 capela 946
1756 capela 952 // Unlock this section down.
1757     lscp_mutex_unlock(pClient->mutex);
1758 capela 946
1759 capela 952 return iVoiceCount;
1760 capela 946 }
1761    
1762    
1763     /**
1764     * Maximum amount of active voices:
1765     * GET TOTAL_VOICE_COUNT_MAX
1766     *
1767     * @param pClient Pointer to client instance structure.
1768     *
1769     * @returns The maximum amount of voices currently active,
1770     * -1 in case of failure.
1771     */
1772     int lscp_get_total_voice_count_max ( lscp_client_t *pClient )
1773     {
1774 capela 952 int iVoiceCount = -1;
1775 capela 946
1776 capela 975 if (pClient == NULL)
1777     return -1;
1778    
1779 capela 952 // Lock this section up.
1780     lscp_mutex_lock(pClient->mutex);
1781 capela 946
1782 capela 952 if (lscp_client_call(pClient, "GET TOTAL_VOICE_COUNT_MAX\r\n", 0) == LSCP_OK)
1783     iVoiceCount = atoi(lscp_client_get_result(pClient));
1784 capela 946
1785 capela 952 // Unlock this section down.
1786     lscp_mutex_unlock(pClient->mutex);
1787 capela 946
1788 capela 952 return iVoiceCount;
1789 capela 946 }
1790    
1791    
1792     /**
1793 capela 1019 * Get global volume attenuation:
1794     * GET VOLUME
1795     *
1796     * @param pClient Pointer to client instance structure.
1797     *
1798     * @returns The global volume as positive floating point value usually in
1799     * the range between 0.0 and 1.0; in case of failure 0.0 is returned.
1800     */
1801     float lscp_get_volume ( lscp_client_t *pClient )
1802     {
1803     float fVolume = 0.0f;
1804    
1805     if (pClient == NULL)
1806     return 0.0f;
1807    
1808     // Lock this section up.
1809     lscp_mutex_lock(pClient->mutex);
1810    
1811     if (lscp_client_call(pClient, "GET VOLUME\r\n", 0) == LSCP_OK)
1812     fVolume = (float) atof(lscp_client_get_result(pClient));
1813    
1814     // Unlock this section down.
1815     lscp_mutex_unlock(pClient->mutex);
1816    
1817     return fVolume;
1818     }
1819    
1820    
1821     /**
1822     * Setting global volume attenuation:
1823     * SET VOLUME <volume>
1824     *
1825     * @param pClient Pointer to client instance structure.
1826     * @param fVolume Global volume parameter as positive floating point
1827     * value usually be in the range between 0.0 and 1.0,
1828     * that is for attenuating the overall volume.
1829     *
1830     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1831     */
1832     lscp_status_t lscp_set_volume ( lscp_client_t *pClient, float fVolume )
1833     {
1834     char szQuery[LSCP_BUFSIZ];
1835    
1836     if (fVolume < 0.0f)
1837     return LSCP_FAILED;
1838    
1839     sprintf(szQuery, "SET VOLUME %g\r\n", fVolume);
1840     return lscp_client_query(pClient, szQuery);
1841     }
1842    
1843    
1844     /**
1845     * Add an effect send to a sampler channel:
1846     * CREATE FX_SEND <sampler-channel> <midi-ctrl> [<name>]
1847     *
1848     * @param pClient Pointer to client instance structure.
1849     * @param iSamplerChannel Sampler channel number.
1850     * @param iMidiController MIDI controller used to alter the effect,
1851     * usually a number between 0 and 127.
1852     * @param pszName Optional name for the effect send entity,
1853     * does not have to be unique.
1854     *
1855     * @returns The new effect send number identifier, or -1 in case of failure.
1856     */
1857     int lscp_create_fxsend ( lscp_client_t *pClient, int iSamplerChannel, int iMidiController, const char *pszFxName )
1858     {
1859     int iFxSend = -1;
1860     char szQuery[LSCP_BUFSIZ];
1861    
1862     if (pClient == NULL)
1863     return -1;
1864     if (iSamplerChannel < 0 || iMidiController < 0 || iMidiController > 127)
1865     return -1;
1866    
1867     // Lock this section up.
1868     lscp_mutex_lock(pClient->mutex);
1869    
1870     sprintf(szQuery, "CREATE FX_SEND %d %d", iSamplerChannel, iMidiController);
1871    
1872     if (pszFxName)
1873     sprintf(szQuery + strlen(szQuery), " '%s'", pszFxName);
1874    
1875     strcat(szQuery, "\r\n");
1876    
1877     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
1878     iFxSend = atoi(lscp_client_get_result(pClient));
1879    
1880     // Unlock this section down.
1881     lscp_mutex_unlock(pClient->mutex);
1882    
1883     return iFxSend;
1884     }
1885    
1886    
1887     /**
1888     * Remove an effect send from a sampler channel:
1889     * DESTROY FX_SEND <sampler-channel> <fx-send-id>
1890     *
1891     * @param pClient Pointer to client instance structure.
1892     * @param iSamplerChannel Sampler channel number.
1893     * @param iFxSend Effect send number.
1894     *
1895     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
1896     */
1897     lscp_status_t lscp_destroy_fxsend ( lscp_client_t *pClient, int iSamplerChannel, int iFxSend )
1898     {
1899     char szQuery[LSCP_BUFSIZ];
1900    
1901     if (iSamplerChannel < 0 || iFxSend < 0)
1902     return LSCP_FAILED;
1903    
1904     sprintf(szQuery, "DESTROY FX_SEND %d %d\r\n", iSamplerChannel, iFxSend);
1905    
1906     return lscp_client_query(pClient, szQuery);
1907     }
1908    
1909    
1910     /**
1911     * Get amount of effect sends on a sampler channel:
1912     * GET FX_SENDS <sampler-channel>
1913     *
1914     * @param pClient Pointer to client instance structure.
1915     * @param iSamplerChannel Sampler channel number.
1916     *
1917     * @returns The current total number of effect sends of the sampler channel
1918     * on success, -1 otherwise.
1919     */
1920     int lscp_get_fxsends ( lscp_client_t *pClient, int iSamplerChannel )
1921     {
1922     int iFxSends = -1;
1923     char szQuery[LSCP_BUFSIZ];
1924    
1925     if (pClient == NULL)
1926     return -1;
1927     if (iSamplerChannel < 0)
1928     return -1;
1929    
1930     // Lock this section up.
1931     lscp_mutex_lock(pClient->mutex);
1932    
1933     sprintf(szQuery, "GET FX_SENDS %d\r\n", iSamplerChannel);
1934    
1935     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
1936     iFxSends = atoi(lscp_client_get_result(pClient));
1937    
1938     // Unlock this section doen.
1939     lscp_mutex_unlock(pClient->mutex);
1940    
1941     return iFxSends;
1942     }
1943    
1944    
1945     /**
1946     * List all effect sends on a sampler channel:
1947     * LIST FX_SENDS <sampler-channel>
1948     *
1949     * @param pClient Pointer to client instance structure.
1950     * @param iSamplerChannel Sampler channel number.
1951     *
1952     * @returns An array of the effect sends identifiers as positive integers,
1953     * terminated with -1 on success, NULL otherwise.
1954     */
1955     int *lscp_list_fxsends ( lscp_client_t *pClient, int iSamplerChannel )
1956     {
1957     const char *pszSeps = ",";
1958     char szQuery[LSCP_BUFSIZ];
1959    
1960     if (pClient == NULL)
1961     return NULL;
1962    
1963     // Lock this section up.
1964     lscp_mutex_lock(pClient->mutex);
1965    
1966     if (pClient->fxsends) {
1967     lscp_isplit_destroy(pClient->fxsends);
1968     pClient->fxsends = NULL;
1969     }
1970    
1971     sprintf(szQuery, "LIST FX_SENDS %d\r\n", iSamplerChannel);
1972    
1973     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
1974     pClient->fxsends = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
1975    
1976     // Unlock this section down.
1977     lscp_mutex_unlock(pClient->mutex);
1978    
1979     return pClient->fxsends;
1980     }
1981    
1982    
1983     /**
1984     * Getting effect send information
1985     * GET FX_SEND INFO <sampler-channel> <fx-send-id>
1986     *
1987     * @param pClient Pointer to client instance structure.
1988     * @param iSamplerChannel Sampler channel number.
1989     * @param iFxSend Effect send number.
1990     *
1991     * @returns A pointer to a @ref lscp_fxsend_info_t structure, with the
1992     * information of the given FX send, or NULL in case of failure.
1993     */
1994     lscp_fxsend_info_t *lscp_get_fxsend_info ( lscp_client_t *pClient, int iSamplerChannel, int iFxSend )
1995     {
1996     lscp_fxsend_info_t *pFxSendInfo;
1997     char szQuery[LSCP_BUFSIZ];
1998     const char *pszResult;
1999     const char *pszSeps = ":";
2000     const char *pszCrlf = "\r\n";
2001     char *pszToken;
2002     char *pch;
2003    
2004     if (pClient == NULL)
2005     return NULL;
2006     if (iSamplerChannel < 0 || iFxSend < 0)
2007     return NULL;
2008    
2009     // Lock this section up.
2010     lscp_mutex_lock(pClient->mutex);
2011    
2012     pFxSendInfo = &(pClient->fxsend_info);
2013     lscp_fxsend_info_reset(pFxSendInfo);
2014    
2015     sprintf(szQuery, "GET FX_SEND INFO %d %d\r\n", iSamplerChannel, iFxSend);
2016     if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
2017     pszResult = lscp_client_get_result(pClient);
2018     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
2019     while (pszToken) {
2020     if (strcasecmp(pszToken, "NAME") == 0) {
2021     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2022     if (pszToken)
2023     lscp_unquote_dup(&(pFxSendInfo->name), &pszToken);
2024     }
2025     else if (strcasecmp(pszToken, "MIDI_CONTROLLER") == 0) {
2026     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2027     if (pszToken)
2028     pFxSendInfo->midi_controller = atoi(lscp_ltrim(pszToken));
2029     }
2030     else if (strcasecmp(pszToken, "AUDIO_OUTPUT_ROUTING") == 0) {
2031     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2032     if (pszToken) {
2033     if (pFxSendInfo->audio_routing)
2034 capela 1020 lscp_isplit_destroy(pFxSendInfo->audio_routing);
2035     pFxSendInfo->audio_routing = lscp_isplit_create(pszToken, ",");
2036 capela 1019 }
2037     }
2038     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
2039     }
2040     }
2041     else pFxSendInfo = NULL;
2042    
2043     // Unlock this section up.
2044     lscp_mutex_unlock(pClient->mutex);
2045    
2046     return pFxSendInfo;
2047     }
2048    
2049    
2050     /**
2051     * Alter effect send's audio routing:
2052     * SET FX_SEND AUDIO_OUTPUT_CHANNEL <sampler-chan> <fx-send-id>
2053     * <audio-src> <audio-dst>
2054     *
2055     * @param pClient Pointer to client instance structure.
2056     * @param iSamplerChannel Sampler channel number.
2057     * @param iFxSend Effect send number.
2058     * @param iAudioSrc Audio output device channel to be routed from.
2059     * @param iAudioDst Audio output device channel to be routed into.
2060     *
2061     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2062     */
2063     lscp_status_t lscp_set_fxsend_audio_channel ( lscp_client_t *pClient, int iSamplerChannel, int iFxSend, int iAudioSrc, int iAudioDst )
2064     {
2065     char szQuery[LSCP_BUFSIZ];
2066    
2067     if (iSamplerChannel < 0 || iFxSend < 0 || iAudioSrc < 0 || iAudioDst < 0)
2068     return LSCP_FAILED;
2069    
2070     sprintf(szQuery, "SET FX_SEND AUDIO_OUTPUT_CHANNEL %d %d %d %d\r\n", iSamplerChannel, iFxSend, iAudioSrc, iAudioDst);
2071     return lscp_client_query(pClient, szQuery);
2072     }
2073    
2074    
2075     /**
2076 capela 975 * Create a new MIDI instrument map:
2077     * ADD MIDI_INSTRUMENT_MAP [<name>]
2078     *
2079     * @param pClient Pointer to client instance structure.
2080     * @param pszMapName MIDI instrument map name (optional)
2081     *
2082     * @returns The new MIDI instrument map number identifier,
2083     * or -1 in case of failure.
2084     */
2085     int lscp_add_midi_instrument_map ( lscp_client_t *pClient, const char *pszMapName )
2086     {
2087     int iMidiMap = -1;
2088     char szQuery[LSCP_BUFSIZ];
2089    
2090     if (pClient == NULL)
2091     return -1;
2092    
2093     // Lock this section up.
2094     lscp_mutex_lock(pClient->mutex);
2095    
2096     strcpy(szQuery, "ADD MIDI_INSTRUMENT_MAP");
2097    
2098     if (pszMapName)
2099     sprintf(szQuery + strlen(szQuery), " '%s'", pszMapName);
2100    
2101     strcat(szQuery, "\r\n");
2102    
2103     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
2104     iMidiMap = atoi(lscp_client_get_result(pClient));
2105    
2106     // Unlock this section down.
2107     lscp_mutex_unlock(pClient->mutex);
2108    
2109     return iMidiMap;
2110     }
2111    
2112    
2113     /**
2114     * Delete one particular or all MIDI instrument maps:
2115     * REMOVE MIDI_INSTRUMENT_MAP <midi-map>
2116     *
2117     * @param pClient Pointer to client instance structure.
2118     * @param iMidiMap MIDI instrument map number.
2119     *
2120     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2121     */
2122     lscp_status_t lscp_remove_midi_instrument_map ( lscp_client_t *pClient, int iMidiMap )
2123     {
2124     char szQuery[LSCP_BUFSIZ];
2125    
2126     if (iMidiMap < 0)
2127     return LSCP_FAILED;
2128    
2129     sprintf(szQuery, "REMOVE MIDI_INSTRUMENT_MAP %d\r\n", iMidiMap);
2130    
2131     return lscp_client_query(pClient, szQuery);
2132     }
2133    
2134    
2135     /**
2136     * Get amount of existing MIDI instrument maps:
2137     * GET MIDI_INSTRUMENT_MAPS
2138     *
2139     * @param pClient Pointer to client instance structure.
2140     *
2141     * @returns The current total number of MIDI instrument maps
2142     * on success, -1 otherwise.
2143     */
2144     int lscp_get_midi_instrument_maps ( lscp_client_t *pClient )
2145     {
2146     int iMidiMaps = -1;
2147    
2148     if (pClient == NULL)
2149     return -1;
2150    
2151     // Lock this section up.
2152     lscp_mutex_lock(pClient->mutex);
2153    
2154     if (lscp_client_call(pClient, "GET MIDI_INSTRUMENT_MAPS\r\n", 0) == LSCP_OK)
2155     iMidiMaps = atoi(lscp_client_get_result(pClient));
2156    
2157     // Unlock this section doen.
2158     lscp_mutex_unlock(pClient->mutex);
2159    
2160     return iMidiMaps;
2161     }
2162    
2163    
2164     /**
2165     * Getting all created MIDI instrument maps:
2166     * LIST MIDI_INSTRUMENT_MAPS
2167     *
2168     * @param pClient Pointer to client instance structure.
2169     *
2170     * @returns An array of the MIDI instrument map identifiers as positive
2171     * integers, terminated with -1 on success, NULL otherwise.
2172     */
2173     int *lscp_list_midi_instrument_maps ( lscp_client_t *pClient )
2174     {
2175     const char *pszSeps = ",";
2176    
2177     if (pClient == NULL)
2178     return NULL;
2179    
2180     // Lock this section up.
2181     lscp_mutex_lock(pClient->mutex);
2182    
2183     if (pClient->midi_maps) {
2184     lscp_isplit_destroy(pClient->midi_maps);
2185     pClient->midi_maps = NULL;
2186     }
2187    
2188     if (lscp_client_call(pClient, "LIST MIDI_INSTRUMENT_MAPS\r\n", 0) == LSCP_OK)
2189     pClient->midi_maps = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
2190    
2191     // Unlock this section down.
2192     lscp_mutex_unlock(pClient->mutex);
2193    
2194     return pClient->midi_maps;
2195     }
2196    
2197    
2198     /**
2199     * Getting a MIDI instrument map name:
2200     * GET MIDI_INSTRUMENT_MAP INFO <midi-map>
2201     *
2202     * @param pClient Pointer to client instance structure.
2203     * @param iMidiMap MIDI instrument map number.
2204     *
2205     * @returns The MIDI instrument map name on success, NULL on failure.
2206     */
2207     const char *lscp_get_midi_instrument_map_name ( lscp_client_t *pClient, int iMidiMap )
2208     {
2209     char szQuery[LSCP_BUFSIZ];
2210     const char *pszResult;
2211     const char *pszSeps = ":";
2212     const char *pszCrlf = "\r\n";
2213     char *pszToken;
2214     char *pch;
2215    
2216     if (pClient == NULL)
2217     return NULL;
2218     if (iMidiMap < 0)
2219     return NULL;
2220    
2221     // Lock this section up.
2222     lscp_mutex_lock(pClient->mutex);
2223    
2224     if (pClient->midi_map_name) {
2225     free(pClient->midi_map_name);
2226     pClient->midi_map_name = NULL;
2227     }
2228    
2229     sprintf(szQuery, "GET MIDI_INSTRUMENT_MAP INFO %d\r\n", iMidiMap);
2230 capela 1019 if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
2231 capela 975 pszResult = lscp_client_get_result(pClient);
2232     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
2233     while (pszToken) {
2234     if (strcasecmp(pszToken, "NAME") == 0) {
2235     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2236     if (pszToken)
2237     lscp_unquote_dup(&(pClient->midi_map_name), &pszToken);
2238     }
2239     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
2240     }
2241     }
2242    
2243     // Unlock this section down.
2244     lscp_mutex_unlock(pClient->mutex);
2245    
2246     return pClient->midi_map_name;
2247     }
2248    
2249    
2250     /**
2251     * Renaming a MIDI instrument map:
2252     * SET MIDI_INSTRUMENT_MAP NAME <midi-map> <map-name>
2253     *
2254     * @param pClient Pointer to client instance structure.
2255     * @param iMidiMap MIDI instrument map number.
2256     * @param pszMapName MIDI instrument map name.
2257     *
2258     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2259     */
2260     lscp_status_t lscp_set_midi_instrument_map_name ( lscp_client_t *pClient, int iMidiMap, const char *pszMapName )
2261     {
2262     char szQuery[LSCP_BUFSIZ];
2263    
2264     if (iMidiMap < 0)
2265     return LSCP_FAILED;
2266     if (pszMapName == NULL)
2267     return LSCP_FAILED;
2268    
2269     sprintf(szQuery, "SET MIDI_INSTRUMENT_MAP NAME %d '%s'\r\n",
2270     iMidiMap, pszMapName);
2271    
2272     return lscp_client_query(pClient, szQuery);
2273     }
2274    
2275    
2276     /**
2277 capela 946 * Create or replace a MIDI instrumnet map entry:
2278 capela 975 * MAP MIDI_INSTRUMENT <midi-map> <midi-bank> <midi-prog>
2279     * <engine-name> <filename> <instr-index> <volume> [<load-mode> [<name>]}
2280 capela 946 *
2281     * @param pClient Pointer to client instance structure.
2282     * @param pMidiInstr MIDI instrument bank and program parameter key.
2283     * @param pszEngineName Engine name.
2284     * @param pszFileName Instrument file name.
2285     * @param iInstrIndex Instrument index number.
2286     * @param fVolume Reflects the master volume of the instrument as
2287     * a positive floating point number, where a value
2288     * less than 1.0 for attenuation, and greater than
2289     * 1.0 for amplification.
2290     * @param load_mode Instrument load life-time strategy, either
2291     * @ref LSCP_LOAD_DEFAULT, or
2292     * @ref LSCP_LOAD_ON_DEMAND, or
2293     * @ref LSCP_LOAD_ON_DEMAND_HOLD, or
2294     * @ref LSCP_LOAD_PERSISTENT.
2295 capela 975 * @param pszName Instrument custom name for the map entry (optional).
2296 capela 946 *
2297     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2298     */
2299     lscp_status_t lscp_map_midi_instrument ( lscp_client_t *pClient, lscp_midi_instrument_t *pMidiInstr, const char *pszEngineName, const char *pszFileName, int iInstrIndex, float fVolume, lscp_load_mode_t load_mode, const char *pszName )
2300     {
2301 capela 952 char szQuery[LSCP_BUFSIZ];
2302 capela 963
2303 capela 975 if (pMidiInstr->map < 0)
2304 capela 952 return LSCP_FAILED;
2305 capela 975 if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
2306 capela 952 return LSCP_FAILED;
2307 capela 975 if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
2308 capela 952 return LSCP_FAILED;
2309     if (pszEngineName == NULL || pszFileName == NULL)
2310     return LSCP_FAILED;
2311 capela 963
2312 capela 952 if (fVolume < 0.0f)
2313     fVolume = 1.0f;
2314 capela 963
2315 capela 952 sprintf(szQuery, "MAP MIDI_INSTRUMENT %d %d %d %s '%s' %d %g",
2316 capela 975 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog,
2317 capela 952 pszEngineName, pszFileName, iInstrIndex, fVolume);
2318 capela 963
2319 capela 952 switch (load_mode) {
2320     case LSCP_LOAD_PERSISTENT:
2321     strcat(szQuery, " PERSISTENT");
2322     break;
2323     case LSCP_LOAD_ON_DEMAND_HOLD:
2324     strcat(szQuery, " ON_DEMAND_HOLD");
2325     break;
2326     case LSCP_LOAD_ON_DEMAND:
2327 capela 963 strcat(szQuery, " ON_DEMAND");
2328 capela 952 break;
2329     case LSCP_LOAD_DEFAULT:
2330     default:
2331     break;
2332     }
2333 capela 963
2334 capela 952 if (pszName)
2335     sprintf(szQuery + strlen(szQuery), " '%s'", pszName);
2336 capela 963
2337 capela 952 strcat(szQuery, "\r\n");
2338 capela 963
2339 capela 952 return lscp_client_query(pClient, szQuery);
2340 capela 946 }
2341    
2342    
2343     /**
2344     * Remove an entry from the MIDI instrument map:
2345 capela 975 * UNMAP MIDI_INSTRUMENT <midi-map> <midi-bank> <midi-prog>
2346 capela 946 *
2347     * @param pClient Pointer to client instance structure.
2348     * @param pMidiInstr MIDI instrument bank and program parameter key.
2349     *
2350     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2351     */
2352     lscp_status_t lscp_unmap_midi_instrument ( lscp_client_t *pClient, lscp_midi_instrument_t *pMidiInstr )
2353     {
2354 capela 952 char szQuery[LSCP_BUFSIZ];
2355 capela 946
2356 capela 975 if (pMidiInstr->map < 0)
2357 capela 952 return LSCP_FAILED;
2358 capela 975 if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
2359 capela 952 return LSCP_FAILED;
2360 capela 975 if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
2361 capela 952 return LSCP_FAILED;
2362 capela 946
2363 capela 952 sprintf(szQuery, "UNMAP MIDI_INSTRUMENT %d %d %d\r\n",
2364 capela 975 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog);
2365 capela 946
2366 capela 952 return lscp_client_query(pClient, szQuery);
2367 capela 946 }
2368    
2369    
2370     /**
2371     * Get the total count of MIDI instrument map entries:
2372 capela 975 * GET MIDI_INSTRUMENTS ALL|<midi-map>
2373 capela 946 *
2374     * @param pClient Pointer to client instance structure.
2375 capela 975 * @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
2376 capela 946 *
2377     * @returns The current total number of MIDI instrument map entries
2378     * on success, -1 otherwise.
2379     */
2380 capela 975 int lscp_get_midi_instruments ( lscp_client_t *pClient, int iMidiMap )
2381 capela 946 {
2382 capela 952 int iInstruments = -1;
2383 capela 975 char szQuery[LSCP_BUFSIZ];
2384 capela 946
2385 capela 975 if (pClient == NULL)
2386     return -1;
2387    
2388 capela 952 // Lock this section up.
2389     lscp_mutex_lock(pClient->mutex);
2390 capela 946
2391 capela 975 strcpy(szQuery, "GET MIDI_INSTRUMENTS ");
2392    
2393     if (iMidiMap < 0)
2394     strcat(szQuery, "ALL");
2395     else
2396     sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
2397    
2398     strcat(szQuery, "\r\n");
2399    
2400     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
2401 capela 952 iInstruments = atoi(lscp_client_get_result(pClient));
2402 capela 946
2403 capela 952 // Unlock this section down.
2404     lscp_mutex_unlock(pClient->mutex);
2405 capela 946
2406 capela 952 return iInstruments;
2407 capela 946 }
2408    
2409    
2410     /**
2411 capela 948 * Getting indeces of all MIDI instrument map entries:
2412 capela 975 * LIST MIDI_INSTRUMENTS ALL|<midi-map>
2413 capela 948 *
2414     * @param pClient Pointer to client instance structure.
2415 capela 975 * @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
2416 capela 948 *
2417     * @returns An array of @ref lscp_midi_instrument_t, terminated with the
2418     * {-1,-1,-1} triplet, NULL otherwise.
2419     */
2420 capela 975 lscp_midi_instrument_t *lscp_list_midi_instruments ( lscp_client_t *pClient, int iMidiMap )
2421 capela 948 {
2422 capela 975 char szQuery[LSCP_BUFSIZ];
2423    
2424 capela 952 if (pClient == NULL)
2425     return NULL;
2426 capela 948
2427 capela 952 // Lock this section up.
2428     lscp_mutex_lock(pClient->mutex);
2429 capela 948
2430 capela 952 if (pClient->midi_instruments) {
2431     lscp_midi_instruments_destroy(pClient->midi_instruments);
2432     pClient->midi_instruments = NULL;
2433     }
2434 capela 948
2435 capela 975 strcpy(szQuery, "LIST MIDI_INSTRUMENTS ");
2436    
2437     if (iMidiMap < 0)
2438     strcat(szQuery, "ALL");
2439     else
2440     sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
2441    
2442     strcat(szQuery, "\r\n");
2443    
2444     if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
2445 capela 952 pClient->midi_instruments = lscp_midi_instruments_create(lscp_client_get_result(pClient));
2446 capela 948
2447 capela 952 // Unlock this section down.
2448     lscp_mutex_unlock(pClient->mutex);
2449 capela 948
2450 capela 952 return pClient->midi_instruments;
2451 capela 948 }
2452    
2453    
2454     /**
2455 capela 946 * Getting information about a MIDI instrument map entry:
2456 capela 975 * GET MIDI_INSTRUMENT INFO <midi-map> <midi-bank> <midi-prog>
2457 capela 946 *
2458     * @param pClient Pointer to client instance structure.
2459     * @param pMidiInstr MIDI instrument bank and program parameter key.
2460     *
2461     * @returns A pointer to a @ref lscp_midi_instrument_info_t structure,
2462     * with all the information of the given MIDI instrument map entry,
2463     * or NULL in case of failure.
2464     */
2465     lscp_midi_instrument_info_t *lscp_get_midi_instrument_info ( lscp_client_t *pClient, lscp_midi_instrument_t *pMidiInstr )
2466     {
2467 capela 952 lscp_midi_instrument_info_t *pInstrInfo;
2468     char szQuery[LSCP_BUFSIZ];
2469     const char *pszResult;
2470     const char *pszSeps = ":";
2471     const char *pszCrlf = "\r\n";
2472     char *pszToken;
2473     char *pch;
2474 capela 963
2475 capela 975 if (pClient == NULL)
2476 capela 952 return NULL;
2477 capela 975 if (pMidiInstr->map < 0)
2478 capela 952 return NULL;
2479 capela 975 if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
2480 capela 952 return NULL;
2481 capela 975 if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
2482     return NULL;
2483 capela 963
2484 capela 952 // Lock this section up.
2485     lscp_mutex_lock(pClient->mutex);
2486    
2487     pInstrInfo = &(pClient->midi_instrument_info);
2488     lscp_midi_instrument_info_reset(pInstrInfo);
2489 capela 963
2490 capela 952 sprintf(szQuery, "GET MIDI_INSTRUMENT INFO %d %d %d\r\n",
2491 capela 975 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog);
2492 capela 952 if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
2493     pszResult = lscp_client_get_result(pClient);
2494     pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
2495     while (pszToken) {
2496     if (strcasecmp(pszToken, "NAME") == 0) {
2497     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2498     if (pszToken)
2499     lscp_unquote_dup(&(pInstrInfo->name), &pszToken);
2500     }
2501     else if (strcasecmp(pszToken, "ENGINE_NAME") == 0) {
2502     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2503     if (pszToken)
2504     lscp_unquote_dup(&(pInstrInfo->engine_name), &pszToken);
2505     }
2506     else if (strcasecmp(pszToken, "INSTRUMENT_FILE") == 0) {
2507     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2508     if (pszToken)
2509     lscp_unquote_dup(&(pInstrInfo->instrument_file), &pszToken);
2510     }
2511     else if (strcasecmp(pszToken, "INSTRUMENT_NR") == 0) {
2512     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2513     if (pszToken)
2514     pInstrInfo->instrument_nr = atoi(lscp_ltrim(pszToken));
2515     }
2516     else if (strcasecmp(pszToken, "INSTRUMENT_NAME") == 0) {
2517     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2518     if (pszToken)
2519     lscp_unquote_dup(&(pInstrInfo->instrument_name), &pszToken);
2520     }
2521     else if (strcasecmp(pszToken, "LOAD_MODE") == 0) {
2522     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2523     if (pszToken) {
2524     pszToken = lscp_ltrim(pszToken);
2525     if (strcasecmp(pszToken, "ON_DEMAND") == 0)
2526     pInstrInfo->load_mode = LSCP_LOAD_ON_DEMAND;
2527     else
2528     if (strcasecmp(pszToken, "ON_DEMAND_HOLD") == 0)
2529     pInstrInfo->load_mode = LSCP_LOAD_ON_DEMAND_HOLD;
2530     else
2531     if (strcasecmp(pszToken, "PERSISTENT") == 0)
2532     pInstrInfo->load_mode = LSCP_LOAD_PERSISTENT;
2533     else
2534     pInstrInfo->load_mode = LSCP_LOAD_DEFAULT;
2535     }
2536     }
2537     else if (strcasecmp(pszToken, "VOLUME") == 0) {
2538     pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
2539     if (pszToken)
2540     pInstrInfo->volume = (float) atof(lscp_ltrim(pszToken));
2541     }
2542     pszToken = lscp_strtok(NULL, pszSeps, &(pch));
2543     }
2544     }
2545     else pInstrInfo = NULL;
2546 capela 963
2547 capela 952 // Unlock this section down.
2548     lscp_mutex_unlock(pClient->mutex);
2549 capela 963
2550 capela 952 return pInstrInfo;
2551 capela 946 }
2552    
2553    
2554     /**
2555     * Clear the MIDI instrumnet map:
2556 capela 975 * CLEAR MIDI_INSTRUMENTS ALL|<midi-map>
2557 capela 946 *
2558 capela 975 * @param pClient Pointer to client instance structure.
2559     * @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
2560 capela 946 *
2561     * @returns LSCP_OK on success, LSCP_FAILED otherwise.
2562     */
2563 capela 975 lscp_status_t lscp_clear_midi_instruments ( lscp_client_t *pClient, int iMidiMap )
2564 capela 946 {
2565 capela 975 char szQuery[LSCP_BUFSIZ];
2566    
2567     strcpy(szQuery, "CLEAR MIDI_INSTRUMENTS ");
2568    
2569     if (iMidiMap < 0)
2570     strcat(szQuery, "ALL");
2571     else
2572     sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
2573    
2574     strcat(szQuery, "\r\n");
2575    
2576     return lscp_client_query(pClient, szQuery);
2577 capela 946 }
2578    
2579    
2580 capela 107 // end of client.c

  ViewVC Help
Powered by ViewVC