Reported by Fedora team for gcc-13 and Andrew created patch here
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / virtualnode.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  * Copyright (C) 2003-2016 Cinelerra CV contributors
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  */
22
23 #include "attachmentpoint.h"
24 #include "auto.h"
25 #include "automation.h"
26 #include "autos.h"
27 #include "bcsignals.h"
28 #include "floatauto.h"
29 #include "floatautos.h"
30 #include "intauto.h"
31 #include "intautos.h"
32 #include "mainerror.h"
33 #include "mwindow.h"
34 #include "module.h"
35 #include "panauto.h"
36 #include "panautos.h"
37 #include "patchbay.h"
38 #include "plugin.h"
39 #include "pluginserver.h"
40 #include "renderengine.h"
41 #include "tracks.h"
42 #include "transition.h"
43 #include "transportque.h"
44 #include "virtualconsole.h"
45 #include "virtualnode.h"
46
47 VirtualNode::VirtualNode(RenderEngine *renderengine,
48                 VirtualConsole *vconsole,
49                 Module *real_module,
50                 Plugin *real_plugin,
51                 Track *track,
52                 VirtualNode *parent_node)
53 {
54         this->renderengine = renderengine;
55         this->vconsole = vconsole;
56         this->real_module = real_module;
57         this->real_plugin = real_plugin;
58         this->track = track;
59         this->parent_node = parent_node;
60
61
62         render_count = 0;
63         plugin_type = 0;
64         waiting_real_plugin = 0;
65         plugin_buffer_number = 0;
66         plugin_autos = 0;
67         plugin_auto_before = plugin_auto_after = 0;
68         attachment = 0;
69         is_exit = 0;
70 //printf("VirtualNode::VirtualNode 1\n");
71 }
72
73 VirtualNode::~VirtualNode()
74 {
75         subnodes.remove_all_objects();
76 //printf("VirtualNode::VirtualNode 2\n");
77 }
78
79 #define PRINT_INDENT for(int j = 0; j < indent; j++) printf(" ");
80
81 void VirtualNode::dump(int indent)
82 {
83         PRINT_INDENT
84         printf("VirtualNode %p title=%s real_module=%p %s\n",
85                 this,
86                 track->title,
87                 real_module,
88                 is_exit ? "*" : " ");
89         if(real_module)
90         {
91                 PRINT_INDENT
92                 printf(" Plugins total=%d\n", subnodes.total);
93                 for(int i = 0; i < subnodes.total; i++)
94                 {
95                         subnodes.values[i]->dump(indent + 2);
96                 }
97         }
98         else
99         if(real_plugin)
100         {
101                 printf("    Plugin %s\n", real_plugin->title);
102         }
103 }
104
105 int VirtualNode::expand(int persistent_plugins, int64_t current_position)
106 {
107         const int debug = 0;
108
109
110
111 // TODO: need to use speed curve to determine chain for current position
112
113
114 // module needs to know where the input data for the next process is
115 if(debug) printf("VirtualNode::expand %d real_module=%p real_plugin=%p\n",
116 __LINE__,
117 real_module,
118 real_plugin);
119         if(real_module)
120         {
121 if(debug) printf("VirtualNode::expand %d\n", __LINE__);
122                 expand_as_module(persistent_plugins, current_position);
123         }
124         else
125         if(real_plugin)
126         {
127 // attach to a real plugin for a plugin
128 // plugin always takes data from input to output
129 if(debug) printf("VirtualNode::expand %d\n", __LINE__);
130                 expand_as_plugin(persistent_plugins);
131         }
132
133         return 0;
134 }
135
136 int VirtualNode::expand_as_module(int duplicate, int64_t current_position)
137 {
138 // create the plugins for this module
139         for(int i = 0; i < track->plugin_set.total; i++)
140         {
141                 Plugin *plugin = track->get_current_plugin(current_position,
142                         i,
143                         renderengine->command->get_direction(),
144                         0,
145                         1);
146
147 //printf("VirtualNode::expand_as_module %d plugin=%p\n", __LINE__, plugin);
148                 int circular_reference = 0;
149 // Switch off if circular reference.  This happens if a plugin set or a track is deleted.
150                 if(plugin == real_plugin) circular_reference = 1;
151
152 // Switch off consecutive references to the same plugin
153                 if(plugin &&
154                         (plugin->plugin_type == PLUGIN_SHAREDPLUGIN ||
155                         plugin->plugin_type == PLUGIN_SHAREDMODULE))
156                 {
157                         int real_module_number = plugin->shared_location.module;
158                         int real_plugin_number = plugin->shared_location.plugin;
159
160                         for(int j = i - 1; j >= 0; j--)
161                         {
162                                 Plugin *prev_plugin = track->get_current_plugin(current_position,
163                                         j,
164                                         renderengine->command->get_direction(),
165                                         0,
166                                         1);
167                                 if(prev_plugin &&
168                                         prev_plugin->plugin_type == PLUGIN_SHAREDPLUGIN &&
169                                         plugin->plugin_type == PLUGIN_SHAREDPLUGIN)
170                                 {
171                                         int prev_module_number = prev_plugin->shared_location.module;
172                                         int prev_plugin_number = prev_plugin->shared_location.plugin;
173                                         if(real_module_number == prev_module_number &&
174                                                 real_plugin_number == prev_plugin_number)
175                                         {
176                                                 circular_reference = 1;
177                                                 break;
178                                         }
179                                 }
180                                 else
181                                 if(prev_plugin &&
182                                         prev_plugin->plugin_type == PLUGIN_SHAREDMODULE &&
183                                         plugin->plugin_type == PLUGIN_SHAREDMODULE)
184                                 {
185                                         int prev_module_number = prev_plugin->shared_location.module;
186                                         if(real_module_number == prev_module_number)
187                                         {
188                                                 circular_reference = 1;
189                                                 break;
190                                         }
191                                 }
192                         }
193                 }
194
195                 if(circular_reference) continue;
196
197                 if(plugin && plugin->on)
198                 {
199                         int plugin_type = plugin->plugin_type;
200                         if(plugin_type == PLUGIN_SHAREDMODULE)
201                         {
202 // plugin is a module
203                                 attach_virtual_module(plugin,
204                                         i,
205                                         duplicate,
206                                         current_position);
207                         }
208                         else
209                         if(plugin_type == PLUGIN_SHAREDPLUGIN ||
210                                 plugin_type == PLUGIN_STANDALONE)
211                         {
212 // plugin is a plugin
213                                 attach_virtual_plugin(plugin,
214                                         i,
215                                         duplicate,
216                                         current_position);
217                         }
218                 }
219         }
220
221
222         if(!parent_node) vconsole->append_exit_node(this);
223 //printf("VirtualNode::expand_as_module %d parent_node=%p\n", __LINE__, parent_node);
224
225         return 0;
226 }
227
228 int VirtualNode::expand_as_plugin(int duplicate)
229 {
230         plugin_type = real_plugin->plugin_type;
231
232         if(plugin_type == PLUGIN_SHAREDPLUGIN)
233         {
234 // Attached to a shared plugin.
235 // Get the real real plugin it's attached to.
236
237 // Redirect the real_plugin to the shared plugin.
238                 int real_module_number = real_plugin->shared_location.module;
239                 int real_plugin_number = real_plugin->shared_location.plugin;
240                 Module *real_module = vconsole->module_number(real_module_number);
241                 real_plugin = 0;
242 // module references are absolute so may get the wrong data type track.
243                 if(real_module)
244                 {
245                         attachment = real_module->get_attachment(real_plugin_number);
246 // Attachment is NULL if off
247                         if(attachment)
248                         {
249                                 real_plugin = attachment->plugin;
250
251 // Real plugin not on then null it.
252                                 if(!real_plugin || !real_plugin->on) real_plugin = 0;
253                         }
254                 }
255         }
256
257
258
259
260
261
262         if(plugin_type == PLUGIN_STANDALONE)
263         {
264 // Get plugin server
265                 Module *module = vconsole->module_of(track);
266
267                 attachment = module->attachment_of(real_plugin);
268         }
269
270
271
272
273
274 // Add to real plugin's list of virtual plugins for configuration updates
275 // and plugin_server initializations.
276 // Input and output are taken care of when the parent module creates this plugin.
277 // Get number for passing to render.
278 // real_plugin may become NULL after shared plugin test.
279         if(real_plugin && attachment)
280         {
281                 if(attachment)
282                         plugin_buffer_number = attachment->attach_virtual_plugin(this);
283         }
284
285
286
287
288         return 0;
289 }
290
291 int VirtualNode::check_circular(Track *track)
292 {
293         if( real_module && real_module->track == track ) return 1;
294         return !parent_node ? 0 : parent_node->check_circular(track);
295 }
296
297 int VirtualNode::attach_virtual_module(Plugin *plugin, int plugin_set_no,
298                 int duplicate, int64_t current_position)
299 {
300         if( plugin->on ) {
301                 int shared_track_no = plugin->shared_location.module;
302                 Module *real_module = vconsole->module_number(shared_track_no);
303 // If a track is deleted real_module is not found
304                 if( !real_module ) return 1;
305                 Track *real_track = real_module->track;
306 // Switch off if circular reference.  This happens if a track is deleted.
307                 if( check_circular(real_track) ) {
308                         int plugin_track_no = plugin->track->get_item_number();
309                         eprintf("circular references, track %d, plugin_set %d, plugin %d\n",
310                                 plugin_track_no, plugin_set_no, plugin->get_item_number());
311                         return 1;
312                 }
313                 VirtualNode *virtual_module = create_module(plugin, real_module, real_track);
314
315                 subnodes.append(virtual_module);
316                 virtual_module->expand(duplicate, current_position);
317         }
318
319         return 0;
320 }
321
322 int VirtualNode::attach_virtual_plugin(Plugin *plugin,
323         int plugin_number,
324         int duplicate,
325         int64_t current_position)
326 {
327 // Get real plugin and test if it is on.
328         int is_on = 1;
329         if(plugin->plugin_type == PLUGIN_SHAREDPLUGIN)
330         {
331                 int real_module_number = plugin->shared_location.module;
332                 int real_plugin_number = plugin->shared_location.plugin;
333                 Module *real_module = vconsole->module_number(real_module_number);
334                 if(real_module)
335                 {
336                         AttachmentPoint *attachment = real_module->get_attachment(real_plugin_number);
337                         if(attachment)
338                         {
339                                 Plugin *real_plugin = attachment->plugin;
340                                 if(!real_plugin || !real_plugin->on)
341                                         is_on = 0;
342                         }
343                         else
344                                 is_on = 0;
345                 }
346                 else
347                         is_on = 0;
348         }
349
350         if(is_on)
351         {
352                 VirtualNode *virtual_plugin = create_plugin(plugin);
353                 subnodes.append(virtual_plugin);
354                 virtual_plugin->expand(duplicate, current_position);
355         }
356         return 0;
357 }
358
359 VirtualNode* VirtualNode::get_previous_plugin(VirtualNode *current_node)
360 {
361         for(int i = 0; i < subnodes.total; i++)
362         {
363 // Assume plugin is on
364                 if(subnodes.values[i] == current_node)
365                 {
366                         if(i > 0)
367                                 return subnodes.values[i - 1];
368                         else
369                                 return 0;
370                 }
371         }
372         return 0;
373 }
374
375
376
377 void VirtualNode::get_mute_fragment(int64_t input_position,
378                                 int &mute_constant,
379                                 int &fragment_len,
380                                 Autos *autos,
381                                 int direction,
382                                 int use_nudge)
383 {
384         if(use_nudge) input_position += track->nudge;
385
386         Auto *prev_keyframe = 0;
387         Auto *next_keyframe = 0;
388         prev_keyframe = autos->get_prev_auto(input_position,
389                 direction, prev_keyframe);
390         next_keyframe = autos->get_next_auto(input_position,
391                 direction, next_keyframe);
392         IntAuto *prev_int_auto = (IntAuto *)prev_keyframe;
393         IntAuto *next_int_auto = (IntAuto *)next_keyframe;
394
395         if(direction == PLAY_FORWARD)
396         {
397 // Two distinct keyframes within range
398                 if(next_int_auto->position > prev_int_auto->position)
399                 {
400                         mute_constant = prev_int_auto->value;
401
402                         if(next_int_auto->position < input_position + fragment_len)
403                                 fragment_len = next_int_auto->position - input_position;
404                 }
405                 else
406 // One keyframe within range
407                 {
408                         mute_constant = prev_int_auto->value;
409                 }
410         }
411         else
412         {
413 // Two distinct keyframes within range
414                 if(next_int_auto->position < prev_int_auto->position)
415                 {
416                         mute_constant = next_int_auto->value;
417
418                         if(next_int_auto->position > input_position - fragment_len)
419                                 fragment_len = input_position - next_int_auto->position;
420                 }
421                 else
422 // One keyframe within range
423                 {
424                         mute_constant = next_int_auto->value;
425                 }
426         }
427 }
428
429
430
431
432
433