shuttle and transportque reworks, new shdmp, titler font textbox tweak
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / pluginset.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "edl.h"
23 #include "edlsession.h"
24 #include "filexml.h"
25 #include "keyframe.h"
26 #include "keyframes.h"
27 #include "plugin.h"
28 #include "pluginautos.h"
29 #include "pluginset.h"
30 #include "track.h"
31 #include "transportque.inc"
32
33 #include <string.h>
34
35 PluginSet::PluginSet(EDL *edl, Track *track)
36  : Edits(edl, track)
37 {
38         record = 1;
39 }
40
41 PluginSet::~PluginSet()
42 {
43         while(last) delete last;
44 }
45
46
47 PluginSet& PluginSet::operator=(PluginSet& plugins)
48 {
49 printf("PluginSet::operator= 1\n");
50         copy_from(&plugins);
51         return *this;
52 }
53
54 void PluginSet::copy_from(PluginSet *src)
55 {
56         while(last) delete last;
57         for(Plugin *current = (Plugin*)src->first; current; current = (Plugin*)NEXT)
58         {
59                 Plugin *new_plugin;
60                 append(new_plugin = (Plugin*)create_edit());
61                 new_plugin->copy_from(current);
62         }
63         this->record = src->record;
64 }
65
66 Plugin* PluginSet::get_first_plugin()
67 {
68 // Called when a new pluginset is added.
69 // Get first non-silence plugin in the plugin set.
70         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
71         {
72                 if(current && current->plugin_type != PLUGIN_NONE)
73                 {
74                         return current;
75                 }
76         }
77         return 0;
78 }
79
80 int64_t PluginSet::plugin_change_duration(int64_t input_position,
81         int64_t input_length,
82         int reverse)
83 {
84         int result = input_length;
85         Edit *current;
86
87         if(reverse)
88         {
89                 int input_start = input_position - input_length;
90                 for(current = last; current; current = PREVIOUS)
91                 {
92                         int start = current->startproject;
93                         int end = start + current->length;
94                         if(end > input_start && end < input_position)
95                         {
96                                 result = input_position - end;
97                                 return result;
98                         }
99                         else
100                         if(start > input_start && start < input_position)
101                         {
102                                 result = input_position - start;
103                                 return result;
104                         }
105                 }
106         }
107         else
108         {
109                 int input_end = input_position + input_length;
110                 for(current = first; current; current = NEXT)
111                 {
112                         int start = current->startproject;
113                         int end = start + current->length;
114                         if(start > input_position && start < input_end)
115                         {
116                                 result = start - input_position;
117                                 return result;
118                         }
119                         else
120                         if(end > input_position && end < input_end)
121                         {
122                                 result = end - input_position;
123                                 return result;
124                         }
125                 }
126         }
127         return input_length;
128 }
129
130 void PluginSet::synchronize_params(PluginSet *plugin_set)
131 {
132         for(Plugin *this_plugin = (Plugin*)first, *that_plugin = (Plugin*)plugin_set->first;
133                 this_plugin && that_plugin;
134                 this_plugin = (Plugin*)this_plugin->next, that_plugin = (Plugin*)that_plugin->next)
135         {
136                 this_plugin->synchronize_params(that_plugin);
137         }
138 }
139
140 Plugin* PluginSet::insert_plugin(const char *title,
141         int64_t unit_position, int64_t unit_length, int plugin_type,
142         SharedLocation *shared_location, KeyFrame *default_keyframe,
143         int do_optimize)
144 {
145         Plugin *plugin = (Plugin*)create_silence(unit_position, unit_position + unit_length);
146         plugin->init(title, unit_position, unit_length, plugin_type,
147                         shared_location, default_keyframe);
148 // May delete the plugin we just added so not desirable while loading.
149         if( do_optimize ) optimize();
150         return plugin;
151 }
152
153 Edit* PluginSet::create_edit()
154 {
155         Plugin* result = new Plugin(edl, this, "");
156         return result;
157 }
158
159 Edit* PluginSet::insert_edit_after(Edit *previous_edit)
160 {
161         Plugin *current = new Plugin(edl, this, "");
162         List<Edit>::insert_after(previous_edit, current);
163         return (Edit*)current;
164 }
165
166 KeyFrame *PluginSet::nearest_keyframe(int64_t pos, int dir)
167 {
168         Plugin *plugin = (Plugin*)editof(pos, dir, 0);
169         if( !plugin ) return 0;
170         KeyFrame *keyframe = (KeyFrame *)(dir == PLAY_FORWARD ?
171                 plugin->keyframes->nearest_after(pos) :
172                 plugin->keyframes->nearest_before(pos));
173         return keyframe;
174 }
175
176 int PluginSet::get_number()
177 {
178         return track->plugin_set.number_of(this);
179 }
180
181 void PluginSet::clear(int64_t start, int64_t end, int edit_autos)
182 {
183         if(edit_autos)
184         {
185 // Clear keyframes
186                 for(Plugin *current = (Plugin*)first;
187                         current;
188                         current = (Plugin*)NEXT)
189                 {
190                         current->keyframes->clear(start, end, 1);
191                 }
192         }
193
194 // Clear edits
195         Edits::clear(start, end);
196 }
197
198 //void PluginSet::clear_recursive(int64_t start, int64_t end)
199 //{
200 //printf("PluginSet::clear_recursive 1\n");
201 //      clear(start, end, 1);
202 //}
203
204 void PluginSet::shift_keyframes_recursive(int64_t position, int64_t length)
205 {
206 // Plugin keyframes are shifted in shift_effects
207 }
208
209 void PluginSet::shift_effects_recursive(int64_t position, int64_t length, int edit_autos)
210 {
211 // Effects are shifted in length extension
212 }
213
214
215 void PluginSet::clear_keyframes(int64_t start, int64_t end)
216 {
217         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
218         {
219                 current->clear_keyframes(start, end);
220         }
221 }
222
223 void PluginSet::copy_keyframes(int64_t start,
224         int64_t end,
225         FileXML *file,
226         int default_only,
227         int active_only)
228 {
229         file->tag.set_title("PLUGINSET");
230         file->append_tag();
231         file->append_newline();
232
233         for(Plugin *current = (Plugin*)first;
234                 current;
235                 current = (Plugin*)NEXT)
236         {
237                 current->copy_keyframes(start, end, file, default_only, active_only);
238         }
239
240         file->tag.set_title("/PLUGINSET");
241         file->append_tag();
242         file->append_newline();
243 }
244
245
246 void PluginSet::paste_keyframes(int64_t start,
247         int64_t length,
248         FileXML *file,
249         int default_only,
250         int active_only)
251 {
252         int result = 0;
253         int first_keyframe = 1;
254         Plugin *current;
255
256
257         while(!result)
258         {
259                 result = file->read_tag();
260
261                 if(!result)
262                 {
263                         if(file->tag.title_is("/PLUGINSET"))
264                                 result = 1;
265                         else
266                         if(file->tag.title_is("KEYFRAME"))
267                         {
268                                 int64_t position = file->tag.get_property("POSITION", 0);
269                                 if(first_keyframe && default_only)
270                                 {
271                                         position = start;
272                                 }
273                                 else
274                                 {
275                                         position += start;
276                                 }
277
278 // Get plugin owning keyframe
279                                 for(current = (Plugin*)last;
280                                         current;
281                                         current = (Plugin*)PREVIOUS)
282                                 {
283 // We want keyframes to exist beyond the end of the last plugin to
284 // make editing intuitive, but it will always be possible to
285 // paste keyframes from one plugin into an incompatible plugin.
286                                         if(position >= current->startproject)
287                                         {
288                                                 KeyFrame *keyframe = 0;
289                                                 if(file->tag.get_property("DEFAULT", 0) || default_only)
290                                                 {
291                                                         keyframe = (KeyFrame*)current->keyframes->default_auto;
292                                                 }
293                                                 else
294                                                 if(!default_only)
295                                                 {
296                                                         keyframe =
297                                                                 (KeyFrame*)current->keyframes->insert_auto(position);
298                                                 }
299
300                                                 if(keyframe)
301                                                 {
302                                                         keyframe->load(file);
303                                                         keyframe->position = position;
304                                                 }
305                                                 break;
306                                         }
307                                 }
308
309                                 first_keyframe = 0;
310                         }
311                 }
312         }
313 }
314
315 void PluginSet::shift_effects(int64_t start, int64_t length, int edit_autos)
316 {
317         for(Plugin *current = (Plugin*)first;
318                 current;
319                 current = (Plugin*)NEXT)
320         {
321 // Shift beginning of this effect
322                 if(current->startproject >= start)
323                 {
324                         current->startproject += length;
325                 }
326                 else
327 // Extend end of this effect.
328 // In loading new files, the effect should extend to fill the entire track.
329 // In muting, the effect must extend to fill the gap if another effect follows.
330 // The user should use Settings->edit effects to disable this.
331                 if(current->startproject + current->length >= start)
332                 {
333                         current->length += length;
334                 }
335
336 // Shift keyframes in this effect.
337 // If the default keyframe lands on the starting point, it must be shifted
338 // since the effect start is shifted.
339                 if(edit_autos && current->keyframes->default_auto->position >= start)
340                         current->keyframes->default_auto->position += length;
341
342                 if(edit_autos) current->keyframes->paste_silence(start, start + length);
343         }
344 }
345
346 void PluginSet::paste_silence(int64_t start, int64_t end, int edit_autos)
347 {
348         Plugin *new_plugin = (Plugin *) insert_new_edit(start);
349         int64_t length = end - start;
350         new_plugin->length = length;
351         while( (new_plugin=(Plugin *)new_plugin->next) != 0 ) {
352                 new_plugin->startproject += length;
353                 if( !edit_autos ) continue;
354                 new_plugin->keyframes->default_auto->position += length;
355                 new_plugin->keyframes->paste_silence(start, end);
356         }
357 }
358
359 void PluginSet::copy(int64_t start, int64_t end, FileXML *file)
360 {
361         file->tag.set_title("PLUGINSET");
362         file->tag.set_property("RECORD", record);
363         file->append_tag();
364         file->append_newline();
365
366         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
367         {
368                 current->copy(start, end, file);
369         }
370
371         file->tag.set_title("/PLUGINSET");
372         file->append_tag();
373         file->append_newline();
374 }
375
376 void PluginSet::save(FileXML *file)
377 {
378         copy(0, length(), file);
379 }
380
381 void PluginSet::load(FileXML *file, uint32_t load_flags)
382 {
383         int result = 0;
384 // Current plugin being amended
385         Plugin *plugin = (Plugin*)first;
386         int64_t startproject = 0;
387
388         record = file->tag.get_property("RECORD", record);
389         do{
390                 result = file->read_tag();
391
392
393                 if(!result)
394                 {
395                         if(file->tag.title_is("/PLUGINSET"))
396                         {
397                                 result = 1;
398                         }
399                         else
400                         if(file->tag.title_is("PLUGIN"))
401                         {
402                                 int64_t length = file->tag.get_property("LENGTH", (int64_t)0);
403                                 int plugin_type = file->tag.get_property("TYPE", 1);
404                                 char title[BCTEXTLEN];
405                                 title[0] = 0;
406                                 file->tag.get_property("TITLE", title);
407                                 Plugin::fix_plugin_title(title);
408                                 SharedLocation shared_location;
409                                 shared_location.load(file);
410
411
412                                 if(load_flags & LOAD_EDITS)
413                                 {
414                                         plugin = insert_plugin(title,
415                                                 startproject,
416                                                 length,
417                                                 plugin_type,
418                                                 &shared_location,
419                                                 0,
420                                                 0);
421                                         plugin->load(file);
422                                         startproject += length;
423                                 }
424                                 else
425                                 if(load_flags & LOAD_AUTOMATION)
426                                 {
427                                         if(plugin)
428                                         {
429                                                 plugin->load(file);
430                                                 plugin = (Plugin*)plugin->next;
431                                         }
432                                 }
433                         }
434                 }
435         } while(!result);
436
437         optimize();
438 }
439
440 int PluginSet::optimize()
441 {
442         int result = 1;
443         Plugin *current_edit;
444
445
446 // Delete keyframes out of range
447         for(current_edit = (Plugin*)first;
448                 current_edit;
449                 current_edit = (Plugin*)current_edit->next)
450         {
451                 current_edit->keyframes->default_auto->position = 0;
452                 for(KeyFrame *current_keyframe = (KeyFrame*)current_edit->keyframes->last;
453                         current_keyframe; )
454                 {
455                         KeyFrame *previous_keyframe = (KeyFrame*)current_keyframe->previous;
456                         if(current_keyframe->position >
457                                 current_edit->startproject + current_edit->length ||
458                                 current_keyframe->position < current_edit->startproject)
459                         {
460                                 delete current_keyframe;
461                         }
462                         current_keyframe = previous_keyframe;
463                 }
464         }
465
466 // Insert silence between plugins
467         for(Plugin *current = (Plugin*)last; current; current = (Plugin*)PREVIOUS)
468         {
469                 if(current->previous)
470                 {
471                         Plugin *previous = (Plugin*)PREVIOUS;
472
473                         if(current->startproject -
474                                 previous->startproject -
475                                 previous->length > 0)
476                         {
477                                 Plugin *new_plugin = (Plugin*)create_edit();
478                                 insert_before(current, new_plugin);
479                                 new_plugin->startproject = previous->startproject +
480                                         previous->length;
481                                 new_plugin->length = current->startproject -
482                                         previous->startproject -
483                                         previous->length;
484                         }
485                 }
486                 else
487                 if(current->startproject > 0)
488                 {
489                         Plugin *new_plugin = (Plugin*)create_edit();
490                         insert_before(current, new_plugin);
491                         new_plugin->length = current->startproject;
492                 }
493         }
494
495
496 // delete 0 length plugins
497         while(result)
498         {
499                 result = 0;
500
501                 for(current_edit = (Plugin*)first; !result && current_edit; ) {
502                         Plugin* next = (Plugin*)current_edit->next;
503                         if(current_edit->length == 0) {
504                                 delete current_edit;
505                                 result = 1;
506                         }
507                         current_edit = next;
508                 }
509
510
511 // merge identical plugins with same keyframes
512                 for( current_edit = (Plugin*)first;
513                         !result && current_edit && current_edit->next; ) {
514                         Plugin *next_edit = (Plugin*)current_edit->next;
515
516 // plugins identical
517                         if(next_edit->identical(current_edit)) {
518                                 current_edit->length += next_edit->length;
519 // Merge keyframes
520                                 for(KeyFrame *source = (KeyFrame*)next_edit->keyframes->first;
521                                         source;
522                                         source = (KeyFrame*)source->next) {
523                                         KeyFrame *dest = new KeyFrame(edl, current_edit->keyframes);
524                                         dest->copy_from(source);
525                                         current_edit->keyframes->append(dest);
526                                 }
527                                 remove(next_edit);
528                                 result = 1;
529                                 continue;
530                         }
531
532                         current_edit = next_edit;
533
534 // delete last edit if 0 length or silence
535                         if( last && (last->silence() || !last->length) ) {
536                                 delete last;
537                                 result = 1;
538                         }
539                 }
540         }
541
542         return 0;
543 }
544
545
546
547
548
549 void PluginSet::dump(FILE *fp)
550 {
551         fprintf(fp,"   PLUGIN_SET:\n");
552         for(Plugin *current = (Plugin*)first; current; current =  (Plugin*)NEXT)
553                 current->dump(fp);
554 }