trunk/src/device.c

// device.c
//
/****************************************************************************
   liblscp - LinuxSampler Control Protocol API
   Copyright (C) 2004-2006, 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
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*****************************************************************************/

#include "common.h"


// Local prototypes.

static lscp_driver_info_t *_lscp_driver_info_query (lscp_client_t *pClient, lscp_driver_info_t *pDriverInfo, char *pszQuery);
static lscp_device_info_t *_lscp_device_info_query (lscp_client_t *pClient, lscp_device_info_t *pDeviceInfo, char *pszQuery);
static lscp_param_info_t  *_lscp_param_info_query  (lscp_client_t *pClient, lscp_param_info_t *pParamInfo, char *pszQuery, int cchMaxQuery, lscp_param_t *pDepList);

static lscp_device_port_info_t *_lscp_device_port_info_query (lscp_client_t *pClient, lscp_device_port_info_t *pDevicePortInfo, char *pszQuery);


//-------------------------------------------------------------------------
// Local funtions.

// Common driver type query command.
static lscp_driver_info_t *_lscp_driver_info_query ( lscp_client_t *pClient, lscp_driver_info_t *pDriverInfo, char *pszQuery )
{
    const char *pszResult;
    const char *pszSeps = ":";
    const char *pszCrlf = "\r\n";
    char *pszToken;
    char *pch;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    lscp_driver_info_reset(pDriverInfo);
    if (lscp_client_call(pClient, pszQuery, 1) == LSCP_OK) {
        pszResult = lscp_client_get_result(pClient);
        pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
        while (pszToken) {
            if (strcasecmp(pszToken, "DESCRIPTION") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pDriverInfo->description), &pszToken);
            }
            else if (strcasecmp(pszToken, "VERSION") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pDriverInfo->version), &pszToken);
            }
            else if (strcasecmp(pszToken, "PARAMETERS") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken) {
                    if (pDriverInfo->parameters)
                        lscp_szsplit_destroy(pDriverInfo->parameters);
                    pDriverInfo->parameters = lscp_szsplit_create(pszToken, ",");
                }
            }
            pszToken = lscp_strtok(NULL, pszSeps, &(pch));
        }
    }
    else pDriverInfo = NULL;
    
    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pDriverInfo;
}


// Common device info query command.
static lscp_device_info_t *_lscp_device_info_query ( lscp_client_t *pClient, lscp_device_info_t *pDeviceInfo, char *pszQuery )
{
    const char *pszResult;
    const char *pszSeps = ":";
    const char *pszCrlf = "\r\n";
    char *pszToken;
    char *pch;
    char *pszKey;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    lscp_device_info_reset(pDeviceInfo);
    if (lscp_client_call(pClient, pszQuery, 1) == LSCP_OK) {
        pszResult = lscp_client_get_result(pClient);
        pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
        while (pszToken) {
            if (strcasecmp(pszToken, "DRIVER") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pDeviceInfo->driver), &pszToken);
            }
            else {
                pszKey = pszToken;
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_plist_append(&(pDeviceInfo->params), pszKey, lscp_unquote(&pszToken, 0));
            }
            pszToken = lscp_strtok(NULL, pszSeps, &(pch));
        }
    }
    else pDeviceInfo = NULL;

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pDeviceInfo;
}


// Common device channel/port info query command.
static lscp_device_port_info_t *_lscp_device_port_info_query ( lscp_client_t *pClient, lscp_device_port_info_t *pDevicePortInfo, char *pszQuery )
{
    const char *pszResult;
    const char *pszSeps = ":";
    const char *pszCrlf = "\r\n";
    char *pszToken;
    char *pch;
    char *pszKey;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    lscp_device_port_info_reset(pDevicePortInfo);
    if (lscp_client_call(pClient, pszQuery, 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(&(pDevicePortInfo->name), &pszToken);
            }
            else {
                pszKey = pszToken;
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_plist_append(&(pDevicePortInfo->params), pszKey, lscp_unquote(&pszToken, 0));
            }
            pszToken = lscp_strtok(NULL, pszSeps, &(pch));
        }
    }
    else pDevicePortInfo = NULL;

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pDevicePortInfo;
}


// Common parameter info query command.
static lscp_param_info_t *_lscp_param_info_query ( lscp_client_t *pClient, lscp_param_info_t *pParamInfo, char *pszQuery, int cchMaxQuery, lscp_param_t *pDepList )
{
    const char *pszResult;
    const char *pszSeps = ":";
    const char *pszCrlf = "\r\n";
    char *pszToken;
    char *pch;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    lscp_param_info_reset(pParamInfo);
    lscp_param_concat(pszQuery, cchMaxQuery, pDepList);
    if (lscp_client_call(pClient, pszQuery, 1) == LSCP_OK) {
        pszResult = lscp_client_get_result(pClient);
        pszToken = lscp_strtok((char *) pszResult, pszSeps, &(pch));
        while (pszToken) {
            if (strcasecmp(pszToken, "TYPE") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken) {
                    pszToken = lscp_unquote(&pszToken, 0);
                    if (strcasecmp(pszToken, "BOOL") == 0)
                        pParamInfo->type = LSCP_TYPE_BOOL;
                    else if (strcasecmp(pszToken, "INT") == 0)
                        pParamInfo->type = LSCP_TYPE_INT;
                    else if (strcasecmp(pszToken, "FLOAT") == 0)
                        pParamInfo->type = LSCP_TYPE_FLOAT;
                    else if (strcasecmp(pszToken, "STRING") == 0)
                        pParamInfo->type = LSCP_TYPE_STRING;
                }
            }
            else if (strcasecmp(pszToken, "DESCRIPTION") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pParamInfo->description), &pszToken);
            }
            else if (strcasecmp(pszToken, "MANDATORY") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    pParamInfo->mandatory = (strcasecmp(lscp_unquote(&pszToken, 0), "TRUE") == 0);
            }
            else if (strcasecmp(pszToken, "FIX") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    pParamInfo->fix = (strcasecmp(lscp_unquote(&pszToken, 0), "TRUE") == 0);
            }
            else if (strcasecmp(pszToken, "MULTIPLICITY") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    pParamInfo->multiplicity = (strcasecmp(lscp_unquote(&pszToken, 0), "TRUE") == 0);
            }
            else if (strcasecmp(pszToken, "DEPENDS") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken) {
                    if (pParamInfo->depends)
                        lscp_szsplit_destroy(pParamInfo->depends);
                    pParamInfo->depends = lscp_szsplit_create(pszToken, ",");
                }
            }
            else if (strcasecmp(pszToken, "DEFAULT") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pParamInfo->defaultv), &pszToken);
            }
            else if (strcasecmp(pszToken, "RANGE_MIN") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pParamInfo->range_min), &pszToken);
            }
            else if (strcasecmp(pszToken, "RANGE_MAX") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken)
                    lscp_unquote_dup(&(pParamInfo->range_max), &pszToken);
            }
            else if (strcasecmp(pszToken, "POSSIBILITIES") == 0) {
                pszToken = lscp_strtok(NULL, pszCrlf, &(pch));
                if (pszToken) {
                    if (pParamInfo->possibilities)
                        lscp_szsplit_destroy(pParamInfo->possibilities);
                    pParamInfo->possibilities = lscp_szsplit_create(pszToken, ",");
                }
            }
            pszToken = lscp_strtok(NULL, pszSeps, &(pch));
        }
    }
    else pParamInfo = NULL;

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pParamInfo;
}


//-------------------------------------------------------------------------
// Audio driver control functions.

/**
 *  Getting all available audio output driver count.
 *  GET AVAILABLE_AUDIO_OUTPUT_DRIVERS
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns The current total number of audio output drivers on success,
 *  -1 otherwise.
 */
int lscp_get_available_audio_drivers ( lscp_client_t *pClient )
{
    int iAudioDrivers = -1;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (lscp_client_call(pClient, "GET AVAILABLE_AUDIO_OUTPUT_DRIVERS\r\n", 0) == LSCP_OK)
        iAudioDrivers = atoi(lscp_client_get_result(pClient));

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return iAudioDrivers;
}


/**
 *  Getting all available audio output drivers.
 *  LIST AVAILABLE_AUDIO_OUTPUT_DRIVERS
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns A NULL terminated array of audio output driver type
 *  name strings, or NULL in case of failure.
 */
const char ** lscp_list_available_audio_drivers ( lscp_client_t *pClient )
{
    const char *pszSeps = ",";

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (pClient->audio_drivers) {
        lscp_szsplit_destroy(pClient->audio_drivers);
        pClient->audio_drivers = NULL;
    }

    if (lscp_client_call(pClient, "LIST AVAILABLE_AUDIO_OUTPUT_DRIVERS\r\n", 0) == LSCP_OK)
        pClient->audio_drivers = lscp_szsplit_create(lscp_client_get_result(pClient), pszSeps);

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return (const char **) pClient->audio_drivers;
}


/**
 *  Getting informations about a specific audio output driver.
 *  GET AUDIO_OUTPUT_DRIVER INFO <audio-output-type>
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszAudioDriver   Audio driver type string (e.g. "ALSA").
 *
 *  @returns A pointer to a @ref lscp_driver_info_t structure, with
 *  the given audio driver information, or NULL in case of failure.
 */
lscp_driver_info_t* lscp_get_audio_driver_info ( lscp_client_t *pClient, const char *pszAudioDriver )
{
    char szQuery[LSCP_BUFSIZ];

    if (pszAudioDriver == NULL)
        return NULL;

    sprintf(szQuery, "GET AUDIO_OUTPUT_DRIVER INFO %s\r\n", pszAudioDriver);
    return _lscp_driver_info_query(pClient, &(pClient->audio_driver_info), szQuery);
}


/**
 *  Getting informations about specific audio output driver parameter.
 *  GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO <audio-output-driver> <param> [<dep-list>]
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszAudioDriver   Audio driver type string (e.g. "ALSA").
 *  @param pszParam         Audio driver parameter name.
 *  @param pDepList         Pointer to specific dependencies parameter list.
 *
 *  @returns A pointer to a @ref lscp_param_info_t structure, with
 *  the given audio driver parameter information, or NULL in case of failure.
 */
lscp_param_info_t *lscp_get_audio_driver_param_info ( lscp_client_t *pClient, const char *pszAudioDriver, const char *pszParam, lscp_param_t *pDepList )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (pszAudioDriver == NULL)
        return NULL;
    if (pszParam == NULL)
        return NULL;

    sprintf(szQuery, "GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO %s %s", pszAudioDriver, pszParam);
    return _lscp_param_info_query(pClient, &(pClient->audio_param_info), szQuery, sizeof(szQuery), pDepList);
}


//-------------------------------------------------------------------------
// Audio device control functions.

/**
 *  Creating an audio output device.
 *  CREATE AUDIO_OUTPUT_DEVICE <audio-output-driver> [<params>]
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszAudioDriver   Audio driver type string (e.g. "ALSA").
 *  @param pParams          Pointer to specific parameter list.
 *
 *  @returns The new audio device number identifier on success,
 *  or -1 in case of failure.
 */
int lscp_create_audio_device ( lscp_client_t *pClient, const char *pszAudioDriver, lscp_param_t *pParams )
{
    char szQuery[LSCP_BUFSIZ];
    int iAudioDevice = -1;

    if (pClient == NULL)
        return iAudioDevice;
    if (pszAudioDriver == NULL)
        return iAudioDevice;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    sprintf(szQuery, "CREATE AUDIO_OUTPUT_DEVICE %s", pszAudioDriver);
    lscp_param_concat(szQuery, sizeof(szQuery), pParams);
    if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
        iAudioDevice = atoi(lscp_client_get_result(pClient));

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return iAudioDevice;
}


/**
 *  Destroying an audio output device.
 *  DESTROY AUDIO_OUTPUT_DEVICE <audio-device-id>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iAudioDevice Audio device number identifier.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_destroy_audio_device ( lscp_client_t *pClient, int iAudioDevice )
{
    lscp_status_t ret = LSCP_FAILED;
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return ret;
    if (iAudioDevice < 0)
        return ret;

    sprintf(szQuery, "DESTROY AUDIO_OUTPUT_DEVICE %d\r\n", iAudioDevice);
    return lscp_client_query(pClient, szQuery);
}


/**
 *  Getting all created audio output device count.
 *  GET AUDIO_OUTPUT_DEVICES
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns The current total number of audio devices on success,
 *  -1 otherwise.
 */
int lscp_get_audio_devices ( lscp_client_t *pClient )
{
    int iAudioDevices = -1;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (lscp_client_call(pClient, "GET AUDIO_OUTPUT_DEVICES\r\n", 0) == LSCP_OK)
        iAudioDevices = atoi(lscp_client_get_result(pClient));

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return iAudioDevices;
}


/**
 *  Getting all created audio output device list.
 *  LIST AUDIO_OUTPUT_DEVICES
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns An array of audio device number identifiers,
 *  terminated with -1 on success, or NULL in case of failure.
 */
int *lscp_list_audio_devices ( lscp_client_t *pClient )
{
    const char *pszSeps = ",";

    if (pClient == NULL)
        return NULL;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (pClient->audio_devices) {
        lscp_isplit_destroy(pClient->audio_devices);
        pClient->audio_devices = NULL;
    }

    if (lscp_client_call(pClient, "LIST AUDIO_OUTPUT_DEVICES\r\n", 0) == LSCP_OK)
        pClient->audio_devices = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pClient->audio_devices;
}


/**
 *  Getting current settings of an audio output device.
 *  GET AUDIO_OUTPUT_DEVICE INFO <audio-device-id>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iAudioDevice Audio device number identifier.
 *
 *  @returns A pointer to a @ref lscp_device_info_t structure, with
 *  the given audio device information, or NULL in case of failure.
 */
lscp_device_info_t *lscp_get_audio_device_info ( lscp_client_t *pClient, int iAudioDevice )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iAudioDevice < 0)
        return NULL;

    sprintf(szQuery, "GET AUDIO_OUTPUT_DEVICE INFO %d\r\n", iAudioDevice);
    return _lscp_device_info_query(pClient, &(pClient->audio_device_info), szQuery);
}


/**
 *  Changing settings of audio output devices.
 *  SET AUDIO_OUTPUT_DEVICE_PARAMETER <audio-device-id> <param>=<value>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iAudioDevice Audio device number identifier.
 *  @param pParam       Pointer to a key-valued audio device parameter.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_set_audio_device_param ( lscp_client_t *pClient, int iAudioDevice, lscp_param_t *pParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return LSCP_FAILED;
    if (iAudioDevice < 0)
        return LSCP_FAILED;
    if (pParam == NULL)
        return LSCP_FAILED;

    sprintf(szQuery, "SET AUDIO_OUTPUT_DEVICE_PARAMETER %d %s='%s'\r\n", iAudioDevice, pParam->key, pParam->value);
    return lscp_client_query(pClient, szQuery);
}


/**
 *  Getting informations about an audio channel.
 *  GET AUDIO_OUTPUT_CHANNEL INFO <audio-device-id> <audio-channel>
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param iAudioDevice     Audio device number identifier.
 *  @param iAudioChannel    Audio channel number.
 *
 *  @returns A pointer to a @ref lscp_device_port_info_t structure,
 *  with the given audio channel information, or NULL in case of failure.
 */
lscp_device_port_info_t* lscp_get_audio_channel_info ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iAudioDevice < 0)
        return NULL;
    if (iAudioChannel < 0)
        return NULL;

    sprintf(szQuery, "GET AUDIO_OUTPUT_CHANNEL INFO %d %d\r\n", iAudioDevice, iAudioChannel);
    return _lscp_device_port_info_query(pClient, &(pClient->audio_channel_info), szQuery);
}


/**
 *  Getting informations about specific audio channel parameter.
 *  GET AUDIO_OUTPUT_CHANNEL_PARAMETER INFO <audio-device-id> <audio-channel> <param>
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param iAudioDevice     Audio device number identifier.
 *  @param iAudioChannel    Audio channel number.
 *  @param pszParam         Audio channel parameter name.
 *
 *  @returns A pointer to a @ref lscp_param_info_t structure, with
 *  the given audio channel parameter information, or NULL in case of failure.
 */
lscp_param_info_t* lscp_get_audio_channel_param_info ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel, const char *pszParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iAudioDevice < 0)
        return NULL;
    if (iAudioChannel < 0)
        return NULL;
    if (pszParam == NULL)
        return NULL;

    sprintf(szQuery, "GET AUDIO_OUTPUT_CHANNEL_PARAMETER INFO %d %d %s", iAudioDevice, iAudioChannel, pszParam);
    return _lscp_param_info_query(pClient, &(pClient->audio_channel_param_info), szQuery, sizeof(szQuery), NULL);
}


/**
 *  Changing settings of audio output channels.
 *  SET AUDIO_OUTPUT_CHANNEL_PARAMETER <audio-device-id> <audio-channel> <param> <value>
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param iAudioDevice     Audio device number identifier.
 *  @param iAudioChannel    Audio channel number.
 *  @param pParam           Pointer to a key-valued audio channel parameter.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_set_audio_channel_param ( lscp_client_t *pClient, int iAudioDevice, int iAudioChannel, lscp_param_t *pParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return LSCP_FAILED;
    if (iAudioDevice < 0)
        return LSCP_FAILED;
    if (iAudioChannel < 0)
        return LSCP_FAILED;
    if (pParam == NULL)
        return LSCP_FAILED;

    sprintf(szQuery, "SET AUDIO_OUTPUT_CHANNEL_PARAMETER %d %d %s='%s'\r\n", iAudioDevice, iAudioChannel, pParam->key, pParam->value);
    return lscp_client_query(pClient, szQuery);
}


//-------------------------------------------------------------------------
// MIDI driver control functions.

/**
 *  Getting all available MIDI input driver count.
 *  GET AVAILABLE_MIDI_INPUT_DRIVERS
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns The current total number of MIDI input drivers on success,
 *  -1 otherwise.
 */
int lscp_get_available_midi_drivers ( lscp_client_t *pClient )
{
    int iMidiDrivers = -1;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (lscp_client_call(pClient, "GET AVAILABLE_MIDI_INPUT_DRIVERS\r\n", 0) == LSCP_OK)
        iMidiDrivers = atoi(lscp_client_get_result(pClient));

    // Unlock this section up.
    lscp_mutex_unlock(pClient->mutex);

    return iMidiDrivers;
}


/**
 *  Getting all available MIDI input drivers.
 *  LIST AVAILABLE_MIDI_INPUT_DRIVERS
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns A NULL terminated array of MIDI input driver type
 *  name strings, or NULL in case of failure.
 */
const char** lscp_list_available_midi_drivers ( lscp_client_t *pClient )
{
    const char *pszSeps = ",";

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (pClient->midi_drivers) {
        lscp_szsplit_destroy(pClient->midi_drivers);
        pClient->midi_drivers = NULL;
    }

    if (lscp_client_call(pClient, "LIST AVAILABLE_MIDI_INPUT_DRIVERS\r\n", 0) == LSCP_OK)
        pClient->midi_drivers = lscp_szsplit_create(lscp_client_get_result(pClient), pszSeps);

    // Unlock this section up.
    lscp_mutex_unlock(pClient->mutex);

    return (const char **) pClient->midi_drivers;
}


/**
 *  Getting informations about a specific MIDI input driver.
 *  GET MIDI_INPUT_DRIVER INFO <midi-input-type>
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszMidiDriver    MIDI driver type string (e.g. "ALSA").
 *
 *  @returns A pointer to a @ref lscp_driver_info_t structure, with
 *  the given MIDI driver information, or NULL in case of failure.
 */
lscp_driver_info_t* lscp_get_midi_driver_info ( lscp_client_t *pClient, const char *pszMidiDriver )
{
    char szQuery[LSCP_BUFSIZ];

    if (pszMidiDriver == NULL)
        return NULL;

    sprintf(szQuery, "GET MIDI_INPUT_DRIVER INFO %s\r\n", pszMidiDriver);
    return _lscp_driver_info_query(pClient, &(pClient->midi_driver_info), szQuery);
}


/**
 *  Getting informations about specific MIDI input driver parameter.
 *  GET MIDI_INPUT_DRIVER_PARAMETER INFO <midi-input-driver> <param> [<dep-list>]
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszMidiDriver    MIDI driver type string (e.g. "ALSA").
 *  @param pszParam         MIDI driver parameter name.
 *  @param pDepList         Pointer to specific dependencies parameter list.
 *
 *  @returns A pointer to a @ref lscp_param_info_t structure, with
 *  the given MIDI driver parameter information, or NULL in case of failure.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_param_info_t *lscp_get_midi_driver_param_info ( lscp_client_t *pClient, const char *pszMidiDriver, const char *pszParam, lscp_param_t *pDepList )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (pszMidiDriver == NULL)
        return NULL;
    if (pszParam == NULL)
        return NULL;

    sprintf(szQuery, "GET MIDI_INPUT_DRIVER_PARAMETER INFO %s %s", pszMidiDriver, pszParam);
    return _lscp_param_info_query(pClient, &(pClient->midi_param_info), szQuery, sizeof(szQuery), pDepList);
}


//-------------------------------------------------------------------------
// MIDI device control functions.

/**
 *  Creating a MIDI input device.
 *  CREATE MIDI_INPUT_DEVICE <midi-input-driver> [<params>]
 *
 *  @param pClient          Pointer to client instance structure.
 *  @param pszMidiDriver    MIDI driver type string (e.g. "ALSA").
 *  @param pParams          Pointer to specific parameter list.
 *
 *  @returns The new audio device number identifier on success,
 *  or -1 in case of failure.
 */
int lscp_create_midi_device ( lscp_client_t *pClient, const char *pszMidiDriver, lscp_param_t *pParams )
{
    char szQuery[LSCP_BUFSIZ];
    int iMidiDevice = -1;

    if (pClient == NULL)
        return iMidiDevice;
    if (pszMidiDriver == NULL)
        return iMidiDevice;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    sprintf(szQuery, "CREATE MIDI_INPUT_DEVICE %s", pszMidiDriver);
    lscp_param_concat(szQuery, sizeof(szQuery), pParams);
    if (lscp_client_call(pClient, szQuery, 0) == LSCP_OK)
        iMidiDevice = atoi(lscp_client_get_result(pClient));

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return iMidiDevice;
}


/**
 *  Destroying a MIDI input device.
 *  DESTROY MIDI_INPUT_DEVICE <midi-device-id>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_destroy_midi_device ( lscp_client_t *pClient, int iMidiDevice )
{
    lscp_status_t ret = LSCP_FAILED;
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return ret;
    if (iMidiDevice < 0)
        return ret;

    sprintf(szQuery, "DESTROY MIDI_INPUT_DEVICE %d\r\n", iMidiDevice);
    return lscp_client_query(pClient, szQuery);
}


/**
 *  Getting all created MIDI intput device count.
 *  GET MIDI_INPUT_DEVICES
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns The current total number of MIDI devices on success,
 *  -1 otherwise.
 */
int lscp_get_midi_devices ( lscp_client_t *pClient )
{
    int iMidiDevices = -1;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (lscp_client_call(pClient, "GET MIDI_INPUT_DEVICES\r\n", 0) == LSCP_OK)
        iMidiDevices = atoi(lscp_client_get_result(pClient));
        
    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return iMidiDevices;
}


/**
 *  Getting all created MIDI intput device list.
 *  LIST MIDI_INPUT_DEVICES
 *
 *  @param pClient  Pointer to client instance structure.
 *
 *  @returns An array of MIDI device number identifiers,
 *  terminated with -1 on success, or NULL in case of failure.
 */
int *lscp_list_midi_devices ( lscp_client_t *pClient )
{
    const char *pszSeps = ",";

    if (pClient == NULL)
        return NULL;

    // Lock this section up.
    lscp_mutex_lock(pClient->mutex);

    if (pClient->midi_devices) {
        lscp_isplit_destroy(pClient->midi_devices);
        pClient->midi_devices = NULL;
    }

    if (lscp_client_call(pClient, "LIST MIDI_INPUT_DEVICES\r\n", 0) == LSCP_OK)
        pClient->midi_devices = lscp_isplit_create(lscp_client_get_result(pClient), pszSeps);

    // Unlock this section down.
    lscp_mutex_unlock(pClient->mutex);

    return pClient->midi_devices;
}


/**
 *  Getting current settings of a MIDI input device.
 *  GET MIDI_INPUT_DEVICE INFO <midi-device-id>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *
 *  @returns A pointer to a @ref lscp_device_info_t structure, with
 *  the given MIDI device information, or NULL in case of failure.
 */
lscp_device_info_t* lscp_get_midi_device_info ( lscp_client_t *pClient, int iMidiDevice )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iMidiDevice < 0)
        return NULL;

    sprintf(szQuery, "GET MIDI_INPUT_DEVICE INFO %d\r\n", iMidiDevice);
    return _lscp_device_info_query(pClient, &(pClient->midi_device_info), szQuery);
}


/**
 *  Changing settings of MIDI input devices.
 *  SET MIDI_INPUT_DEVICE_PARAMETER <midi-device-id> <param>=<value>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *  @param pParam       Pointer to a key-valued MIDI device parameter.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_set_midi_device_param ( lscp_client_t *pClient, int iMidiDevice, lscp_param_t *pParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return LSCP_FAILED;
    if (iMidiDevice < 0)
        return LSCP_FAILED;
    if (pParam == NULL)
        return LSCP_FAILED;

    sprintf(szQuery, "SET MIDI_INPUT_DEVICE_PARAMETER %d %s='%s'\r\n", iMidiDevice, pParam->key, pParam->value);
    return lscp_client_query(pClient, szQuery);
}


/**
 *  Getting informations about a MIDI port.
 *  GET MIDI_INPUT_PORT INFO <midi-device-id> <midi-port>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *  @param iMidiPort    MIDI port number.
 *
 *  @returns A pointer to a @ref lscp_device_port_info_t structure,
 *  with the given MIDI port information, or NULL in case of failure.
 */
lscp_device_port_info_t* lscp_get_midi_port_info ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iMidiDevice < 0)
        return NULL;
    if (iMidiPort < 0)
        return NULL;

    sprintf(szQuery, "GET MIDI_INPUT_PORT INFO %d %d\r\n", iMidiDevice, iMidiPort);
    return _lscp_device_port_info_query(pClient, &(pClient->midi_port_info), szQuery);
}


/**
 *  Getting informations about specific MIDI port parameter.
 *  GET MIDI_INPUT_PORT_PARAMETER INFO <midi-device-id> <midi-port> <param>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *  @param iMidiPort    MIDI port number.
 *  @param pszParam     MIDI port parameter name.
 *
 *  @returns A pointer to a @ref lscp_param_info_t structure, with
 *  the given MIDI port parameter information, or NULL in case of failure.
 */
lscp_param_info_t* lscp_get_midi_port_param_info ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort, const char *pszParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return NULL;
    if (iMidiDevice < 0)
        return NULL;
    if (iMidiPort < 0)
        return NULL;
    if (pszParam == NULL)
        return NULL;

    sprintf(szQuery, "GET MIDI_INPUT_PORT_PARAMETER INFO %d %d %s", iMidiDevice, iMidiPort, pszParam);
    return _lscp_param_info_query(pClient, &(pClient->midi_port_param_info), szQuery, sizeof(szQuery), NULL);
}


/**
 *  Changing settings of MIDI input ports.
 *  SET MIDI_INPUT_PORT_PARAMETER <midi-device-id> <midi-port> <param> <value>
 *
 *  @param pClient      Pointer to client instance structure.
 *  @param iMidiDevice  MIDI device number identifier.
 *  @param iMidiPort    MIDI port number.
 *  @param pParam       Pointer to a key-valued MIDI port parameter.
 *
 *  @returns LSCP_OK on success, LSCP_FAILED otherwise.
 */
lscp_status_t lscp_set_midi_port_param ( lscp_client_t *pClient, int iMidiDevice, int iMidiPort, lscp_param_t *pParam )
{
    char szQuery[LSCP_BUFSIZ];

    if (pClient == NULL)
        return LSCP_FAILED;
    if (iMidiDevice < 0)
        return LSCP_FAILED;
    if (iMidiPort < 0)
        return LSCP_FAILED;
    if (pParam == NULL)
        return LSCP_FAILED;

    sprintf(szQuery, "SET MIDI_INPUT_PORT_PARAMETER %d %d %s='%s'\r\n", iMidiDevice, iMidiPort, pParam->key, pParam->value);
    return lscp_client_query(pClient, szQuery);
}


//-------------------------------------------------------------------------
// Generic parameter list functions.

const char *lscp_get_param_value ( lscp_param_t *pParams, const char *pszParam )
{
    int i;

    for (i = 0; pParams && pParams[i].key; i++) {
        if (strcasecmp(pParams[i].key, pszParam) == 0)
            return (const char *) pParams[i].value;
    }
    return NULL;
}


// end of device.c
