/*

 *  EMU10k1 loader lib

 *  Copyright (c) 2003,2004 by Peter Zubaj

 *

 *

 *   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 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 Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include "ld10k1_error.h"

#include "ld10k1_fnc.h"

#include "comm.h"

#include "liblo10k1.h"

#include "liblo10k1ef.h"

#define AS10K1_FILE_SIGNATURE_ALSA "EMU10K1 FX8010 1"

#define AS10K1_FILE_SIGNATURE_EMU "emu10k1-dsp-file"

#define AS10K1_FILE_FORMAT_VERSION_EMU 1

liblo10k1_emu_patch_t *liblo10k1_emu_new_patch()

{

	liblo10k1_emu_patch_t *tmp = (liblo10k1_emu_patch_t *)malloc(sizeof(liblo10k1_emu_patch_t));

	if (!tmp)

		return NULL;

	memset(tmp, 0, sizeof(liblo10k1_emu_patch_t));

	return tmp;

}

void liblo10k1_emu_free_patch(liblo10k1_emu_patch_t *p)

{

	liblo10k1_emu_patch_set_in_count(p, 0);

	liblo10k1_emu_patch_set_out_count(p, 0);

	liblo10k1_emu_patch_set_dyn_count(p, 0);

	liblo10k1_emu_patch_set_sta_count(p, 0);

	liblo10k1_emu_patch_set_ctl_count(p, 0);

	liblo10k1_emu_patch_set_con_count(p, 0);

	liblo10k1_emu_patch_set_lookup_count(p, 0);

	liblo10k1_emu_patch_set_delay_count(p, 0);

	liblo10k1_emu_patch_set_instr_count(p, 0);

	free(p);

}

int liblo10k1_emu_patch_set_in_count(liblo10k1_emu_patch_t *p, int count)

{

	unsigned int *tmp = NULL;

	if (count > 0) {

		tmp = (unsigned int *)malloc(sizeof(unsigned int)*count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(unsigned int) * count);

	}

	p->in_count = count;

	if (p->ins)

		free(p->ins);

	p->ins = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_out_count(liblo10k1_emu_patch_t *p, int count)

{

	unsigned int *tmp = NULL;

	if (count > 0) {

		tmp = (unsigned int *)malloc(sizeof(unsigned int)*count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(unsigned int) * count);

	}

	p->out_count = count;

	if (p->outs)

		free(p->outs);

	p->outs = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_dyn_count(liblo10k1_emu_patch_t *p, int count)

{

	unsigned int *tmp = NULL;

	if (count > 0) {

		tmp = (unsigned int *)malloc(sizeof(unsigned int)*count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(unsigned int) * count);

	}

	p->dyn_count = count;

	if (p->dyns)

		free(p->dyns);

	p->dyns = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_sta_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_sc_t *tmp = NULL;

	if (count > 0) {

		tmp = (liblo10k1_emu_sc_t *)malloc(sizeof(liblo10k1_emu_sc_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_sc_t)*count);

	}

	p->sta_count = count;

	if (p->stas)

		free(p->stas);

	p->stas = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_ctl_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_ctl_t *tmp = NULL;

	if (count > 0) {

		tmp = (liblo10k1_emu_ctl_t *)malloc(sizeof(liblo10k1_emu_ctl_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_ctl_t)*count);

	}

	p->ctl_count = count;

	if (p->ctls)

		free(p->ctls);

	p->ctls = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_con_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_sc_t *tmp = NULL;

	if (count > 0) {

		tmp = (liblo10k1_emu_sc_t *)malloc(sizeof(liblo10k1_emu_sc_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_sc_t)*count);

	}

	p->con_count = count;

	if (p->cons)

		free(p->cons);

	p->cons = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_line_count(liblo10k1_emu_tram_t *t, int write, int count)

{

	liblo10k1_emu_tram_line_t *tmp = NULL;

	if (count > 0) {

		tmp = (liblo10k1_emu_tram_line_t *)malloc(sizeof(liblo10k1_emu_tram_line_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_tram_line_t)*count);

	}

	if (write) {

		t->write_line_count = count;

		if (t->write_lines)

			free(t->write_lines);

		t->write_lines = tmp;

	} else {

		t->read_line_count = count;

		if (t->read_lines)

			free(t->read_lines);

		t->read_lines = tmp;

	}

	return 0;

}

int liblo10k1_emu_patch_set_lookup_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_tram_t *tmp = NULL;

	int i;

	if (count > 0) {

		tmp = (liblo10k1_emu_tram_t *)malloc(sizeof(liblo10k1_emu_tram_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_tram_t)*count);

	}

	if (p->tram_lookups) {

		for (i = 0; i < p->tram_lookup_count; i++) {

			liblo10k1_emu_patch_set_line_count(&(p->tram_lookups[i]), 0, 0);

			liblo10k1_emu_patch_set_line_count(&(p->tram_lookups[i]), 1, 0);

		}

		free(p->tram_lookups);

	}

	p->tram_lookup_count = count;

	p->tram_lookups = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_delay_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_tram_t *tmp = NULL;

	int i;

	if (count > 0) {

		tmp = (liblo10k1_emu_tram_t *)malloc(sizeof(liblo10k1_emu_tram_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_tram_t)*count);

	}

	if (p->tram_delays) {

		for (i = 0; i < p->tram_delay_count; i++) {

			liblo10k1_emu_patch_set_line_count(&(p->tram_delays[i]), 0, 0);

			liblo10k1_emu_patch_set_line_count(&(p->tram_delays[i]), 1, 0);

		}

		free(p->tram_delays);

	}

	p->tram_delay_count = count;

	p->tram_delays = tmp;

	return 0;

}

int liblo10k1_emu_patch_set_instr_count(liblo10k1_emu_patch_t *p, int count)

{

	liblo10k1_emu_instr_t *tmp = NULL;

	if (count > 0) {

		tmp = (liblo10k1_emu_instr_t *)malloc(sizeof(liblo10k1_emu_instr_t) * count);

		if (!tmp)

			return LD10K1_ERR_NO_MEM;

		memset(tmp, 0, sizeof(liblo10k1_emu_instr_t)*count);

	}

	p->instr_count = count;

	if (p->instrs)

		free(p->instrs);

	p->instrs = tmp;

	return 0;

}

static int read_byte(char *patch_data, int size, int *pos, unsigned char *out)

{

	if (*pos < size) {

		*out = patch_data[*pos];

		(*pos)++;

		return 0;

	} else

		return LD10K1_EF_ERR_FORMAT;

}

static int read_ushort(char *patch_data, int size, int *pos, unsigned short *out)

{

	if (*pos + 1 < size) {

		*out = *((unsigned short *)(patch_data + *pos));

		*(pos) += 2;

		return 0;

	} else

		return LD10K1_EF_ERR_FORMAT;

}

static int read_uint(char *patch_data, int size, int *pos, unsigned int *out)

{

	if (*pos + 3 < size) {

		*out = *((unsigned int *)(patch_data + *pos));

		(*pos) += 4;

		return 0;

	} else

		return LD10K1_EF_ERR_FORMAT;

}

static int read_string(char *patch_data, int size, int *pos, char *out, int ssize)

{

	if (*pos + ssize - 1 < size) {

		strncpy(out, &(patch_data[*pos]), ssize - 1);

		out[ssize - 1] = '\0';

		(*pos) += ssize;

		return 0;

	} else

		return LD10K1_EF_ERR_FORMAT;

}

int liblo10k1_emu_load_patch(char *file_name, liblo10k1_emu_patch_t **p)

{

	struct stat patch_stat;

	char *patch_data;

	FILE *patch_file;

	liblo10k1_emu_patch_t *new_patch = NULL;

	unsigned int i, j, z, k;

	int en = 0;

	int file_pos = 0;

	int file_size = 0;

	unsigned char byte_tmp;

	unsigned short ushort_tmp;

	liblo10k1_emu_tram_t *tmp_tram;

	liblo10k1_emu_tram_line_t *tmp_tram_lines;

	unsigned int part1, part2;

	if (!(patch_file = fopen(file_name, "r")))

		return LD10K1_EF_ERR_OPEN;

	/* first load patch to mem */

	if (stat(file_name, &patch_stat))

		return LD10K1_EF_ERR_STAT;

	/* minimal patch len is 57 */

	if (patch_stat.st_size < 57 || patch_stat.st_size > 1000000)

		return LD10K1_EF_ERR_SIZE;

	file_size = patch_stat.st_size;

	patch_data = (char *)malloc(patch_stat.st_size);

	if (!patch_data)

		return LD10K1_ERR_NO_MEM;

	if (fread(patch_data, patch_stat.st_size, 1, patch_file) != 1) {

		fclose(patch_file);

		en = LD10K1_EF_ERR_READ;

		goto err;

	} else

		fclose(patch_file);

	int file_sig = 0;

	/* signature checks - two kinds of as10k1 files, one from alsa-tools, other from emu-tools. */

	if(strncmp(patch_data, AS10K1_FILE_SIGNATURE_ALSA, 16) != 0)

	{

	  if((strncmp(patch_data, AS10K1_FILE_SIGNATURE_EMU, 16) == 0) && (*((unsigned short *)&patch_data[17]) == AS10K1_FILE_FORMAT_VERSION_EMU))

	    file_sig = 3;

		else	

		{

	    en = LD10K1_EF_ERR_SIGNATURE;

	    goto err;

		}

	}

	new_patch = liblo10k1_emu_new_patch();

	if (!new_patch) {

		en = LD10K1_ERR_NO_MEM;

		goto err;

	}

	/* next patch name */

	strncpy(new_patch->patch_name, &(patch_data[16 + file_sig]), 31);

	new_patch->patch_name[31] = '\0';

	/* registers */

	file_pos = 32+16 + file_sig; 

	/* in count */

	if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

		  goto err;

	if (byte_tmp >= 32) {

		en = LD10K1_EF_ERR_FORMAT;

		goto err;

	}

	if ((en = liblo10k1_emu_patch_set_in_count(new_patch, byte_tmp)) < 0 ||

		(en = liblo10k1_emu_patch_set_out_count(new_patch, byte_tmp)) < 0)

		goto err;

	/* read in gprs */

	for (i = 0; i < new_patch->in_count; i++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->ins[i] = byte_tmp;

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->outs[i] = byte_tmp;

	}

	/* read dyn gprs */

	if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

		goto err;

	if ((en = liblo10k1_emu_patch_set_dyn_count(new_patch, byte_tmp)) < 0)

		goto err;

	for (i = 0; i < new_patch->dyn_count; i++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->dyns[i] = byte_tmp;

	}

	/* read sta gprs */

	if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

		goto err;

	if ((en = liblo10k1_emu_patch_set_sta_count(new_patch, byte_tmp)) < 0)

		goto err;

	for (i = 0; i < new_patch->sta_count; i++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->stas[i].sc = byte_tmp;

		if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->stas[i].sc_val))) < 0)

			goto err;

	}

	/* read ctl gprs */

	if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

		goto err;

	if ((en = liblo10k1_emu_patch_set_ctl_count(new_patch, byte_tmp)) < 0)

		goto err;

	for (i = 0; i < new_patch->ctl_count; i++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->ctls[i].ctl = byte_tmp;

		if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->ctls[i].ctl_val))) < 0)

			goto err;

		if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->ctls[i].ctl_val_min))) < 0)

			goto err;

		if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->ctls[i].ctl_val_max))) < 0)

			goto err;

		if ((en = read_string(patch_data, file_size, &file_pos, new_patch->ctls[i].ctl_name, 32)) < 0)

			goto err;

	}

	/* read const gprs */

	if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

		goto err;

	if ((en = liblo10k1_emu_patch_set_con_count(new_patch, byte_tmp)) < 0)

		goto err;

	for (i = 0; i < new_patch->con_count; i++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		new_patch->cons[i].sc = byte_tmp;

		if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->cons[i].sc_val))) < 0)

			goto err;

	}

	/* read tram lookup gprs */

	for (z = 0; z < 2; z++) {

		if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

			goto err;

		if (z) {

			if ((en = liblo10k1_emu_patch_set_delay_count(new_patch, byte_tmp)) < 0)

				goto err;

		} else {		

			if ((en = liblo10k1_emu_patch_set_lookup_count(new_patch, byte_tmp)) < 0)

				goto err;

		}

		for (i = 0; i < (z ? new_patch->tram_delay_count : new_patch->tram_lookup_count); i++) {

			/* size */

			if (z) {

				if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->tram_delays[i].size))) < 0)

					goto err;

				tmp_tram = new_patch->tram_delays + i;

			} else {

				if ((en = read_uint(patch_data, file_size, &file_pos, &(new_patch->tram_lookups[i].size))) < 0)

					goto err;

				tmp_tram = new_patch->tram_lookups + i;

			}

			for (k = 0; k < 2; k++) {

				/* read lines */

				if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

					goto err;

				if ((en = liblo10k1_emu_patch_set_line_count(tmp_tram, k, byte_tmp)) < 0)

					goto err;

				if (k)

					tmp_tram_lines = tmp_tram->write_lines;

				else

					tmp_tram_lines = tmp_tram->read_lines;

				for (j = 0; j < (k ? tmp_tram->write_line_count : tmp_tram->read_line_count); j++) {

					if ((en = read_byte(patch_data, file_size, &file_pos, &byte_tmp)) < 0)

						goto err;

					tmp_tram_lines[j].line = byte_tmp;

					if ((en = read_uint(patch_data, file_size, &file_pos, &(tmp_tram_lines[j].line_size))) < 0)

						goto err;

				}

			}

		}

	}

	/* instruction lines */

	if ((en = read_ushort(patch_data, file_size, &file_pos, &ushort_tmp)) < 0)

		goto err;

	if(file_sig)

	  ushort_tmp >>= 1;

	if ((en = liblo10k1_emu_patch_set_instr_count(new_patch, ushort_tmp)) < 0)

		goto err;

	for (i = 0; i < new_patch->instr_count; i++) {

		if ((en = read_uint(patch_data, file_size, &file_pos, &part1)) < 0)

			goto err;

		if ((en = read_uint(patch_data, file_size, &file_pos, &part2)) < 0)

			goto err;

		/* fill instr */

		new_patch->instrs[i].arg[2] = part1 >> 10;

		new_patch->instrs[i].arg[3] = part1 & 0x3FF;

		new_patch->instrs[i].op = part2 >> 20;

		new_patch->instrs[i].arg[0] = (part2 >> 10) & 0x3FF;

		new_patch->instrs[i].arg[1] = part2 & 0x3FF;

	}

	*p = new_patch;

	if (patch_data)

		free(patch_data);

	return 0;

err:

	if (patch_data)

		free(patch_data);

	if (new_patch)

		liblo10k1_emu_free_patch(new_patch);

	return en;

}

typedef struct

{

	unsigned int gpr;

	unsigned int ld_gpr;

} used_gpr_t;

static int check_if_used(used_gpr_t *gprs, int count, unsigned int gpr)

{

	int i;

	for (i = 0; i < count; i++) {

		if (gprs[i].gpr == gpr)

			return i;

	}

	return -1;

}

static char *default_in_names[] =

{

	"IL",

	"IR",

	"IRL",

	"IRR",

	"IC",

	"ILFE"

};

static char *default_out_names[] =

{

	"OL",

	"OR",

	"ORL",

	"ORR",

	"OC",

	"OLFE"

};

int liblo10k1_patch_find_ctl_by_name(liblo10k1_dsp_patch_t *p, char *ctl_name)

{

	int i;

	for (i = 0; i < p->ctl_count; i++)

		if (strcmp(p->ctl[i].name, ctl_name) == 0)

			return i;

	return -1;

}

int liblo10k1_patch_ctl_set_trans(liblo10k1_dsp_patch_t *p, int idx, int trans) 

{

	int i;

	switch (trans) {

		case EMU10K1_GPR_TRANSLATION_NONE:

			break;

		case EMU10K1_GPR_TRANSLATION_TABLE100:

			if (p->ctl[idx].min != 0 && p->ctl[idx].max != 100)

				return LD10K1_EF_ERR_TRANSFORM_TRANS;

			break;

		case EMU10K1_GPR_TRANSLATION_BASS:

		case EMU10K1_GPR_TRANSLATION_TREBLE:

			if (p->ctl[idx].min != 0 && p->ctl[idx].max != 0xFFFFFFFF)

				return LD10K1_EF_ERR_TRANSFORM_TRANS;

			if (p->ctl[idx].count != 5)

				return LD10K1_EF_ERR_TRANSFORM_TRANS;

			break;

		case EMU10K1_GPR_TRANSLATION_ONOFF:

			if (p->ctl[idx].min != 0 && p->ctl[idx].max != 1)

				return LD10K1_EF_ERR_TRANSFORM_TRANS;

			break;

	}

	for (i = 0; i < p->ctl[idx].count; i++)

		if (p->ctl[idx].value[i] < p->ctl[idx].min || p->ctl[idx].value[i] > p->ctl[idx].max)

			return LD10K1_EF_ERR_TRANSFORM_TRANS;

	p->ctl[idx].translation = trans;

	return 0;

}

int liblo10k1_patch_ctl_set_vcount(liblo10k1_dsp_patch_t *p, int idx, int vc) 

{

	if (p->ctl[idx].count < vc)

		return LD10K1_EF_ERR_TRANSFORM_CTL;

	p->ctl[idx].vcount = vc;

	return 0;

}

int liblo10k1_patch_ctl_set_index(liblo10k1_dsp_patch_t *p, int idx, int i) 

{

	p->ctl[idx].index = i;

	return 0;

}

int liblo10k1_patch_ctl_set_value(liblo10k1_dsp_patch_t *p, int idx, int vi, int val) 

{

	if (p->ctl[idx].count < vi)

		return LD10K1_EF_ERR_TRANSFORM_CTL;

	if (val < p->ctl[idx].min || val > p->ctl[idx].max)

			return LD10K1_EF_ERR_TRANSFORM_CTL;

	p->ctl[idx].value[vi] = val;

	return 0;

}

int liblo10k1_emu_transform_patch(liblo10k1_emu_patch_t *ep,  liblo10k1_ctl_transform_t *tctl, int tctl_count, liblo10k1_dsp_patch_t **lp)

{

	used_gpr_t used_gpr[0x400];

	int used_gpr_count = 0;

	int i, j, k;

	int gpr;

	int tmp_cnt;

	int idx;

	int en = 0;

	int io_name_map[6];

	int transformed;

	liblo10k1_dsp_ctl_t *tmp_nctl;

	liblo10k1_emu_ctl_t *tmp_octl;

	int const_count, hw_count;	/*int ctl_transform_map[256];*/

	liblo10k1_dsp_patch_t *np = NULL;

	liblo10k1_emu_tram_t *tram_tmp;

	liblo10k1_dsp_tram_acc_t *tram_nacc;

	liblo10k1_emu_tram_line_t *tram_line;

	int val, addhw, addconst;

	/* for all instruction get used gpr list */

	for (i = 0; i < ep->instr_count; i++) {

		for (j = 0; j < 4; j++) {

			gpr = ep->instrs[i].arg[j];

			for (k = 0; k < used_gpr_count; k++)

				if (gpr == used_gpr[k].gpr)

					break;

			if (k < used_gpr_count)

				continue;

			used_gpr[used_gpr_count].gpr = gpr;

			used_gpr[used_gpr_count].ld_gpr = 0;

			used_gpr_count++;

		}

	}

	np = liblo10k1_patch_alloc(0, 0, 0, 0, 0, 0, 0, 0, 0, ep->instr_count);

	if (!np)

		return LD10K1_ERR_NO_MEM;

	/* set patch name */

	strcpy(np->patch_name, ep->patch_name);

	/* in gprs */

	tmp_cnt = 0;

	for (i = 0; i < ep->in_count; i++) {

		idx = check_if_used(used_gpr, used_gpr_count, ep->ins[i] + 0x100);

		if (idx >= 0) {

			used_gpr[idx].ld_gpr = EMU10K1_PREG_IN(tmp_cnt);

			if (i < 6)

				io_name_map[i] = tmp_cnt;

			tmp_cnt++;

		} else {

			if (i < 6)

				io_name_map[i] = -1;

		}

	}

	if ((en = liblo10k1_patch_set_in_count(np, tmp_cnt)) < 0)

		goto err;

	/* set in name */

	if (ep->in_count == 2 || /* stereo */

		ep->in_count == 4 || /* 4 channel */

		ep->in_count == 6) { /* 5.1 */

		for (i = 0; i < ep->in_count; i++) {

			if (io_name_map[i] >= 0)

				strcpy(np->ins[io_name_map[i]].name, default_in_names[i]);

		}

	}

	/* out gprs */

	tmp_cnt = 0;

	for (i = 0; i < ep->out_count; i++) {

		idx = check_if_used(used_gpr, used_gpr_count, ep->outs[i] + 0x100);

		if (idx >= 0) {

			used_gpr[idx].ld_gpr = EMU10K1_PREG_OUT(tmp_cnt);

			if (i < 6)

				io_name_map[i] = tmp_cnt;

			tmp_cnt++;

		} else {

			if (i < 6)

				io_name_map[i] = -1;

		}

	}

	if ((en = liblo10k1_patch_set_out_count(np, tmp_cnt)) < 0)

		goto err;

	/* set out name */

	if (ep->out_count == 2 || /* stereo */

		ep->out_count == 4 || /* 4 channel */

		ep->out_count == 6) { /* 5.1 */

		for (i = 0; i < ep->out_count; i++) {

			if (io_name_map[i] >= 0)

				strcpy(np->outs[io_name_map[i]].name, default_out_names[i]);

		}

	}

	/* dyn regs */

	tmp_cnt = 0;

	for (i = 0; i < ep->dyn_count; i++) {

		idx = check_if_used(used_gpr, used_gpr_count, ep->dyns[i] + 0x100);

		if (idx >= 0) {

			used_gpr[idx].ld_gpr = EMU10K1_PREG_DYN(tmp_cnt);

			tmp_cnt++;

		}

	}

	if ((en = liblo10k1_patch_set_dyn_count(np, tmp_cnt)) < 0)

		goto err;

	/* sta regs */

	tmp_cnt = 0;

	for (i = 0; i < ep->sta_count; i++) {

		idx = check_if_used(used_gpr, used_gpr_count, ep->stas[i].sc + 0x100);

		if (idx >= 0) {

			used_gpr[idx].ld_gpr = EMU10K1_PREG_STA(tmp_cnt);

			tmp_cnt++;

		}

	}

	if ((en = liblo10k1_patch_set_sta_count(np, tmp_cnt)) < 0)

		goto err;

	/* sta regs - initilization */

	tmp_cnt = 0;

	for (i = 0; i < ep->sta_count; i++) {

		idx = check_if_used(used_gpr, used_gpr_count, ep->stas[i].sc + 0x100);

		if (idx >= 0) {

			np->stas[tmp_cnt].const_val = ep->stas[i].sc_val;

			tmp_cnt++;

		}

	}

	/* FIXME - ak je niektoty ctl pouzity v tctl viackrat tak to zblbne */

	/* ctls regs */

	/* first get count of ctls */

	tmp_cnt = 0;

	for (i = 0; i < tctl_count; i++)

		tmp_cnt += tctl[i].emu_ctl_count;

	if ((en = liblo10k1_patch_set_ctl_count(np, ep->ctl_count - tmp_cnt + tctl_count)) < 0)

		goto err;

	tmp_cnt = 0;

	for (i = 0; i < ep->ctl_count; i++) {

		tmp_octl = &(ep->ctls[i]);

		/* find if transformed */

		transformed = 0;

		for (j = 0; j < tctl_count; j++) {

			for (k = 0; k < tctl[j].emu_ctl_count; k++) {

				if (i == tctl[j].emu_ctls[k]) {

					/* it is transformed */

					tmp_nctl = &(np->ctl[j]);

					if (strcmp(tmp_nctl->name, "") != 0) {

						/* initialized - check min, max */

						if (tmp_octl->ctl_val_min != tmp_nctl->min ||

							tmp_octl->ctl_val_max != tmp_nctl->max) {

							en = LD10K1_EF_ERR_TRANSFORM_CTL;

							goto err;

						}

						tmp_nctl->value[k] = tmp_octl->ctl_val;

					} else {

						/* initialize it */

						strcpy(tmp_nctl->name, tctl[j].ctl_name);

						tmp_nctl->index = -1;

						tmp_nctl->vcount = tctl[j].emu_ctl_count;/*1;*/

						tmp_nctl->count = tctl[j].emu_ctl_count;/*1;*/

						tmp_nctl->value[k] = tmp_octl->ctl_val;

						tmp_nctl->min = tmp_octl->ctl_val_min;

						tmp_nctl->max = tmp_octl->ctl_val_max;

						tmp_nctl->translation = EMU10K1_GPR_TRANSLATION_NONE;

					}

					idx = check_if_used(used_gpr, used_gpr_count, tmp_octl->ctl + 0x100);

					if (idx >= 0)

						used_gpr[idx].ld_gpr = EMU10K1_PREG_CTL(j, k);

					transformed = 1;

					break;

				}

			}

			if (transformed)

				break;

		}

		if (transformed)

			continue;

		/* not transformed */

		tmp_nctl = &(np->ctl[tmp_cnt + tctl_count]);

		strcpy(tmp_nctl->name, tmp_octl->ctl_name);

		tmp_nctl->index = -1;

		tmp_nctl->vcount = 1;

		tmp_nctl->count = 1;

		tmp_nctl->value[0] = tmp_octl->ctl_val;

		tmp_nctl->min = tmp_octl->ctl_val_min;

		tmp_nctl->max = tmp_octl->ctl_val_max;

		tmp_nctl->translation = EMU10K1_GPR_TRANSLATION_NONE;

		idx = check_if_used(used_gpr, used_gpr_count, tmp_octl->ctl + 0x100);

		if (idx >= 0)

			used_gpr[idx].ld_gpr = EMU10K1_PREG_CTL(tmp_cnt + tctl_count, 0);

		tmp_cnt++;

		if (tmp_cnt > np->ctl_count) {

			en = LD10K1_EF_ERR_TRANSFORM_CTL;

			goto err;

		}

	}

	if (tmp_cnt + tctl_count < np->ctl_count) {

		en = LD10K1_EF_ERR_TRANSFORM_CTL;

		goto err;

	}

	/* tram */

	if ((en = liblo10k1_patch_set_tram_count(np, ep->tram_lookup_count + ep->tram_delay_count)) < 0)

		goto err;

	tmp_cnt = 0;

	for (i = 0; i < ep->tram_lookup_count + ep->tram_delay_count; i++) {

		if (i < ep->tram_lookup_count)

			tram_tmp = &(ep->tram_lookups[i]);

		else

			tram_tmp = &(ep->tram_delays[i - ep->tram_lookup_count]);

		tmp_cnt += tram_tmp->read_line_count + tram_tmp->write_line_count;

		np->tram[i].grp_type = i < ep->tram_lookup_count ? TRAM_GRP_TABLE : TRAM_GRP_DELAY;

		np->tram[i].grp_size = tram_tmp->size;