&& tone->envkeyfnum == 0 && tone->envvelfnum == 0
static Instrument *load_gus_instrument(char *name,		ToneBank *bank, int dr, int prog, char *infomsg){	ToneBankElement *tone;	int amp, note_to_use, panning, strip_envelope, strip_loop, strip_tail;	Instrument *ip;	struct timidity_file *tf;	uint8 tmp[1024], fractions;	Sample *sp;	int i, j, noluck = 0;		if (! name)		return 0;	if (infomsg != NULL)		ctl->cmsg(CMSG_INFO, VERB_NOISY, "%s: %s", infomsg, name);	else		ctl->cmsg(CMSG_INFO, VERB_NOISY, "Loading instrument %s", name);	if (bank) {		tone = &bank->tone[prog];		amp = tone->amp;		note_to_use = (tone->note != -1) ? tone->note : ((dr) ? prog : -1);		panning = tone->pan;		strip_envelope = (tone->strip_envelope != -1)				? tone->strip_envelope : ((dr) ? 1 : -1);		strip_loop = (tone->strip_loop != -1)				? tone->strip_loop : ((dr) ? 1 : -1);		strip_tail = tone->strip_tail;	} else {		tone = NULL;		amp = note_to_use = panning = -1;		strip_envelope = strip_loop = strip_tail = 0;	}	if (tone && tone->tunenum == 0			&& tone->envratenum == 0 && tone->envofsnum == 0			&& tone->tremnum == 0 && tone->vibnum == 0			&& tone->sclnotenum == 0 && tone->scltunenum == 0			&& tone->modenvratenum == 0 && tone->modenvofsnum == 0			&& tone->modenvkeyfnum == 0 && tone->modenvvelfnum == 0			&& tone->envkeyfnum == 0 && tone->envvelfnum == 0			&& tone->trempitchnum == 0 && tone->tremfcnum == 0			&& tone->modpitchnum == 0 && tone->modfcnum == 0			&& tone->fcnum == 0 && tone->resonum == 0)		if ((ip = search_instrument_cache(name, panning, amp, note_to_use,				strip_loop, strip_envelope, strip_tail)) != NULL) {			ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * Cached");			return ip;		}	/* Open patch file */	if (! (tf = open_file(name, 2, OF_NORMAL))) {#ifdef PATCH_EXT_LIST		int name_len, ext_len;		static char *patch_ext[] = PATCH_EXT_LIST;#endif				noluck = 1;#ifdef PATCH_EXT_LIST		name_len = strlen(name);		/* Try with various extensions */		for (i = 0; patch_ext[i]; i++) {			ext_len = strlen(patch_ext[i]);			if (name_len + ext_len < 1024) {				if (name_len >= ext_len && strcmp(name + name_len - ext_len,						patch_ext[i]) == 0)					continue;	/* duplicated ext. */				strcpy((char *) tmp, name);				strcat((char *) tmp, patch_ext[i]);				if ((tf = open_file((char *) tmp, 1, OF_NORMAL))) {					noluck = 0;					break;				}			}		}#endif	}	if (noluck) {		ctl->cmsg(CMSG_ERROR, VERB_NORMAL,				"Instrument `%s' can't be found.", name);		return 0;	}	/* Read some headers and do cursory sanity checks. There are loads	 * of magic offsets.  This could be rewritten...	 */	tmp[0] = tf_getc(tf);	if (tmp[0] == '\0') {		/* for Mac binary */		skip(tf, 127);		tmp[0] = tf_getc(tf);	}	if ((tf_read(tmp + 1, 1, 238, tf) != 238)			|| (memcmp(tmp, "GF1PATCH110\0ID#000002", 22)			&& memcmp(tmp, "GF1PATCH100\0ID#000002", 22))) {			/* don't know what the differences are */		ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: not an instrument", name);		close_file(tf);		return 0;	}	/* instruments.  To some patch makers, 0 means 1 */	if (tmp[82] != 1 && tmp[82] != 0) {		ctl->cmsg(CMSG_ERROR, VERB_NORMAL,				"Can't handle patches with %d instruments", tmp[82]);		close_file(tf);		return 0;	}	if (tmp[151] != 1 && tmp[151] != 0) {	/* layers.  What's a layer? */		ctl->cmsg(CMSG_ERROR, VERB_NORMAL,				"Can't handle instruments with %d layers", tmp[151]);		close_file(tf);		return 0;	}	ip = (Instrument *) safe_malloc(sizeof(Instrument));	ip->type = INST_GUS;	ip->samples = tmp[198];	ip->sample = (Sample *) safe_malloc(sizeof(Sample) * ip->samples);	memset(ip->sample, 0, sizeof(Sample) * ip->samples);	for (i = 0; i < ip->samples; i++) {		skip(tf, 7);	/* Skip the wave name */		if (tf_read(&fractions, 1, 1, tf) != 1) {fail:			ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Error reading sample %d", i);			for (j = 0; j < i; j++)				free(ip->sample[j].data);			free(ip->sample);			free(ip);			close_file(tf);			return 0;		}		sp = &(ip->sample[i]);		sp->low_vel = 0;		sp->high_vel = 127;		sp->cutoff_freq = sp->resonance = 0;		sp->tremolo_to_pitch = sp->tremolo_to_fc = 0;		sp->modenv_to_pitch = sp->modenv_to_fc = 0;		sp->vel_to_fc = sp->key_to_fc = sp->vel_to_resonance = 0;		sp->envelope_velf_bpo = sp->modenv_velf_bpo = 64;		sp->vel_to_fc_threshold = 64;		sp->key_to_fc_bpo = 60;		sp->envelope_delay = sp->modenv_delay = 0;		sp->tremolo_delay = sp->vibrato_delay = 0;		sp->inst_type = INST_GUS;		sp->sample_type = SF_SAMPLETYPE_MONO;		sp->sf_sample_link = -1;		sp->sf_sample_index = 0;		memset(sp->envelope_velf, 0, sizeof(sp->envelope_velf));		memset(sp->envelope_keyf, 0, sizeof(sp->envelope_keyf));		memset(sp->modenv_velf, 0, sizeof(sp->modenv_velf));		memset(sp->modenv_keyf, 0, sizeof(sp->modenv_keyf));		memset(sp->modenv_rate, 0, sizeof(sp->modenv_rate));		memset(sp->modenv_offset, 0, sizeof(sp->modenv_offset));		READ_LONG(sp->data_length);		READ_LONG(sp->loop_start);		READ_LONG(sp->loop_end);		READ_SHORT(sp->sample_rate);		READ_LONG(sp->low_freq);		READ_LONG(sp->high_freq);		READ_LONG(sp->root_freq);		skip(tf, 2);	/* Why have a "root frequency" and then "tuning"?? */		READ_CHAR(tmp[0]);		ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Rate/Low/Hi/Root = %d/%d/%d/%d",				sp->sample_rate, sp->low_freq, sp->high_freq, sp->root_freq);		if (panning == -1)			/* 0x07 and 0x08 are both center panning */			sp->panning = ((tmp[0] - ((tmp[0] < 8) ? 7 : 8)) * 63) / 7 + 64;		else			sp->panning = (uint8) (panning & 0x7f);		/* envelope, tremolo, and vibrato */		if (tf_read(tmp, 1, 18, tf) != 18)			goto fail;		if (! tmp[13] || ! tmp[14]) {			sp->tremolo_sweep_increment = sp->tremolo_phase_increment = 0;			sp->tremolo_depth = 0;			ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * no tremolo");		} else {			sp->tremolo_sweep_increment = convert_tremolo_sweep(tmp[12]);			sp->tremolo_phase_increment = convert_tremolo_rate(tmp[13]);			sp->tremolo_depth = tmp[14];			ctl->cmsg(CMSG_INFO, VERB_DEBUG,					" * tremolo: sweep %d, phase %d, depth %d",					sp->tremolo_sweep_increment, sp->tremolo_phase_increment,					sp->tremolo_depth);		}		if (! tmp[16] || ! tmp[17]) {			sp->vibrato_sweep_increment = sp->vibrato_control_ratio = 0;			sp->vibrato_depth = 0;			ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * no vibrato");		} else {			sp->vibrato_control_ratio = convert_vibrato_rate(tmp[16]);			sp->vibrato_sweep_increment = convert_vibrato_sweep(tmp[15],					sp->vibrato_control_ratio);			sp->vibrato_depth = tmp[17];			ctl->cmsg(CMSG_INFO, VERB_DEBUG,					" * vibrato: sweep %d, ctl %d, depth %d",					sp->vibrato_sweep_increment, sp->vibrato_control_ratio,					sp->vibrato_depth);		}		READ_CHAR(sp->modes);		ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * mode: 0x%02x", sp->modes);		READ_SHORT(sp->scale_freq);		READ_SHORT(sp->scale_factor);		skip(tf, 36);	/* skip reserved space */		/* Mark this as a fixed-pitch instrument if such a deed is desired. */		sp->note_to_use = (note_to_use != -1) ? (uint8) note_to_use : 0;		/* seashore.pat in the Midia patch set has no Sustain.  I don't		 * understand why, and fixing it by adding the Sustain flag to		 * all looped patches probably breaks something else.  We do it		 * anyway.		 */		if (sp->modes & MODES_LOOPING)			sp->modes |= MODES_SUSTAIN;		/* Strip any loops and envelopes we're permitted to */		if ((strip_loop == 1) && (sp->modes & (MODES_SUSTAIN | MODES_LOOPING				| MODES_PINGPONG | MODES_REVERSE))) {			sp->modes &= ~(MODES_SUSTAIN | MODES_LOOPING					| MODES_PINGPONG | MODES_REVERSE);			ctl->cmsg(CMSG_INFO, VERB_DEBUG,					" - Removing loop and/or sustain");		}		if (strip_envelope == 1) {			if (sp->modes & MODES_ENVELOPE)				ctl->cmsg(CMSG_INFO, VERB_DEBUG, " - Removing envelope");			sp->modes &= ~MODES_ENVELOPE;		} else if (strip_envelope != 0) {			/* Have to make a guess. */			if (! (sp->modes & (MODES_LOOPING					| MODES_PINGPONG | MODES_REVERSE))) {				/* No loop? Then what's there to sustain?				 * No envelope needed either...				 */				sp->modes &= ~(MODES_SUSTAIN|MODES_ENVELOPE);				ctl->cmsg(CMSG_INFO, VERB_DEBUG,						" - No loop, removing sustain and envelope");			} else if (! memcmp(tmp, "??????", 6) || tmp[11] >= 100) {				/* Envelope rates all maxed out?				 * Envelope end at a high "offset"?				 * That's a weird envelope.  Take it out.				 */				sp->modes &= ~MODES_ENVELOPE;				ctl->cmsg(CMSG_INFO, VERB_DEBUG,						" - Weirdness, removing envelope");			} else if (! (sp->modes & MODES_SUSTAIN)) {				/* No sustain? Then no envelope.  I don't know if this is				 * justified, but patches without sustain usually don't need				 * the envelope either... at least the Gravis ones.  They're				 * mostly drums.  I think.				 */				sp->modes &= ~MODES_ENVELOPE;				ctl->cmsg(CMSG_INFO, VERB_DEBUG,						" - No sustain, removing envelope");			}		}		for (j = 0; j < 6; j++) {			sp->envelope_rate[j]= convert_envelope_rate(tmp[j]);			sp->envelope_offset[j] = convert_envelope_offset(tmp[j + 6]);		}		/* this envelope seems to give reverb like effects to most patches		 * use the same method as soundfont		 */		if (modify_release) {			sp->envelope_offset[3] = to_offset(5);			sp->envelope_rate[3] = calc_rate(255, modify_release);			sp->envelope_offset[4] = to_offset(4);			sp->envelope_rate[4] = to_offset(200);			sp->envelope_offset[5] = to_offset(4);			sp->envelope_rate[5] = to_offset(200);		}		/* Then read the sample data */		sp->data = (sample_t *) safe_malloc(sp->data_length + 4);		sp->data_alloced = 1;		if ((j = tf_read(sp->data, 1, sp->data_length, tf))				!= sp->data_length) {			ctl->cmsg(CMSG_ERROR, VERB_NORMAL,					"Too small this patch length: %d < %d",					j, sp->data_length);			goto fail;		}		if (! (sp->modes & MODES_16BIT)) {	/* convert to 16-bit data */			int32 i;			uint16 *tmp;			uint8 *cp = (uint8 *) sp->data;						tmp = (uint16 *) safe_malloc(sp->data_length * 2 + 4);			for (i = 0; i < sp->data_length; i++)				tmp[i] = (uint16) cp[i] << 8;			sp->data = (sample_t *) tmp;			free(cp);			sp->data_length *= 2;			sp->loop_start *= 2;			sp->loop_end *= 2;		}#ifndef LITTLE_ENDIAN		else {	/* convert to machine byte order */			int32 i;			int16 *tmp = (int16 *) sp->data, s;						for (i = 0; i < sp->data_length / 2; i++)				s = LE_SHORT(tmp[i]), tmp[i] = s;		}#endif		if (sp->modes & MODES_UNSIGNED) {	/* convert to signed data */			int32 i = sp->data_length / 2;			int16 *tmp = (int16 *) sp->data;						while (i--)				*tmp++ ^= 0x8000;		}		/* Reverse loops and pass them off as normal loops */		if (sp->modes & MODES_REVERSE) {			/* The GUS apparently plays reverse loops by reversing the			 * whole sample.  We do the same because the GUS does not SUCK.			 */			int32 t;						reverse_data((int16 *) sp->data, 0, sp->data_length / 2);			t = sp->loop_start;			sp->loop_start = sp->data_length - sp->loop_end;			sp->loop_end = sp->data_length - t;			sp->modes &= ~MODES_REVERSE;			sp->modes |= MODES_LOOPING;	/* just in case */			ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "Reverse loop in %s", name);		}		/* If necessary do some anti-aliasing filtering */		if (antialiasing_allowed)			antialiasing((int16 *) sp->data, sp->data_length / 2,					sp->sample_rate, play_mode->rate);#ifdef ADJUST_SAMPLE_VOLUMES		if (amp != -1)			sp->volume = (double) amp / 100;		else {			/* Try to determine a volume scaling factor for the sample.			 * This is a very crude adjustment, but things sound more			 * balanced with it.  Still, this should be a runtime option.			 */			int32 i, a, maxamp = 0;			int16 *tmp = (int16 *) sp->data;						for (i = 0; i < sp->data_length / 2; i++)				if ((a = abs(tmp[i])) > maxamp)					maxamp = a;			sp->volume = 32768 / (double) maxamp;			ctl->cmsg(CMSG_INFO, VERB_DEBUG,					" * volume comp: %f", sp->volume);		}#else		sp->volume = (amp != -1) ? (double) amp / 100 : 1.0;#endif		/* These are in bytes.  Convert into samples. */		sp->data_length /= 2;		sp->loop_start /= 2;		sp->loop_end /= 2;		/* The sample must be padded out by 2 extra sample, so that		 * round off errors in the offsets used in interpolation will not		 * cause a "pop" by reading random data beyond data_length		 */		sp->data[sp->data_length] = sp->data[sp->data_length + 1] = 0;		/* Remove abnormal loops which cause pop noise		 * in long sustain stage		 */		if (! (sp->modes & MODES_LOOPING)) {			sp->loop_start = sp->data_length - 1;			sp->loop_end = sp->data_length;			sp->data[sp->data_length - 1] = 0;		}		/* Then fractional samples */		sp->data_length <<= FRACTION_BITS;		sp->loop_start <<= FRACTION_BITS;		sp->loop_end <<= FRACTION_BITS;		/* Adjust for fractional loop points. This is a guess.  Does anyone		 * know what "fractions" really stands for?		 */		sp->loop_start |= (fractions & 0x0f) << (FRACTION_BITS - 4);		sp->loop_end |= ((fractions >> 4) & 0x0f) << (FRACTION_BITS - 4);		/* If this instrument will always be played on the same note,		 * and it's not looped, we can resample it now.		 */		if (sp->note_to_use && ! (sp->modes & MODES_LOOPING))			pre_resample(sp);#ifdef LOOKUP_HACK		/* Squash the 16-bit data into 8 bits. */		{			uint8 *gulp, *ulp;			int16 *swp;			int l = sp->data_length >> FRACTION_BITS;						gulp = ulp = (uint8 *) safe_malloc(l + 1);			swp = (int16 *) sp->data;			while (l--)				*ulp++ = (*swp++ >> 8) & 0xff;			free(sp->data);			sp->data = (sample_t *) gulp;		}#endif		if (strip_tail == 1) {			/* Let's not really, just say we did. */			sp->data_length = sp->loop_end;			ctl->cmsg(CMSG_INFO, VERB_DEBUG, " - Stripping tail");		}	}	close_file(tf);	store_instrument_cache(ip, name, panning, amp, note_to_use,			strip_loop, strip_envelope, strip_tail);	return ip;}