/*
* 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_info;
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_info = 0;
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':
opt_info = 1;
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(¶ms, &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;
}