/*
 *  EMU10k1 loader
 *
 *  Copyright (c) 2003,2004 by Peter Zubaj
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <getopt.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/stat.h>
#include <unistd.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <alsa/asoundlib.h>
#include "version.h"
#include "comm.h"
#include "ld10k1_fnc.h"
#include "ld10k1_error.h"
#include "ld10k1_debug.h"

#include "liblo10k1.h"
#include "liblo10k1ef.h"
#include "liblo10k1lf.h"

char comm_pipe[256];
liblo10k1_connection_t conn;

static void error(const char *fmt,...)
{
	va_list va;

	va_start(va, fmt);
	fprintf(stderr, "Error: ");
	vfprintf(stderr, fmt, va);
	fprintf(stderr, "\n");
	va_end(va);
}

static void help(char *command)
{
	fprintf(stderr,
		"Usage: %s [-options]\n"
		"\nAvailable options:\n"
		"  -h, --help           this help\n"
		"  -p, --pipe_name      connect to this, default = /tmp/.ld10k1_port\n"
		"  -l, --list           dump lkoaded patch\n"
		"  -i, --info           print some info\n"
		"  -s, --setup          setup DSP\n"
		"  -a, --add            load patch\n"
		"  -d, --del            unload patch\n"
		"  -q, --conadd         connect 2 patches\n"
		"  -w, --condel         delete connection\n"
		"      --debug          print debug information\n"
		"  -n, --defionames     define default in/out names for loaded patch\n"
		"      --ctrl           modify control parameters for loaded patch\n"
		"      --patch_name     load patch with this name\n"
		"      --where          insert patch before\n"
		"      --renam          rename patch, input, output, fx, patch input, patch output\n"
		"      --dump           dump DSP setup to file, can by loaded by dl10k1\n"
		"      --host           lo10k1 uses network socket instead of named socked (host,port)\n"
		"  -P, --path           include path\n"
		"      --store          store DSP setup\n"
		"      --restore        restore DSP setup\n"
		, command);
}

typedef struct tag_path_info {
	char *path;
	struct tag_path_info *next;
} path_t;

path_t *first_path;
path_t *last_path;

static void add_path(char *path)
{
	path_t *path_info = malloc(sizeof(path_t));

	path_info->path = strdup(path);
	path_info->next = NULL;

	if (last_path)
		last_path->next = path_info;

	last_path = path_info;

	if (!first_path)
		first_path = path_info;
}

static void add_paths(char *paths)
{
	char *str = strdup(paths);
	char *path = strtok(str, ":");
	
	while (path) {
		add_path(path);

		path = strtok(NULL, ":");
	}

	free (str);
}

static void free_all_paths()
{
	path_t *path_info = first_path;
	path_t *path_info_n = NULL;

	while (path_info) {
		path_info_n = path_info->next;
		free(path_info);
		path_info = path_info_n;
	}
}

static liblo10k1_emu_patch_t *try_patch(char *file_name)
{
	int en;
	
	liblo10k1_emu_patch_t *p = NULL;
	if ((en = liblo10k1_emu_load_patch(file_name, &p)) < 0)
		return NULL;

	return p;
}

static liblo10k1_emu_patch_t *open_patch(char *file_name)
{
	liblo10k1_emu_patch_t *patch;
	path_t *path_info = first_path;

	patch = try_patch(file_name);
	
	if (patch)
		return patch;

	while (path_info) {
		char path[256]; /* FIXME */

		memset(path, 0, sizeof(path));
		snprintf(path, sizeof(path)-1, "%s/%s", 
			 path_info->path, file_name);
		
		patch = try_patch(path);

		if (patch) {
			return patch;
		}

		snprintf(path, sizeof(path)-1, "%s/%s.emu10k1", 
			 path_info->path, file_name);

		patch = try_patch(path);

		if (patch) {
			return patch;
		}

		path_info = path_info->next;
	}

	return NULL;
}

static int load_patch(char *file_name, liblo10k1_emu_patch_t **p)
{
	liblo10k1_emu_patch_t *patch;
	
	if (!(patch = open_patch(file_name))) {
		error("unable to load patch %s", file_name);
		return 1;
	}
	
	*p = patch;
	return 0;
}

static char get_str(char **str, char *out, int maxlen, char *sep, int isnum)
{
	char ch = **str;
	char *tmpsep;
	int len = 0;
	int found = 0;
	
	*out = '\0';
	
	if (ch == '\0')
		return ch;
	
	len = 0;
	while (**str && len < maxlen) {
		found = 0;
		ch = **str;
		for (tmpsep = sep; *tmpsep; tmpsep++) {
			if (ch == *tmpsep) {
				found = 1;
				break;
			}
		}
		
		if (found)
			break;
 		if (isnum && !isdigit(ch))
			break;
		
		*out++ = *(*str)++;
			len++;
	}
	
	*out = '\0';
	return ch;
}

static int transfer_patch(int udin, char *ctrl_opt, liblo10k1_emu_patch_t *ep, liblo10k1_dsp_patch_t **p)
{
	int i, j, k;
	
	char ctrl_from_concate[16][32][MAX_NAME_LEN]; /* max 32 ctrl to 1 and max 16 of this*/
	char ctrl_to_concate[16][MAX_NAME_LEN]; 
	int ctrl_to_concate_count;
	int ctrl_from_count[16];
	
	char ctrl_visible[16][MAX_NAME_LEN];
	char ctrl_visible_max[16];
	unsigned char ctrl_visible_count;

	char ctrl_translate[16][MAX_NAME_LEN];
	char ctrl_translate_type[16];
	unsigned char ctrl_translate_count;
	
	char ctrl_index[16][MAX_NAME_LEN];
	int ctrl_index_val[16];
	unsigned char ctrl_index_count;

	char ctrl_values[16][MAX_NAME_LEN];
	int ctrl_values_val[16][32];
	unsigned char ctrl_values_cnt[16];
	unsigned char ctrl_values_count;

	char *tmp_str;
	char *tmp_num;
	char tmp_num_str[20];
	
	char sep;

	liblo10k1_ctl_transform_t *tctl;
	int ctl_idx;
	
	liblo10k1_dsp_patch_t *np = NULL;
	

	ctrl_to_concate_count = 0;
	ctrl_visible_count = 0;
	ctrl_translate_count = 0;
	ctrl_index_count = 0;
	ctrl_values_count = 0;
	for (i = 0; i < 16; i++) {
		ctrl_from_count[i] = 0;
		ctrl_to_concate[i][0] = '\0';
		ctrl_visible[i][0] = '\0';
		ctrl_visible_max[i] = 1;
		ctrl_translate[i][0] = '\0';
		ctrl_translate_type[i] = 1;
		
		ctrl_index[i][0] = '\0';
		ctrl_index_val[i] = -1;

		ctrl_values[i][0] = '\0';
		ctrl_values_cnt[i] = 0;
		for (j = 0; j < 32; j++) {
			ctrl_from_concate[i][j][0] = '\0';
			ctrl_values_val[i][j] = 0;
		}
	}

	/* parse ctrl opt */

	/* TODO - check for name boundary */
	while (ctrl_opt && *ctrl_opt) {
		switch (*ctrl_opt++) {
			case 'c':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (c) - waiting -");
					return 1;
				}
				while (1) {
					tmp_str = ctrl_from_concate[ctrl_to_concate_count][ctrl_from_count[ctrl_to_concate_count]];
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ",:", 0);
					if (strlen(ctrl_from_concate[ctrl_to_concate_count][ctrl_from_count[ctrl_to_concate_count]]) == 0) {
						error("wrong ctrl option format (c) - wrong source ctrl name");
						return 1;
					}
					ctrl_from_count[ctrl_to_concate_count]++;

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					if (sep != ',') {
						error("wrong ctrl option format (c) - wrong separator - waiting , %c", sep);
						return 1;
					}

					ctrl_opt++;
				}

				tmp_str = ctrl_to_concate[ctrl_to_concate_count];
				/* next is new ctrl name */
				sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ",", 0);
				if (strlen(ctrl_to_concate[ctrl_to_concate_count]) == 0) {
					error("wrong ctrl option format (c) - wrong target ctrl name");
					return 1;
				}
				ctrl_to_concate_count++;
				break;
			case 'v':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (v) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = ctrl_visible[ctrl_visible_count];
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(ctrl_visible[ctrl_visible_count]) == 0) {
						error("wrong ctrl option format (v) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}

				tmp_num = tmp_num_str;
				/* next is new ctrl name */
				sep = get_str(&ctrl_opt, tmp_num, 10, ",", 1);
				if (strlen(tmp_num_str) == 0) {
					error("wrong ctrl option format (v) - wrong vcount count");
					return 1;
				}
				ctrl_visible_max[ctrl_visible_count] = atoi(tmp_num_str);
				ctrl_visible_count++;
				break;
			case 't':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (t) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = ctrl_translate[ctrl_translate_count];
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(ctrl_translate[ctrl_translate_count]) == 0) {
						error("wrong ctrl option format (t) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}

				tmp_num = tmp_num_str;
				/* next is new ctrl translate */
				sep = get_str(&ctrl_opt, tmp_num, 10, ",", 1);
				if (strlen(tmp_num_str) == 0) {
					error("wrong ctrl option format (t) - wrong translation function num");
					return 1;
				}
				ctrl_translate_type[ctrl_translate_count] = atoi(tmp_num_str);
				ctrl_translate_count++;
				break;
			case 'i':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (i) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = ctrl_index[ctrl_index_count];
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(ctrl_index[ctrl_index_count]) == 0) {
						error("wrong ctrl option format (i) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}

				tmp_num = tmp_num_str;
				/* next is new ctrl index */
				sep = get_str(&ctrl_opt, tmp_num, 10, ",", 1);
				if (strlen(tmp_num_str) == 0) {
					error("wrong ctrl option format (i) - wrong index num");
					return 1;
				}
				ctrl_index_val[ctrl_index_count] = atoi(tmp_num_str);
				ctrl_index_count++;
				break;
			case 's':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (s) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = ctrl_values[ctrl_values_count];
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(ctrl_values[ctrl_values_count]) == 0) {
						error("wrong ctrl option format (s) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}

				/* next is new ctrl name */
				do {
					tmp_num = tmp_num_str;

					sep = get_str(&ctrl_opt, tmp_num, 10, ",#", 1);
					if (strlen(tmp_num_str) == 0) {
						error("wrong ctrl option format (s) - wrong value");
						return 1;
					}
					ctrl_values_val[ctrl_values_count][ctrl_values_cnt[ctrl_values_count]] = atoi(tmp_num_str);
					ctrl_values_cnt[ctrl_values_count]++;
					if (sep != '#')
						break;
					ctrl_opt++;
				} while (1);
				ctrl_values_count++;
				break;
			default:
				error("wrong ctrl option format - unknown subfunction");
				return 1;
		}
		if (*ctrl_opt) {
			if (*ctrl_opt != ',') {
				error("wrong ctrl option format - wrong separator beetwen subfunctions");
				return 1;
			} else {
				ctrl_opt++;
			}
		}
	}
	
	tctl = (liblo10k1_ctl_transform_t *)malloc(sizeof(liblo10k1_ctl_transform_t) * ctrl_to_concate_count);
	memset(tctl, 0, sizeof(liblo10k1_ctl_transform_t) * ctrl_to_concate_count);
	
	for (i = 0; i < ctrl_to_concate_count; i++) {
		/* find all controls for this ctl */
		for (k = 0; k < ctrl_from_count[i]; k++) {
			for (j = 0; j < ep->ctl_count; j++) {
				if (strcmp(ctrl_from_concate[i][k], ep->ctls[j].ctl_name) == 0) {
					tctl[i].emu_ctls[tctl[i].emu_ctl_count++] = j;
					break;
				}
			}
		}
		strcpy(tctl[i].ctl_name, ctrl_to_concate[i]);
	}
	
	if (liblo10k1_emu_transform_patch(ep,  tctl, ctrl_to_concate_count, &np) < 0)
	{
		error("error on liblo10k1_emu_transform_patch");
		return 1;
	}
	
	free(tctl);
	
	for (i = 0; i < ctrl_visible_count; i++) {
		ctl_idx = liblo10k1_patch_find_ctl_by_name(np, ctrl_visible[i]);
		if (ctl_idx < 0)
			goto err;
		if (liblo10k1_patch_ctl_set_vcount(np, ctl_idx, ctrl_visible_max[i]) < 0)
			goto err;
	}

	for (i = 0; i < ctrl_translate_count; i++) {
		ctl_idx = liblo10k1_patch_find_ctl_by_name(np, ctrl_translate[i]);
		if (ctl_idx < 0)
			goto err;
		if (liblo10k1_patch_ctl_set_trans(np, ctl_idx, ctrl_translate_type[i]) < 0)
			goto err;
	}
	
	for (i = 0; i < ctrl_index_count; i++) {
		ctl_idx = liblo10k1_patch_find_ctl_by_name(np, ctrl_index[i]);
		if (ctl_idx < 0)
			goto err;
		if (liblo10k1_patch_ctl_set_index(np, ctl_idx, ctrl_index_val[i]) < 0)
			goto err;
	}

	for (i = 0; i < ctrl_values_count; i++) {
		ctl_idx = liblo10k1_patch_find_ctl_by_name(np, ctrl_values[i]);
		if (ctl_idx < 0)
			goto err;
		for (j = 0; j < ctrl_values_cnt[i]; j++) {
			if (liblo10k1_patch_ctl_set_value(np, ctl_idx, j, ctrl_values_val[i][j]) < 0)
				goto err;
		}
	}
	
	*p = np;
	return 0;
err:
	if (np)
		liblo10k1_patch_free(np);
	return 1;
}

static int transfer_native_patch(liblo10k1_dsp_patch_t *p, char *ctrl_opt)
{
	unsigned char ctrl_values_count;

	char tmp_name_from_str[MAX_NAME_LEN];
	char tmp_name_to_str[MAX_NAME_LEN];
	char *tmp_str;
	char *tmp_num;
	char tmp_num_str[20];
	
	char sep;

	int ctl_idx;
		
	/* parse ctrl opt */

	/* TODO - check for name boundary */
	while (ctrl_opt && *ctrl_opt) {
		switch (*ctrl_opt++) {
			case 'r':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (r) - waiting -");
					return 1;
				}
				while (1) {
					tmp_str = tmp_name_from_str;
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ",:", 0);
					if (strlen(tmp_name_from_str) == 0) {
						error("wrong ctrl option format (r) - wrong source ctrl name");
						return 1;
					}
					
					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					
					ctrl_opt++;
				}

				tmp_str = tmp_name_to_str;
				/* next is new ctrl name */
				sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ",", 0);
				if (strlen(tmp_name_to_str) == 0) {
					error("wrong ctrl option format (r) - wrong target ctrl name");
					return 1;
				}
				
				ctl_idx = liblo10k1_patch_find_ctl_by_name(p, tmp_name_from_str);
				if (ctl_idx < 0) {
					error("unknown ctrl name");
					return 1;
				}
				strcpy(p->ctl[ctl_idx].name, tmp_name_to_str);
				break;
			case 'i':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (i) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = tmp_name_from_str;
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(tmp_name_from_str) == 0) {
						error("wrong ctrl option format (i) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}

				tmp_num = tmp_num_str;
				/* next is new ctrl index */
				sep = get_str(&ctrl_opt, tmp_num, 10, ",", 1);
				if (strlen(tmp_num_str) == 0) {
					error("wrong ctrl option format (i) - wrong index num");
					return 1;
				}
				ctl_idx = liblo10k1_patch_find_ctl_by_name(p, tmp_name_from_str);
				if (ctl_idx < 0) {
					error("unknown ctrl name");
					return 1;
				}
				if (liblo10k1_patch_ctl_set_index(p, ctl_idx, atoi(tmp_num_str)) < 0) {
					error("can not set ctrl index");
					return 1;
				}
				break;
			case 's':
				if (*ctrl_opt++ != '-') {
					error("wrong ctrl option format (s) - waiting -");
					return 1;
				}
				while (1)
				{
					tmp_str = tmp_name_from_str;
					sep = get_str(&ctrl_opt, tmp_str, MAX_NAME_LEN, ":", 0);
					if (strlen(tmp_name_from_str) == 0) {
						error("wrong ctrl option format (s) - wrong ctrl name");
						return 1;
					}

					if (sep == ':') {
						ctrl_opt++;
						break;
					}
					ctrl_opt++;
				}
				ctl_idx = liblo10k1_patch_find_ctl_by_name(p, tmp_name_from_str);
				if (ctl_idx < 0){
					error("unknown ctrl name");
					return 1;
				}
				
				/* next is value */
				ctrl_values_count = 0;
				do {
					tmp_num = tmp_num_str;

					sep = get_str(&ctrl_opt, tmp_num, 10, ",#", 1);
					if (strlen(tmp_num_str) == 0) {
						error("wrong ctrl option format (s) - wrong value");
						return 1;
					}
					if (liblo10k1_patch_ctl_set_value(p, ctl_idx, ctrl_values_count, atoi(tmp_num_str)) < 0){
						error("can not set ctrl value");
						return 1;
					}
					if (sep != '#')
						break;
					ctrl_opt++;
					ctrl_values_count++;
				} while (1);
				break;
			default:
				error("wrong ctrl option format - unknown subfunction");
				return 1;
		}
		if (*ctrl_opt) {
			if (*ctrl_opt != ',') {
				error("wrong ctrl option format - wrong separator beetwen subfunctions");
				return 1;
			} else {
				ctrl_opt++;
			}
		}
	}
	
	return 0;
}

static int list_patch(char *file_name)
{
	int err, i, j;
	liblo10k1_emu_patch_t *p;

	err = load_patch(file_name, &p);
	if (err)
		return err;

 	/* and now print */
	printf("Patch name : %s\n", p->patch_name);
	printf("IN:\n");
	for (i = 0; i < p->in_count; i++)
		printf("%03d: %08x\n", i, p->ins[i]);
	printf("OUT:\n");
	for (i = 0; i < p->out_count; i++)
		printf("%03d: %08x\n", i, p->outs[i]);
	
	printf("DYN:\n");
	for (i = 0; i < p->dyn_count; i++)
		printf("%03d: %08x\n", i, p->dyns[i]);
	
	printf("STA:\n");
	for (i = 0; i < p->sta_count; i++)
		printf("%03d: %08x  %08x\n", i, p->stas[i].sc, p->stas[i].sc_val);

	printf("CTRL:\n");
	for (i = 0; i < p->ctl_count; i++)
		printf("%03d: %08x   %08x  %08x  %08x   %s\n", i, p->ctls[i].ctl, p->ctls[i].ctl_val, p->ctls[i].ctl_val_min, p->ctls[i].ctl_val_max, p->ctls[i].ctl_name);
	
	printf("CON:\n");
	for (i = 0; i < p->con_count; i++)
		printf("%03d: %08x  %08x\n", i, p->cons[i].sc, p->cons[i].sc_val);
	
	printf("TRAM LOOKUP:\n");
	for (i = 0; i < p->tram_lookup_count; i++) {
		printf("%03d: %08x\n", i, p->tram_lookups[i].size);
		for (j = 0; j < p->tram_lookups[i].read_line_count; j++)
			printf("  %03d: %c  %03d  %08x  %08x\n", i, 'R', j, p->tram_lookups[i].read_lines[j].line,p->tram_lookups[i].read_lines[j].line_size);
		for (j = 0; j < p->tram_lookups[i].write_line_count; j++)
			printf("  %03d: %c  %03d  %08x  %08x\n", i, 'W', j, p->tram_lookups[i].write_lines[j].line,p->tram_lookups[i].write_lines[j].line_size);
	}
	
	printf("TRAM DELAY:\n");
	for (i = 0; i < p->tram_delay_count; i++) {
		printf("%03d: %08x\n", i, p->tram_delays[i].size);
		for (j = 0; j < p->tram_delays[i].read_line_count; j++)
			printf("  %03d: %c  %03d  %08x  %08x\n", i, 'R', j, p->tram_delays[i].read_lines[j].line,p->tram_delays[i].read_lines[j].line_size);
		for (j = 0; j < p->tram_delays[i].write_line_count; j++)
			printf("  %03d: %c  %03d  %08x  %08x\n", i, 'W', j, p->tram_delays[i].write_lines[j].line,p->tram_delays[i].write_lines[j].line_size);
	}
		
	printf("INSTR:\n");
	for (i = 0; i < p->instr_count; i++)
		printf("%03d: %08x  %08x  %08x  %08x  %08x\n", i, p->instrs[i].op, p->instrs[i].arg[0], p->instrs[i].arg[1], p->instrs[i].arg[2], p->instrs[i].arg[3]);
	return 0;
}

static int add_patch(char *file_name, int udin, char *ctrl_opt, char *opt_patch_name, int where)
{
	int err;
	liblo10k1_emu_patch_t *ep;
	liblo10k1_dsp_patch_t *p;
	
	err = load_patch(file_name, &ep);
	if (err)
		return err;

	err = transfer_patch(udin, ctrl_opt, ep, &p);
	if (err) {
		error("unable to transfer patch");
		return err;
	}
	
	if (opt_patch_name) {
		strncpy(p->patch_name, opt_patch_name, MAX_NAME_LEN - 1);
		p->patch_name[MAX_NAME_LEN - 1] = '\0';
	}
		
	if ((err = liblo10k1_patch_load(&conn, p, where, NULL, NULL)) < 0) {
		error("unable to load patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}

	return 0;
}

static int load_dsp_patch(char *file_name, char *ctrl_opt, char *opt_patch_name, int where)
{
	int err;
	liblo10k1_dsp_patch_t *p;
	liblo10k1_file_info_t *fi;
	
	fi = NULL;
	
	if ((err = liblo10k1lf_load_dsp_patch(&p, file_name, &fi)) < 0) {
		error("unable to load dsp patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	err = transfer_native_patch(p, ctrl_opt);
	if (err)
		goto err;
	
	if (opt_patch_name) {
		strncpy(p->patch_name, opt_patch_name, MAX_NAME_LEN - 1);
		p->patch_name[MAX_NAME_LEN - 1] = '\0';
	}
		
	if ((err = liblo10k1_patch_load(&conn, p, where, NULL, NULL)) < 0) {
		error("unable to load dsp patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}

	liblo10k1lf_file_info_free(fi);
	liblo10k1_patch_free(p);
	return 0;
err:
	if (fi)
		liblo10k1lf_file_info_free(fi);
	if (p)
		liblo10k1_patch_free(p);
	return 1;
}


static int save_dsp_patch(char *file_name, int pn)
{
	int err;
 	
	liblo10k1_dsp_patch_t *p;
	liblo10k1_file_info_t *fi;
	
	if (pn < 0) {
		error("wrong patch num");
		return 1;
	}
	
	fi = liblo10k1lf_file_info_alloc();
	if (!fi) {
		error("no mem");
		goto err;
	}
		
	if ((err = liblo10k1_patch_get(&conn, pn, &p)) < 0) {
		error("unable to get dsp patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	fi->creater = strdup("lo10k1 - emu10k1/emu10k2 effect loader for alsa");
	
	if ((err = liblo10k1lf_save_dsp_patch(p, file_name, fi)) < 0) {
		error("unable to save dsp patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	liblo10k1lf_file_info_free(fi);
	liblo10k1_patch_free(p);
	return 0;
err:
	if (fi)
		liblo10k1lf_file_info_free(fi);
	if (p)
		liblo10k1_patch_free(p);
	return 1;
}

void debug_print(char *str)
{
	printf("%s", str);
}

static int debug(int deb)
{
	int err;
	
	if ((err = liblo10k1_debug(&conn, deb, debug_print)) < 0) {
		error("unable to debug (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}

	return 0;
}

static int del_patch(char *file_name)
{
	int err;

	if ((err = liblo10k1_patch_unload(&conn, atoi(file_name))) < 0 ) {
		error("unable to del patch (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}

	return 0;
}

static int setup_dsp()
{
	int err;

	if ((err = liblo10k1_dsp_init(&conn)) < 0) {
		error("unable to setup DSP (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}
	
	return 0;
}

static int is_num(char *str)
{
	int i;

	for (i = 0; i < strlen(str); i++)
		if (!isdigit(str[i]))
			return 0;
	return 1;
}

typedef struct
{
	char type;
	int patch;
	int io;
} conn_info_t;

char *parse_connect_sym(char *con_str, char *sym, int *len, int max_len)
{
	*len = 0;
	while (*len < max_len && *con_str && *con_str != ',' && *con_str != ')') {
		*sym++ = *con_str++;
		(*len)++;
	}

	*sym++ = '\0';
	if (*len == 0)
		return NULL;
	return con_str;
}

char *parse_simple_params(char *con_str, char io_type, int pn, conn_info_t *con_info, int *con_info_count, int max_con_info_count)
{
	char con_arg[255];
	int con_arg_len = 0;
	int io_idx;

	while(1) {
		if (*con_info_count >= max_con_info_count)
			return NULL;
		if (!(con_str = parse_connect_sym(con_str, con_arg, &con_arg_len, sizeof(con_arg) - 1)))
			return NULL;
		if (*con_str != ')' && *con_str != ',')
			return NULL; /* wrong format */

		con_info[*con_info_count].type = io_type;

		if (is_num(con_arg)) {
			/* input number */
			if (io_type == 'A' || io_type == 'B') {
				con_info[*con_info_count].patch = pn;
				con_info[(*con_info_count)++].io = atoi(con_arg);
			} else {
				con_info[*con_info_count].patch = -1;
				con_info[(*con_info_count)++].io = atoi(con_arg);
			}
		} else {
			/* input name */
			switch (io_type) {
				case 'A':
					if (liblo10k1_find_patch_in(&conn, pn, con_arg, &io_idx) < 0)
						return NULL;
					con_info[*con_info_count].patch = pn;
					con_info[(*con_info_count)++].io = io_idx;
					break;
				case 'B':
					if (liblo10k1_find_patch_out(&conn, pn, con_arg, &io_idx) < 0)
						return NULL;
					con_info[*con_info_count].patch = pn;
					con_info[(*con_info_count)++].io = io_idx;
					break;
				case 'F':
					if (liblo10k1_find_fx(&conn, con_arg, &io_idx) < 0)
						return NULL;
					con_info[*con_info_count].patch = -1;
					con_info[(*con_info_count)++].io = io_idx;
					break;
				case 'I':
					if (liblo10k1_find_in(&conn, con_arg, &io_idx) < 0)
						return NULL;
					con_info[*con_info_count].patch = -1;
					con_info[(*con_info_count)++].io = io_idx;
					break;
				case 'O':
					if (liblo10k1_find_out(&conn, con_arg, &io_idx) < 0)
						return NULL;
					con_info[*con_info_count].patch = -1;
					con_info[(*con_info_count)++].io = io_idx;
					break;
			}
		}

		if (*con_str != ',')
			break;
		con_str++;
	}
	return con_str;
}

char *parse_patch_params(char *con_str, char io_type, conn_info_t *con_info, int *con_info_count, int max_con_info_count)
{
	char con_arg[255];
	int con_arg_len = 0;
	int i;
	int patch_num = -1;
	int io_count = 0;

	if (!(con_str = parse_connect_sym(con_str, con_arg, &con_arg_len, sizeof(con_arg) - 1)))
		return NULL;
	if (*con_str != ')' && *con_str != ',')
		return NULL;

	if (is_num(con_arg))
		/* patch number */
		patch_num = atoi(con_arg);
	else
		/* patch name - find patch */
		if (liblo10k1_find_patch(&conn, con_arg, &patch_num) < 0)
			return NULL;

	/* argumenty */
	if (*con_str == ',') {
		con_str++;
		if (*con_info_count >= max_con_info_count)
			return NULL;
		if (!(con_str = parse_simple_params(con_str, io_type, patch_num, con_info, con_info_count, max_con_info_count)))
			return NULL;
	} else {
		/* add all patch inputs or outputs */
		if (io_type == 'A') {
			/* get all inputs */
			if (liblo10k1_get_pin_count(&conn, patch_num, &io_count) < 0)
				return NULL;
		} else {
			/* get all outputs */
			if (liblo10k1_get_pout_count(&conn, patch_num, &io_count) < 0)
				return NULL;
		}

		i = 0;
		while (i < io_count) {
			if (*con_info_count >= max_con_info_count) {
				return NULL;
			}
			con_info[*con_info_count].type = io_type;
			con_info[*con_info_count].patch = patch_num;
			con_info[(*con_info_count)++].io = i;
			i++;
		}
	}
	return con_str;
}

int parse_connect(int add, char *con_str, int *multi, int *simple, conn_info_t **con_info, int *con_info_count, int max_con_info_count)
{
	char con[10];
	int con_len;

	int ft = 0;
	while (1) {
		con_len = 0;
		for(;*con_str && *con_str != '('; con_str++) {
			if (con_len >= sizeof(con) - 1)
				return 1;/* ERROR */
			con[con_len++] = *con_str;
		}
		con[con_len++] = '\0';

		if (*con_str != '(')
			return 1;/* ERROR */
		con_str++;

		if (ft && strcmp(con,"FX") == 0) {
			if (!(con_str = parse_simple_params(con_str, 'F', -1, con_info[ft], &(con_info_count[ft]), max_con_info_count)))
				return 1;/* ERROR */
		} else if (ft && strcmp(con,"IN") == 0) {
			if (!(con_str = parse_simple_params(con_str, 'I',  -1, con_info[ft], &(con_info_count[ft]), max_con_info_count)))
				return 1;/* ERROR */
		} else if (ft && strcmp(con,"OUT") == 0) {
			if (!(con_str = parse_simple_params(con_str, 'O', -1, con_info[ft], &(con_info_count[ft]), max_con_info_count)))
				return 1;/* ERROR */
		} else if (strcmp(con,"PIN") == 0) {
			if (!(con_str = parse_patch_params(con_str, 'A', con_info[ft], &(con_info_count[ft]), max_con_info_count)))
				return 1;/* ERROR */
		} else if (strcmp(con,"POUT") == 0) {
			if (!(con_str = parse_patch_params(con_str, 'B', con_info[ft], &(con_info_count[ft]), max_con_info_count)))
				return 1;/* ERROR */
		} else
			return 1;/* ERROR */

		con_str++;

		if (ft && !*con_str)
			return 0; /* OK */
		if (!add) {
			if (!*con_str)
				return 0;
			else
				return 1;
		}
		
		if (add && !ft && (*con_str == '=' || *con_str == '>' || *con_str == ':')) {
			ft++;
			if (*con_str == '=') {
				*multi = 0;
				*simple = 0;
			} else if (*con_str == ':') {
				*multi = 0;
				*simple = 1;
			} else
				*multi = 1;

		} else if (add &&*con_str != '+')
			return 1;/* ERROR */
		/* process next */
		con_str++;
	}
}

int parse_rename(char *con_str, char *io_type, int *pn, int *io, char **new_name)
{
	char con[10];
	int con_len = 0;

	char con_arg1[255];
	int con_arg_len1 = 0;
	int is_arg_num1 = 0;
	int arg_num1 = -1;

	char con_arg2[255];
	int con_arg_len2 = 0;
	int is_arg_num2 = 0;
	int arg_num2 = -1;

	for(;*con_str && *con_str != '('; con_str++) {
		if (con_len >= sizeof(con) - 1)
			return 1;/* ERROR */
		con[con_len++] = *con_str;
	}
	con[con_len++] = '\0';

	if (*con_str != '(')
		return 1;/* ERROR */
	con_str++;

	*io_type = '\0';
	if (strcmp(con,"FX") == 0)
		*io_type = 'F';
	else if (strcmp(con,"IN") == 0)
		*io_type = 'I';
	else if (strcmp(con,"OUT") == 0)
		*io_type = 'O';
	else if (strcmp(con,"PIN") == 0)
		*io_type = 'A';
	else if (strcmp(con,"POUT") == 0)
		*io_type = 'B';
	else if (strcmp(con,"PATCH") == 0)
		*io_type = 'P';
	else
		return 1;/* ERROR */

	if (!(con_str = parse_connect_sym(con_str, con_arg1, &con_arg_len1, sizeof(con_arg1) - 1)))
			return 1;

	if ((is_arg_num1 = is_num(con_arg1)))
		arg_num1 = atoi(con_arg1);

	if (*io_type == 'A' || *io_type == 'B') {
		/* two arguments */
		if (*con_str != ',')
			return 1; /* ERROR */
		con_str++;
		if (!(con_str = parse_connect_sym(con_str, con_arg2, &con_arg_len2, sizeof(con_arg2) - 1)))
			return 1;

		if ((is_arg_num2 = is_num(con_arg2)))
			arg_num2 = atoi(con_arg2);
	}

	if (*con_str != ')')
		return 1; /* ERROR */

	switch (*io_type) {
		case 'A':
			if (!is_arg_num1)
				if (liblo10k1_find_patch(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			if (!is_arg_num2)
				if (liblo10k1_find_patch_in(&conn, arg_num1, con_arg2, &arg_num2) < 0)
					return 1;
			break;
		case 'B':
			if (!is_arg_num1)
				if (liblo10k1_find_patch(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			if (!is_arg_num2)
				if (liblo10k1_find_patch_out(&conn, arg_num1, con_arg2, &arg_num2) < 0)
					return 1;
			break;
		case 'F':
			if (!is_arg_num1)
				if (liblo10k1_find_fx(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			break;
		case 'I':
			if (!is_arg_num1)
				if (liblo10k1_find_in(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			break;
		case 'O':
			if (!is_arg_num1)
				if (liblo10k1_find_out(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			break;
		case 'P':
			if (!is_arg_num1)
				if (liblo10k1_find_patch(&conn, con_arg1, &arg_num1) < 0)
					return 1;
			break;
	}

	con_str++;
	if (*con_str != '=')
		return 1; /* ERROR */
	con_str++;

	if (*io_type == 'A' || *io_type == 'B' || *io_type == 'P') {
		*pn = arg_num1;
		*io = arg_num2;
	} else {
		*io = arg_num1;
	}

	*new_name = con_str;
	return 0;
}

static int con_add(char *file_name)
{
	int err, i;
	int multi = 0;
	int simple = 0;

	conn_info_t con_infof[32];
	conn_info_t con_infot[32];
	conn_info_t *con_info[2] = {con_infof, con_infot};

	int con_info_count[2] = {0, 0};

	if (parse_connect(1, file_name, &multi, &simple, con_info, con_info_count, 32)) {
		error("wrong parameter - connection string");
		return 1;
	}

	if (con_info_count[0] != con_info_count[1]) {
		error("wrong parameter - connection string from <> to");
		return 1;
	}

	if (!con_info_count[0]) {
		error("wrong parameter - connection string");
		return 1;
	}

	for (i = 0; i < con_info_count[0]; i++) {
		if ((err = liblo10k1_con_add(&conn, multi, simple,
			con_infof[i].type, con_infof[i].patch, con_infof[i].io,
			con_infot[i].type, con_infot[i].patch, con_infot[i].io,
			NULL)) < 0) {
			error("unable to connect  (ld10k1 error:%s)", liblo10k1_error_str(err));
			return err;
		}
	}

	return 0;
}

static int con_del(char *file_name)
{
	conn_info_t con_info[32];
	int err, i;

	conn_info_t *con_info_p = con_info;

	int con_info_count = 0;

	if (parse_connect(0, file_name, NULL, NULL, &con_info_p, &con_info_count, 32)) {
		error("wrong parameter - disconnection string");
		return 1;
	}

	if (!con_info_count) {
		error("wrong parameter - disconnection string");
		return 1;
	}

	for (i = 0; i < con_info_count; i++) {
		if ((err = liblo10k1_con_del(&conn, con_info[i].type, con_info[i].patch, con_info[i].io, NULL)) < 0) {
			error("unable to connect  (ld10k1 error:%s)", liblo10k1_error_str(err));
			return err;
		}
	}
	
	return 0;
}

static int rename_arg(char *arg_name)
{
	char io_type = '\0';
	int pn = -1;
	int io = -1;
	char *new_name = NULL;

	if (parse_rename(arg_name, &io_type, &pn, &io, &new_name)) {
		error("wrong parameter for rename");
		return 1;
	}

	switch (io_type) {
		case 'A':
			if (liblo10k1_rename_patch_in(&conn, pn, io, new_name) < 0) {
				error("couldn't rename patch in");
				return 1;
			}
			break;
		case 'B':
			if (liblo10k1_rename_patch_out(&conn, pn, io, new_name) < 0) {
				error("couldn't rename patch out");
				return 1;
			}
			break;
		case 'F':
			if (liblo10k1_rename_fx(&conn, io, new_name) < 0) {
				error("couldn't rename fx");
				return 1;
			}
			break;
		case 'I':
			if (liblo10k1_rename_in(&conn, io, new_name) < 0) {
				error("couldn't rename in");
				return 1;
			}
			break;
		case 'O':
			if (liblo10k1_rename_out(&conn, io, new_name) < 0) {
				error("couldn't rename out");
				return 1;
			}
			break;
		case 'P':
			if (liblo10k1_rename_patch(&conn, pn, new_name) < 0) {
				error("couldn't rename patch");
				return 1;
			}
			break;
	}

	return 0;
}

static int dump(char *file_name)
{
	int err;
	void *dump = NULL;
	int size = 0;

	FILE *dump_file = NULL;

	if ((err = liblo10k1_dump(&conn, &dump, &size)) < 0 ) {
		error("unable to dump (ld10k1 error:%s)", liblo10k1_error_str(err));
		return err;
	}

	dump_file = fopen(file_name, "w");
	if (!dump_file) {
		free(dump);
		error("unable to open dump");
		return 1;
	}

	if (fwrite(dump, 1, size, dump_file) < size) {
		free(dump);
		error("unable to write dump");
		return 1;
	}

	free(dump);
	fclose(dump_file);

	return 0;
}

static int store_dsp(char *file_name)
{
	int err;
 	
	liblo10k1_file_dsp_setup_t *setup;
	liblo10k1_file_info_t *fi;
	
	fi = liblo10k1lf_file_info_alloc();
	if (!fi) {
		error("no mem");
		goto err;
	}
		
	if ((err = liblo10k1lf_get_dsp_config(&conn, &setup)) < 0) {
		error("unable to get dsp config (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	fi->creater = strdup("lo10k1 - emu10k1/emu10k2 effect loader for alsa");
	
	if ((err = liblo10k1lf_save_dsp_config(setup, file_name, fi)) < 0) {
		error("unable to store dsp config (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	liblo10k1lf_file_info_free(fi);
	liblo10k1lf_dsp_config_free(setup);
	return 0;
err:
	if (fi)
		liblo10k1lf_file_info_free(fi);
	return 1;
}

static int restore_dsp(char *file_name)
{
	int err;
 	
	liblo10k1_file_dsp_setup_t *setup;
	liblo10k1_file_info_t *fi;
	
	fi = NULL;
	
	if ((err = liblo10k1lf_load_dsp_config(&setup, file_name, &fi)) < 0) {
		error("unable to restore dsp config (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	if ((err = liblo10k1lf_put_dsp_config(&conn, setup)) < 0) {
		error("unable to put dsp config (ld10k1 error:%s)", liblo10k1_error_str(err));
		goto err;
	}
	
	liblo10k1lf_file_info_free(fi);
	liblo10k1lf_dsp_config_free(setup);
	return 0;
err:
	if (fi)
		liblo10k1lf_file_info_free(fi);
	return 1;
}
int main(int argc, char *argv[])
{
	int  c;

	int opt_list;
	int opt_setup;
	int opt_add;
	int opt_del;
	int opt_con_add;
	int opt_con_del;
	int opt_debug;
	char *opt_list_patch;
	int opt_use_default_io_names;
	char *opt_ctrl;
	char *opt_patch_name;
	char *opt_new_name;
	int opt_where;
	int option_index = 0;
	char *opt_dump_name;
	char *opt_host;
	char *tmp = NULL;
	
	int opt_store;
	int opt_restore;
	char *opt_store_restore_file;
	
	int opt_load_patch;
	int opt_save_patch;
	
	unsigned int opt_wait_for_conn;

	liblo10k1_param params;

	int err = 0;
	
 	static struct option long_options[] = {
				{"pipe_name", 1, 0, 'p'},
    				{"list", 1, 0, 'l'},
				{"info", 0, 0, 'i'},
				{"add", 1, 0, 'a'},
				{"del", 1, 0, 'd'},
				{"conadd", 1, 0, 'q'},
				{"condel", 1, 0, 'w'},
				{"debug", 1, 0, 0},
				{"defionames", 0, 0, 'n'},
				{"ctrl", 1, 0, 0},
				{"patch_name", 1, 0, 0},
				{"where", 1, 0, 0},
				{"setup", 1, 0, 's'},
				{"renam", 1, 0, 0},
				{"dump", 1, 0, 0},
				{"host", 1, 0, 0},
				{"path", 1, 0, 'P'},
				{"store", 1, 0, 0},
				{"restore", 1, 0, 0},
				{"load_patch", 1, 0, 0},
				{"save_patch", 1, 0, 0},
				{"wait", 1, 0, 0},
				{0, 0, 0, 0}
	};

	opt_list = 0;
	opt_add = 0;
	opt_del = 0;
	opt_list_patch = NULL;
	opt_con_add = 0;
	opt_con_del = 0;
	opt_debug = 0;
	opt_use_default_io_names = 0;
	opt_ctrl = NULL;
	opt_patch_name = NULL;
	opt_new_name = NULL;
	opt_where = -1;
	opt_setup = 0;
	opt_dump_name = NULL;
	opt_host = NULL;
	
	opt_store = 0;
	opt_restore = 0;
	opt_store_restore_file = NULL;
	
	opt_load_patch = 0;
	opt_save_patch = 0;
	
	opt_wait_for_conn = 500;

	strcpy(comm_pipe,"/tmp/.ld10k1_port");

	if (argc > 1 && !strcmp(argv[1], "--help")) {
		help(argv[0]);
		return 0;
	}

	first_path = NULL;
#ifdef EFFECTSDIR
	add_paths(EFFECTSDIR);
#endif

	while ((c = getopt_long(argc, argv, "hil:p:a:d:q:w:nsh:P:",
	        long_options, &option_index)) != EOF) {
		switch (c) {
		case 0:
			if (strcmp(long_options[option_index].name, "debug") == 0)
				opt_debug = atoi(optarg);
			else if (strcmp(long_options[option_index].name, "ctrl") == 0)
				opt_ctrl = optarg;
			else if (strcmp(long_options[option_index].name, "patch_name") == 0)
				opt_patch_name = optarg;
			else if (strcmp(long_options[option_index].name, "where") == 0)
				opt_where = atoi(optarg);
			else if (strcmp(long_options[option_index].name, "renam") == 0)
				opt_new_name = optarg;
			else if (strcmp(long_options[option_index].name, "dump") == 0)
				opt_dump_name = optarg;
			else if (strcmp(long_options[option_index].name, "host") == 0)
				opt_host = optarg;
			else if (strcmp(long_options[option_index].name, "wait") == 0) {
				opt_wait_for_conn = atoi(optarg);
				if (opt_wait_for_conn < 0)
					opt_wait_for_conn = 0;
				else if (opt_wait_for_conn > 500)
					opt_wait_for_conn = 500;
			}
			else if (strcmp(long_options[option_index].name, "store") == 0) {
				opt_store = 1;
				opt_store_restore_file = optarg;
			} else if (strcmp(long_options[option_index].name, "restore") == 0) {
				opt_restore = 1;
				opt_store_restore_file = optarg;
			} else if (strcmp(long_options[option_index].name, "load_patch") == 0) {
				opt_load_patch = 1;
				opt_store_restore_file = optarg;
			} else if (strcmp(long_options[option_index].name, "save_patch") == 0) {
				opt_save_patch = 1;
				opt_store_restore_file = optarg;
			}
			break;
		case 'h':
			help(argv[0]);
			return 0;
		case 'l':
			opt_list = 1;
			opt_list_patch = optarg;
			break;
		case 'p':
			strcpy(comm_pipe, optarg);
			break;
		case 'a':
			opt_add = 1;
			opt_list_patch = optarg;
			break;
		case 'd':
			opt_del = 1;
			opt_list_patch = optarg;
			break;
		case 'i':
			/* nothing */
			break;
		case 'q':
			opt_con_add = 1;
			opt_list_patch = optarg;
			break;
		case 'w':
			opt_con_del = 1;
			opt_list_patch = optarg;
			break;
		case 'n':
			opt_use_default_io_names = 1;
			break;
		case 's':
			opt_setup = 1;
			break;
		case 'P':
			add_path(optarg);
			break;
		case '?':
			break;
		default:
			error("unknown option %c", c);
			return 1;
		}
	}

	params.wfc = opt_wait_for_conn;
	if (opt_host) {
		params.type = COMM_TYPE_IP;
		params.name = strtok(opt_host, ":");
		if (!params.name)
			error("wrong hostname");
		tmp = strtok(NULL, ":");
		if (!tmp)
			error("wrong port");
		params.port = atoi(tmp);
	} else {
		params.type = COMM_TYPE_LOCAL;
		params.name = comm_pipe;
	}

	params.server = 0;

	while (1) {
		if ((err = liblo10k1_connect(&params, &conn))) {
			error("unable to connect ld10k1");
			break;
		}
		
		if ((err = liblo10k1_check_version(&conn))) {
			error("Wrong ld10k1 version");
			break;
		}
		
		if (opt_store || opt_restore) {
			if (opt_store) {
				if ((err = store_dsp(opt_store_restore_file)))
					break;
			} else {
				if ((err = restore_dsp(opt_store_restore_file)))
					break;
			}
		} else {
			if (opt_setup)
				if ((err = setup_dsp()))
					break;
			if (opt_list)
				if ((err = list_patch(opt_list_patch)))
					break;
	
			if (opt_add)
				if ((err = add_patch(opt_list_patch, opt_use_default_io_names, opt_ctrl, opt_patch_name, opt_where)))
					break;
			
			if (opt_load_patch)
				if ((err = load_dsp_patch(opt_store_restore_file, opt_ctrl, opt_patch_name, opt_where)))
					break;
					
			if (opt_save_patch)
				if ((err = save_dsp_patch(opt_store_restore_file, opt_where)))
					break;
	
			if (opt_del)
				if ((err = del_patch(opt_list_patch)))
					break;
	
			if (opt_con_add)
				if ((err = con_add(opt_list_patch)))
					break;
	
			if (opt_con_del)
				if ((err = con_del(opt_list_patch)))
					break;
	
			if (opt_debug)
				if ((err = debug(opt_debug)))
					break;
	
			if (opt_new_name)
				if ((err = rename_arg(opt_new_name)))
					break;
	
			if (opt_dump_name)
				if ((err = dump(opt_dump_name)))
					break;
		}
		break;
	}	

	if (liblo10k1_is_open(&conn)) {
		/*send_msg(conn_num, FNC_CLOSE_CONN, NULL, 0);
		free_comm(conn_num);*/
		liblo10k1_disconnect(&conn);
	}
	
	free_all_paths();

	return err;
}
