tags 769264 +patch
thanks
Hi,
On Wed, Nov 12, 2014 at 11:45:28AM +0100, Lucas Nussbaum wrote:
> > ./fusebirth > fused_loop.c 2>/dev/null
> > make[1]: *** [fused_loop.c] Error 139
So what happens here is that fusebirth segfaults on i386 in topo_sort(),
while trying to sort whatever in order to generate fused_loop.c.
Tracing through topo_sort() with a debugger, it seems that after a dozen
or so recursions into it, get_children(node) returns an invalid (but not
NULL) pointer, and on the next iteration we get a segfault in it.
I stared at the code for a few hours, but it doesn't look like this is
how GLib is supposed to be used nowadays, so I went for an alternative
solution: I just included the auto-generated .c code into the source
package and changed the build system to not generate/delete that .c file.
I made sure the generated source is the same on amd64 and s390x and will
test on a couple more architectures to make sure.
Proposed Debdiff attached.
Michael
diff -u freebirth-0.3.2/Makefile freebirth-0.3.2/Makefile
--- freebirth-0.3.2/Makefile
+++ freebirth-0.3.2/Makefile
@@ -19,14 +19,11 @@
all: freebirth
clean: Makefile.deps
- -rm -f *.o freebirth fusebirth fused_loop.c Makefile.deps *~
+ -rm -f *.o freebirth fusebirth Makefile.deps *~
freebirth: $(OFILES) fused_loop.o freebirth.o
$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
-fused_loop.c: fusebirth
- ./fusebirth > fused_loop.c 2>/dev/null
-
fusebirth: $(OFILES) fuse_loops.o fusebirth.o
$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
diff -u freebirth-0.3.2/debian/changelog freebirth-0.3.2/debian/changelog
--- freebirth-0.3.2/debian/changelog
+++ freebirth-0.3.2/debian/changelog
@@ -1,3 +1,11 @@
+freebirth (0.3.2-9.1) unstable; urgency=medium
+
+ * Non-maintainer upload.
+ * fused_loop.c: Include auto-generated C-file (closes: #769264).
+ * Makefile: Do not generate or remove fused_loop.c.
+
+ -- Michael Banck <[email protected]> Sat, 22 Nov 2014 20:36:11 +0100
+
freebirth (0.3.2-9) unstable; urgency=medium
* debian/control: add homepage, thanks to Francisco Javier Garrote Cruz
only in patch2:
unchanged:
--- freebirth-0.3.2.orig/fused_loop.c
+++ freebirth-0.3.2/fused_loop.c
@@ -0,0 +1,597 @@
+/* generated file -- don't edit */
+#include <unistd.h>
+#include <math.h>
+#include <endian.h>
+#include "freebirth.h"
+/* borrowed from glib2 */
+#define SHORT_SWAP_LE_BE(val) ((short) ( \
+ (short) ((short) (val) >> 8) | \
+ (short) ((short) (val) << 8)))
+static void swap_endian(short *data, int length)
+{
+ int i;
+ for (i = 0; i < length; i += 1, data++)
+ *data = SHORT_SWAP_LE_BE(*data);
+}
+
+sample_producer *sp[31];
+
+int play_buffer(gpointer data, gint source, GdkInputCondition condition)
+{
+ int i;
+ short buffer[TBASS_BUFF_SIZE * 2];
+
+ sample samp0;
+ sample samp1;
+ sample samp2;
+ sample samp3;
+ sample samp4;
+ sample samp5;
+ sample samp6;
+ sample samp7;
+ sample samp8;
+ sample samp9;
+ sample samp10;
+ sample samp11;
+ sample samp12;
+ sample samp13;
+ sample samp14;
+ sample samp15;
+ sample samp16;
+ sample samp17;
+ sample samp18;
+ sample samp19;
+ sample samp20;
+ sample samp21;
+ sample samp22;
+ sample samp23;
+ sample samp24;
+ sample samp25;
+ sample samp26;
+ sample samp27;
+ sample samp28;
+ sample samp29;
+ sample samp30;
+
+ int seq_off = sequencer->current_sample_offset;
+ int seq_spb = sequencer->spb;
+ event_list *el;
+ int j;
+
+ sample *n0_table = ((raw_wave *)sp[0])->table;
+ int n0_length = ((raw_wave *)sp[0])->length;
+ sample n0_s1, n0_s2;
+ double n0_ci_w, n0_ci_f, n0_pitch = ((raw_wave *)sp[0])->pitch;
+
+ sample *n1_table = ((raw_wave *)sp[1])->table;
+ int n1_length = ((raw_wave *)sp[1])->length;
+ sample n1_s1, n1_s2;
+ double n1_ci_w, n1_ci_f, n1_pitch = ((raw_wave *)sp[1])->pitch;
+
+ sample *n2_table = ((raw_wave *)sp[2])->table;
+ int n2_length = ((raw_wave *)sp[2])->length;
+ sample n2_s1, n2_s2;
+ double n2_ci_w, n2_ci_f, n2_pitch = ((raw_wave *)sp[2])->pitch;
+
+ sample *n3_table = ((raw_wave *)sp[3])->table;
+ int n3_length = ((raw_wave *)sp[3])->length;
+ sample n3_s1, n3_s2;
+ double n3_ci_w, n3_ci_f, n3_pitch = ((raw_wave *)sp[3])->pitch;
+
+ sample *n4_table = ((raw_wave *)sp[4])->table;
+ int n4_length = ((raw_wave *)sp[4])->length;
+ sample n4_s1, n4_s2;
+ double n4_ci_w, n4_ci_f, n4_pitch = ((raw_wave *)sp[4])->pitch;
+
+ int n5_phase_offset = ((osc *)sp[5])->phase_offset;
+ double n5_freq_offset = ((osc *)sp[5])->freq_offset;
+ int n5_freq = ((osc *)sp[5])->freq;
+ int n5_phase_factor = n5_phase_offset / n5_freq;
+ sample *n5_table = ((osc *)sp[5])->table;
+ int n5_i = ((osc *)sp[5])->current_index;
+
+ int n6_phase_offset = ((osc *)sp[6])->phase_offset;
+ double n6_freq_offset = ((osc *)sp[6])->freq_offset;
+ int n6_freq = ((osc *)sp[6])->freq;
+ int n6_phase_factor = n6_phase_offset / n6_freq;
+ sample *n6_table = ((osc *)sp[6])->table;
+ int n6_i = ((osc *)sp[6])->current_index;
+
+ int n7_phase_offset = ((osc *)sp[7])->phase_offset;
+ double n7_freq_offset = ((osc *)sp[7])->freq_offset;
+ int n7_freq = ((osc *)sp[7])->freq;
+ int n7_phase_factor = n7_phase_offset / n7_freq;
+ sample *n7_table = ((osc *)sp[7])->table;
+ int n7_i = ((osc *)sp[7])->current_index;
+
+ int n8_blend = ((blender *)sp[8])->blend_factor;
+ int n8_strength0 = ((blender *)sp[8])->strength[0];
+ int n8_strength1 = ((blender *)sp[8])->strength[1];
+ int n8_strength2 = ((blender *)sp[8])->strength[2];
+
+ int n9_attack = ((env *)sp[9])->attack;
+ int n9_release = ((env *)sp[9])->release;
+
+ int n10_fc = ((filter *)sp[10])->fc;
+ float n10_Q = ((filter *)sp[10])->Q;
+ float n10_s;
+
+ int n11_attack = ((env *)sp[11])->attack;
+ int n11_release = ((env *)sp[11])->release;
+
+ int n12_amp0 = ((mixer *)sp[12])->amplitude[0];
+ int n12_amp1 = ((mixer *)sp[12])->amplitude[1];
+ int n12_amp2 = ((mixer *)sp[12])->amplitude[2];
+ int n12_amp3 = ((mixer *)sp[12])->amplitude[3];
+ int n12_amp4 = ((mixer *)sp[12])->amplitude[4];
+ int n12_amp5 = ((mixer *)sp[12])->amplitude[5];
+ int n12_mute0 = ((mixer *)sp[12])->mute_map[0];
+ int n12_mute1 = ((mixer *)sp[12])->mute_map[1];
+ int n12_mute2 = ((mixer *)sp[12])->mute_map[2];
+ int n12_mute3 = ((mixer *)sp[12])->mute_map[3];
+ int n12_mute4 = ((mixer *)sp[12])->mute_map[4];
+ int n12_mute5 = ((mixer *)sp[12])->mute_map[5];
+
+ int n13_i = ((delay *)sp[13])->d_index;
+ int n13_size = ((delay *)sp[13])->delay_size;
+ int n13_feedback = ((delay *)sp[13])->feedback;
+ sample *n13_buf = ((delay *)sp[13])->delay_buffer;
+
+ int n14_i = ((delay *)sp[14])->d_index;
+ int n14_size = ((delay *)sp[14])->delay_size;
+ int n14_feedback = ((delay *)sp[14])->feedback;
+ sample *n14_buf = ((delay *)sp[14])->delay_buffer;
+
+ int n15_i = ((delay *)sp[15])->d_index;
+ int n15_size = ((delay *)sp[15])->delay_size;
+ int n15_feedback = ((delay *)sp[15])->feedback;
+ sample *n15_buf = ((delay *)sp[15])->delay_buffer;
+
+ int n16_amp0 = ((mixer *)sp[16])->amplitude[0];
+ int n16_amp1 = ((mixer *)sp[16])->amplitude[1];
+ int n16_amp2 = ((mixer *)sp[16])->amplitude[2];
+ int n16_mute0 = ((mixer *)sp[16])->mute_map[0];
+ int n16_mute1 = ((mixer *)sp[16])->mute_map[1];
+ int n16_mute2 = ((mixer *)sp[16])->mute_map[2];
+
+
+ int n18_amp0 = ((mixer *)sp[18])->amplitude[0];
+ int n18_amp1 = ((mixer *)sp[18])->amplitude[1];
+ int n18_amp2 = ((mixer *)sp[18])->amplitude[2];
+ int n18_amp3 = ((mixer *)sp[18])->amplitude[3];
+ int n18_amp4 = ((mixer *)sp[18])->amplitude[4];
+ int n18_amp5 = ((mixer *)sp[18])->amplitude[5];
+ int n18_mute0 = ((mixer *)sp[18])->mute_map[0];
+ int n18_mute1 = ((mixer *)sp[18])->mute_map[1];
+ int n18_mute2 = ((mixer *)sp[18])->mute_map[2];
+ int n18_mute3 = ((mixer *)sp[18])->mute_map[3];
+ int n18_mute4 = ((mixer *)sp[18])->mute_map[4];
+ int n18_mute5 = ((mixer *)sp[18])->mute_map[5];
+
+ int n19_i = ((delay *)sp[19])->d_index;
+ int n19_size = ((delay *)sp[19])->delay_size;
+ int n19_feedback = ((delay *)sp[19])->feedback;
+ sample *n19_buf = ((delay *)sp[19])->delay_buffer;
+
+ int n20_i = ((delay *)sp[20])->d_index;
+ int n20_size = ((delay *)sp[20])->delay_size;
+ int n20_feedback = ((delay *)sp[20])->feedback;
+ sample *n20_buf = ((delay *)sp[20])->delay_buffer;
+
+ int n21_i = ((delay *)sp[21])->d_index;
+ int n21_size = ((delay *)sp[21])->delay_size;
+ int n21_feedback = ((delay *)sp[21])->feedback;
+ sample *n21_buf = ((delay *)sp[21])->delay_buffer;
+
+ int n22_i = ((delay *)sp[22])->d_index;
+ int n22_size = ((delay *)sp[22])->delay_size;
+ int n22_feedback = ((delay *)sp[22])->feedback;
+ sample *n22_buf = ((delay *)sp[22])->delay_buffer;
+
+ int n23_i = ((delay *)sp[23])->d_index;
+ int n23_size = ((delay *)sp[23])->delay_size;
+ int n23_feedback = ((delay *)sp[23])->feedback;
+ sample *n23_buf = ((delay *)sp[23])->delay_buffer;
+
+ int n24_i = ((delay *)sp[24])->d_index;
+ int n24_size = ((delay *)sp[24])->delay_size;
+ int n24_feedback = ((delay *)sp[24])->feedback;
+ sample *n24_buf = ((delay *)sp[24])->delay_buffer;
+
+ int n25_amp0 = ((mixer *)sp[25])->amplitude[0];
+ int n25_amp1 = ((mixer *)sp[25])->amplitude[1];
+ int n25_amp2 = ((mixer *)sp[25])->amplitude[2];
+ int n25_amp3 = ((mixer *)sp[25])->amplitude[3];
+ int n25_amp4 = ((mixer *)sp[25])->amplitude[4];
+ int n25_amp5 = ((mixer *)sp[25])->amplitude[5];
+ int n25_mute0 = ((mixer *)sp[25])->mute_map[0];
+ int n25_mute1 = ((mixer *)sp[25])->mute_map[1];
+ int n25_mute2 = ((mixer *)sp[25])->mute_map[2];
+ int n25_mute3 = ((mixer *)sp[25])->mute_map[3];
+ int n25_mute4 = ((mixer *)sp[25])->mute_map[4];
+ int n25_mute5 = ((mixer *)sp[25])->mute_map[5];
+
+ int n26_i = ((all_pass *)sp[26])->d_index;
+ int n26_size = ((all_pass *)sp[26])->delay_size;
+ int n26_feedback = ((all_pass *)sp[26])->feedback;
+ sample *n26_buf = ((all_pass *)sp[26])->delay_buffer;
+
+ int n27_i = ((all_pass *)sp[27])->d_index;
+ int n27_size = ((all_pass *)sp[27])->delay_size;
+ int n27_feedback = ((all_pass *)sp[27])->feedback;
+ sample *n27_buf = ((all_pass *)sp[27])->delay_buffer;
+
+
+ int n29_amp0 = ((mixer *)sp[29])->amplitude[0];
+ int n29_amp1 = ((mixer *)sp[29])->amplitude[1];
+ int n29_amp2 = ((mixer *)sp[29])->amplitude[2];
+ int n29_amp3 = ((mixer *)sp[29])->amplitude[3];
+ int n29_amp4 = ((mixer *)sp[29])->amplitude[4];
+ int n29_amp5 = ((mixer *)sp[29])->amplitude[5];
+ int n29_amp6 = ((mixer *)sp[29])->amplitude[6];
+ int n29_amp7 = ((mixer *)sp[29])->amplitude[7];
+ int n29_mute0 = ((mixer *)sp[29])->mute_map[0];
+ int n29_mute1 = ((mixer *)sp[29])->mute_map[1];
+ int n29_mute2 = ((mixer *)sp[29])->mute_map[2];
+ int n29_mute3 = ((mixer *)sp[29])->mute_map[3];
+ int n29_mute4 = ((mixer *)sp[29])->mute_map[4];
+ int n29_mute5 = ((mixer *)sp[29])->mute_map[5];
+ int n29_mute6 = ((mixer *)sp[29])->mute_map[6];
+ int n29_mute7 = ((mixer *)sp[29])->mute_map[7];
+
+ int n30_amp0 = ((mixer *)sp[30])->amplitude[0];
+ int n30_amp1 = ((mixer *)sp[30])->amplitude[1];
+ int n30_amp2 = ((mixer *)sp[30])->amplitude[2];
+ int n30_amp3 = ((mixer *)sp[30])->amplitude[3];
+ int n30_amp4 = ((mixer *)sp[30])->amplitude[4];
+ int n30_amp5 = ((mixer *)sp[30])->amplitude[5];
+ int n30_amp6 = ((mixer *)sp[30])->amplitude[6];
+ int n30_amp7 = ((mixer *)sp[30])->amplitude[7];
+ int n30_mute0 = ((mixer *)sp[30])->mute_map[0];
+ int n30_mute1 = ((mixer *)sp[30])->mute_map[1];
+ int n30_mute2 = ((mixer *)sp[30])->mute_map[2];
+ int n30_mute3 = ((mixer *)sp[30])->mute_map[3];
+ int n30_mute4 = ((mixer *)sp[30])->mute_map[4];
+ int n30_mute5 = ((mixer *)sp[30])->mute_map[5];
+ int n30_mute6 = ((mixer *)sp[30])->mute_map[6];
+ int n30_mute7 = ((mixer *)sp[30])->mute_map[7];
+
+ for (i = 0; i < TBASS_BUFF_SIZE; i++) {
+ seq_off++;
+ if (seq_off >= seq_spb) {
+ sequencer->current_step++;
+ if (sequencer->current_step >= sequencer->length)
+ sequencer->current_step = 0;
+ sequencer->callback(sequencer->current_step);
+ seq_off -= seq_spb;
+ el = sequencer->event_map[sequencer->current_step];
+ for (j=0; j < el->length; j++) {
+ event *e = el->events[j];
+ e->fire(e, sequencer->victims[e->seq_handle]);
+ }
+ }
+
+ if (((raw_wave *)sp[0])->current_index >= n0_length)
+ samp0 = 0;
+ else {
+ n0_ci_f = modf(((raw_wave *)sp[0])->current_index, &n0_ci_w);
+ n0_s1 = n0_table[(int)n0_ci_w];
+ n0_s2 = n0_table[(int)n0_ci_w +1];
+ ((raw_wave *)sp[0])->current_index += n0_pitch;
+ samp0 = (n0_s2 - n0_s1) * n0_ci_f + n0_s1;
+ }
+
+ if (((raw_wave *)sp[1])->current_index >= n1_length)
+ samp1 = 0;
+ else {
+ n1_ci_f = modf(((raw_wave *)sp[1])->current_index, &n1_ci_w);
+ n1_s1 = n1_table[(int)n1_ci_w];
+ n1_s2 = n1_table[(int)n1_ci_w +1];
+ ((raw_wave *)sp[1])->current_index += n1_pitch;
+ samp1 = (n1_s2 - n1_s1) * n1_ci_f + n1_s1;
+ }
+
+ if (((raw_wave *)sp[2])->current_index >= n2_length)
+ samp2 = 0;
+ else {
+ n2_ci_f = modf(((raw_wave *)sp[2])->current_index, &n2_ci_w);
+ n2_s1 = n2_table[(int)n2_ci_w];
+ n2_s2 = n2_table[(int)n2_ci_w +1];
+ ((raw_wave *)sp[2])->current_index += n2_pitch;
+ samp2 = (n2_s2 - n2_s1) * n2_ci_f + n2_s1;
+ }
+
+ if (((raw_wave *)sp[3])->current_index >= n3_length)
+ samp3 = 0;
+ else {
+ n3_ci_f = modf(((raw_wave *)sp[3])->current_index, &n3_ci_w);
+ n3_s1 = n3_table[(int)n3_ci_w];
+ n3_s2 = n3_table[(int)n3_ci_w +1];
+ ((raw_wave *)sp[3])->current_index += n3_pitch;
+ samp3 = (n3_s2 - n3_s1) * n3_ci_f + n3_s1;
+ }
+
+ if (((raw_wave *)sp[4])->current_index >= n4_length)
+ samp4 = 0;
+ else {
+ n4_ci_f = modf(((raw_wave *)sp[4])->current_index, &n4_ci_w);
+ n4_s1 = n4_table[(int)n4_ci_w];
+ n4_s2 = n4_table[(int)n4_ci_w +1];
+ ((raw_wave *)sp[4])->current_index += n4_pitch;
+ samp4 = (n4_s2 - n4_s1) * n4_ci_f + n4_s1;
+ }
+
+ samp5 = n5_table[n5_i + n5_phase_factor];
+ n5_i += n5_freq + (n5_freq * n5_freq_offset) / MAX_FREQ_OFFSET;
+ if (n5_i + n5_phase_factor >= RATE)
+ n5_i = n5_i + n5_phase_factor - RATE;
+
+ samp6 = n6_table[n6_i + n6_phase_factor];
+ n6_i += n6_freq + (n6_freq * n6_freq_offset) / MAX_FREQ_OFFSET;
+ if (n6_i + n6_phase_factor >= RATE)
+ n6_i = n6_i + n6_phase_factor - RATE;
+
+ samp7 = n7_table[n7_i + n7_phase_factor];
+ n7_i += n7_freq + (n7_freq * n7_freq_offset) / MAX_FREQ_OFFSET;
+ if (n7_i + n7_phase_factor >= RATE)
+ n7_i = n7_i + n7_phase_factor - RATE;
+
+ samp8 = (samp5 * n8_strength0 / n8_blend) + (samp6 * n8_strength1 /
n8_blend) + (samp7 * n8_strength2 / n8_blend);
+
+ if (((env *)sp[9])->current_index < n9_attack)
+ samp9 = (SAMPLE_MAX - ((env *)sp[9])->start) * ((env
*)sp[9])->current_index / n9_attack + ((env *)sp[9])->start;
+ else if (((env *)sp[9])->current_index < (n9_attack + n9_release))
+ samp9 = -SAMPLE_MAX * (((env *)sp[9])->current_index - n9_attack) /
n9_release + SAMPLE_MAX;
+ else
+ samp9 = 0;
+ ((env *)sp[9])->current_index++;
+
+ filter_set_coeffs((filter *)sp[10], n10_fc *
+ (samp9 * (SAMPLE_MAX - LIMIT) / SAMPLE_MAX + LIMIT) /
+ SAMPLE_MAX, n10_Q);
+ n10_s = filter_process_sample((filter *)sp[10], samp8);
+ if (n10_s > SAMPLE_MAX) n10_s = SAMPLE_MAX;
+ else if (n10_s < SAMPLE_MIN) n10_s = SAMPLE_MIN;
+ samp10 = n10_s;
+
+ if (((env *)sp[11])->current_index < n11_attack)
+ samp11 = ((SAMPLE_MAX - ((env *)sp[11])->start) * ((env
*)sp[11])->current_index /
+ n11_attack + ((env *)sp[11])->start) * samp10 / SAMPLE_MAX;
+ else if (((env *)sp[11])->current_index < (n11_attack + n11_release))
+ samp11 = (-SAMPLE_MAX * (((env *)sp[11])->current_index - n11_attack) /
n11_release + SAMPLE_MAX) *
+ samp10 / SAMPLE_MAX;
+ else
+ samp11 = 0;
+ ((env *)sp[11])->current_index++;
+
+ if(n12_mute0 > 0)
+ n12_amp0 = 0;
+if(n12_mute1 > 0)
+ n12_amp1 = 0;
+if(n12_mute2 > 0)
+ n12_amp2 = 0;
+if(n12_mute3 > 0)
+ n12_amp3 = 0;
+if(n12_mute4 > 0)
+ n12_amp4 = 0;
+if(n12_mute5 > 0)
+ n12_amp5 = 0;
+
+ samp12 = (samp0 * n12_amp0 / MIX_MAX_AMP) + (samp1 * n12_amp1 /
MIX_MAX_AMP) + (samp2 * n12_amp2 / MIX_MAX_AMP) + (samp3 * n12_amp3 /
MIX_MAX_AMP) + (samp4 * n12_amp4 / MIX_MAX_AMP) + (samp11 * n12_amp5 /
MIX_MAX_AMP);
+
+ if (n13_i >= n13_size)
+ n13_i = 0;
+ samp13 = n13_buf[n13_i];
+ n13_buf[n13_i] = samp12 + n13_buf[n13_i] * n13_feedback / MAX_FEEDBACK;
+ n13_i++;
+
+ if (n14_i >= n14_size)
+ n14_i = 0;
+ samp14 = n14_buf[n14_i];
+ n14_buf[n14_i] = samp13 + n14_buf[n14_i] * n14_feedback / MAX_FEEDBACK;
+ n14_i++;
+
+ if (n15_i >= n15_size)
+ n15_i = 0;
+ samp15 = n15_buf[n15_i];
+ n15_buf[n15_i] = samp14 + n15_buf[n15_i] * n15_feedback / MAX_FEEDBACK;
+ n15_i++;
+
+ if(n16_mute0 > 0)
+ n16_amp0 = 0;
+if(n16_mute1 > 0)
+ n16_amp1 = 0;
+if(n16_mute2 > 0)
+ n16_amp2 = 0;
+
+ samp16 = (samp13 * n16_amp0 / MIX_MAX_AMP) + (samp14 * n16_amp1 /
MIX_MAX_AMP) + (samp15 * n16_amp2 / MIX_MAX_AMP);
+
+ samp17 = samp16;
+
+ if(n18_mute0 > 0)
+ n18_amp0 = 0;
+if(n18_mute1 > 0)
+ n18_amp1 = 0;
+if(n18_mute2 > 0)
+ n18_amp2 = 0;
+if(n18_mute3 > 0)
+ n18_amp3 = 0;
+if(n18_mute4 > 0)
+ n18_amp4 = 0;
+if(n18_mute5 > 0)
+ n18_amp5 = 0;
+
+ samp18 = (samp0 * n18_amp0 / MIX_MAX_AMP) + (samp1 * n18_amp1 /
MIX_MAX_AMP) + (samp2 * n18_amp2 / MIX_MAX_AMP) + (samp3 * n18_amp3 /
MIX_MAX_AMP) + (samp4 * n18_amp4 / MIX_MAX_AMP) + (samp11 * n18_amp5 /
MIX_MAX_AMP);
+
+ if (n19_i >= n19_size)
+ n19_i = 0;
+ samp19 = n19_buf[n19_i];
+ n19_buf[n19_i] = samp18 + n19_buf[n19_i] * n19_feedback / MAX_FEEDBACK;
+ n19_i++;
+
+ if (n20_i >= n20_size)
+ n20_i = 0;
+ samp20 = n20_buf[n20_i];
+ n20_buf[n20_i] = samp18 + n20_buf[n20_i] * n20_feedback / MAX_FEEDBACK;
+ n20_i++;
+
+ if (n21_i >= n21_size)
+ n21_i = 0;
+ samp21 = n21_buf[n21_i];
+ n21_buf[n21_i] = samp18 + n21_buf[n21_i] * n21_feedback / MAX_FEEDBACK;
+ n21_i++;
+
+ if (n22_i >= n22_size)
+ n22_i = 0;
+ samp22 = n22_buf[n22_i];
+ n22_buf[n22_i] = samp18 + n22_buf[n22_i] * n22_feedback / MAX_FEEDBACK;
+ n22_i++;
+
+ if (n23_i >= n23_size)
+ n23_i = 0;
+ samp23 = n23_buf[n23_i];
+ n23_buf[n23_i] = samp18 + n23_buf[n23_i] * n23_feedback / MAX_FEEDBACK;
+ n23_i++;
+
+ if (n24_i >= n24_size)
+ n24_i = 0;
+ samp24 = n24_buf[n24_i];
+ n24_buf[n24_i] = samp18 + n24_buf[n24_i] * n24_feedback / MAX_FEEDBACK;
+ n24_i++;
+
+ if(n25_mute0 > 0)
+ n25_amp0 = 0;
+if(n25_mute1 > 0)
+ n25_amp1 = 0;
+if(n25_mute2 > 0)
+ n25_amp2 = 0;
+if(n25_mute3 > 0)
+ n25_amp3 = 0;
+if(n25_mute4 > 0)
+ n25_amp4 = 0;
+if(n25_mute5 > 0)
+ n25_amp5 = 0;
+
+ samp25 = (samp19 * n25_amp0 / MIX_MAX_AMP) + (samp20 * n25_amp1 /
MIX_MAX_AMP) + (samp21 * n25_amp2 / MIX_MAX_AMP) + (samp22 * n25_amp3 /
MIX_MAX_AMP) + (samp23 * n25_amp4 / MIX_MAX_AMP) + (samp24 * n25_amp5 /
MIX_MAX_AMP);
+
+ if (n26_i >= n26_size)
+ n26_i = 0;
+ samp26 = (long)n26_buf[n26_i] +
+ (samp25 * -n26_feedback / MAX_FEEDBACK);
+ n26_buf[n26_i] = samp25 + (long)n26_buf[n26_i] * n26_feedback /
MAX_FEEDBACK;
+ n26_i++;
+
+ if (n27_i >= n27_size)
+ n27_i = 0;
+ samp27 = (long)n27_buf[n27_i] +
+ (samp26 * -n27_feedback / MAX_FEEDBACK);
+ n27_buf[n27_i] = samp26 + (long)n27_buf[n27_i] * n27_feedback /
MAX_FEEDBACK;
+ n27_i++;
+
+ samp28 = samp27;
+
+ if(n29_mute0 > 0)
+ n29_amp0 = 0;
+if(n29_mute1 > 0)
+ n29_amp1 = 0;
+if(n29_mute2 > 0)
+ n29_amp2 = 0;
+if(n29_mute3 > 0)
+ n29_amp3 = 0;
+if(n29_mute4 > 0)
+ n29_amp4 = 0;
+if(n29_mute5 > 0)
+ n29_amp5 = 0;
+if(n29_mute6 > 0)
+ n29_amp6 = 0;
+if(n29_mute7 > 0)
+ n29_amp7 = 0;
+
+ samp29 = (samp0 * n29_amp0 / MIX_MAX_AMP) + (samp1 * n29_amp1 /
MIX_MAX_AMP) + (samp2 * n29_amp2 / MIX_MAX_AMP) + (samp3 * n29_amp3 /
MIX_MAX_AMP) + (samp4 * n29_amp4 / MIX_MAX_AMP) + (samp11 * n29_amp5 /
MIX_MAX_AMP) + (samp17 * n29_amp6 / MIX_MAX_AMP) + (samp28 * n29_amp7 /
MIX_MAX_AMP);
+
+ if(n30_mute0 > 0)
+ n30_amp0 = 0;
+if(n30_mute1 > 0)
+ n30_amp1 = 0;
+if(n30_mute2 > 0)
+ n30_amp2 = 0;
+if(n30_mute3 > 0)
+ n30_amp3 = 0;
+if(n30_mute4 > 0)
+ n30_amp4 = 0;
+if(n30_mute5 > 0)
+ n30_amp5 = 0;
+if(n30_mute6 > 0)
+ n30_amp6 = 0;
+if(n30_mute7 > 0)
+ n30_amp7 = 0;
+
+ samp30 = (samp0 * n30_amp0 / MIX_MAX_AMP) + (samp1 * n30_amp1 /
MIX_MAX_AMP) + (samp2 * n30_amp2 / MIX_MAX_AMP) + (samp3 * n30_amp3 /
MIX_MAX_AMP) + (samp4 * n30_amp4 / MIX_MAX_AMP) + (samp11 * n30_amp5 /
MIX_MAX_AMP) + (samp17 * n30_amp6 / MIX_MAX_AMP) + (samp28 * n30_amp7 /
MIX_MAX_AMP);
+ if ((samp29 < CLIP) && (samp29 >-CLIP))
+ buffer[2 * i] = (short)samp29;
+ else if (samp29 > 0)
+ buffer[2 * i] = (short)MIX_MAX_AMP-(CLIP_A/(CLIP_B+samp29));
+ else
+ buffer[2 * i] = (short)-(MIX_MAX_AMP-(CLIP_A/(CLIP_B-samp29)));
+ if ((samp30 < CLIP) && (samp30 >-CLIP))
+ buffer[2 * i + 1] = (short)samp30;
+ else if (samp30 > 0)
+ buffer[2 * i + 1] = (short)MIX_MAX_AMP-(CLIP_A/(CLIP_B+samp30));
+ else
+ buffer[2 * i + 1] = (short)-(MIX_MAX_AMP-(CLIP_A/(CLIP_B-samp30)));
+ }
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ swap_endian(buffer, 2 * TBASS_BUFF_SIZE);
+#endif
+ write(fd, buffer, 2 * TBASS_BUFF_SIZE * sizeof(short));
+
+ sequencer->current_sample_offset = seq_off;
+
+
+
+
+
+
+ ((osc *)sp[5])->current_index = n5_i;
+
+ ((osc *)sp[6])->current_index = n6_i;
+
+ ((osc *)sp[7])->current_index = n7_i;
+
+
+
+
+
+
+ ((delay *)sp[13])->d_index = n13_i;
+
+ ((delay *)sp[14])->d_index = n14_i;
+
+ ((delay *)sp[15])->d_index = n15_i;
+
+
+
+
+ ((delay *)sp[19])->d_index = n19_i;
+
+ ((delay *)sp[20])->d_index = n20_i;
+
+ ((delay *)sp[21])->d_index = n21_i;
+
+ ((delay *)sp[22])->d_index = n22_i;
+
+ ((delay *)sp[23])->d_index = n23_i;
+
+ ((delay *)sp[24])->d_index = n24_i;
+
+
+ ((all_pass *)sp[26])->d_index = n26_i;
+
+ ((all_pass *)sp[27])->d_index = n27_i;
+
+
+
+
+ return 1;
+}
