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

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

Parent Directory | Revision Log | View Patch Patch

-revision 963 by capela,
Sun Dec  3 18:30:04 2006 UTC
+revision 2424 by capela,
Sun Feb 24 19:02:30 2013 UTC
 Line 2
  //
  /****************************************************************************
     liblscp - LinuxSampler Control Protocol API
-    Copyright (C) 2004-2006, rncbc aka Rui Nuno Capela. All rights reserved.
+    Copyright (C) 2004-2013, rncbc aka Rui Nuno Capela. All rights reserved.
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
 Line 20
  *****************************************************************************/
+ #include <locale.h>
  #include "common.h"
  // Default timeout value (in milliseconds).
  #define LSCP_TIMEOUT_MSECS  500
+ // Whether to use getaddrinfo() instead
+ // of deprecated gethostbyname()
+ #if !defined(WIN32)
+ #define USE_GETADDRINFO 1
+ #endif
  // Local prototypes.
- static void             _lscp_client_evt_proc       (void *pvClient);
+ static void _lscp_client_evt_proc (void *pvClient);
- static lscp_status_t    _lscp_client_evt_connect    (lscp_client_t *pClient);
+ static lscp_status_t _lscp_client_evt_connect (lscp_client_t *pClient);
- static lscp_status_t    _lscp_client_evt_request    (lscp_client_t *pClient, int iSubscribe, lscp_event_t event);
+ static lscp_status_t _lscp_client_evt_request (lscp_client_t *pClient,
+         int iSubscribe, lscp_event_t event);
+ //-------------------------------------------------------------------------
+ // General helper functions.
+ struct _locale_t {
+         char numeric[32];
+         char ctype[32];
+ };
+ // we need to ensure a constant locale setting e.g. for parsing
+ // floating point numbers with atof(), as the floating point separator
+ // character varies by the invidual locale settings
+ static void _save_and_set_c_locale(struct _locale_t* locale)
+ {
+         strncpy(locale->numeric, setlocale(LC_NUMERIC, NULL), 32);
+         strncpy(locale->ctype, setlocale(LC_CTYPE, NULL), 32);
+         setlocale(LC_NUMERIC, "C");
+         setlocale(LC_CTYPE, "C");
+ }
+ // restore the original locale setting as nothing happened
+ static void _restore_locale(struct _locale_t* locale)
+ {
+         setlocale(LC_NUMERIC, locale->numeric);
+         setlocale(LC_CTYPE, locale->ctype);
+ }
+ // seems the standard atof() function doesnt care much about locale
+ // runtime modifications, so we use this workaround
+ static float _atof(const char* txt) {
+         float f;
+         sscanf(txt, "%f", &f); // yeah, you're a good boy sscanf()
+         return f;
+ }
  //-------------------------------------------------------------------------
-Line 50 
 static void _lscp_client_evt_proc ( void
+Line 94 
 static void _lscp_client_evt_proc ( void
          char   achBuffer[LSCP_BUFSIZ];
          int    cchBuffer;
          const char *pszSeps = ":\r\n";
-         char * pszToken;
+         char  *pszToken;
-         char * pch;
+         char  *pch;
-         int     cchToken;
+         int    cchToken;
          lscp_event_t event;
  #ifdef DEBUG
-Line 84 
 static void _lscp_client_evt_proc ( void
+Line 129 
 static void _lscp_client_evt_proc ( void
                          if (cchBuffer > 0) {
                                  // Make sure received buffer it's null terminated.
                                  achBuffer[cchBuffer] = (char) 0;
-                                 // Parse for the notification event message...
+                                 pch = achBuffer;
-                                 pszToken = lscp_strtok(achBuffer, pszSeps, &(pch)); // Have "NOTIFY".
+                                 do {
-                                 if (strcasecmp(pszToken, "NOTIFY") == 0) {
+                                         // Parse for the notification event message...
-                                         pszToken = lscp_strtok(NULL, pszSeps, &(pch));
+                                         pszToken = lscp_strtok(NULL, pszSeps, &(pch)); // Have "NOTIFY"
-                                         event    = lscp_event_from_text(pszToken);
+                                         if (strcasecmp(pszToken, "NOTIFY") == 0) {
-                                         // And pick the rest of data...
+                                                 pszToken = lscp_strtok(NULL, pszSeps, &(pch));
-                                         pszToken = lscp_strtok(NULL, pszSeps, &(pch));
+                                                 event    = lscp_event_from_text(pszToken);
-                                         cchToken = (pszToken == NULL ? 0 : strlen(pszToken));
+                                                 // And pick the rest of data...
-                                         // Double-check if we're really up to it...
+                                                 pszToken = lscp_strtok(NULL, pszSeps, &(pch));
-                                         if (pClient->events & event) {
+                                                 cchToken = (pszToken == NULL ? 0 : strlen(pszToken));
-                                                 // Invoke the client event callback...
+                                                 // Double-check if we're really up to it...
-                                                 if ((*pClient->pfnCallback)(
+                                                 if (pClient->events & event) {
-                                                                 pClient,
+                                                         // Invoke the client event callback...
-                                                                 event,
+                                                         if ((*pClient->pfnCallback)(
-                                                                 pszToken,
+                                                                         pClient,
-                                                                 cchToken,
+                                                                         event,
-                                                                 pClient->pvData) != LSCP_OK) {
+                                                                         pszToken,
-                                                         pClient->evt.iState = 0;
+                                                                         cchToken,
+                                                                         pClient->pvData) != LSCP_OK) {
+                                                                 pClient->evt.iState = 0;
+                                                         }
                                                  }
                                          }
-                                 }
+                                 } while (*pch);
                          } else {
                                  lscp_socket_perror("_lscp_client_evt_proc: recv");
                                  pClient->evt.iState = 0;
-Line 146 
 static lscp_status_t _lscp_client_evt_co
+Line 194 
 static lscp_status_t _lscp_client_evt_co
          }
  #if defined(WIN32)
-         if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
+         if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER,
+                         (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
                  lscp_socket_perror("lscp_client_evt_connect: setsockopt(SO_DONTLINGER)");
  #endif
-Line 174 
 static lscp_status_t _lscp_client_evt_co
+Line 223 
 static lscp_status_t _lscp_client_evt_co
  // Subscribe to a single event.
- static lscp_status_t _lscp_client_evt_request ( lscp_client_t *pClient, int iSubscribe, lscp_event_t event )
+ static lscp_status_t _lscp_client_evt_request ( lscp_client_t *pClient,
+         int iSubscribe, lscp_event_t event )
  {
          const char *pszEvent;
          char  szQuery[LSCP_BUFSIZ];
-Line 189 
 static lscp_status_t _lscp_client_evt_re
+Line 239 
 static lscp_status_t _lscp_client_evt_re
                  return LSCP_FAILED;
          // Build the query string...
-         cchQuery = sprintf(szQuery, "%sSUBSCRIBE %s\n\n", (iSubscribe == 0 ? "UN" : ""), pszEvent);
+         cchQuery = sprintf(szQuery, "%sSUBSCRIBE %s\n\n",
+                 (iSubscribe == 0 ? "UN" : ""), pszEvent);
          // Just send data, forget result...
          if (send(pClient->evt.sock, szQuery, cchQuery, 0) < cchQuery) {
                  lscp_socket_perror("_lscp_client_evt_request: send");
-Line 240 
 const char* lscp_client_build   (void) {
+Line 291 
 const char* lscp_client_build   (void) {
   *  @returns The new client instance pointer if successfull, which shall be
   *  used on all subsequent client calls, NULL otherwise.
   */
- lscp_client_t* lscp_client_create ( const char *pszHost, int iPort, lscp_client_proc_t pfnCallback, void *pvData )
+ lscp_client_t* lscp_client_create ( const char *pszHost, int iPort,
+         lscp_client_proc_t pfnCallback, void *pvData )
  {
          lscp_client_t  *pClient;
+ #if defined(USE_GETADDRINFO)
+         char szPort[33];
+         struct addrinfo hints;
+         struct addrinfo *result, *res;
+ #else
          struct hostent *pHost;
-         lscp_socket_t sock;
          struct sockaddr_in addr;
          int cAddr;
+ #endif  /* !USE_GETADDRINFO */
+         lscp_socket_t sock;
  #if defined(WIN32)
          int iSockOpt = (-1);
  #endif
-Line 256 
 lscp_client_t* lscp_client_create ( cons
+Line 314 
 lscp_client_t* lscp_client_create ( cons
                  return NULL;
          }
+ #if defined(USE_GETADDRINFO)
+         // Convert port number to string/name...
+         snprintf(szPort, sizeof(szPort), "%d", iPort);
+         // Obtain address(es) matching host/port...
+         memset(&hints, 0, sizeof(struct addrinfo));
+         hints.ai_family = AF_INET;
+         hints.ai_socktype = SOCK_STREAM;
+         result = NULL;
+         if (getaddrinfo(pszHost, szPort, &hints, &result)) {
+                 lscp_socket_herror("lscp_client_create: getaddrinfo");
+                 return NULL;
+         }
+ #else
+         // Obtain host matching name...
          pHost = gethostbyname(pszHost);
          if (pHost == NULL) {
                  lscp_socket_herror("lscp_client_create: gethostbyname");
                  return NULL;
          }
+ #endif  /* !USE_GETADDRINFO */
          // Allocate client descriptor...
          pClient = (lscp_client_t *) malloc(sizeof(lscp_client_t));
-Line 275 
 lscp_client_t* lscp_client_create ( cons
+Line 355 
 lscp_client_t* lscp_client_create ( cons
          pClient->pvData = pvData;
  #ifdef DEBUG
-         fprintf(stderr, "lscp_client_create: pClient=%p: pszHost=%s iPort=%d.\n", pClient, pszHost, iPort);
+         fprintf(stderr,
+                 "lscp_client_create: pClient=%p: pszHost=%s iPort=%d.\n",
+                  pClient, pszHost, iPort);
  #endif
          // Prepare the command connection socket...
+ #if defined(USE_GETADDRINFO)
+         // getaddrinfo() returns a list of address structures;
+         // try each address until we successfully connect(2);
+         // if socket or connect fails, we close the socket and
+         // try the next address...
+         sock = INVALID_SOCKET;
+         for (res = result; res; res = res->ai_next) {
+                 sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+                 if (sock == INVALID_SOCKET)
+                         continue;
+         #if defined(WIN32)
+                 if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER,
+                                 (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
+                         lscp_socket_perror("lscp_client_create: cmd: setsockopt(SO_DONTLINGER)");
+         #endif
+         #ifdef DEBUG
+                 lscp_socket_getopts("lscp_client_create: cmd", sock);
+         #endif
+                 if (connect(sock, res->ai_addr, res->ai_addrlen) != SOCKET_ERROR)
+                         break;
+                 closesocket(sock);
+         }
+         if (sock == INVALID_SOCKET) {
+                 lscp_socket_perror("lscp_client_create: cmd: socket");
+                 free(pClient);
+                 return NULL;
+         }
+         if (res == NULL) {
+                 lscp_socket_perror("lscp_client_create: cmd: connect");
+                 free(pClient);
+                 return NULL;
+         }
+         // Initialize the command socket agent struct...
+         lscp_socket_agent_init(&(pClient->cmd), sock,
+                 (struct sockaddr_in *) res->ai_addr, res->ai_addrlen);
+         // No longer needed...
+         freeaddrinfo(result);
+ #else
          sock = socket(AF_INET, SOCK_STREAM, 0);
          if (sock == INVALID_SOCKET) {
                  lscp_socket_perror("lscp_client_create: cmd: socket");
-Line 288 
 lscp_client_t* lscp_client_create ( cons
+Line 416 
 lscp_client_t* lscp_client_create ( cons
          }
  #if defined(WIN32)
-         if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
+         if (setsockopt(sock, SOL_SOCKET, SO_DONTLINGER,
+                         (char *) &iSockOpt, sizeof(int)) == SOCKET_ERROR)
                  lscp_socket_perror("lscp_client_create: cmd: setsockopt(SO_DONTLINGER)");
  #endif
-Line 312 
 lscp_client_t* lscp_client_create ( cons
+Line 441 
 lscp_client_t* lscp_client_create ( cons
          // Initialize the command socket agent struct...
          lscp_socket_agent_init(&(pClient->cmd), sock, &addr, cAddr);
+ #endif  /* !USE_GETADDRINFO */
  #ifdef DEBUG
-         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));
+         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));
  #endif
          // Initialize the event service socket struct...
-Line 327 
 lscp_client_t* lscp_client_create ( cons
+Line 462 
 lscp_client_t* lscp_client_create ( cons
          pClient->midi_devices = NULL;
          pClient->engines = NULL;
          pClient->channels = NULL;
+         pClient->fxsends = NULL;
          pClient->midi_instruments = NULL;
+         pClient->midi_maps = NULL;
+         pClient->midi_map_name = NULL;
          lscp_driver_info_init(&(pClient->audio_driver_info));
          lscp_driver_info_init(&(pClient->midi_driver_info));
          lscp_device_info_init(&(pClient->audio_device_info));
-Line 341 
 lscp_client_t* lscp_client_create ( cons
+Line 479 
 lscp_client_t* lscp_client_create ( cons
          lscp_server_info_init(&(pClient->server_info));
          lscp_engine_info_init(&(pClient->engine_info));
          lscp_channel_info_init(&(pClient->channel_info));
+         lscp_fxsend_info_init(&(pClient->fxsend_info));
          lscp_midi_instrument_info_init(&(pClient->midi_instrument_info));
          // Initialize error stuff.
          pClient->pszResult = NULL;
-Line 403 
 lscp_status_t lscp_client_destroy ( lscp
+Line 542 
 lscp_status_t lscp_client_destroy ( lscp
          // Free up all cached members.
          lscp_midi_instrument_info_free(&(pClient->midi_instrument_info));
+         lscp_fxsend_info_free(&(pClient->fxsend_info));
          lscp_channel_info_free(&(pClient->channel_info));
          lscp_engine_info_free(&(pClient->engine_info));
          lscp_server_info_free(&(pClient->server_info));
-Line 423 
 lscp_status_t lscp_client_destroy ( lscp
+Line 563 
 lscp_status_t lscp_client_destroy ( lscp
          lscp_isplit_destroy(pClient->midi_devices);
          lscp_szsplit_destroy(pClient->engines);
          lscp_isplit_destroy(pClient->channels);
+         lscp_isplit_destroy(pClient->fxsends);
          lscp_midi_instruments_destroy(pClient->midi_instruments);
+         lscp_isplit_destroy(pClient->midi_maps);
+         if (pClient->midi_map_name)
+                 free(pClient->midi_map_name);
          // Make them null.
          pClient->audio_drivers = NULL;
          pClient->midi_drivers = NULL;
-Line 431 
 lscp_status_t lscp_client_destroy ( lscp
+Line 575 
 lscp_status_t lscp_client_destroy ( lscp
          pClient->midi_devices = NULL;
          pClient->engines = NULL;
          pClient->channels = NULL;
+         pClient->fxsends = NULL;
          pClient->midi_instruments = NULL;
+         pClient->midi_maps = NULL;
+         pClient->midi_map_name = NULL;
          // Free result error stuff.
          lscp_client_set_result(pClient, NULL, 0);
          // Free stream usage stuff.
-Line 512 
 lscp_status_t lscp_client_query ( lscp_c
+Line 659 
 lscp_status_t lscp_client_query ( lscp_c
  {
          lscp_status_t ret;
+         if (pClient == NULL)
+                 return LSCP_FAILED;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 563 
 int lscp_client_get_errno ( lscp_client_
+Line 713 
 int lscp_client_get_errno ( lscp_client_
  // Client registration protocol functions.
  /**
-  *  Register frontend for receiving event messages:
+  *  Register frontend for receiving event messages by the sampler backend.
-  *  SUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT | BUFFER_FILL
+  *  @e Caution: since liblscp v0.5.5.4 you have to call lscp_client_subscribe()
-  *      | CHANNEL_INFO | MISCELLANEOUS
+  *  for @e each event you want to subscribe. That is the old bitflag approach
+  *  was abondoned at this point. You can however still register all older
+  *  events with one lscp_client_subscribe() call at once. Thus, the old
+  *  behavior of this functions was not broken. Those older events are namely:
+  *  @code
+  *  SUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT
+  *      | BUFFER_FILL | CHANNEL_INFO | TOTAL_VOICE_COUNT
+  *      | AUDIO_OUTPUT_DEVICE_COUNT | AUDIO_OUTPUT_DEVICE_INFO
+  *      | MIDI_INPUT_DEVICE_COUNT | MIDI_INPUT_DEVICE_INFO
+  *      | MIDI_INSTRUMENT_MAP_COUNT | MIDI_INSTRUMENT_MAP_INFO
+  *      | MIDI_INSTRUMENT_COUNT | MIDI_INSTRUMENT_INFO
+  *      | MISCELLANEOUS
+  *  @endcode
+  *  The old events occupy the lower 16 bits (as bit flags), and all younger
+  *  events enumerate the whole upper 16 bits range. The new, enumerated
+  *  events are namely:
+  *  @code
+  *  SUBSCRIBE CHANNEL_MIDI
+  *  @endcode
   *
   *  @param pClient  Pointer to client instance structure.
-  *  @param events   Bit-wise OR'ed event flags to subscribe.
+  *  @param events   LSCP event to subscribe.
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
  lscp_status_t lscp_client_subscribe ( lscp_client_t *pClient, lscp_event_t events )
  {
-         lscp_status_t ret = LSCP_FAILED;
+         lscp_status_t ret = LSCP_OK;
+         lscp_event_t currentEvent;
          if (pClient == NULL)
                  return LSCP_FAILED;
-Line 597 
 lscp_status_t lscp_client_subscribe ( ls
+Line 766 
 lscp_status_t lscp_client_subscribe ( ls
                  ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_BUFFER_FILL);
          if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_INFO))
                  ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_CHANNEL_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_TOTAL_VOICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_TOTAL_VOICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_INFO))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_INFO))
+                 ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MIDI_INSTRUMENT_INFO);
          if (ret == LSCP_OK && (events & LSCP_EVENT_MISCELLANEOUS))
                  ret = _lscp_client_evt_request(pClient, 1, LSCP_EVENT_MISCELLANEOUS);
+         // Caution: for the upper 16 bits, we don't use bit flags anymore ...
+         currentEvent = events & 0xffff0000;
+         if (ret == LSCP_OK && currentEvent) {
+                 switch (currentEvent) {
+                         case LSCP_EVENT_CHANNEL_MIDI:
+                         case LSCP_EVENT_DEVICE_MIDI:
+                                 ret = _lscp_client_evt_request(pClient, 1, currentEvent);
+                                 break;
+                         default: // unknown "upper" event type
+                                 ret = LSCP_FAILED;
+                                 break;
+                 }
+         }
          // Unlock this section down.
          lscp_mutex_unlock(pClient->mutex);
-Line 608 
 lscp_status_t lscp_client_subscribe ( ls
+Line 808 
 lscp_status_t lscp_client_subscribe ( ls
  /**
-  *  Deregister frontend from receiving UDP event messages anymore:
+  *  Deregister frontend from receiving UDP event messages anymore.
-  *  SUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT | BUFFER_FILL
+  *  @e Caution: since liblscp v0.5.5.4 you have to call
-  *      | CHANNEL_INFO | MISCELLANEOUS
+  *  lscp_client_unsubscribe() for @e each event you want to unsubscribe.
+  *  That is the old bitflag approach was abondoned at this point. You can
+  *  however still register all older events with one lscp_client_subscribe()
+  *  call at once. Thus, the old behavior of this functions was not broken.
+  *  Those older events are namely:
+  *  @code
+  *  UNSUBSCRIBE CHANNEL_COUNT | VOICE_COUNT | STREAM_COUNT
+  *      | BUFFER_FILL | CHANNEL_INFO | TOTAL_VOICE_COUNT
+  *      | AUDIO_OUTPUT_DEVICE_COUNT | AUDIO_OUTPUT_DEVICE_INFO
+  *      | MIDI_INPUT_DEVICE_COUNT | MIDI_INPUT_DEVICE_INFO
+  *      | MIDI_INSTRUMENT_MAP_COUNT | MIDI_INSTRUMENT_MAP_INFO
+  *      | MIDI_INSTRUMENT_COUNT | MIDI_INSTRUMENT_INFO
+  *      | MISCELLANEOUS
+  *  @endcode
+  *  The old events occupy the lower 16 bits (as bit flags), and all younger
+  *  events enumerate the whole upper 16 bits range. The new, enumerated
+  *  events are namely:
+  *  @code
+  *  UNSUBSCRIBE CHANNEL_MIDI
+  *  @endcode
   *
   *  @param pClient  Pointer to client instance structure.
-  *  @param events   Bit-wise OR'ed event flags to unsubscribe.
+  *  @param events   LSCP event to unsubscribe.
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
  lscp_status_t lscp_client_unsubscribe ( lscp_client_t *pClient, lscp_event_t events )
  {
          lscp_status_t ret = LSCP_OK;
+         lscp_event_t currentEvent;
          if (pClient == NULL)
                  return LSCP_FAILED;
-Line 638 
 lscp_status_t lscp_client_unsubscribe (
+Line 858 
 lscp_status_t lscp_client_unsubscribe (
                  ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_BUFFER_FILL);
          if (ret == LSCP_OK && (events & LSCP_EVENT_CHANNEL_INFO))
                  ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_CHANNEL_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_TOTAL_VOICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_TOTAL_VOICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INPUT_DEVICE_INFO))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_MAP_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_MAP_INFO);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_COUNT))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_COUNT);
+         if (ret == LSCP_OK && (events & LSCP_EVENT_MIDI_INSTRUMENT_INFO))
+                 ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MIDI_INSTRUMENT_INFO);
          if (ret == LSCP_OK && (events & LSCP_EVENT_MISCELLANEOUS))
                  ret = _lscp_client_evt_request(pClient, 0, LSCP_EVENT_MISCELLANEOUS);
+         // Caution: for the upper 16 bits, we don't use bit flags anymore ...
+         currentEvent = events & 0xffff0000;
+         if (ret == LSCP_OK && currentEvent) {
+                 switch (currentEvent) {
+                         case LSCP_EVENT_CHANNEL_MIDI:
+                         case LSCP_EVENT_DEVICE_MIDI:
+                                 ret = _lscp_client_evt_request(pClient, 0, currentEvent);
+                                 break;
+                         default: // unknown "upper" event type
+                                 ret = LSCP_FAILED;
+                                 break;
+                 }
+         }
          // If necessary, close the alternate connection...
          if (pClient->events == LSCP_EVENT_NONE)
-Line 682 
 lscp_event_t lscp_client_get_events ( ls
+Line 933 
 lscp_event_t lscp_client_get_events ( ls
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_load_instrument ( lscp_client_t *pClient, const char *pszFileName, int iInstrIndex, int iSamplerChannel )
+ lscp_status_t lscp_load_instrument ( lscp_client_t *pClient,
+         const char *pszFileName, int iInstrIndex, int iSamplerChannel )
  {
          char szQuery[LSCP_BUFSIZ];
          if (pszFileName == NULL || iSamplerChannel < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "LOAD INSTRUMENT '%s' %d %d\r\n", pszFileName, iInstrIndex, iSamplerChannel);
+         sprintf(szQuery, "LOAD INSTRUMENT '%s' %d %d\r\n",
+                 pszFileName, iInstrIndex, iSamplerChannel);
          return lscp_client_query(pClient, szQuery);
  }
-Line 705 
 lscp_status_t lscp_load_instrument ( lsc
+Line 958 
 lscp_status_t lscp_load_instrument ( lsc
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_load_instrument_non_modal ( lscp_client_t *pClient, const char *pszFileName, int iInstrIndex, int iSamplerChannel )
+ lscp_status_t lscp_load_instrument_non_modal ( lscp_client_t *pClient,
+         const char *pszFileName, int iInstrIndex, int iSamplerChannel )
  {
          char szQuery[LSCP_BUFSIZ];
          if (pszFileName == NULL || iSamplerChannel < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "LOAD INSTRUMENT NON_MODAL '%s' %d %d\r\n", pszFileName, iInstrIndex, iSamplerChannel);
+         sprintf(szQuery, "LOAD INSTRUMENT NON_MODAL '%s' %d %d\r\n",
+                 pszFileName, iInstrIndex, iSamplerChannel);
          return lscp_client_query(pClient, szQuery);
  }
-Line 734 
 lscp_status_t lscp_load_engine ( lscp_cl
+Line 989 
 lscp_status_t lscp_load_engine ( lscp_cl
          if (pszEngineName == NULL || iSamplerChannel < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "LOAD ENGINE %s %d\r\n", pszEngineName, iSamplerChannel);
+         sprintf(szQuery, "LOAD ENGINE %s %d\r\n",
+                 pszEngineName, iSamplerChannel);
          return lscp_client_query(pClient, szQuery);
  }
-Line 752 
 int lscp_get_channels ( lscp_client_t *p
+Line 1008 
 int lscp_get_channels ( lscp_client_t *p
  {
          int iChannels = -1;
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 812 
 int lscp_add_channel ( lscp_client_t *pC
+Line 1071 
 int lscp_add_channel ( lscp_client_t *pC
  {
          int iSamplerChannel = -1;
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 859 
 int lscp_get_available_engines ( lscp_cl
+Line 1121 
 int lscp_get_available_engines ( lscp_cl
  {
          int iAvailableEngines = -1;
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 885 
 const char **lscp_list_available_engines
+Line 1150 
 const char **lscp_list_available_engines
  {
          const char *pszSeps = ",";
+         if (pClient == NULL)
+                 return NULL;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 913 
 const char **lscp_list_available_engines
+Line 1181 
 const char **lscp_list_available_engines
   *  @returns A pointer to a @ref lscp_engine_info_t structure, with all the
   *  information of the given sampler engine, or NULL in case of failure.
   */
- lscp_engine_info_t *lscp_get_engine_info ( lscp_client_t *pClient, const char *pszEngineName )
+ lscp_engine_info_t *lscp_get_engine_info ( lscp_client_t *pClient,
+         const char *pszEngineName )
  {
          lscp_engine_info_t *pEngineInfo;
          char szQuery[LSCP_BUFSIZ];
-Line 923 
 lscp_engine_info_t *lscp_get_engine_info
+Line 1192 
 lscp_engine_info_t *lscp_get_engine_info
          char *pszToken;
          char *pch;
+         if (pClient == NULL)
+                 return NULL;
          if (pszEngineName == NULL)
                  return NULL;
-Line 978 
 lscp_channel_info_t *lscp_get_channel_in
+Line 1249 
 lscp_channel_info_t *lscp_get_channel_in
          const char *pszCrlf = "\r\n";
          char *pszToken;
          char *pch;
+         struct _locale_t locale;
+         if (pClient == NULL)
+                 return NULL;
          if (iSamplerChannel < 0)
                  return NULL;
-Line 988 
 lscp_channel_info_t *lscp_get_channel_in
+Line 1262 
 lscp_channel_info_t *lscp_get_channel_in
          pChannelInfo = &(pClient->channel_info);
          lscp_channel_info_reset(pChannelInfo);
+         _save_and_set_c_locale(&locale);
          sprintf(szQuery, "GET CHANNEL INFO %d\r\n", iSamplerChannel);
          if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
                  pszResult = lscp_client_get_result(pClient);
-Line 1012 
 lscp_channel_info_t *lscp_get_channel_in
+Line 1288 
 lscp_channel_info_t *lscp_get_channel_in
                                  pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                                  if (pszToken) {
                                          if (pChannelInfo->audio_routing)
-                                                 lscp_szsplit_destroy(pChannelInfo->audio_routing);
+                                                 lscp_isplit_destroy(pChannelInfo->audio_routing);
-                                         pChannelInfo->audio_routing = lscp_szsplit_create(pszToken, ",");
+                                         pChannelInfo->audio_routing = lscp_isplit_create(pszToken, ",");
                                  }
                          }
                          else if (strcasecmp(pszToken, "INSTRUMENT_FILE") == 0) {
-Line 1056 
 lscp_channel_info_t *lscp_get_channel_in
+Line 1332 
 lscp_channel_info_t *lscp_get_channel_in
                                                  pChannelInfo->midi_channel = atoi(pszToken);
                                  }
                          }
+                         else if (strcasecmp(pszToken, "MIDI_INSTRUMENT_MAP") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken) {
+                                         pszToken = lscp_ltrim(pszToken);
+                                         if (strcasecmp(pszToken, "NONE") == 0)
+                                                 pChannelInfo->midi_map = LSCP_MIDI_MAP_NONE;
+                                         else
+                                         if (strcasecmp(pszToken, "DEFAULT") == 0)
+                                                 pChannelInfo->midi_map = LSCP_MIDI_MAP_DEFAULT;
+                                         else
+                                                 pChannelInfo->midi_map = atoi(pszToken);
+                                 }
+                         }
                          else if (strcasecmp(pszToken, "VOLUME") == 0) {
                                  pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                                  if (pszToken)
-                                         pChannelInfo->volume = (float) atof(lscp_ltrim(pszToken));
+                                         pChannelInfo->volume = _atof(lscp_ltrim(pszToken));
                          }
                          else if (strcasecmp(pszToken, "MUTE") == 0) {
                                  pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
-Line 1076 
 lscp_channel_info_t *lscp_get_channel_in
+Line 1365 
 lscp_channel_info_t *lscp_get_channel_in
          }
          else pChannelInfo = NULL;
+         _restore_locale(&locale);
          // Unlock this section up.
          lscp_mutex_unlock(pClient->mutex);
-Line 1097 
 int lscp_get_channel_voice_count ( lscp_
+Line 1388 
 int lscp_get_channel_voice_count ( lscp_
          char szQuery[LSCP_BUFSIZ];
          int iVoiceCount = -1;
+         if (pClient == NULL)
+                 return -1;
          if (iSamplerChannel < 0)
-                 return iVoiceCount;
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1128 
 int lscp_get_channel_stream_count ( lscp
+Line 1421 
 int lscp_get_channel_stream_count ( lscp
          char szQuery[LSCP_BUFSIZ];
          int iStreamCount = -1;
+         if (pClient == NULL)
+                 return -1;
          if (iSamplerChannel < 0)
-                 return iStreamCount;
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1165 
 int lscp_get_channel_stream_usage ( lscp
+Line 1460 
 int lscp_get_channel_stream_usage ( lscp
          int   iStream;
          int   iPercent;
+         if (pClient == NULL)
+                 return -1;
          if (iSamplerChannel < 0)
-                 return iStreamUsage;
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1213 
 int lscp_get_channel_stream_usage ( lscp
+Line 1510 
 int lscp_get_channel_stream_usage ( lscp
   *  information of the current disk stream buffer fill usage, for the given
   *  sampler channel, or NULL in case of failure.
   */
- lscp_buffer_fill_t *lscp_get_channel_buffer_fill ( lscp_client_t *pClient, lscp_usage_t usage_type, int iSamplerChannel )
+ lscp_buffer_fill_t *lscp_get_channel_buffer_fill ( lscp_client_t *pClient,
+         lscp_usage_t usage_type, int iSamplerChannel )
  {
          lscp_buffer_fill_t *pBufferFill;
          char szQuery[LSCP_BUFSIZ];
-Line 1227 
 lscp_buffer_fill_t *lscp_get_channel_buf
+Line 1525 
 lscp_buffer_fill_t *lscp_get_channel_buf
          // Retrieve a channel stream estimation.
          iStreamCount = lscp_get_channel_stream_count(pClient, iSamplerChannel);
-         if (pClient->iStreamCount < 0)
+         if (iStreamCount < 0)
                  return NULL;
          // Lock this section up.
-Line 1286 
 lscp_buffer_fill_t *lscp_get_channel_buf
+Line 1584 
 lscp_buffer_fill_t *lscp_get_channel_buf
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_audio_type ( lscp_client_t *pClient, int iSamplerChannel, const char *pszAudioDriver )
+ lscp_status_t lscp_set_channel_audio_type ( lscp_client_t *pClient,
+         int iSamplerChannel, const char *pszAudioDriver )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || pszAudioDriver == NULL)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_TYPE %d %s\r\n", iSamplerChannel, pszAudioDriver);
+         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_TYPE %d %s\r\n",
+                 iSamplerChannel, pszAudioDriver);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1308 
 lscp_status_t lscp_set_channel_audio_typ
+Line 1608 
 lscp_status_t lscp_set_channel_audio_typ
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_audio_device ( lscp_client_t *pClient, int iSamplerChannel, int iAudioDevice )
+ lscp_status_t lscp_set_channel_audio_device ( lscp_client_t *pClient,
+         int iSamplerChannel, int iAudioDevice )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iAudioDevice < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_DEVICE %d %d\r\n", iSamplerChannel, iAudioDevice);
+         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_DEVICE %d %d\r\n",
+                 iSamplerChannel, iAudioDevice);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1331 
 lscp_status_t lscp_set_channel_audio_dev
+Line 1633 
 lscp_status_t lscp_set_channel_audio_dev
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_audio_channel ( lscp_client_t *pClient, int iSamplerChannel, int iAudioOut, int iAudioIn )
+ lscp_status_t lscp_set_channel_audio_channel ( lscp_client_t *pClient,
+         int iSamplerChannel, int iAudioOut, int iAudioIn )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iAudioOut < 0 || iAudioIn < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_CHANNEL %d %d %d\r\n", iSamplerChannel, iAudioOut, iAudioIn);
+         sprintf(szQuery, "SET CHANNEL AUDIO_OUTPUT_CHANNEL %d %d %d\r\n",
+                 iSamplerChannel, iAudioOut, iAudioIn);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1353 
 lscp_status_t lscp_set_channel_audio_cha
+Line 1657 
 lscp_status_t lscp_set_channel_audio_cha
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_midi_type ( lscp_client_t *pClient, int iSamplerChannel, const char *pszMidiDriver )
+ lscp_status_t lscp_set_channel_midi_type ( lscp_client_t *pClient,
+         int iSamplerChannel, const char *pszMidiDriver )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || pszMidiDriver == NULL)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_TYPE %d %s\r\n", iSamplerChannel, pszMidiDriver);
+         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_TYPE %d %s\r\n",
+                 iSamplerChannel, pszMidiDriver);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1375 
 lscp_status_t lscp_set_channel_midi_type
+Line 1681 
 lscp_status_t lscp_set_channel_midi_type
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_midi_device ( lscp_client_t *pClient, int iSamplerChannel, int iMidiDevice )
+ lscp_status_t lscp_set_channel_midi_device ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMidiDevice )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iMidiDevice < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_DEVICE %d %d\r\n", iSamplerChannel, iMidiDevice);
+         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_DEVICE %d %d\r\n",
+                 iSamplerChannel, iMidiDevice);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1397 
 lscp_status_t lscp_set_channel_midi_devi
+Line 1705 
 lscp_status_t lscp_set_channel_midi_devi
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_midi_port ( lscp_client_t *pClient, int iSamplerChannel, int iMidiPort )
+ lscp_status_t lscp_set_channel_midi_port ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMidiPort )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iMidiPort < 0)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_PORT %d %d\r\n", iSamplerChannel, iMidiPort);
+         sprintf(szQuery, "SET CHANNEL MIDI_INPUT_PORT %d %d\r\n",
+                 iSamplerChannel, iMidiPort);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1416 
 lscp_status_t lscp_set_channel_midi_port
+Line 1726 
 lscp_status_t lscp_set_channel_midi_port
   *  @param pClient          Pointer to client instance structure.
   *  @param iSamplerChannel  Sampler channel number.
   *  @param iMidiChannel     MIDI channel address number to listen (0-15) or
-  *                          LSCP_MIDI_CHANNEL_ALL (16) to listen on all channels.
+  *                          @ref LSCP_MIDI_CHANNEL_ALL (16) to listen on all channels.
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_midi_channel ( lscp_client_t *pClient, int iSamplerChannel, int iMidiChannel )
+ lscp_status_t lscp_set_channel_midi_channel ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMidiChannel )
  {
          char szQuery[LSCP_BUFSIZ];
-Line 1428 
 lscp_status_t lscp_set_channel_midi_chan
+Line 1739 
 lscp_status_t lscp_set_channel_midi_chan
                  return LSCP_FAILED;
          if (iMidiChannel == LSCP_MIDI_CHANNEL_ALL)
-                 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d ALL\r\n", iSamplerChannel);
+                 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d ALL\r\n",
+                         iSamplerChannel);
+         else
+                 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d %d\r\n",
+                         iSamplerChannel, iMidiChannel);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Setting MIDI instrument map:
+  *  SET CHANNEL MIDI_INSTRUMENT_MAP <sampler-channel> <midi-map>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iMidiMap         MIDI instrument map number, or either
+  *                          @ref LSCP_MIDI_MAP_NONE or
+  *                          @ref LSCP_MIDI_MAP_DEFAULT .
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_channel_midi_map ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMidiMap )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iSamplerChannel < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET CHANNEL MIDI_INSTRUMENT_MAP %d ", iSamplerChannel);
+         if (iMidiMap == LSCP_MIDI_MAP_NONE)
+                 strcat(szQuery , "NONE");
+         else
+         if (iMidiMap == LSCP_MIDI_MAP_DEFAULT)
+                 strcat(szQuery , "DEFAULT");
          else
-                 sprintf(szQuery, "SET CHANNEL MIDI_INPUT_CHANNEL %d %d\r\n", iSamplerChannel, iMidiChannel);
+                 sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
+         strcat(szQuery, "\r\n");
          return lscp_client_query(pClient, szQuery);
  }
-Line 1447 
 lscp_status_t lscp_set_channel_midi_chan
+Line 1795 
 lscp_status_t lscp_set_channel_midi_chan
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_volume ( lscp_client_t *pClient, int iSamplerChannel, float fVolume )
+ lscp_status_t lscp_set_channel_volume ( lscp_client_t *pClient,
+         int iSamplerChannel, float fVolume )
  {
          char szQuery[LSCP_BUFSIZ];
+         struct _locale_t locale;
-         if (iSamplerChannel < 0 || fVolume < 0.0)
+         if (iSamplerChannel < 0 || fVolume < 0.0f)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL VOLUME %d %g\r\n", iSamplerChannel, fVolume);
+         _save_and_set_c_locale(&locale);
+         sprintf(szQuery, "SET CHANNEL VOLUME %d %g\r\n",
+                 iSamplerChannel, fVolume);
+         _restore_locale(&locale);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1471 
 lscp_status_t lscp_set_channel_volume (
+Line 1825 
 lscp_status_t lscp_set_channel_volume (
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_mute ( lscp_client_t *pClient, int iSamplerChannel, int iMute )
+ lscp_status_t lscp_set_channel_mute ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMute )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iMute < 0 || iMute > 1)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL MUTE %d %d\r\n", iSamplerChannel, iMute);
+         sprintf(szQuery, "SET CHANNEL MUTE %d %d\r\n",
+                 iSamplerChannel, iMute);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1495 
 lscp_status_t lscp_set_channel_mute ( ls
+Line 1851 
 lscp_status_t lscp_set_channel_mute ( ls
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_set_channel_solo ( lscp_client_t *pClient, int iSamplerChannel, int iSolo )
+ lscp_status_t lscp_set_channel_solo ( lscp_client_t *pClient,
+         int iSamplerChannel, int iSolo )
  {
          char szQuery[LSCP_BUFSIZ];
          if (iSamplerChannel < 0 || iSolo < 0 || iSolo > 1)
                  return LSCP_FAILED;
-         sprintf(szQuery, "SET CHANNEL SOLO %d %d\r\n", iSamplerChannel, iSolo);
+         sprintf(szQuery, "SET CHANNEL SOLO %d %d\r\n",
+                 iSamplerChannel, iSolo);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1538 
 lscp_status_t lscp_reset_channel ( lscp_
+Line 1896 
 lscp_status_t lscp_reset_channel ( lscp_
   */
  lscp_status_t lscp_reset_sampler ( lscp_client_t *pClient )
  {
+         // Do actual whole sampler reset...
          return lscp_client_query(pClient, "RESET\r\n");
  }
-Line 1560 
 lscp_server_info_t *lscp_get_server_info
+Line 1919 
 lscp_server_info_t *lscp_get_server_info
          char *pszToken;
          char *pch;
+         if (pClient == NULL)
+                 return NULL;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1580 
 lscp_server_info_t *lscp_get_server_info
+Line 1942 
 lscp_server_info_t *lscp_get_server_info
                                  if (pszToken)
                                          lscp_unquote_dup(&(pServerInfo->version), &pszToken);
                          }
+                         else if (strcasecmp(pszToken, "PROTOCOL_VERSION") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken)
+                                         lscp_unquote_dup(&(pServerInfo->protocol_version), &pszToken);
+                         }
                          pszToken = lscp_strtok(NULL, pszSeps, &(pch));
                  }
          }
-Line 1605 
 int lscp_get_total_voice_count ( lscp_cl
+Line 1972 
 int lscp_get_total_voice_count ( lscp_cl
  {
          int iVoiceCount = -1;
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1631 
 int lscp_get_total_voice_count_max ( lsc
+Line 2001 
 int lscp_get_total_voice_count_max ( lsc
  {
          int iVoiceCount = -1;
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-Line 1645 
 int lscp_get_total_voice_count_max ( lsc
+Line 2018 
 int lscp_get_total_voice_count_max ( lsc
  /**
+  *  Get global volume attenuation:
+  *  GET VOLUME
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *
+  *  @returns The global volume as positive floating point value usually in
+  *  the range between 0.0 and 1.0; in case of failure 0.0 is returned.
+  */
+ float lscp_get_volume ( lscp_client_t *pClient )
+ {
+         float fVolume = 0.0f;
+         struct _locale_t locale;
+         if (pClient == NULL)
+                 return 0.0f;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         _save_and_set_c_locale(&locale);
+         if (lscp_client_call(pClient, "GET VOLUME\r\n", 0) == LSCP_OK)
+                 fVolume = _atof(lscp_client_get_result(pClient));
+         _restore_locale(&locale);
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return fVolume;
+ }
+ /**
+  *  Setting global volume attenuation:
+  *  SET VOLUME <volume>
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *  @param fVolume  Global volume parameter as positive floating point
+  *                  value usually be in the range between 0.0 and 1.0,
+  *                  that is for attenuating the overall volume.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_volume ( lscp_client_t *pClient, float fVolume )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         struct _locale_t locale;
+         if (fVolume < 0.0f)
+                 return LSCP_FAILED;
+         _save_and_set_c_locale(&locale);
+         sprintf(szQuery, "SET VOLUME %g\r\n", fVolume);
+         _restore_locale(&locale);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Get global voice limit setting:
+  *  @code
+  *  GET VOICES
+  *  @endcode
+  *  This value reflects the maximum amount of voices a sampler engine
+  *  processes simultaniously before voice stealing kicks in.
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *
+  *  @returns The current global maximum amount of voices limit or a
+  *           negative value on error (e.g. if sampler doesn't support
+  *           this command).
+  */
+ int lscp_get_voices ( lscp_client_t *pClient )
+ {
+         int iVoices = -1;
+         if (pClient == NULL)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (lscp_client_call(pClient, "GET VOICES\r\n", 0) == LSCP_OK)
+                 iVoices = atoi(lscp_client_get_result(pClient));
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return iVoices;
+ }
+ /**
+  *  Setting global voice limit setting:
+  *  @code
+  *  SET VOICES <max-voices>
+  *  @endcode
+  *  This value reflects the maximum amount of voices a sampler engine
+  *  processes simultaniously before voice stealing kicks in. Note that
+  *  this value will be passed to all sampler engine instances, that is
+  *  the total amount of maximum voices on the running system is thus
+  *  @param iMaxVoices multiplied with the current amount of sampler
+  *  engine instances.
+  *
+  *  @param pClient     Pointer to client instance structure.
+  *  @param iMaxVoices  Global voice limit setting as integer value larger
+  *                     or equal to 1.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_voices ( lscp_client_t *pClient, int iMaxVoices )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iMaxVoices < 1)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET VOICES %d\r\n", iMaxVoices);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Get global disk streams limit setting:
+  *  @code
+  *  GET STREAMS
+  *  @endcode
+  *  This value reflects the maximum amount of disk streams a sampler
+  *  engine processes simultaniously.
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *
+  *  @returns The current global maximum amount of disk streams limit
+  *           or a negative value on error (e.g. if sampler doesn't
+  *           support this command).
+  */
+ int lscp_get_streams ( lscp_client_t *pClient )
+ {
+         int iStreams = -1;
+         if (pClient == NULL)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (lscp_client_call(pClient, "GET STREAMS\r\n", 0) == LSCP_OK)
+                 iStreams = atoi(lscp_client_get_result(pClient));
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return iStreams;
+ }
+ /**
+  *  Setting global disk streams limit setting:
+  *  @code
+  *  SET STREAMS <max-streams>
+  *  @endcode
+  *  This value reflects the maximum amount of dist streams a sampler
+  *  engine instance processes simultaniously. Note that this value will
+  *  be passed to all sampler engine instances, that is the total amount
+  *  of maximum disk streams on the running system is thus
+  *  @param iMaxStreams multiplied with the current amount of sampler
+  *  engine instances.
+  *
+  *  @param pClient      Pointer to client instance structure.
+  *  @param iMaxStreams  Global streams limit setting as positive integer
+  *                      value (larger or equal to 0).
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_streams ( lscp_client_t *pClient, int iMaxStreams )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iMaxStreams < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET STREAMS %d\r\n", iMaxStreams);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Add an effect send to a sampler channel:
+  *  CREATE FX_SEND <sampler-channel> <midi-ctrl> [<fx-name>]
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iMidiController  MIDI controller used to alter the effect,
+  *                          usually a number between 0 and 127.
+  *  @param pszFxName        Optional name for the effect send entity,
+  *                          does not have to be unique.
+  *
+  *  @returns The new effect send number identifier, or -1 in case of failure.
+  */
+ int lscp_create_fxsend ( lscp_client_t *pClient,
+         int iSamplerChannel, int iMidiController, const char *pszFxName )
+ {
+         int iFxSend = -1;
+         char szQuery[LSCP_BUFSIZ];
+         if (pClient == NULL)
+                 return -1;
+         if (iSamplerChannel < 0 || iMidiController < 0 || iMidiController > 127)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         sprintf(szQuery, "CREATE FX_SEND %d %d",
+                 iSamplerChannel, iMidiController);
+         if (pszFxName)
+                 sprintf(szQuery + strlen(szQuery), " '%s'", pszFxName);
+         strcat(szQuery, "\r\n");
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
+                 iFxSend = atoi(lscp_client_get_result(pClient));
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return iFxSend;
+ }
+ /**
+  *  Remove an effect send from a sampler channel:
+  *  DESTROY FX_SEND <sampler-channel> <fx-send-id>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_destroy_fxsend ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iSamplerChannel < 0 || iFxSend < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "DESTROY FX_SEND %d %d\r\n",
+                 iSamplerChannel, iFxSend);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Get amount of effect sends on a sampler channel:
+  *  GET FX_SENDS <sampler-channel>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *
+  *  @returns The current total number of effect sends of the sampler channel
+  *  on success, -1 otherwise.
+  */
+ int lscp_get_fxsends ( lscp_client_t *pClient, int iSamplerChannel )
+ {
+         int iFxSends = -1;
+         char szQuery[LSCP_BUFSIZ];
+         if (pClient == NULL)
+                 return -1;
+         if (iSamplerChannel < 0)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         sprintf(szQuery, "GET FX_SENDS %d\r\n", iSamplerChannel);
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
+                 iFxSends = atoi(lscp_client_get_result(pClient));
+         // Unlock this section doen.
+         lscp_mutex_unlock(pClient->mutex);
+         return iFxSends;
+ }
+ /**
+  *  List all effect sends on a sampler channel:
+  *  LIST FX_SENDS <sampler-channel>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *
+  *  @returns An array of the effect sends identifiers as positive integers,
+  *  terminated with -1 on success, NULL otherwise.
+  */
+ int *lscp_list_fxsends ( lscp_client_t *pClient, int iSamplerChannel )
+ {
+         const char *pszSeps = ",";
+         char szQuery[LSCP_BUFSIZ];
+         if (pClient == NULL)
+                 return NULL;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (pClient->fxsends) {
+                 lscp_isplit_destroy(pClient->fxsends);
+                 pClient->fxsends = NULL;
+         }
+         sprintf(szQuery, "LIST FX_SENDS %d\r\n", iSamplerChannel);
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
+                 pClient->fxsends = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return pClient->fxsends;
+ }
+ /**
+  *  Getting effect send information
+  *  GET FX_SEND INFO <sampler-channel> <fx-send-id>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *
+  *  @returns A pointer to a @ref lscp_fxsend_info_t structure, with the
+  *  information of the given FX send, or NULL in case of failure.
+  */
+ lscp_fxsend_info_t *lscp_get_fxsend_info ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend )
+ {
+         lscp_fxsend_info_t *pFxSendInfo;
+         char szQuery[LSCP_BUFSIZ];
+         const char *pszResult;
+         const char *pszSeps = ":";
+         const char *pszCrlf = "\r\n";
+         char *pszToken;
+         char *pch;
+         struct _locale_t locale;
+         if (pClient == NULL)
+                 return NULL;
+         if (iSamplerChannel < 0 || iFxSend < 0)
+                 return NULL;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         _save_and_set_c_locale(&locale);
+         pFxSendInfo = &(pClient->fxsend_info);
+         lscp_fxsend_info_reset(pFxSendInfo);
+         sprintf(szQuery, "GET FX_SEND INFO %d %d\r\n", iSamplerChannel, iFxSend);
+         if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
+                 pszResult = lscp_client_get_result(pClient);
+                 pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
+                 while (pszToken) {
+                         if (strcasecmp(pszToken, "NAME") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken)
+                                         lscp_unquote_dup(&(pFxSendInfo->name), &pszToken);
+                         }
+                         else if (strcasecmp(pszToken, "MIDI_CONTROLLER") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken)
+                                         pFxSendInfo->midi_controller = atoi(lscp_ltrim(pszToken));
+                         }
+                         else if (strcasecmp(pszToken, "AUDIO_OUTPUT_ROUTING") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken) {
+                                         if (pFxSendInfo->audio_routing)
+                                                 lscp_isplit_destroy(pFxSendInfo->audio_routing);
+                                         pFxSendInfo->audio_routing = lscp_isplit_create(pszToken, ",");
+                                 }
+                         }
+                         else if (strcasecmp(pszToken, "LEVEL") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken)
+                                         pFxSendInfo->level = _atof(lscp_ltrim(pszToken));
+                         }
+                         pszToken = lscp_strtok(NULL, pszSeps, &(pch));
+                 }
+         }
+         else pFxSendInfo = NULL;
+         _restore_locale(&locale);
+         // Unlock this section up.
+         lscp_mutex_unlock(pClient->mutex);
+         return pFxSendInfo;
+ }
+ /**
+  *  Alter effect send's name:
+  *  @code
+  *  SET FX_SEND NAME <sampler-chan> <fx-send-id> <name>
+  *  @endcode
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *  @param pszFxName        Effect send's new name.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_fxsend_name ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend, const char *pszFxName )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (!pClient || iSamplerChannel < 0 || iFxSend < 0 || !pszFxName)
+                 return LSCP_FAILED;
+         snprintf(szQuery, LSCP_BUFSIZ, "SET FX_SEND NAME %d %d '%s'\r\n",
+                 iSamplerChannel, iFxSend, pszFxName);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Alter effect send's audio routing:
+  *  SET FX_SEND AUDIO_OUTPUT_CHANNEL <sampler-chan> <fx-send-id>
+  *    <audio-src> <audio-dst>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *  @param iAudioSrc        Audio output device channel to be routed from.
+  *  @param iAudioDst        Audio output device channel to be routed into.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_fxsend_audio_channel ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend, int iAudioSrc, int iAudioDst )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iSamplerChannel < 0 || iFxSend < 0 || iAudioSrc < 0 || iAudioDst < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET FX_SEND AUDIO_OUTPUT_CHANNEL %d %d %d %d\r\n",
+                 iSamplerChannel, iFxSend, iAudioSrc, iAudioDst);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Alter effect send's MIDI controller:
+  *  SET FX_SEND MIDI_CONTROLLER <sampler-chan> <fx-send-id> <midi-ctrl>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *  @param iMidiController  MIDI controller used to alter the effect,
+  *                          usually a number between 0 and 127.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_fxsend_midi_controller ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend, int iMidiController )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iSamplerChannel < 0 || iFxSend < 0 ||
+                 iMidiController < 0 || iMidiController > 127)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET FX_SEND MIDI_CONTROLLER %d %d %d\r\n",
+                 iSamplerChannel, iFxSend, iMidiController);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Alter effect send's audio level:
+  *  SET FX_SEND LEVEL <sampler-chan> <fx-send-id> <level>
+  *
+  *  @param pClient          Pointer to client instance structure.
+  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iFxSend          Effect send number.
+  *  @param fLevel           Effect send volume level.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_fxsend_level ( lscp_client_t *pClient,
+         int iSamplerChannel, int iFxSend, float fLevel )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         struct _locale_t locale;
+         if (iSamplerChannel < 0 || iFxSend < 0 || fLevel < 0.0f)
+                 return LSCP_FAILED;
+         _save_and_set_c_locale(&locale);
+         sprintf(szQuery, "SET FX_SEND LEVEL %d %d %f\r\n",
+                 iSamplerChannel, iFxSend, fLevel);
+         _restore_locale(&locale);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Create a new MIDI instrument map:
+  *  ADD MIDI_INSTRUMENT_MAP [<name>]
+  *
+  *  @param pClient      Pointer to client instance structure.
+  *  @param pszMapName   MIDI instrument map name (optional)
+  *
+  *  @returns The new MIDI instrument map number identifier,
+  *  or -1 in case of failure.
+  */
+ int lscp_add_midi_instrument_map ( lscp_client_t *pClient, const char *pszMapName )
+ {
+         int iMidiMap = -1;
+         char szQuery[LSCP_BUFSIZ];
+         if (pClient == NULL)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         strcpy(szQuery, "ADD MIDI_INSTRUMENT_MAP");
+         if (pszMapName)
+                 sprintf(szQuery + strlen(szQuery), " '%s'", pszMapName);
+         strcat(szQuery, "\r\n");
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
+                 iMidiMap = atoi(lscp_client_get_result(pClient));
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return iMidiMap;
+ }
+ /**
+  *  Delete one particular or all MIDI instrument maps:
+  *  REMOVE MIDI_INSTRUMENT_MAP <midi-map>
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *  @param iMidiMap MIDI instrument map number.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_remove_midi_instrument_map ( lscp_client_t *pClient, int iMidiMap )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iMidiMap < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "REMOVE MIDI_INSTRUMENT_MAP %d\r\n", iMidiMap);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  *  Get amount of existing MIDI instrument maps:
+  *  GET MIDI_INSTRUMENT_MAPS
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *
+  *  @returns The current total number of MIDI instrument maps
+  *  on success, -1 otherwise.
+  */
+ int lscp_get_midi_instrument_maps ( lscp_client_t *pClient )
+ {
+         int iMidiMaps = -1;
+         if (pClient == NULL)
+                 return -1;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (lscp_client_call(pClient, "GET MIDI_INSTRUMENT_MAPS\r\n", 0) == LSCP_OK)
+                 iMidiMaps = atoi(lscp_client_get_result(pClient));
+         // Unlock this section doen.
+         lscp_mutex_unlock(pClient->mutex);
+         return iMidiMaps;
+ }
+ /**
+  *  Getting all created MIDI instrument maps:
+  *  LIST MIDI_INSTRUMENT_MAPS
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *
+  *  @returns An array of the MIDI instrument map identifiers as positive
+  *  integers, terminated with -1 on success, NULL otherwise.
+  */
+ int *lscp_list_midi_instrument_maps ( lscp_client_t *pClient )
+ {
+         const char *pszSeps = ",";
+         if (pClient == NULL)
+                 return NULL;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (pClient->midi_maps) {
+                 lscp_isplit_destroy(pClient->midi_maps);
+                 pClient->midi_maps = NULL;
+         }
+         if (lscp_client_call(pClient, "LIST MIDI_INSTRUMENT_MAPS\r\n", 0) == LSCP_OK)
+                 pClient->midi_maps = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return pClient->midi_maps;
+ }
+ /**
+  *  Getting a MIDI instrument map name:
+  *  GET MIDI_INSTRUMENT_MAP INFO <midi-map>
+  *
+  *  @param pClient  Pointer to client instance structure.
+  *  @param iMidiMap MIDI instrument map number.
+  *
+  *  @returns The MIDI instrument map name on success, NULL on failure.
+  */
+ const char *lscp_get_midi_instrument_map_name ( lscp_client_t *pClient, int iMidiMap )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         const char *pszResult;
+         const char *pszSeps = ":";
+         const char *pszCrlf = "\r\n";
+         char *pszToken;
+         char *pch;
+         if (pClient == NULL)
+                 return NULL;
+         if (iMidiMap < 0)
+                 return NULL;
+         // Lock this section up.
+         lscp_mutex_lock(pClient->mutex);
+         if (pClient->midi_map_name) {
+                 free(pClient->midi_map_name);
+                 pClient->midi_map_name = NULL;
+         }
+         sprintf(szQuery, "GET MIDI_INSTRUMENT_MAP INFO %d\r\n", iMidiMap);
+         if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
+                 pszResult = lscp_client_get_result(pClient);
+                 pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
+                 while (pszToken) {
+                         if (strcasecmp(pszToken, "NAME") == 0) {
+                                 pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
+                                 if (pszToken)
+                                         lscp_unquote_dup(&(pClient->midi_map_name), &pszToken);
+                         }
+                         pszToken = lscp_strtok(NULL, pszSeps, &(pch));
+                 }
+         }
+         // Unlock this section down.
+         lscp_mutex_unlock(pClient->mutex);
+         return pClient->midi_map_name;
+ }
+ /**
+  *  Renaming a MIDI instrument map:
+  *  SET MIDI_INSTRUMENT_MAP NAME <midi-map> <map-name>
+  *
+  *  @param pClient      Pointer to client instance structure.
+  *  @param iMidiMap     MIDI instrument map number.
+  *  @param pszMapName   MIDI instrument map name.
+  *
+  *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_set_midi_instrument_map_name ( lscp_client_t *pClient, int iMidiMap, const char *pszMapName )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         if (iMidiMap < 0)
+                 return LSCP_FAILED;
+         if (pszMapName == NULL)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "SET MIDI_INSTRUMENT_MAP NAME %d '%s'\r\n",
+                 iMidiMap, pszMapName);
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
   *  Create or replace a MIDI instrumnet map entry:
-  *  MAP MIDI_INSTRUMENT <midi-bank-msb> <midi-bank-lsb> <midi-prog>
+  *  MAP MIDI_INSTRUMENT <midi-map> <midi-bank> <midi-prog>
-  *      <engine-name> <filename> <instr-index> <volume> <load-mode> [<name>]
+  *      <engine-name> <filename> <instr-index> <volume> [<load-mode> [<name>]}
   *
   *  @param pClient          Pointer to client instance structure.
   *  @param pMidiInstr       MIDI instrument bank and program parameter key.
-Line 1655 
 int lscp_get_total_voice_count_max ( lsc
+Line 2749 
 int lscp_get_total_voice_count_max ( lsc
   *  @param pszFileName      Instrument file name.
   *  @param iInstrIndex      Instrument index number.
   *  @param fVolume          Reflects the master volume of the instrument as
   *                          a positive floating point number, where a value
   *                          less than 1.0 for attenuation, and greater than
   *                          1.0 for amplification.
   *  @param load_mode        Instrument load life-time strategy, either
-Line 1663 
 int lscp_get_total_voice_count_max ( lsc
+Line 2757 
 int lscp_get_total_voice_count_max ( lsc
   *                          @ref LSCP_LOAD_ON_DEMAND, or
   *                          @ref LSCP_LOAD_ON_DEMAND_HOLD, or
   *                          @ref LSCP_LOAD_PERSISTENT.
-  *  @param pszName          Instrument custom name for the map entry.
+  *  @param pszName         Instrument custom name for the map entry (optional).
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- 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 )
+ 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 )
  {
          char szQuery[LSCP_BUFSIZ];
+         struct _locale_t locale;
-         if (pMidiInstr->bank_msb < 0 || pMidiInstr->bank_msb > 127)
+         if (pMidiInstr->map < 0)
                  return LSCP_FAILED;
-         if (pMidiInstr->bank_lsb < 0 || pMidiInstr->bank_lsb > 127)
+         if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
                  return LSCP_FAILED;
-         if (pMidiInstr->program < 0 || pMidiInstr->program > 127)
+         if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
                  return LSCP_FAILED;
          if (pszEngineName == NULL || pszFileName == NULL)
                  return LSCP_FAILED;
-Line 1683 
 lscp_status_t lscp_map_midi_instrument (
+Line 2781 
 lscp_status_t lscp_map_midi_instrument (
          if (fVolume < 0.0f)
                  fVolume = 1.0f;
+         _save_and_set_c_locale(&locale);
          sprintf(szQuery, "MAP MIDI_INSTRUMENT %d %d %d %s '%s' %d %g",
-                 pMidiInstr->bank_msb, pMidiInstr->bank_lsb, pMidiInstr->program,
+                 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog,
                  pszEngineName, pszFileName, iInstrIndex, fVolume);
+         _restore_locale(&locale);
          switch (load_mode) {
          case LSCP_LOAD_PERSISTENT:
-Line 1713 
 lscp_status_t lscp_map_midi_instrument (
+Line 2813 
 lscp_status_t lscp_map_midi_instrument (
  /**
   *  Remove an entry from the MIDI instrument map:
-  *  UNMAP MIDI_INSTRUMENT <midi-bank-msb> <midi-bank-lsb> <midi-prog>
+  *  UNMAP MIDI_INSTRUMENT <midi-map> <midi-bank> <midi-prog>
   *
   *  @param pClient      Pointer to client instance structure.
   *  @param pMidiInstr   MIDI instrument bank and program parameter key.
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_unmap_midi_instrument ( lscp_client_t *pClient, lscp_midi_instrument_t *pMidiInstr )
+ lscp_status_t lscp_unmap_midi_instrument ( lscp_client_t *pClient,
+         lscp_midi_instrument_t *pMidiInstr )
  {
          char szQuery[LSCP_BUFSIZ];
-         if (pMidiInstr->bank_msb < 0 || pMidiInstr->bank_msb > 127)
+         if (pMidiInstr->map < 0)
                  return LSCP_FAILED;
-         if (pMidiInstr->bank_lsb < 0 || pMidiInstr->bank_lsb > 127)
+         if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
                  return LSCP_FAILED;
-         if (pMidiInstr->program < 0 || pMidiInstr->program > 127)
+         if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
                  return LSCP_FAILED;
          sprintf(szQuery, "UNMAP MIDI_INSTRUMENT %d %d %d\r\n",
-                 pMidiInstr->bank_msb, pMidiInstr->bank_lsb, pMidiInstr->program);
+                 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog);
          return lscp_client_query(pClient, szQuery);
  }
-Line 1740 
 lscp_status_t lscp_unmap_midi_instrument
+Line 2841 
 lscp_status_t lscp_unmap_midi_instrument
  /**
   *  Get the total count of MIDI instrument map entries:
-  *  GET MIDI_INSTRUMENTS
+  *  GET MIDI_INSTRUMENTS ALL|<midi-map>
   *
   *  @param pClient  Pointer to client instance structure.
+  *  @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
   *
   *  @returns The current total number of MIDI instrument map entries
   *  on success, -1 otherwise.
   */
- int lscp_get_midi_instruments ( lscp_client_t *pClient )
+ int lscp_get_midi_instruments ( lscp_client_t *pClient, int iMidiMap )
  {
          int iInstruments = -1;
+         char szQuery[LSCP_BUFSIZ];
+         if (pClient == NULL)
+                 return -1;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
-         if (lscp_client_call(pClient, "GET MIDI_INSTRUMENTS\r\n", 0) == LSCP_OK)
+         strcpy(szQuery, "GET MIDI_INSTRUMENTS ");
+         if (iMidiMap < 0)
+                 strcat(szQuery, "ALL");
+         else
+                 sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
+         strcat(szQuery, "\r\n");
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
                  iInstruments = atoi(lscp_client_get_result(pClient));
          // Unlock this section down.
-Line 1766 
 int lscp_get_midi_instruments ( lscp_cli
+Line 2881 
 int lscp_get_midi_instruments ( lscp_cli
  /**
   *  Getting indeces of all MIDI instrument map entries:
-  *  LIST MIDI_INSTRUMENTS
+  *  LIST MIDI_INSTRUMENTS ALL|<midi-map>
   *
   *  @param pClient  Pointer to client instance structure.
+  *  @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
   *
   *  @returns An array of @ref lscp_midi_instrument_t, terminated with the
   *  {-1,-1,-1} triplet, NULL otherwise.
   */
- lscp_midi_instrument_t *lscp_list_midi_instruments ( lscp_client_t *pClient )
+ lscp_midi_instrument_t *lscp_list_midi_instruments ( lscp_client_t *pClient, int iMidiMap )
  {
+         char szQuery[LSCP_BUFSIZ];
          if (pClient == NULL)
                  return NULL;
-Line 1786 
 lscp_midi_instrument_t *lscp_list_midi_i
+Line 2904 
 lscp_midi_instrument_t *lscp_list_midi_i
                  pClient->midi_instruments = NULL;
          }
-         if (lscp_client_call(pClient, "LIST MIDI_INSTRUMENTS\r\n", 0) == LSCP_OK)
+         strcpy(szQuery, "LIST MIDI_INSTRUMENTS ");
-                 pClient->midi_instruments = lscp_midi_instruments_create(lscp_client_get_result(pClient));
+         if (iMidiMap < 0)
+                 strcat(szQuery, "ALL");
+         else
+                 sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
+         strcat(szQuery, "\r\n");
+         if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
+                 pClient->midi_instruments = lscp_midi_instruments_create(
+                         lscp_client_get_result(pClient));
          // Unlock this section down.
          lscp_mutex_unlock(pClient->mutex);
-Line 1798 
 lscp_midi_instrument_t *lscp_list_midi_i
+Line 2926 
 lscp_midi_instrument_t *lscp_list_midi_i
  /**
   *  Getting information about a MIDI instrument map entry:
-  *  GET MIDI_INSTRUMENT INFO <midi-bank-msb> <midi-bank-lsb> <midi-prog>
+  *  GET MIDI_INSTRUMENT INFO <midi-map> <midi-bank> <midi-prog>
   *
   *  @param pClient      Pointer to client instance structure.
   *  @param pMidiInstr   MIDI instrument bank and program parameter key.
-Line 1807 
 lscp_midi_instrument_t *lscp_list_midi_i
+Line 2935 
 lscp_midi_instrument_t *lscp_list_midi_i
   *  with all the information of the given MIDI instrument map entry,
   *  or NULL in case of failure.
   */
- lscp_midi_instrument_info_t *lscp_get_midi_instrument_info ( lscp_client_t *pClient, lscp_midi_instrument_t *pMidiInstr )
+ lscp_midi_instrument_info_t *lscp_get_midi_instrument_info ( lscp_client_t *pClient,
+         lscp_midi_instrument_t *pMidiInstr )
  {
          lscp_midi_instrument_info_t *pInstrInfo;
          char szQuery[LSCP_BUFSIZ];
-Line 1816 
 lscp_midi_instrument_info_t *lscp_get_mi
+Line 2945 
 lscp_midi_instrument_info_t *lscp_get_mi
          const char *pszCrlf = "\r\n";
          char *pszToken;
          char *pch;
+         struct _locale_t locale;
-         if (pMidiInstr->bank_msb < 0 || pMidiInstr->bank_msb > 127)
+         if (pClient == NULL)
+                 return NULL;
+         if (pMidiInstr->map < 0)
                  return NULL;
-         if (pMidiInstr->bank_lsb < 0 || pMidiInstr->bank_lsb > 127)
+         if (pMidiInstr->bank < 0 || pMidiInstr->bank > 16383)
                  return NULL;
-         if (pMidiInstr->program < 0 || pMidiInstr->program > 127)
+         if (pMidiInstr->prog < 0 || pMidiInstr->prog > 127)
                  return NULL;
          // Lock this section up.
          lscp_mutex_lock(pClient->mutex);
+         _save_and_set_c_locale(&locale);
          pInstrInfo = &(pClient->midi_instrument_info);
          lscp_midi_instrument_info_reset(pInstrInfo);
          sprintf(szQuery, "GET MIDI_INSTRUMENT INFO %d %d %d\r\n",
-                 pMidiInstr->bank_msb, pMidiInstr->bank_lsb, pMidiInstr->program);
+                 pMidiInstr->map, pMidiInstr->bank, pMidiInstr->prog);
          if (lscp_client_call(pClient, szQuery, 1) == LSCP_OK) {
                  pszResult = lscp_client_get_result(pClient);
                  pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
-Line 1880 
 lscp_midi_instrument_info_t *lscp_get_mi
+Line 3014 
 lscp_midi_instrument_info_t *lscp_get_mi
                          else if (strcasecmp(pszToken, "VOLUME") == 0) {
                                  pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                                  if (pszToken)
-                                         pInstrInfo->volume = (float) atof(lscp_ltrim(pszToken));
+                                         pInstrInfo->volume = _atof(lscp_ltrim(pszToken));
                          }
                          pszToken = lscp_strtok(NULL, pszSeps, &(pch));
                  }
          }
          else pInstrInfo = NULL;
+         _restore_locale(&locale);
          // Unlock this section down.
          lscp_mutex_unlock(pClient->mutex);
-Line 1896 
 lscp_midi_instrument_info_t *lscp_get_mi
+Line 3032 
 lscp_midi_instrument_info_t *lscp_get_mi
  /**
   *  Clear the MIDI instrumnet map:
-  *  CLEAR MIDI_INSTRUMENTS
+  *  CLEAR MIDI_INSTRUMENTS ALL|<midi-map>
   *
-  *  @param pClient         Pointer to client instance structure.
+  *  @param pClient  Pointer to client instance structure.
-  *  @param iSamplerChannel  Sampler channel number.
+  *  @param iMidiMap MIDI instrument map number, or @ref LSCP_MIDI_MAP_ALL .
   *
   *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
   */
- lscp_status_t lscp_clear_midi_instruments  ( lscp_client_t *pClient )
+ lscp_status_t lscp_clear_midi_instruments  ( lscp_client_t *pClient, int iMidiMap )
+ {
+         char szQuery[LSCP_BUFSIZ];
+         strcpy(szQuery, "CLEAR MIDI_INSTRUMENTS ");
+         if (iMidiMap < 0)
+                 strcat(szQuery, "ALL");
+         else
+                 sprintf(szQuery + strlen(szQuery), "%d", iMidiMap);
+         strcat(szQuery, "\r\n");
+         return lscp_client_query(pClient, szQuery);
+ }
+ /**
+  * Open an instrument editor application for the instrument
+  * on the given sampler channel:
+  * EDIT CHANNEL INSTRUMENT <sampler-channel>
+  *
+  * @param pClient         Pointer to client instance structure.
+  * @param iSamplerChannel Sampler Channel.
+  *
+  * @returns LSCP_OK on success, LSCP_FAILED otherwise.
+  */
+ lscp_status_t lscp_edit_channel_instrument ( lscp_client_t *pClient, int iSamplerChannel )
  {
-         return lscp_client_query(pClient, "CLEAR MIDI_INSTRUMENTS\r\n");
+         char szQuery[LSCP_BUFSIZ];
+         if (iSamplerChannel < 0)
+                 return LSCP_FAILED;
+         sprintf(szQuery, "EDIT CHANNEL INSTRUMENT %d\r\n", iSamplerChannel);
+         return lscp_client_query(pClient, szQuery);
  }

 Legend:



Removed from v.963
 


changed lines


 
Added in v.2424
 Legend:



Removed from v.963
 


changed lines


 
Added in v.2424
-Removed from v.963
+Added in v.2424

	ViewVC Help
Powered by ViewVC