It's 2020...
[terminatorX.git] / src / tX_legacy_vtt.cc
1 /*
2     terminatorX - realtime audio scratching software
3     Copyright (C) 1999-2020  Alexander K├Ânig
4  
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.
9  
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.
14  
15     You should have received a copy of the GNU General Public License
16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  
18     File: tX_legacy_vtt.cc
19 */    
20
21 #include <config.h>
22
23 #ifdef ENABLE_TX_LEGACY
24
25 #include <stdio.h>
26 #include "tX_vtt.h"
27 #include "tX_global.h"
28 #include "tX_loaddlg.h"
29 #include "tX_mastergui.h"
30 #include "tX_sequencer.h"
31 #include <string.h>
32
33 #define atload(data); if (fread((void *) &data, sizeof(data), 1, input)!=1) res+=1;
34
35 int vtt_class :: load_10(FILE * input)
36 {
37         int res=0;
38         int obsolete_int;
39         
40         atload(name);
41         atload(filename);
42         atload(is_sync_master);
43         atload(is_sync_client);
44         atload(sync_cycles);
45         atload(rel_volume);
46         recalc_volume();
47         atload(rel_pitch);
48         recalc_pitch();
49         
50         atload(autotrigger);
51         atload(loop);
52         
53         atload(mute);
54         atload(obsolete_int); //x_control
55         atload(obsolete_int); //y_control
56         
57         atload(lp_enable);
58         atload(lp_gain);
59         atload(lp_reso);
60         atload(lp_freq);
61         lp_setup(lp_gain, lp_reso, lp_freq);
62         
63         atload(ec_enable);
64         atload(ec_length);
65         ec_set_length(ec_length);
66         atload(ec_feedback);
67         ec_set_feedback(ec_feedback);
68         
69         return(res);
70 }
71
72
73 int vtt_class :: load_11(FILE * input)
74 {
75         int res=0;
76         guint32 pid;
77         int32_t gui_page;
78         int obsolete_int;
79         
80         atload(name);
81         atload(filename);
82         atload(is_sync_master);
83         atload(is_sync_client);
84         atload(sync_cycles);
85         atload(rel_volume);
86         recalc_volume();
87         atload(rel_pitch);
88         recalc_pitch();
89         
90         atload(autotrigger);
91         atload(loop);
92         
93         atload(mute);
94         atload(obsolete_int); //x_control
95         atload(obsolete_int); //y_control
96         
97         atload(lp_enable);
98         atload(lp_gain);
99         atload(lp_reso);
100         atload(lp_freq);
101         lp_setup(lp_gain, lp_reso, lp_freq);
102         
103         atload(ec_enable);
104         atload(ec_length);
105         ec_set_length(ec_length);
106         atload(ec_feedback);
107         ec_set_feedback(ec_feedback);
108
109         atload(pid);
110         sp_speed.set_persistence_id(pid);
111         atload(pid);
112         sp_volume.set_persistence_id(pid);
113         atload(pid);
114         sp_pitch.set_persistence_id(pid);
115         atload(pid);
116         sp_trigger.set_persistence_id(pid);
117         atload(pid);
118         sp_loop.set_persistence_id(pid);
119         atload(pid);
120         sp_sync_client.set_persistence_id(pid);
121         atload(pid);
122         sp_sync_cycles.set_persistence_id(pid);
123         atload(pid);
124         sp_lp_enable.set_persistence_id(pid);
125         atload(pid);
126         sp_lp_gain.set_persistence_id(pid);
127         atload(pid);
128         sp_lp_reso.set_persistence_id(pid);
129         atload(pid);
130         sp_lp_freq.set_persistence_id(pid);
131         atload(pid);
132         sp_ec_enable.set_persistence_id(pid);
133         atload(pid);
134         sp_ec_length.set_persistence_id(pid);
135         atload(pid);
136         sp_ec_feedback.set_persistence_id(pid);
137         atload(pid);
138         sp_mute.set_persistence_id(pid);
139         atload(pid);
140         sp_spin.set_persistence_id(pid);
141         
142         atload(gui_page);
143         
144         return(res);
145 }
146
147 int vtt_class :: load_12(FILE * input)
148 {
149         int res=0;
150         guint32 pid;
151         int32_t counter;
152         int32_t type;
153         long id;
154         int i;
155         unsigned int t;
156         LADSPA_Plugin *plugin;
157         char buffer[256];
158         vtt_fx_ladspa *ladspa_effect;
159         guint8 hidden;
160         
161         atload(buffer);
162         this->set_name(buffer);
163         atload(filename);
164         atload(is_sync_master);
165         atload(is_sync_client);
166         atload(sync_cycles);
167         atload(rel_volume);
168         recalc_volume();
169         atload(rel_pitch);
170         recalc_pitch();
171         
172         atload(autotrigger);
173         atload(loop);
174         
175         atload(mute);
176         
177         atload(lp_enable);
178         atload(lp_gain);
179         atload(lp_reso);
180         atload(lp_freq);
181         lp_setup(lp_gain, lp_reso, lp_freq);
182         
183         atload(ec_enable);
184         atload(ec_length);
185         ec_set_length(ec_length);
186         atload(ec_feedback);
187         ec_set_feedback(ec_feedback);
188
189         atload(pid);
190         sp_speed.set_persistence_id(pid);
191         atload(pid);
192         sp_volume.set_persistence_id(pid);
193         atload(pid);
194         sp_pitch.set_persistence_id(pid);
195         atload(pid);
196         sp_trigger.set_persistence_id(pid);
197         atload(pid);
198         sp_loop.set_persistence_id(pid);
199         atload(pid);
200         sp_sync_client.set_persistence_id(pid);
201         atload(pid);
202         sp_sync_cycles.set_persistence_id(pid);
203         atload(pid);
204         sp_lp_enable.set_persistence_id(pid);
205         atload(pid);
206         sp_lp_gain.set_persistence_id(pid);
207         atload(pid);
208         sp_lp_reso.set_persistence_id(pid);
209         atload(pid);
210         sp_lp_freq.set_persistence_id(pid);
211         atload(pid);
212         sp_ec_enable.set_persistence_id(pid);
213         atload(pid);
214         sp_ec_length.set_persistence_id(pid);
215         atload(pid);
216         sp_ec_feedback.set_persistence_id(pid);
217         atload(pid);
218         sp_mute.set_persistence_id(pid);
219         atload(pid);
220         sp_spin.set_persistence_id(pid);
221                 
222         atload(counter);
223         
224         for (i=0; i<counter; i++)
225         {
226                 atload(type);
227                 switch(type)
228                 {
229                         case TX_FX_BUILTINCUTOFF:
230                                 for (t=0; t<fx_list.size(); t++) effect_down(lp_fx);
231                         break;
232                         
233                         case TX_FX_BUILTINECHO:
234                                 for (t=0; t<fx_list.size(); t++) effect_down(ec_fx);
235                         break;
236                         
237                         case TX_FX_LADSPA:
238                                 atload(id);
239                                 plugin=LADSPA_Plugin::getPluginByUniqueID(id);
240                                 if (plugin)
241                                 {
242                                         ladspa_effect=add_effect(plugin);
243                                         ladspa_effect->load(input);
244                                 }
245                                 else
246                                 {
247                                         sprintf(buffer,"Couldn't find required plugin with ID [%li].", id);
248                                         tx_note(buffer, true);
249                                         res++;
250                                 }
251                         break;
252                         
253                         default:
254                                 tx_note("Fatal error loading set: unknown effect type!", true);
255                                 res++;
256                 }               
257         }
258
259         atload(pid);
260         
261         if (pid)
262         {
263                 atload(pid);
264                 set_x_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
265         }
266         else set_x_input_parameter(NULL);
267         
268         atload(pid);
269         
270         if (pid)
271         {
272                 atload(pid);
273                 set_y_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
274         }
275         else set_y_input_parameter(NULL);
276
277         atload(hidden);
278         gui.main_panel->hide(hidden);
279
280         atload(hidden);
281         gui.trigger_panel->hide(hidden);
282
283         atload(hidden);
284         gui.lp_panel->hide(hidden);
285
286         atload(hidden);
287         gui.ec_panel->hide(hidden);
288         
289         return(res);
290 }
291
292 int vtt_class :: load_13(FILE * input)
293 {
294         int res=0;
295         guint32 pid;
296         int32_t counter;
297         int32_t type;
298         long id;
299         int i;
300         unsigned int t;
301         LADSPA_Plugin *plugin;
302         char buffer[256];
303         vtt_fx_ladspa *ladspa_effect;
304         guint8 hidden;
305         
306         atload(buffer);
307         this->set_name(buffer);
308         atload(filename);
309         atload(is_sync_master);
310         atload(is_sync_client);
311         atload(sync_cycles);
312         atload(rel_volume);
313         atload(rel_pitch);
314         recalc_pitch();
315         
316         atload(autotrigger);
317         atload(loop);
318         
319         atload(mute);
320         atload(pan);
321         
322         atload(lp_enable);
323         atload(lp_gain);
324         atload(lp_reso);
325         atload(lp_freq);
326         lp_setup(lp_gain, lp_reso, lp_freq);
327         
328         atload(ec_enable);
329         atload(ec_length);
330         ec_set_length(ec_length);
331         atload(ec_feedback);
332         ec_set_feedback(ec_feedback);
333         atload(ec_pan);
334         ec_set_pan(ec_pan);
335         atload(ec_volume);
336         ec_set_volume(ec_volume);
337
338         recalc_volume();
339
340         atload(pid);
341         sp_speed.set_persistence_id(pid);
342         atload(pid);
343         sp_volume.set_persistence_id(pid);
344         atload(pid);
345         sp_pitch.set_persistence_id(pid);
346         atload(pid);
347         sp_trigger.set_persistence_id(pid);
348         atload(pid);
349         sp_loop.set_persistence_id(pid);
350         atload(pid);
351         sp_sync_client.set_persistence_id(pid);
352         atload(pid);
353         sp_sync_cycles.set_persistence_id(pid);
354         atload(pid);
355         sp_lp_enable.set_persistence_id(pid);
356         atload(pid);
357         sp_lp_gain.set_persistence_id(pid);
358         atload(pid);
359         sp_lp_reso.set_persistence_id(pid);
360         atload(pid);
361         sp_lp_freq.set_persistence_id(pid);
362         atload(pid);
363         sp_ec_enable.set_persistence_id(pid);
364         atload(pid);
365         sp_ec_length.set_persistence_id(pid);
366         atload(pid);
367         sp_ec_feedback.set_persistence_id(pid);
368         atload(pid);
369         sp_ec_volume.set_persistence_id(pid);
370         atload(pid);
371         sp_ec_pan.set_persistence_id(pid);
372         atload(pid);
373         sp_mute.set_persistence_id(pid);
374         atload(pid);
375         sp_spin.set_persistence_id(pid);
376         atload(pid);
377         sp_pan.set_persistence_id(pid);
378                 
379         atload(counter);
380         
381         for (i=0; i<counter; i++)
382         {
383                 atload(type);
384                 switch(type)
385                 {
386                         case TX_FX_BUILTINCUTOFF:
387                                 for (t=0; t<fx_list.size(); t++) effect_down(lp_fx);
388                         break;
389                         
390                         case TX_FX_BUILTINECHO:
391                                 for (t=0; t<fx_list.size(); t++) effect_down(ec_fx);
392                         break;
393                         
394                         case TX_FX_LADSPA:
395                                 atload(id);
396                                 plugin=LADSPA_Plugin::getPluginByUniqueID(id);
397                                 if (plugin)
398                                 {
399                                         ladspa_effect=add_effect(plugin);
400                                         ladspa_effect->load(input);
401                                 }
402                                 else
403                                 {
404                                         sprintf(buffer,"Couldn't find required plugin with ID [%li].", id);
405                                         tx_note(buffer, true);
406                                         res++;
407                                 }
408                         break;
409                         
410                         default:
411                                 tx_note("Fatal error loading set: unknown effect type!", true);
412                                 res++;
413                 }               
414         }
415
416         atload(pid);
417         
418         if (pid)
419         {
420                 atload(pid);
421                 set_x_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
422         }
423         else set_x_input_parameter(NULL);
424         
425         atload(pid);
426         
427         if (pid)
428         {
429                 atload(pid);
430                 set_y_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
431         }
432         else set_y_input_parameter(NULL);
433
434         atload(hidden);
435         gui.main_panel->hide(hidden);
436
437         atload(hidden);
438         gui.trigger_panel->hide(hidden);
439
440         atload(hidden);
441         gui.lp_panel->hide(hidden);
442
443         atload(hidden);
444         gui.ec_panel->hide(hidden);
445         
446         return(res);
447 }
448
449 int vtt_class :: load_14(FILE * input)
450 {
451         int res=0;
452         guint32 pid;
453         int32_t counter;
454         int32_t type;
455         long id;
456         int i;
457         unsigned int t;
458         LADSPA_Plugin *plugin;
459         char buffer[256];
460         vtt_fx_ladspa *ladspa_effect;
461         guint8 hidden;
462         
463         atload(buffer);
464         this->set_name(buffer);
465         atload(filename);
466         atload(is_sync_master);
467         atload(is_sync_client);
468         atload(sync_cycles);
469         atload(rel_volume);
470         atload(rel_pitch);
471         recalc_pitch();
472         
473         atload(autotrigger);
474         atload(loop);
475         
476         atload(mute);
477         atload(pan);
478         
479         atload(lp_enable);
480         atload(lp_gain);
481         atload(lp_reso);
482         atload(lp_freq);
483         lp_setup(lp_gain, lp_reso, lp_freq);
484         
485         atload(ec_enable);
486         atload(ec_length);
487         ec_set_length(ec_length);
488         atload(ec_feedback);
489         ec_set_feedback(ec_feedback);
490         atload(ec_pan);
491         ec_set_pan(ec_pan);
492         atload(ec_volume);
493         ec_set_volume(ec_volume);
494
495         atload(audio_hidden);
496         atload(control_hidden);
497         
498         recalc_volume();
499
500         atload(pid);
501         sp_speed.set_persistence_id(pid);
502         atload(pid);
503         sp_volume.set_persistence_id(pid);
504         atload(pid);
505         sp_pitch.set_persistence_id(pid);
506         atload(pid);
507         sp_trigger.set_persistence_id(pid);
508         atload(pid);
509         sp_loop.set_persistence_id(pid);
510         atload(pid);
511         sp_sync_client.set_persistence_id(pid);
512         atload(pid);
513         sp_sync_cycles.set_persistence_id(pid);
514         atload(pid);
515         sp_lp_enable.set_persistence_id(pid);
516         atload(pid);
517         sp_lp_gain.set_persistence_id(pid);
518         atload(pid);
519         sp_lp_reso.set_persistence_id(pid);
520         atload(pid);
521         sp_lp_freq.set_persistence_id(pid);
522         atload(pid);
523         sp_ec_enable.set_persistence_id(pid);
524         atload(pid);
525         sp_ec_length.set_persistence_id(pid);
526         atload(pid);
527         sp_ec_feedback.set_persistence_id(pid);
528         atload(pid);
529         sp_ec_volume.set_persistence_id(pid);
530         atload(pid);
531         sp_ec_pan.set_persistence_id(pid);
532         atload(pid);
533         sp_mute.set_persistence_id(pid);
534         atload(pid);
535         sp_spin.set_persistence_id(pid);
536         atload(pid);
537         sp_pan.set_persistence_id(pid);
538                 
539         atload(counter);
540         
541         for (i=0; i<counter; i++)
542         {
543                 atload(type);
544                 switch(type)
545                 {
546                         case TX_FX_BUILTINCUTOFF:
547                                 for (t=0; t<fx_list.size(); t++) effect_down(lp_fx);
548                         break;
549                         
550                         case TX_FX_BUILTINECHO:
551                                 for (t=0; t<fx_list.size(); t++) effect_down(ec_fx);
552                         break;
553                         
554                         case TX_FX_LADSPA:
555                                 atload(id);
556                                 plugin=LADSPA_Plugin::getPluginByUniqueID(id);
557                                 if (plugin)
558                                 {
559                                         ladspa_effect=add_effect(plugin);
560                                         ladspa_effect->load(input);
561                                 }
562                                 else
563                                 {
564                                         sprintf(buffer,"Couldn't find required plugin with ID [%li].", id);
565                                         tx_note(buffer, true);
566                                         res++;
567                                 }
568                         break;
569                         
570                         default:
571                                 tx_note("Fatal error loading set: unknown effect type!", true);
572                                 res++;
573                 }               
574         }
575
576         atload(pid);
577         
578         if (pid)
579         {
580                 atload(pid);
581                 set_x_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
582         }
583         else set_x_input_parameter(NULL);
584         
585         atload(pid);
586         
587         if (pid)
588         {
589                 atload(pid);
590                 set_y_input_parameter(tX_seqpar :: get_sp_by_persistence_id(pid));
591         }
592         else set_y_input_parameter(NULL);
593
594         atload(hidden);
595         gui.main_panel->hide(hidden);
596
597         atload(hidden);
598         gui.trigger_panel->hide(hidden);
599
600         atload(hidden);
601         gui.lp_panel->hide(hidden);
602
603         atload(hidden);
604         gui.ec_panel->hide(hidden);
605         
606         return(res);
607 }
608
609 int  vtt_class :: load_all_10(FILE* input, char *fname)
610 {
611         int res=0, restmp=0;
612         unsigned int i, max;
613         vtt_class *newvtt;
614         char ftmp[PATH_MAX];
615         
616         while (main_list.size())
617         {
618                 delete((*main_list.begin()));
619         }
620                 
621         atload(max);
622         atload(master_volume);
623         set_master_volume(master_volume);
624         globals.volume=master_volume;
625         atload(globals.pitch);  
626         set_master_pitch(globals.pitch);
627
628         ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
629         ld_set_setname(fname);
630
631         for (i=0; i<max; i++)
632         {
633                 newvtt=new vtt_class(1);
634                 res+=newvtt->load_10(input);
635                 
636                 if (strlen(newvtt->filename))
637                 {
638                         /* ftmp IS NECESSARY !!! */
639                         strcpy(ftmp, newvtt->filename);
640                         ld_set_filename(ftmp);
641                         
642                         //restmp=load_wav(newvtt->filename, &newbuffer, &size);
643                         restmp=(int) newvtt->load_file(ftmp);
644                         res+=restmp;
645                 }
646                 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
647                 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
648         }
649         
650         sequencer.delete_all_events(tX_sequencer::DELETE_ALL);
651         
652         ld_destroy();
653         
654         return(res);
655 }
656
657
658 int  vtt_class :: load_all_11(FILE* input, char *fname)
659 {
660         int res=0, restmp=0;
661         unsigned int i, max;
662         vtt_class *newvtt;
663         char ftmp[PATH_MAX];
664         guint32 pid;
665         
666         while (main_list.size())
667         {
668                 delete((*main_list.begin()));
669         }
670                 
671         atload(max);
672         atload(master_volume);
673         set_master_volume(master_volume);
674         globals.volume=master_volume;
675         atload(globals.pitch);  
676         set_master_pitch(globals.pitch);
677         atload(pid);
678         sp_master_volume.set_persistence_id(pid);
679         atload(pid);
680         sp_master_pitch.set_persistence_id(pid);
681
682         ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
683         ld_set_setname(fname);
684
685         for (i=0; i<max; i++)
686         {
687                 newvtt=new vtt_class(1);
688                 res+=newvtt->load_11(input);
689                 
690                 if (strlen(newvtt->filename))
691                 {
692                         /* ftmp IS NECESSARY !!! */
693                         strcpy(ftmp, newvtt->filename);
694                         ld_set_filename(ftmp);
695                         
696                         //restmp=load_wav(newvtt->filename, &newbuffer, &size);
697                         restmp=(int) newvtt->load_file(ftmp);
698                         res+=restmp;
699                 }
700                 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
701                 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
702                 
703         }
704         
705         sequencer.load(input);
706         
707         ld_destroy();
708         
709         return(res);
710 }
711
712
713 int  vtt_class :: load_all_12(FILE* input, char *fname)
714 {
715         int res=0, restmp=0;
716         unsigned int i, max;
717         vtt_class *newvtt;
718         char ftmp[PATH_MAX];
719         guint32 pid;
720         
721         while (main_list.size())
722         {
723                 delete((*main_list.begin()));
724         }
725                 
726         atload(max);
727         atload(master_volume);
728         set_master_volume(master_volume);
729         globals.volume=master_volume;
730         atload(globals.pitch);  
731         set_master_pitch(globals.pitch);
732         atload(pid);
733         sp_master_volume.set_persistence_id(pid);
734         atload(pid);
735         sp_master_pitch.set_persistence_id(pid);
736
737         ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
738         ld_set_setname(fname);
739
740         for (i=0; i<max; i++)
741         {
742                 newvtt=new vtt_class(1);
743                 res+=newvtt->load_12(input);
744                 
745                 if (strlen(newvtt->filename))
746                 {
747                         /* ftmp IS NECESSARY !!! */
748                         strcpy(ftmp, newvtt->filename);
749                         ld_set_filename(ftmp);
750                         
751                         //restmp=load_wav(newvtt->filename, &newbuffer, &size);
752                         restmp=(int) newvtt->load_file(ftmp);
753                         res+=restmp;
754                 }
755                 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
756                 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
757                 
758         }
759         
760         sequencer.load(input);
761         
762         ld_destroy();
763         
764         return(res);
765 }
766
767 int  vtt_class :: load_all_13(FILE* input, char *fname)
768 {
769         int res=0, restmp=0;
770         unsigned int i, max;
771         vtt_class *newvtt;
772         char ftmp[PATH_MAX];
773         guint32 pid;
774         
775         while (main_list.size())
776         {
777                 delete((*main_list.begin()));
778         }
779                 
780         atload(max);
781         atload(master_volume);
782         set_master_volume(master_volume);
783         globals.volume=master_volume;
784         atload(globals.pitch);  
785         set_master_pitch(globals.pitch);
786         atload(pid);
787         sp_master_volume.set_persistence_id(pid);
788         atload(pid);
789         sp_master_pitch.set_persistence_id(pid);
790
791         ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
792         ld_set_setname(fname);
793
794         for (i=0; i<max; i++)
795         {
796                 newvtt=new vtt_class(1);
797                 res+=newvtt->load_13(input);
798                 
799                 if (strlen(newvtt->filename))
800                 {
801                         /* ftmp IS NECESSARY !!! */
802                         strcpy(ftmp, newvtt->filename);
803                         ld_set_filename(ftmp);
804                         
805                         //restmp=load_wav(newvtt->filename, &newbuffer, &size);
806                         restmp=(int) newvtt->load_file(ftmp);
807                         res+=restmp;
808                 }
809                 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
810                 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
811                 
812         }
813         
814         sequencer.load(input);
815         
816         ld_destroy();
817         
818         return(res);
819 }
820
821 int  vtt_class :: load_all_14(FILE* input, char *fname)
822 {
823         int res=0, restmp=0;
824         unsigned int i, max;
825         vtt_class *newvtt;
826         char ftmp[PATH_MAX];
827         guint32 pid;
828         
829         while (main_list.size())
830         {
831                 delete((*main_list.begin()));
832         }
833                 
834         atload(max);
835         atload(master_volume);
836         set_master_volume(master_volume);
837         globals.volume=master_volume;
838         atload(globals.pitch);  
839         set_master_pitch(globals.pitch);
840         atload(pid);
841         sp_master_volume.set_persistence_id(pid);
842         atload(pid);
843         sp_master_pitch.set_persistence_id(pid);
844
845         ld_create_loaddlg(TX_LOADDLG_MODE_MULTI, max);
846         ld_set_setname(fname);
847
848         for (i=0; i<max; i++)
849         {
850                 newvtt=new vtt_class(1);
851                 res+=newvtt->load_14(input);
852                 
853                 if (strlen(newvtt->filename))
854                 {
855                         /* ftmp IS NECESSARY !!! */
856                         strcpy(ftmp, newvtt->filename);
857                         ld_set_filename(ftmp);
858                         
859                         //restmp=load_wav(newvtt->filename, &newbuffer, &size);
860                         restmp=(int) newvtt->load_file(ftmp);
861                         res+=restmp;
862                 }
863                 gtk_box_pack_start(GTK_BOX(control_parent), newvtt->gui.control_box, TRUE, TRUE, 0);
864                 gtk_box_pack_start(GTK_BOX(audio_parent), newvtt->gui.audio_box, TRUE, TRUE, 0);
865             if (newvtt->audio_hidden) newvtt->hide_audio(newvtt->audio_hidden);
866             if (newvtt->control_hidden) newvtt->hide_control(newvtt->control_hidden);\r
867         }
868         
869         sequencer.load(input);
870         
871         ld_destroy();
872         
873         return(res);
874 }
875
876 void vtt_fx_ladspa :: load (FILE *input)
877 {
878         guint32 count;
879         unsigned int i;
880         list <tX_seqpar_vttfx *> :: iterator sp;
881         guint32 pid;
882         guint8 hidden;
883         float value;
884         
885         fread((void *) &count, sizeof(count), 1, input);
886         
887         if (count!=controls.size())
888         {
889                 fprintf(stderr, "tX: Ouch! Plugin %li has less/more controls than saved!\n", plugin->getUniqueID());
890         }
891         
892         for (i=0, sp=controls.begin(); (i<count) && (sp!=controls.end()); i++, sp++) {
893                 fread((void *) &pid, sizeof(pid), 1, input);
894                 (*sp)->set_persistence_id(pid);
895                 fread((void *) &value, sizeof(value), 1, input);
896                 (*sp)->do_exec(value);
897                 (*sp)->do_update_graphics();
898         } 
899         
900         fread((void *) &hidden, sizeof(hidden), 1, input);
901         panel->hide(hidden);
902 }
903
904 void tX_sequencer :: load(FILE *in)
905 {
906         guint32 event_count=0;
907         guint32 i;
908         tX_event *new_event=NULL;
909         
910         delete_all_events(tX_sequencer::DELETE_ALL);
911         
912         fread ((void *) &event_count, sizeof(event_count), 1, in);
913         
914         max_timestamp=0;
915         
916         for (i=0; i<event_count; i++)
917         {
918                 new_event=new tX_event(in);
919                 song_list.push_back(new_event);
920         }
921         
922         start_timestamp=0;
923         current_timestamp=0;
924         
925         if (new_event) max_timestamp=new_event->get_timestamp();
926 }
927
928 tX_event :: tX_event (FILE *input)
929 {
930         unsigned int sp_persistence_id;
931
932         fread((void *) &sp_persistence_id, sizeof(sp_persistence_id), 1, input);
933         fread((void *) &timestamp, sizeof(timestamp), 1, input);
934         fread((void *) &value, sizeof(value), 1, input);
935
936         sp=tX_seqpar::get_sp_by_persistence_id(sp_persistence_id);
937         if (!sp)
938         {
939                 fprintf(stderr, "oops: couldn't resolve sp by persistence id %i.\n", sp_persistence_id);
940         }
941 }
942
943 #endif