2 terminatorX - realtime audio scratching software
3 Copyright (C) 1999, 2000 Alexander König
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 Description: This implements the new virtual turntable class. It replaces
22 the old turntable.c from terminatorX 3.2 and earlier. The lowpass
23 filter is based on some sample code by Paul Kellett
24 <paul.kellett@maxim.abel.co.uk>
26 08 Dec 1999 - Switched to the new audiofile class
30 #include "tX_global.h"
34 #include "tX_mastergui.h"
35 #include "tX_sequencer.h"
47 #define tX_freemem(ptr, varname, comment); fprintf(stderr, "** free() [%s] at %08x. %s.\n", varname, ptr, comment); free(ptr);
48 #define tX_malloc(ptr, varname, comment, size, type); fprintf(stderr, "**[1/2] malloc() [%s]. Size: %i. %s.\n", varname, size, comment); ptr=type malloc(size); fprintf(stderr, "**[2/2] malloc() [%s]. ptr: %08x.\n", varname, ptr);
50 #define tX_freemem(ptr, varname, comment); free(ptr);
51 #define tX_malloc(ptr, varname, comment, size, type); ptr=type malloc(size);
54 #include "tX_loaddlg.h"
56 #define USE_PREFETCH 1
59 #define my_prefetch(base, index); __asm__ __volatile__ ("prefetch index(%0)\n" : : "r" (base));
60 #define my_prefetchw(base, index); __asm__ __volatile__ ("prefetchw index(%0)\n" : : "r" (base));
62 #define my_prefetch(base, index); /* NOP */;
63 #define my_prefetchw(base, index); /* NOP */;
66 extern void build_vtt_gui(vtt_class *);
67 extern void gui_set_name(vtt_class *vtt, char *newname);
68 extern void gui_set_filename(vtt_class *vtt, char *newname);
69 extern void delete_gui(vtt_class *vtt);
70 extern void gui_update_display(vtt_class *vtt);
71 extern void gui_clear_master_button(vtt_class *vtt);
72 extern void cleanup_vtt(vtt_class *vtt);
73 extern int vg_get_current_page(vtt_class *vtt);
74 extern void vg_set_current_page(vtt_class *vtt, int page);
76 int vtt_class::vtt_amount=0;
77 list <vtt_class *> vtt_class::main_list;
78 list <vtt_class *> vtt_class::render_list;
79 int16_t* vtt_class::mix_out_buffer=NULL;
80 f_prec * vtt_class::mix_buffer=NULL;
81 f_prec * vtt_class::mix_buffer_end=NULL;
83 int vtt_class::samples_in_mix_buffer=0;
84 pthread_mutex_t vtt_class::render_lock=PTHREAD_MUTEX_INITIALIZER;
85 pthread_mutex_t vtt_class::main_lock=PTHREAD_MUTEX_INITIALIZER;
86 f_prec vtt_class::master_volume=1.0;
87 f_prec vtt_class::res_master_volume=1.0;
88 //f_prec vtt_class::saturate_fac=((f_prec) SAMPLE_MAX-SAMPLE_BORDER)*1.0/FLT_MAX;
89 f_prec vtt_class::saturate_fac=0.1;
90 int vtt_class::do_saturate=0;
91 vtt_class * vtt_class::sync_master=NULL;
92 int vtt_class::master_triggered=0;
93 int vtt_class::master_triggered_at=0;
94 vtt_class * vtt_class::focused_vtt=NULL;
95 f_prec vtt_class::mix_max_l=0;
96 f_prec vtt_class::mix_max_r=0;
97 f_prec vtt_class::vol_channel_adjust=1.0;
99 #define GAIN_AUTO_ADJUST 0.8
101 vtt_class :: vtt_class (int do_create_gui)
104 sprintf (name, "Turntable %i", vtt_amount);
105 strcpy(filename, "NONE");
121 x_control=CONTROL_SCRATCH;
122 y_control=CONTROL_CUTOFF;
128 lp_setup(lp_gain, lp_reso, lp_freq);
137 // pthread_mutex_lock(&main_lock);
138 main_list.push_back(this);
139 // pthread_mutex_unlock(&main_lock);
142 /* "connecting" the seq-parameters */
144 sp_speed.set_vtt((void *) this);
145 sp_volume.set_vtt((void *) this);
146 sp_pitch.set_vtt((void *) this);
147 sp_pan.set_vtt((void *) this);
148 sp_trigger.set_vtt((void *) this);
149 sp_loop.set_vtt((void *) this);
150 sp_sync_client.set_vtt((void *) this);
151 sp_sync_cycles.set_vtt((void *) this);
152 sp_lp_enable.set_vtt((void *) this);
153 sp_lp_gain.set_vtt((void *) this);
154 sp_lp_reso.set_vtt((void *) this);
155 sp_lp_freq.set_vtt((void *) this);
156 sp_ec_enable.set_vtt((void *) this);
157 sp_ec_length.set_vtt((void *) this);
158 sp_ec_pan.set_vtt((void *) this);
159 sp_ec_feedback.set_vtt((void *) this);
160 sp_mute.set_vtt((void *) this);
161 sp_spin.set_vtt((void *) this);
166 lp_fx=new vtt_fx_lp();
167 lp_fx->set_vtt((void *) this);
168 fx_list.push_back(lp_fx);
170 ec_fx=new vtt_fx_ec();
171 ec_fx->set_vtt((void *) this);
172 fx_list.push_back(ec_fx);
177 lp_fx->set_panel_widget(gui.lp_panel->get_widget());
178 ec_fx->set_panel_widget(gui.ec_panel->get_widget());
183 set_master_volume(globals.volume);
184 set_output_buffer_size(samples_in_mix_buffer/2);
189 vtt_class :: ~vtt_class()
193 // pthread_mutex_lock(&main_lock);
194 main_list.remove(this);
195 // pthread_mutex_unlock(&main_lock);
196 if (audiofile) delete audiofile;
197 //if (buffer) free(buffer);
198 if (output_buffer) tX_freemem(output_buffer, "output_buffer", "vtt Destructor");
201 while (fx_list.size())
203 effect=(*fx_list.begin());
204 fx_list.remove(effect);
211 void vtt_class :: set_name(char *newname)
213 strcpy(name, newname);
214 gui_set_name(this, name);
217 int vtt_class :: load_file(char *fname)
220 int was_playing=is_playing;
222 if (is_playing) stop();
224 if (audiofile) delete(audiofile);
231 audiofile=new tx_audiofile();
232 res=audiofile->load(fname);
234 if (res==TX_AUDIO_SUCCESS)
236 buffer=audiofile->get_buffer();
237 samples_in_buffer=audiofile->get_no_samples();
238 maxpos=audiofile->get_no_samples();
239 strcpy(filename, fname);
240 if (was_playing) trigger();
241 // printf("Successfully loaded %s, %08x, %i\n", fname, buffer, samples_in_buffer);
246 gui_update_display(this);
248 ec_set_length(ec_length);
253 int vtt_class :: set_output_buffer_size(int newsize)
255 list <vtt_fx *> :: iterator effect;
257 if (ec_output_buffer) tX_freemem(ec_output_buffer, "ec_output_buffer", "vtt set_output_buffer_size()");
258 tX_malloc(ec_output_buffer, "ec_output_buffer", "vtt set_output_buffer_size()", sizeof(float)*newsize, (float *));
260 if (output_buffer) tX_freemem(output_buffer, "output_buffer", "vtt set_output_buffer_size()");
261 //output_buffer = (float *) malloc (sizeof(float)*newsize);
262 tX_malloc(output_buffer, "output_buffer", "vtt set_output_buffer_size()", sizeof(float)*newsize, (float *));
263 end_of_outputbuffer = output_buffer + newsize; //size_t(sizeof(float)*(newsize));
265 samples_in_outputbuffer=newsize;
266 inv_samples_in_outputbuffer=1.0/samples_in_outputbuffer;
268 for (effect=fx_list.begin(); effect != fx_list.end(); effect++)
270 (*effect)->reconnect_buffer();
273 if (output_buffer) return(0);
277 void vtt_class :: set_volume(f_prec newvol)
283 void vtt_class :: recalc_volume()
285 res_volume=rel_volume*res_master_volume;
289 res_volume_left=(1.0-pan)*res_volume;
290 res_volume_right=res_volume;
294 res_volume_left=res_volume;
295 res_volume_right=(1.0+pan)*res_volume;
299 res_volume_left=res_volume_right=res_volume;
304 ec_volume_left=(1.0-ec_pan)*res_volume;
305 ec_volume_right=res_volume;
309 ec_volume_left=res_volume;
310 ec_volume_right=(1.0+ec_pan)*res_volume;
314 ec_volume_left=ec_volume_right=res_volume;
316 // printf("vtt_volume: %f, %f, l: %f, r: %f\n", rel_volume, res_volume, res_volume_left, res_volume_right);
319 mm_res_volume.s[0]=mm_res_volume.s[1]=res_volume;
323 void vtt_class :: set_pan(f_prec newpan)
329 void vtt_class :: set_pitch(f_prec newpitch)
332 // res_pitch=fabs(globals.pitch)*rel_pitch;
333 res_pitch=globals.pitch*rel_pitch;
335 ec_set_length(ec_length);
338 void vtt_class :: recalc_pitch()
340 // res_pitch=fabs(globals.pitch)*rel_pitch;
341 res_pitch=globals.pitch*rel_pitch;
343 ec_set_length(ec_length);
346 void vtt_class :: set_autotrigger(int newstate)
348 autotrigger=newstate;
351 void vtt_class :: set_loop(int newstate)
356 void vtt_class :: set_controls (int x, int y)
362 void vtt_class :: set_mute(int newstate)
367 void vtt_class :: lp_set_enable (int newstate)
372 void vtt_class :: lp_set_gain (f_prec gain)
375 lp_resgain=lp_gain*lp_autogain;
378 void vtt_class :: lp_set_reso(f_prec reso)
382 lp_b=reso*(1.0+(1.0/lp_a));
383 lp_autogain=1.0-reso*GAIN_AUTO_ADJUST;
384 lp_resgain=lp_gain*lp_autogain;
387 void vtt_class :: lp_set_freq(f_prec freq)
392 lp_b=lp_reso*(1.0+(1.0/lp_a));
394 //printf("a %f, b%f\n", lp_a, lp_b);
397 void vtt_class :: lp_setup(f_prec gain, f_prec reso, f_prec freq)
403 lp_b=reso*(1.0+(1.0/lp_a));
405 lp_autogain=1.0-reso*GAIN_AUTO_ADJUST;
406 lp_resgain=lp_gain*lp_autogain;
409 void vtt_class :: ec_set_enable(int newstate)
415 void vtt_class :: ec_set_pan(f_prec pan)
422 /* Max length is 1.0 */
424 void vtt_class :: ec_set_length(f_prec length)
432 ec_res_length=length*samples_in_buffer;
436 ec_res_length=length*samples_in_buffer/res_pitch;
439 if (ec_res_length<0) ec_res_length*=-1;
441 if (ec_res_length>=EC_MAX_BUFFER)
443 ec_res_length=EC_MAX_BUFFER*length;
446 delay=(int )floor(ec_res_length);
448 ec_delay=&ec_buffer[delay];
451 void vtt_class :: ec_set_feedback(f_prec feedback)
453 ec_feedback=feedback;
456 void vtt_class :: ec_clear_buffer()
460 for (i=0; i<EC_MAX_BUFFER; i++)
467 void vtt_class :: render()
469 list <vtt_fx *> :: iterator effect;
476 if (sense_cycles==0) sp_speed.receive_input_value(0);
481 for (effect=fx_list.begin(); effect != fx_list.end(); effect++)
483 if ((*effect)->isEnabled()) (*effect)->run();
487 extern void vg_create_fx_gui(vtt_class *vtt, vtt_fx_ladspa *effect, LADSPA_Plugin *plugin);
489 vtt_fx_ladspa * vtt_class :: add_effect (LADSPA_Plugin *plugin)
491 vtt_fx_ladspa *new_effect;
493 new_effect = new vtt_fx_ladspa (plugin, this);
494 pthread_mutex_lock(&render_lock);
495 fx_list.push_back(new_effect);
496 if (is_playing) new_effect->activate();
497 pthread_mutex_unlock(&render_lock);
498 vg_create_fx_gui(this, new_effect, plugin);
503 void vtt_class :: calc_speed()
505 do_mute=fade_out=fade_in=0;
507 if (speed != speed_target)
510 speed_step=speed_target-speed_real;
514 if (speed_target != speed_real)
516 speed_real+=speed_step;
517 if ((speed_step<0) && (speed_real<speed_target)) speed_real=speed_target;
519 if ((speed_step>0) && (speed_real>speed_target)) speed_real=speed_target;
524 if ((speed_last==0) && (speed_real !=0))
532 if ((speed_last!=0) && (speed_real==0))
539 speed_last = speed_real;
541 if (mute != mute_old)
545 fade_out=1; fade_in=0;
550 fade_in=1; fade_out=0;
561 void vtt_class :: render_scratch()
582 for (sample =0,out=output_buffer, fade_vol=0.0; sample < samples_in_outputbuffer;sample++, out++, fade_vol+=inv_samples_in_outputbuffer)
584 if ((speed_real!=0) || (fade_out))
599 master_triggered_at=sample;
619 master_triggered_at=sample;
629 pos_a_f=floor(pos_f);
630 pos_i=(unsigned int) pos_a_f;
632 amount_b=pos_f-pos_a_f;
633 amount_a=1.0-amount_b;
642 sample_a=(f_prec) *ptr;
644 if (pos_i == samples_in_buffer)
651 sample_b=(f_prec) *ptr;
654 sample_res=(sample_a*amount_a)+(sample_b*amount_b);
658 sample_res*=fade_vol;
663 sample_res*=1.0-fade_vol;
676 void vtt_class :: forward_turntable()
687 if ((speed_real==0) && (!fade_out)) return;
690 /* following code is problematic as adding speed_real*n is
691 different from adding speed_real n times to pos_f.
693 well it speeds things up quite a bit and double precision
694 seems to do a satisfying job.
696 #define pos_f_test to prove that.
699 pos_f_tmp=pos_f+speed_real*samples_in_outputbuffer;
701 if ((pos_f_tmp > 0) && (pos_f_tmp < maxpos))
711 /* now the slow way ;) */
713 for (sample =0; sample < samples_in_outputbuffer; sample++)
727 master_triggered_at=sample;
747 master_triggered_at=sample;
761 diff=pos_f_tmp-pos_f;
762 if (diff!=0) printf("fast: %f, slow: %f, diff: %f, tt: %s\n", pos_f_tmp, pos_f, diff, name);
768 The following lowpass filter is based on some sample code by
769 Paul Kellett <paul.kellett@maxim.abel.co.uk>
772 void vtt_class :: render_lp()
776 for (sample = output_buffer; sample<end_of_outputbuffer; sample++)
778 lp_buf0 = lp_a * lp_buf0 + lp_freq * ((*sample)*lp_resgain + lp_b * (lp_buf0 - lp_buf1));
779 lp_buf1 = lp_a * lp_buf1 + lp_freq * lp_buf0;
785 void vtt_class :: render_ec()
791 for (i=0, sample = output_buffer, ec_sample=ec_output_buffer; i<samples_in_outputbuffer; i++, ec_sample++,sample++, ec_ptr++)
793 if (ec_ptr>ec_delay) ec_ptr=ec_buffer;
794 *ec_sample=(*ec_ptr) *ec_feedback;
795 *ec_ptr=*sample+*ec_sample;
799 int vtt_class :: set_mix_buffer_size(int no_samples)
801 list <vtt_class *> :: iterator vtt;
804 printf("vtt_class::set_mix_buffer_size(), mix_buffer: %12x, mix_out: %12x, samples: %i\n", mix_buffer, mix_out_buffer, no_samples);
806 if (mix_buffer) tX_freemem(mix_buffer, "mix_buffer", "vtt set_mix_buffer_size()");
807 samples_in_mix_buffer=no_samples*2;
808 //mix_buffer=(float *) malloc (sizeof(float)*samples_in_mix_buffer);
809 tX_malloc(mix_buffer, "mix_buffer", "vtt set_mix_buffer_size()", sizeof(float)*samples_in_mix_buffer, (float *));
810 mix_buffer_end=mix_buffer+samples_in_mix_buffer;
811 printf("mix_buffer: %12x\n", mix_buffer);
813 printf("mix_samples: %i, out_samples: %i", samples_in_mix_buffer, no_samples);
815 if (mix_out_buffer) tX_freemem(mix_out_buffer, "mix_out_buffer", "vtt set_mix_buffer_size()");
816 //mix_out_buffer=(int16_t *) malloc (sizeof(int16_t)*samples_in_mix_buffer + 4); /* extra 4 for 3DNow! */
817 tX_malloc(mix_out_buffer, "mix_out_buffer", "vtt set_mix_buffer_size()", sizeof(int16_t)*samples_in_mix_buffer + 4, (int16_t *));
818 printf("mix_out_buffer: %12x\n", mix_out_buffer);
820 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
822 res|=(*vtt)->set_output_buffer_size(no_samples);
825 if ((!mix_buffer) || (!mix_out_buffer) || res) return(1);
829 int16_t * vtt_class :: render_all_turntables()
831 list <vtt_class *> :: iterator vtt, next;
848 int32_t *temp_int=&mm_max.d[1];
852 pthread_mutex_lock(&render_lock);
854 if (render_list.size()==0)
856 for (sample=0; sample<samples_in_mix_buffer; sample++)
858 mix_out_buffer[sample]=0;
863 vtt=render_list.begin();
865 max=(*vtt)->max_value;
868 for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
870 temp=(*vtt)->output_buffer[sample];
871 mix_buffer[mix_sample]=temp*(*vtt)->res_volume_left;
873 mix_buffer[mix_sample]=temp*(*vtt)->res_volume_right;
876 if (temp>max) max=temp;
877 else if (temp<min) min=temp;
881 if (min>max) (*vtt)->max_value=min; else (*vtt)->max_value=max;
883 if ((*vtt)->ec_enable)
885 for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
887 temp=(*vtt)->ec_output_buffer[sample];
889 mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_left;
891 mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_right;
896 if (master_triggered)
898 pthread_mutex_unlock(&render_lock);
899 // pthread_mutex_lock(&main_lock);
900 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
902 if ((*vtt)->is_sync_client)
904 if ((*vtt)->sync_countdown)
906 (*vtt)->sync_countdown--;
910 (*vtt)->sync_countdown=(*vtt)->sync_cycles;
915 // pthread_mutex_unlock(&main_lock);
916 pthread_mutex_lock(&render_lock);
919 vtt=render_list.begin();
920 for (vtt++; vtt!=render_list.end(); vtt++)
923 max=(*vtt)->max_value;
926 for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
928 temp=(*vtt)->output_buffer[sample];
929 mix_buffer[mix_sample]+=temp*(*vtt)->res_volume_left;
931 mix_buffer[mix_sample]+=temp*(*vtt)->res_volume_right;
934 if (temp>max) max=temp;
935 else if (temp<min) min=temp;
939 if (min>max) (*vtt)->max_value=min; else (*vtt)->max_value=max;
941 if ((*vtt)->ec_enable)
943 for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
945 temp=(*vtt)->ec_output_buffer[sample];
947 mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_left;
949 mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_right;
960 for (sample=0; sample<samples_in_mix_buffer; sample+=2)
962 temp=mix_buffer[sample];
963 mix_out_buffer[sample]=(int16_t) temp;
965 if (temp>max) max=temp;
966 else if (temp<min) min=temp;
970 if (min>max) mix_max_l=min; else mix_max_l=max;
977 for (sample=1; sample<samples_in_mix_buffer; sample+=2)
979 temp=mix_buffer[sample];
980 mix_out_buffer[sample]=(int16_t) temp;
982 if (temp>max) max=temp;
983 else if (temp<min) min=temp;
987 if (min>max) mix_max_r=min; else mix_max_r=max;
992 vtt=render_list.begin();
993 while (vtt!=render_list.end())
998 if ((*vtt)->want_stop) (*vtt)->stop_nolock();
1001 pthread_mutex_unlock(&render_lock);
1003 return(mix_out_buffer);
1006 void vtt_class :: forward_all_turntables()
1008 list <vtt_class *> :: iterator vtt, next;
1010 if (render_list.size()>0)
1012 vtt=render_list.begin();
1013 (*vtt)->forward_turntable();
1015 if (master_triggered)
1017 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
1019 if ((*vtt)->is_sync_client)
1021 if ((*vtt)->sync_countdown)
1023 (*vtt)->sync_countdown--;
1027 (*vtt)->sync_countdown=(*vtt)->sync_cycles;
1034 vtt=render_list.begin();
1035 for (vtt++; vtt!=render_list.end(); vtt++)
1037 (*vtt)->forward_turntable();
1042 vtt=render_list.begin();
1043 while (vtt!=render_list.end())
1048 if ((*vtt)->want_stop) (*vtt)->stop_nolock();
1054 int vtt_class :: trigger()
1056 list <vtt_fx *> :: iterator effect;
1058 if (!buffer) return (1);
1060 if (!is_playing) pthread_mutex_lock(&render_lock);
1062 if (res_pitch>=0) pos_f=0;
1066 speed_real=res_pitch;
1067 speed_target=res_pitch;
1072 /* activating plugins */
1073 for (effect=fx_list.begin(); effect != fx_list.end(); effect++)
1075 (*effect)->activate();
1086 master_triggered_at=0;
1095 render_list.push_front(this);
1099 render_list.push_back(this);
1101 pthread_mutex_unlock(&render_lock);
1106 int vtt_class :: stop_nolock()
1108 list <vtt_fx *> :: iterator effect;
1112 pthread_mutex_unlock(&render_lock);
1115 render_list.remove(this);
1126 /* deactivating plugins */
1127 for (effect=fx_list.begin(); effect != fx_list.end(); effect++)
1129 (*effect)->deactivate();
1135 int vtt_class :: stop()
1139 pthread_mutex_lock(&render_lock);
1143 pthread_mutex_unlock(&render_lock);
1148 void vtt_class :: set_sync_master(int master)
1152 if (sync_master) sync_master->set_sync_master(0);
1158 if (sync_master==this) sync_master=0;
1160 gui_clear_master_button(this);
1164 void vtt_class :: set_sync_client(int slave, int cycles)
1166 is_sync_client=slave;
1168 // sync_countdown=cycles;
1172 void vtt_class :: set_sync_client_ug(int slave, int cycles)
1174 set_sync_client(slave, cycles);
1177 void vtt_class :: set_master_volume(f_prec new_volume)
1179 list <vtt_class *> :: iterator vtt;
1181 master_volume=new_volume;
1182 globals.volume=new_volume;
1184 if (main_list.size()>0)
1186 // res_master_volume=master_volume/((f_prec) main_list.size());
1187 vol_channel_adjust=sqrt((f_prec) main_list.size());
1188 res_master_volume=master_volume/vol_channel_adjust;
1192 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
1194 (*vtt)->recalc_volume();
1198 void vtt_class :: set_master_pitch(f_prec new_pitch)
1200 list <vtt_class *> :: iterator vtt;
1202 globals.pitch=new_pitch;
1203 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
1205 (*vtt)->recalc_pitch();
1209 void vtt_class :: enable_saturate (int newstate)
1211 do_saturate=newstate;
1214 void vtt_class :: focus_no(int no)
1216 list <vtt_class *> :: iterator vtt;
1219 for (i=0, vtt=main_list.begin(); vtt!=main_list.end(); vtt++, i++)
1228 void vtt_class :: focus_next()
1230 list <vtt_class *> :: iterator vtt;
1234 if (main_list.size())
1236 focused_vtt=(*main_list.begin());
1241 for (vtt=main_list.begin(); vtt!=main_list.end() ; vtt++)
1243 if ((*vtt)==focused_vtt)
1246 if (vtt==main_list.end())
1248 focused_vtt=(*main_list.begin());
1259 focused_vtt=(*main_list.begin());
1262 void vtt_class :: set_scratch(int newstate)
1266 sp_spin.receive_input_value(0);
1268 sense_cycles=globals.sense_cycles;
1272 sp_spin.receive_input_value(1);
1279 void vtt_class :: handle_input(int control, f_prec value)
1285 case CONTROL_SCRATCH:
1286 if (do_scratch) sp_speed.receive_input_value(value*globals.mouse_speed);
1287 sense_cycles=globals.sense_cycles;
1290 case CONTROL_VOLUME:
1291 temp=rel_volume+MAGIC*value*globals.mouse_speed;
1292 if (temp>2.0) temp=2.0;
1293 else if (temp<0) temp=0;
1294 sp_volume.receive_input_value(temp);
1297 case CONTROL_CUTOFF:
1298 temp=lp_freq+MAGIC*value*globals.mouse_speed;
1299 if (temp>0.99) temp=0.99;
1300 else if (temp<0) temp=0;
1301 sp_lp_freq.receive_input_value(temp);
1304 case CONTROL_FEEDBACK:
1305 temp=ec_feedback+MAGIC*value*globals.mouse_speed;
1306 if (temp>1.0) temp=1.0;
1307 else if (temp<0) temp=0;
1308 sp_ec_feedback.receive_input_value(temp);
1313 void vtt_class :: unfocus()
1318 extern void vg_display_ycontrol(vtt_class *vtt);
1319 extern void vg_display_xcontrol(vtt_class *vtt);
1321 void vtt_class :: set_x_input_parameter(tX_seqpar *sp)
1324 vg_display_xcontrol(this);
1327 void vtt_class :: set_y_input_parameter(tX_seqpar *sp)
1330 vg_display_ycontrol(this);
1333 void vtt_class :: xy_input(f_prec x_value, f_prec y_value)
1335 if (x_par) x_par->handle_mouse_input(x_value*globals.mouse_speed);
1336 if (y_par) y_par->handle_mouse_input(y_value*globals.mouse_speed);
1338 /* handle_input(x_control, x_value);
1339 handle_input(y_control, y_value);*/
1343 #define store(data); if (fwrite((void *) &data, sizeof(data), 1, output)!=1) res+=1;
1345 int vtt_class :: save(FILE * output)
1347 list <vtt_fx *> :: iterator effect;
1356 store(is_sync_master);
1357 store(is_sync_client);
1378 pid=sp_speed.get_persistence_id();
1380 pid=sp_volume.get_persistence_id();
1382 pid=sp_pitch.get_persistence_id();
1384 pid=sp_trigger.get_persistence_id();
1386 pid=sp_loop.get_persistence_id();
1388 pid=sp_sync_client.get_persistence_id();
1390 pid=sp_sync_cycles.get_persistence_id();
1392 pid=sp_lp_enable.get_persistence_id();
1394 pid=sp_lp_gain.get_persistence_id();
1396 pid=sp_lp_reso.get_persistence_id();
1398 pid=sp_lp_freq.get_persistence_id();
1400 pid=sp_ec_enable.get_persistence_id();
1402 pid=sp_ec_length.get_persistence_id();
1404 pid=sp_ec_feedback.get_persistence_id();
1406 pid=sp_ec_pan.get_persistence_id();
1408 pid=sp_mute.get_persistence_id();
1410 pid=sp_spin.get_persistence_id();
1412 pid=sp_pan.get_persistence_id();
1415 counter=fx_list.size();
1418 for (effect=fx_list.begin(); effect!=fx_list.end(); effect++)
1420 (*effect)->save(output);
1427 pid=x_par->get_persistence_id();
1440 pid=y_par->get_persistence_id();
1449 hidden=gui.main_panel->is_hidden();
1452 hidden=gui.trigger_panel->is_hidden();
1455 hidden=gui.lp_panel->is_hidden();
1458 hidden=gui.ec_panel->is_hidden();
1464 #define atload(data); if (fread((void *) &data, sizeof(data), 1, input)!=1) res+=1;
1466 int vtt_class :: load_10(FILE * input)
1472 atload(is_sync_master);
1473 atload(is_sync_client);
1474 atload(sync_cycles);
1480 atload(autotrigger);
1491 lp_setup(lp_gain, lp_reso, lp_freq);
1495 ec_set_length(ec_length);
1496 atload(ec_feedback);
1497 ec_set_feedback(ec_feedback);
1503 int vtt_class :: load_11(FILE * input)
1511 atload(is_sync_master);
1512 atload(is_sync_client);
1513 atload(sync_cycles);
1519 atload(autotrigger);
1530 lp_setup(lp_gain, lp_reso, lp_freq);
1534 ec_set_length(ec_length);
1535 atload(ec_feedback);
1536 ec_set_feedback(ec_feedback);
1539 sp_speed.set_persistence_id(pid);
1541 sp_volume.set_persistence_id(pid);
1543 sp_pitch.set_persistence_id(pid);
1545 sp_trigger.set_persistence_id(pid);
1547 sp_loop.set_persistence_id(pid);
1549 sp_sync_client.set_persistence_id(pid);
1551 sp_sync_cycles.set_persistence_id(pid);
1553 sp_lp_enable.set_persistence_id(pid);
1555 sp_lp_gain.set_persistence_id(pid);
1557 sp_lp_reso.set_persistence_id(pid);
1559 sp_lp_freq.set_persistence_id(pid);
1561 sp_ec_enable.set_persistence_id(pid);
1563 sp_ec_length.set_persistence_id(pid);
1565 sp_ec_feedback.set_persistence_id(pid);
1567 sp_mute.set_persistence_id(pid);
1569 sp_spin.set_persistence_id(pid);
1572 vg_set_current_page(this, gui_page);
1577 int vtt_class :: load_12(FILE * input)
1585 LADSPA_Plugin *plugin;
1587 vtt_fx_ladspa *ladspa_effect;
1591 this->set_name(buffer);
1593 atload(is_sync_master);
1594 atload(is_sync_client);
1595 atload(sync_cycles);
1601 atload(autotrigger);
1610 lp_setup(lp_gain, lp_reso, lp_freq);
1614 ec_set_length(ec_length);
1615 atload(ec_feedback);
1616 ec_set_feedback(ec_feedback);
1619 sp_speed.set_persistence_id(pid);
1621 sp_volume.set_persistence_id(pid);
1623 sp_pitch.set_persistence_id(pid);
1625 sp_trigger.set_persistence_id(pid);
1627 sp_loop.set_persistence_id(pid);
1629 sp_sync_client.set_persistence_id(pid);
1631 sp_sync_cycles.set_persistence_id(pid);
1633 sp_lp_enable.set_persistence_id(pid);
1635 sp_lp_gain.set_persistence_id(pid);
1637 sp_lp_reso.set_persistence_id(pid);
1639 sp_lp_freq.set_persistence_id(pid);
1641 sp_ec_enable.set_persistence_id(pid);
1643 sp_ec_length.set_persistence_id(pid);
1645 sp_ec_feedback.set_persistence_id(pid);
1647 sp_mute.set_persistence_id(pid);
1649 sp_spin.set_persistence_id(pid);
1653 for (i=0; i<counter; i++)
1658 case TX_FX_BUILTINCUTOFF:
1659 for (t=0; t<fx_list.size(); t++) effect_down(lp_fx);
1662 case TX_FX_BUILTINECHO:
1663 for (t=0; t<fx_list.size(); t++) effect_down(ec_fx);
1668 plugin=LADSPA_Plugin::getPluginByUniqueID(id);
1671 ladspa_effect=add_effect(plugin);
1672 ladspa_effect->load(input);
1676 sprintf(buffer,"Fatal Error: Couldn't find required plugin with ID [%i].", id);
1683 tx_note("Fatal Error loading set: unknown effect type!");
1693 set_x_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
1695 else set_x_input_parameter(NULL);
1702 set_y_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
1704 else set_y_input_parameter(NULL);
1707 gui.main_panel->hide(hidden);
1710 gui.trigger_panel->hide(hidden);
1713 gui.lp_panel->hide(hidden);
1716 gui.ec_panel->hide(hidden);
1721 int vtt_class :: load_13(FILE * input)
1729 LADSPA_Plugin *plugin;
1731 vtt_fx_ladspa *ladspa_effect;
1735 this->set_name(buffer);
1737 atload(is_sync_master);
1738 atload(is_sync_client);
1739 atload(sync_cycles);
1744 atload(autotrigger);
1755 lp_setup(lp_gain, lp_reso, lp_freq);
1759 ec_set_length(ec_length);
1760 atload(ec_feedback);
1761 ec_set_feedback(ec_feedback);
1766 sp_speed.set_persistence_id(pid);
1768 sp_volume.set_persistence_id(pid);
1770 sp_pitch.set_persistence_id(pid);
1772 sp_trigger.set_persistence_id(pid);
1774 sp_loop.set_persistence_id(pid);
1776 sp_sync_client.set_persistence_id(pid);
1778 sp_sync_cycles.set_persistence_id(pid);
1780 sp_lp_enable.set_persistence_id(pid);
1782 sp_lp_gain.set_persistence_id(pid);
1784 sp_lp_reso.set_persistence_id(pid);
1786 sp_lp_freq.set_persistence_id(pid);
1788 sp_ec_enable.set_persistence_id(pid);
1790 sp_ec_length.set_persistence_id(pid);
1792 sp_ec_feedback.set_persistence_id(pid);
1794 sp_ec_pan.set_persistence_id(pid);
1796 sp_mute.set_persistence_id(pid);
1798 sp_spin.set_persistence_id(pid);
1800 sp_pan.set_persistence_id(pid);
1804 for (i=0; i<counter; i++)
1809 case TX_FX_BUILTINCUTOFF:
1810 for (t=0; t<fx_list.size(); t++) effect_down(lp_fx);
1813 case TX_FX_BUILTINECHO:
1814 for (t=0; t<fx_list.size(); t++) effect_down(ec_fx);
1819 plugin=LADSPA_Plugin::getPluginByUniqueID(id);
1822 ladspa_effect=add_effect(plugin);
1823 ladspa_effect->load(input);
1827 sprintf(buffer,"Fatal Error: Couldn't find required plugin with ID [%i].", id);
1834 tx_note("Fatal Error loading set: unknown effect type!");
1844 set_x_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
1846 else set_x_input_parameter(NULL);
1853 set_y_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
1855 else set_y_input_parameter(NULL);
1858 gui.main_panel->hide(hidden);
1861 gui.trigger_panel->hide(hidden);
1864 gui.lp_panel->hide(hidden);
1867 gui.ec_panel->hide(hidden);
1873 int vtt_class :: save_all(FILE* output)
1876 list <vtt_class *> :: iterator vtt;
1879 tX_seqpar :: create_persistence_ids();
1882 store(master_volume);
1883 store(globals.pitch);
1884 pid=sp_master_volume.get_persistence_id();
1886 pid=sp_master_pitch.get_persistence_id();
1889 for (vtt=main_list.begin(); vtt!=main_list.end(); vtt++)
1891 res+=(*vtt)->save(output);
1894 sequencer.save(output);
1899 int vtt_class :: load_all_10(FILE* input, char *fname)
1901 int res=0, restmp=0;
1902 list <vtt_class *> :: iterator vtt;
1903 unsigned int i, max, size;
1906 char ftmp[PATH_MAX];
1908 while (main_list.size())
1910 delete((*main_list.begin()));
1914 atload(master_volume);
1915 set_master_volume(master_volume);
1916 globals.volume=master_volume;
1917 atload(globals.pitch);
1918 set_master_pitch(globals.pitch);
1920 ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
1921 ld_set_setname(fname);
1923 for (i=0; i<max; i++)
1925 newvtt=new vtt_class(1);
1926 res+=newvtt->load_10(input);
1928 if (strlen(newvtt->filename))
1930 /* ftmp IS NECESSARY !!! */
1931 strcpy(ftmp, newvtt->filename);
1932 ld_set_filename(ftmp);
1934 //restmp=load_wav(newvtt->filename, &newbuffer, &size);
1935 restmp=newvtt->load_file(ftmp);
1938 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
1939 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
1951 int vtt_class :: load_all_11(FILE* input, char *fname)
1953 int res=0, restmp=0;
1954 list <vtt_class *> :: iterator vtt;
1955 unsigned int i, max, size;
1958 char ftmp[PATH_MAX];
1961 while (main_list.size())
1963 delete((*main_list.begin()));
1967 atload(master_volume);
1968 set_master_volume(master_volume);
1969 globals.volume=master_volume;
1970 atload(globals.pitch);
1971 set_master_pitch(globals.pitch);
1973 sp_master_volume.set_persistence_id(pid);
1975 sp_master_pitch.set_persistence_id(pid);
1977 ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
1978 ld_set_setname(fname);
1980 for (i=0; i<max; i++)
1982 newvtt=new vtt_class(1);
1983 res+=newvtt->load_11(input);
1985 if (strlen(newvtt->filename))
1987 /* ftmp IS NECESSARY !!! */
1988 strcpy(ftmp, newvtt->filename);
1989 ld_set_filename(ftmp);
1991 //restmp=load_wav(newvtt->filename, &newbuffer, &size);
1992 restmp=newvtt->load_file(ftmp);
1995 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
1996 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
2000 sequencer.load(input);
2008 int vtt_class :: load_all_12(FILE* input, char *fname)
2010 int res=0, restmp=0;
2011 list <vtt_class *> :: iterator vtt;
2012 unsigned int i, max, size;
2015 char ftmp[PATH_MAX];
2018 while (main_list.size())
2020 delete((*main_list.begin()));
2024 atload(master_volume);
2025 set_master_volume(master_volume);
2026 globals.volume=master_volume;
2027 atload(globals.pitch);
2028 set_master_pitch(globals.pitch);
2030 sp_master_volume.set_persistence_id(pid);
2032 sp_master_pitch.set_persistence_id(pid);
2034 ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
2035 ld_set_setname(fname);
2037 for (i=0; i<max; i++)
2039 newvtt=new vtt_class(1);
2040 res+=newvtt->load_12(input);
2042 if (strlen(newvtt->filename))
2044 /* ftmp IS NECESSARY !!! */
2045 strcpy(ftmp, newvtt->filename);
2046 ld_set_filename(ftmp);
2048 //restmp=load_wav(newvtt->filename, &newbuffer, &size);
2049 restmp=newvtt->load_file(ftmp);
2052 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
2053 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
2057 sequencer.load(input);
2064 int vtt_class :: load_all_13(FILE* input, char *fname)
2066 int res=0, restmp=0;
2067 list <vtt_class *> :: iterator vtt;
2068 unsigned int i, max, size;
2071 char ftmp[PATH_MAX];
2074 while (main_list.size())
2076 delete((*main_list.begin()));
2080 atload(master_volume);
2081 set_master_volume(master_volume);
2082 globals.volume=master_volume;
2083 atload(globals.pitch);
2084 set_master_pitch(globals.pitch);
2086 sp_master_volume.set_persistence_id(pid);
2088 sp_master_pitch.set_persistence_id(pid);
2090 ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
2091 ld_set_setname(fname);
2093 for (i=0; i<max; i++)
2095 newvtt=new vtt_class(1);
2096 res+=newvtt->load_13(input);
2098 if (strlen(newvtt->filename))
2100 /* ftmp IS NECESSARY !!! */
2101 strcpy(ftmp, newvtt->filename);
2102 ld_set_filename(ftmp);
2104 //restmp=load_wav(newvtt->filename, &newbuffer, &size);
2105 restmp=newvtt->load_file(ftmp);
2108 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
2109 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
2113 sequencer.load(input);
2120 void add_vtt(GtkWidget *ctrl, GtkWidget *audio, char *fn)
2123 hmmpg = new vtt_class(1);
2124 gtk_box_pack_start(GTK_BOX(ctrl), hmmpg->gui.control_box, TRUE, TRUE, 0);
2125 gtk_box_pack_start(GTK_BOX(audio), hmmpg->gui.audio_box, TRUE, TRUE, 0);
2126 if (fn) hmmpg->load_file(fn);
2129 extern void vg_move_fx_panel_up(GtkWidget *wid, vtt_class *vtt);
2130 extern void vg_move_fx_panel_down(GtkWidget *wid, vtt_class *vtt);
2132 //#define debug_fx_stack(); for (i=fx_list.begin(); i != fx_list.end(); i++) puts((*i)->get_info_string());
2133 #define debug_fx_stack();
2135 void vtt_class :: effect_up(vtt_fx *effect)
2137 list <vtt_fx *> :: iterator i;
2138 list <vtt_fx *> :: iterator previous;
2143 if ((*fx_list.begin())==effect) return;
2145 for (previous=i=fx_list.begin(); i != fx_list.end(); i++)
2157 pthread_mutex_lock(&render_lock);
2158 fx_list.remove(effect);
2159 fx_list.insert(previous, effect);
2160 pthread_mutex_unlock(&render_lock);
2162 vg_move_fx_panel_up(effect->get_panel_widget(), this);
2168 void vtt_class :: effect_down(vtt_fx *effect)
2170 list <vtt_fx *> :: iterator i;
2175 for (i=fx_list.begin(); i != fx_list.end(); i++)
2184 if ((ok) && (i!=fx_list.end()))
2187 if (i==fx_list.end()) return;
2190 pthread_mutex_lock(&render_lock);
2191 fx_list.remove(effect);
2193 fx_list.insert(i, effect);
2194 vg_move_fx_panel_down(effect->get_panel_widget(), this);
2195 pthread_mutex_unlock(&render_lock);
2201 void vtt_class :: effect_remove(vtt_fx_ladspa *effect)
2203 pthread_mutex_lock(&render_lock);
2204 fx_list.remove(effect);
2205 pthread_mutex_unlock(&render_lock);