d01f9ddb1299ec93dda1c127704148b9a6242e3c
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / mwindow.h
1 /*
2  * CINELERRA
3  * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
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, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  */
20
21 #ifndef MWINDOW_H
22 #define MWINDOW_H
23
24 #include <stdio.h>
25 #include <stdint.h>
26
27 #include "apatchgui.h"
28 #include "arraylist.h"
29 #include "asset.inc"
30 #include "assets.inc"
31 #include "audiodevice.inc"
32 #include "autos.inc"
33 #include "awindow.inc"
34 #include "batchrender.inc"
35 #include "bcwindowbase.inc"
36 #include "bdcreate.inc"
37 #include "brender.inc"
38 #include "cache.inc"
39 #include "channel.inc"
40 #include "channeldb.inc"
41 #include "commercials.inc"
42 #include "convert.inc"
43 #include "cwindow.inc"
44 #include "bchash.inc"
45 #include "devicedvbinput.inc"
46 #include "devicempeginput.inc"
47 #include "dvdcreate.inc"
48 #include "edit.inc"
49 #include "edl.inc"
50 #include "edlsession.inc"
51 #include "exportedl.inc"
52 #include "filesystem.inc"
53 #include "filexml.inc"
54 #include "framecache.inc"
55 #include "gwindow.inc"
56 #include "indexable.inc"
57 #include "keyframegui.inc"
58 #include "levelwindow.inc"
59 #include "loadmode.inc"
60 #include "mainerror.inc"
61 #include "mainindexes.inc"
62 #include "mainprogress.inc"
63 #include "mainsession.inc"
64 #include "mainundo.inc"
65 #include "maxchannels.h"
66 #include "mixersalign.inc"
67 #include "mutex.inc"
68 #include "mwindow.inc"
69 #include "mwindowgui.inc"
70 #include "new.inc"
71 #include "patchbay.inc"
72 #include "playback3d.inc"
73 #include "playbackengine.inc"
74 #include "plugin.inc"
75 #include "pluginclient.inc"
76 #include "pluginfclient.inc"
77 #include "pluginserver.inc"
78 #include "pluginset.inc"
79 #include "preferences.inc"
80 #include "preferencesthread.inc"
81 #include "proxy.inc"
82 #include "record.inc"
83 #include "recordlabel.inc"
84 #include "render.inc"
85 #include "sharedlocation.inc"
86 #include "sighandler.inc"
87 #include "splashgui.inc"
88 #include "shuttle.inc"
89 #include "theme.inc"
90 #include "thread.h"
91 #include "threadloader.inc"
92 #include "timebar.inc"
93 #include "tipwindow.inc"
94 #include "track.inc"
95 #include "tracking.inc"
96 #include "tracks.inc"
97 #include "transition.inc"
98 #include "transportque.inc"
99 #include "videowindow.inc"
100 #include "vpatchgui.h"
101 #include "vwindow.inc"
102 #include "zwindow.inc"
103 #include "wwindow.inc"
104 #include "wavecache.inc"
105 #include "wintv.inc"
106 #include "x10tv.inc"
107
108 #define FONT_SEARCHPATH "fonts"
109
110 class StackItem
111 {
112 public:
113         EDL *edl, *new_edl;
114         Indexable *idxbl;
115         Edit *edit;
116         MainUndo *undo;
117         int64_t mtime;
118         double duration;
119 };
120
121 class Stack : public ArrayList<StackItem>
122 {
123 public:
124 };
125
126
127 #define BEEP_SAMPLE_RATE 48000
128
129 class Beeper : public Thread
130 {
131 public:
132         typedef int16_t audio_data_t;
133         Beeper(MWindow *mwindow);
134         ~Beeper();
135
136         void run();
137         void start();
138         void stop(int wait);
139         void tone(double freq, double secs, double gain);
140
141         MWindow *mwindow;
142         double freq, secs, gain;
143         AudioDevice *audio;
144         int playing_audio, interrupted;
145         int audio_pos;
146 };
147
148
149 class DrawTrackMovement : public Thread
150 {
151 public:
152         DrawTrackMovement(MWindow *mwindow);
153         ~DrawTrackMovement();
154         void run();
155
156         MWindow *mwindow;
157 };
158
159
160 class MWindow : public Thread
161 {
162 public:
163         MWindow();
164         ~MWindow();
165
166 // ======================================== initialization commands
167         void create_objects(int want_gui,
168                 int want_new,
169                 char *config_path);
170         int uses_opengl();
171         void show_splash();
172         void hide_splash();
173         void start();
174         void run();
175
176         int run_script(FileXML *script);
177         int new_project();
178         int delete_project(int flash = 1);
179         void quit();
180         int restart() { return restart_status; }
181
182         int load_defaults();
183         int save_defaults();
184         int set_filename(const char *filename);
185         int set_titlebar(const char *filename);
186 // Total vertical pixels in timeline
187         int get_tracks_height();
188 // Total horizontal pixels in timeline
189         int get_tracks_width();
190 // session stack
191         void stack_push(EDL *edl, Indexable *idxbl, Edit *edit=0);
192         void stack_pop();
193         int save(EDL *edl, char *filename, int stat);
194         int save(int save_as);
195         void show_plugins();
196         void clip_to_media();
197         void media_to_clip();
198         int create_ref(Asset *asset, EDL *ref);
199 // Show windows
200         void show_vwindow();
201         void show_awindow();
202         void show_lwindow();
203         void show_cwindow();
204         void show_gwindow();
205         void hide_gwindow();
206         void restore_windows();
207         void load_layout(const char *layout);
208         void save_layout(const char *layout);
209         void delete_layout(const char *layout);
210         int tile_windows(int window_config);
211         char *get_cwindow_display();
212         void set_screens(int value);
213         int asset_to_edl(EDL *new_edl,
214                 Asset *new_asset,
215                 RecordLabels *labels = 0);
216
217 // Entry point to insert assets and insert edls.  Called by TrackCanvas
218 // and AssetPopup when assets are dragged in from AWindow.
219 // Takes the drag vectors from MainSession and
220 // pastes either assets or clips depending on which is full.
221 // Returns 1 if the vectors were full
222         int paste_assets(double position, Track *dest_track, int overwrite);
223
224 // Insert the assets at a point in the EDL.  Called by menueffects,
225 // render, and CWindow drop but recording calls paste_edls directly for
226 // labels.
227         void load_assets(ArrayList<Indexable*> *new_assets,
228                 double position,
229                 int load_mode,
230                 Track *first_track /* = 0 */,
231                 RecordLabels *labels /* = 0 */,
232                 int edit_labels,
233                 int edit_plugins,
234                 int edit_autos,
235                 int overwrite);
236         int paste_edls(ArrayList<EDL*> *new_edls,
237                 int load_mode,
238                 Track *first_track /* = 0 */,
239                 double current_position /* = -1 */,
240                 int edit_labels,
241                 int edit_plugins,
242                 int edit_autos,
243                 int overwrite);
244         void collect_effects();
245         void paste_effects();
246
247 // Reset everything for a load
248         void update_project(int load_mode);
249         void update_preferences(Preferences *prefs);
250         void update_vwindow();
251 // Fit selected time to horizontal display range
252         void fit_selection();
253 // Fit selected autos to the vertical display range
254         void fit_autos(int all);
255         void change_currentautorange(int autogrouptype, int increment, int changemax);
256         void expand_autos(int changeall, int domin, int domax);
257         void shrink_autos(int changeall, int domin, int domax);
258 // move the window to include the cursor
259         void find_cursor();
260 // Search plugindb and put results in argument
261         static void search_plugindb(int do_audio,
262                 int do_video,
263                 int is_realtime,
264                 int is_transition,
265                 int is_theme,
266                 ArrayList<PluginServer*> &results);
267 // Find the plugin whose title matches title and return it
268         static PluginServer* scan_plugindb(char *title,
269                 int data_type);
270         static void fix_plugin_title(char *title);
271         static int plugin_exists(const char *plugin_path, ArrayList<PluginServer*> &plugins);
272         static int plugin_exists(char *plugin_path);
273         void dump_plugindb(FILE *fp);
274         void stop_playback(int wait);
275         void stop_transport();
276         void undo_before(const char *description = "", void *creator = 0);
277         void undo_after(const char *description, uint32_t load_flags, int changes_made = 1);
278
279         void handle_mixers(EDL *edl, int command, int wait_tracking,
280                 int use_inout, int toggle_audio, int loop_play, float speed);
281         ZWindow *create_mixer(Indexable *indexable, double position);
282         void create_mixers(double position = 0);
283         void refresh_mixers(int dir=1);
284         void stop_mixers();
285         void close_mixers(int result=1);
286         void open_mixers();
287         ZWindow *get_mixer(Mixer *&mixer);
288         ZWindow *get_mixer(int idx);
289         void close_mixer(ZWindow *zwindow);
290         int mixer_track_active(Track *track);
291         void update_mixer_tracks();
292         void start_mixer();
293         int select_zwindow(ZWindow *zwindow);
294         void tile_mixers();
295         void set_gang_tracks(int v);
296         int load_filenames(ArrayList<char*> *filenames,
297                 int load_mode = LOADMODE_REPLACE,
298                 int edl_mode = LOADMODE_EDL_CLIP,
299 // Cause the project filename on the top of the window to be updated.
300 // Not wanted for loading backups.
301                 int update_filename = 1);
302
303 // Print out plugins which are referenced in the EDL but not loaded.
304         void test_plugins(EDL *new_edl, const char *path);
305
306         int interrupt_indexes();  // Stop index building
307
308         int redraw_time_dependancies();     // after reconfiguring the time format, sample rate, frame rate
309         void draw_trackmovement();          // after reconfiguring tracks/patchbay guis
310         DrawTrackMovement *redraw_tracks;
311
312 // =========================================== movement
313
314         void next_time_format();
315         void prev_time_format();
316         void time_format_common();
317         int reposition_timebar(int new_pixel, int new_height);
318         int expand_sample();
319         int zoom_in_sample();
320         int zoom_sample(int64_t zoom_sample);
321         void zoom_autos(float min, float max);
322         void zoom_amp(int64_t zoom_amp);
323         void zoom_atrack(int64_t zoom);
324         void zoom_vtrack(int64_t zoom);
325         int fit_sample();
326         int move_left(int64_t distance = 0);
327         int move_right(int64_t distance = 0);
328         void move_up(int64_t distance = 0);
329         void move_down(int64_t distance = 0);
330         int find_selection(double position, int scroll_display = 0);
331         void toggle_camera_xyz();
332         void toggle_projector_xyz();
333         double get_position();
334         void set_position(double position);
335
336 // seek to labels
337 // shift_down must be passed by the caller because different windows call
338 // into this
339         int next_label(int shift_down);
340         int prev_label(int shift_down);
341 // seek to edit handles
342         int next_edit_handle(int shift_down);
343         int prev_edit_handle(int shift_down);
344 // seek to keyframes
345         int nearest_plugin_keyframe(int shift_down, int dir);
346         int nearest_auto_keyframe(int shift_down, int dir);
347 // offset is pixels to add to track_start
348         void trackmovement(int offset, int pane_number);
349 // view_start is pixels
350         int samplemovement(int64_t view_start, int pane_number);
351         void select_all();
352         int goto_start();
353         int goto_end();
354         int goto_position(double position);
355         int expand_y();
356         int zoom_in_y();
357         int expand_t();
358         int zoom_in_t();
359         void split_x();
360         void split_y();
361         void crop_video(int mode);
362         void update_plugins();
363         void get_backup_path(char *path, int len);
364 // Call after every edit operation
365         void save_backup();
366         void load_backup();
367         void show_plugin(Plugin *plugin);
368         void hide_plugin(Plugin *plugin, int lock);
369         void hide_plugin(int plugin_id, int lock);
370         void hide_plugins();
371         void delete_plugin(PluginServer *plugin);
372 // Update plugins with configuration changes.
373 // Called by TrackCanvas::cursor_motion_event.
374         void update_plugin_guis(int do_keyframe_guis = 1);
375         void update_plugin_states();
376         void update_plugin_titles();
377 // Called by Attachmentpoint during playback.
378 // Searches for matching plugin and renders data in it.
379         void render_plugin_gui(void *data, Plugin *plugin);
380         void render_plugin_gui(void *data, int size, Plugin *plugin);
381         void reset_plugin_gui_frames(Plugin *plugin);
382         void render_plugin_gui_frames(PluginClientFrames *frames, Plugin *plugin);
383         double get_tracking_position();
384         int get_tracking_direction();
385
386 // Called from PluginVClient::process_buffer
387 // Returns 1 if a GUI for the plugin is open so OpenGL routines can determine if
388 // they can run.
389         int plugin_gui_open(Plugin *plugin);
390         void stop_plugin_guis();
391
392         void show_keyframe_gui(Plugin *plugin);
393         void hide_keyframe_guis();
394         void hide_keyframe_gui(Plugin *plugin);
395         void update_keyframe_guis();
396         int get_hash_color(Edit *edit);
397         int get_hash_color(int v);
398         int get_group_color(int v);
399         int get_title_color(Edit *edit);
400
401 // ============================= editing commands ========================
402
403 // Map each recordable audio track to the desired pattern
404         void map_audio(int pattern);
405         void remap_audio(int pattern);
406         enum
407         {
408                 AUDIO_5_1_TO_2,
409                 AUDIO_1_TO_1
410         };
411         void add_audio_track_entry(int above, Track *dst);
412         int add_audio_track(int above, Track *dst);
413         void add_clip_to_edl(EDL *edl);
414         void add_video_track_entry(Track *dst = 0);
415         int add_video_track(int above, Track *dst);
416         void add_subttl_track_entry(Track *dst = 0);
417         int add_subttl_track(int above, Track *dst);
418
419         void asset_to_all();
420         void asset_to_size();
421         void asset_to_rate();
422 // Entry point for clear operations.
423         void clear_entry();
424 // Clears active region in EDL.
425 // If clear_handle, edit boundaries are cleared if the range is 0.
426 // Called by paste, record, menueffects, render, and CWindow drop.
427         void clear(int clear_handle);
428         void clear_labels();
429         int clear_labels(double start, double end);
430         void clear_hard_edges();
431         int clear_hard_edges(double start, double end);
432         void clear_select();
433         void concatenate_tracks();
434         int copy_flags(int copy_flags=COPY_CLIPBOARD);
435         void copy();
436         int copy(double start, double end);
437         void cut();
438         void blade(double position);
439         void cut(double start, double end, double new_position=-1);
440 // cut edit from current position to handle/label
441         void cut_left_edit();
442         void cut_right_edit();
443         void cut_left_label();
444         void cut_right_label();
445
446 // Calculate aspect ratio from pixel counts
447         static int create_aspect_ratio(float &w, float &h, int width, int height);
448 // Calculate defaults path
449         static void create_defaults_path(char *string, const char *config_file);
450
451         void delete_track(Track *track);
452         void delete_tracks();
453         int feather_edits(int64_t feather_samples, int audio, int video);
454         int64_t get_feather(int audio, int video);
455         float get_aspect_ratio();
456         void insert(double position, FileXML *file,
457                 int edit_labels, int edit_plugins, int edit_autos,
458                 EDL *parent_edl, Track *first_track, int overwrite);
459
460 // TrackCanvas calls this to insert multiple effects from the drag_pluginservers
461 // into pluginset_highlighted.
462         void insert_effects_canvas(Track *dest_track, double start, double length);
463
464 // CWindow calls this to insert multiple effects from
465 // the drag_pluginservers array.
466         void insert_effects_cwindow(Track *dest_track);
467
468 // Attach new effect to all recordable tracks
469 // single_standalone - attach 1 standalone on the first track and share it with
470 // other tracks
471         void insert_effect(char *title,
472                 SharedLocation *shared_location,
473                 int data_type, int plugin_type, int single_standalone);
474
475 // This is called multiple times by the above functions.
476 // It can't sync parameters.
477         void insert_effect(char *title,
478                 SharedLocation *shared_location,
479                 Track *track, PluginSet *plugin_set,
480                 double start, double length, int plugin_type);
481
482         void match_output_size(Track *track);
483         void delete_edit(Edit *edit, const char *msg, int collapse=0);
484         void delete_edits(ArrayList<Edit*> *edits, const char *msg, int collapse=0);
485         void delete_edits(int collapse=0);
486         void cut_selected_edits(int collapse, int packed);
487 // Move edit to new position
488         void move_edits(ArrayList<Edit*> *edits, Track *track, double position,
489                 int mode); // mode: 0 - mute and overwrite,  1 - cut and paste
490         void selected_edits_to_clipboard(int packed);
491         void paste_clipboard(Track *first_track, double position, int overwrite,
492                 int edit_edits, int edit_labels, int edit_autos, int edit_plugins);
493         void move_group(EDL *group, Track *first_track, double position, int overwrite);
494 // Move effect to position
495         void move_effect(Plugin *plugin, Track *track, int64_t position);
496         void move_effect(Plugin *plugin, PluginSet *plugin_set, int64_t position);
497         void move_plugins_up(PluginSet *plugin_set);
498         void move_plugins_down(PluginSet *plugin_set);
499         void move_track_down(Track *track);
500         void move_tracks_down();
501         void move_track_up(Track *track);
502         void move_tracks_up();
503         void mute_selection();
504         void new_folder(const char *new_folder, int is_clips);
505         void delete_folder(char *folder);
506 // For clipboard commands
507         void paste();
508         void paste(double start, Track *first_track, int clear_selection, int overwrite);
509 // For splice and overwrite
510         void overwrite(EDL *source, int all);
511         void splice(EDL *source, int all);
512         int paste(double start, double end, FileXML *file,
513                 int edit_labels, int edit_plugins, int edit_autos,
514                 Track *first_track, int overwrite);
515         int paste_output(int64_t startproject, int64_t endproject,
516                 int64_t startsource_sample, int64_t endsource_sample,
517                 int64_t startsource_frame, int64_t endsource_frame,
518                 Asset *asset, RecordLabels *new_labels);
519         void paste_silence();
520
521 // Detach single transition
522         void detach_transition(Transition *transition);
523 // Detach all transitions in selection
524         void detach_transitions();
525 // Attach dragged transition
526         void paste_transition();
527 // Attach transition to all edits in selection
528         void paste_transitions(int track_type, char *title);
529 // Attach transition dragged onto CWindow
530         void paste_transition_cwindow(Track *dest_track);
531 // Attach default transition to single edit
532         void paste_audio_transition();
533         void paste_video_transition();
534         void shuffle_edits();
535         void reverse_edits();
536         void align_edits();
537         void set_edit_length(double length);
538 // Set length of single transition
539         void set_transition_length(Transition *transition, double length);
540 // Set length in seconds of all transitions in active range
541         void set_transition_length(double length);
542
543         void remove_indexfile(Indexable *indexable);
544         void rebuild_indices();
545 // Asset removal from caches
546         void reset_caches();
547         void remove_from_caches(Indexable *idxbl);
548         void remove_assets_from_project(int push_undo, int redraw, int delete_indexes,
549                 ArrayList<Indexable*> *drag_assets /* mwindow->session->drag_assets */,
550                 ArrayList<EDL*> *drag_clips /* mwindow->session->drag_clips */);
551         void remove_assets_from_disk();
552         void resize_track(Track *track, int w, int h);
553
554         void set_automation_mode(int mode);
555         void set_keyframe_type(int mode);
556         void set_auto_keyframes(int value);
557         void set_span_keyframes(int value);
558         void set_auto_visibility(Autos *autos, int value);
559         void set_labels_follow_edits(int value);
560
561 // Update the editing mode
562         int set_editing_mode(int new_editing_mode);
563         void toggle_editing_mode();
564         void set_inpoint();
565         void set_outpoint();
566         void unset_inoutpoint();
567         void toggle_loop_playback();
568         void trim_selection();
569 // Synchronize EDL settings with all playback engines depending on current
570 // operation.  Doesn't redraw anything.
571         void sync_parameters(int change_type = CHANGE_PARAMS);
572         void save_clip(EDL *new_edl, const char *txt);
573         void to_clip(EDL *edl, const char *txt, int all);
574         int toggle_label();
575         void undo_entry(BC_WindowBase *calling_window_gui);
576         void redo_entry(BC_WindowBase *calling_window_gui);
577         void save_undo_data();
578         void load_undo_data();
579         void remove_undo_data();
580         int copy_target(const char *path, const char *target);
581         int link_target(const char *real_path, const char *link_path, int relative);
582         void save_project(const char *dir, int save_mode, int overwrite, int reload);
583
584         int cut_automation();
585         int copy_automation();
586         int paste_automation();
587         void clear_automation();
588         int cut_default_keyframe();
589         int copy_default_keyframe();
590 // Use paste_automation to paste the default keyframe in other position.
591 // Use paste_default_keyframe to replace the default keyframe with whatever is
592 // in the clipboard.
593         int paste_default_keyframe();
594         int clear_default_keyframe();
595
596         FloatAuto* get_float_auto(PatchGUI *patch,int idx);
597         IntAuto* get_int_auto(PatchGUI *patch,int idx);
598         PanAuto* get_pan_auto(PatchGUI *patch);
599         PatchGUI *get_patchgui(Track *track);
600
601         int modify_edithandles();
602         int modify_pluginhandles();
603         void finish_modify_handles();
604         void rescale_proxy(EDL *clip, int orig_scale, int new_scale);
605         void add_proxy(ArrayList<Indexable*> *orig_assets,
606                         ArrayList<Indexable*> *proxy_assets);
607         int render_proxy(ArrayList<Indexable *> &new_idxbls);
608         void beep(double freq, double secs, double gain);
609         int enable_proxy();
610         int disable_proxy();
611         int to_proxy(Asset *asset, int new_scale, int new_use_scaler);
612         Beeper *beeper;
613
614         void dump_plugins(FILE *fp=stdout);
615         void dump_edl(FILE *fp=stdout);
616         void dump_undo(FILE *fp=stdout);
617         void dump_exe(FILE *fp=stdout);
618         void dump_caches(FILE *fp=stdout);
619         static void trap_hook(FILE *fp, void *vp);
620
621         void reset_android_remote();
622
623 // Send new EDL to caches
624         void age_caches();
625         int optimize_assets();            // delete unused assets from the cache and assets
626 // render edl assets to specified format, then replace in edl
627         void start_convert(Asset *format_asset, const char *suffix,
628                         float beep, int to_proxy, int remove_originals);
629         void finish_convert(int remove_originals);
630         ConvertRender *convert_render;
631
632         void select_point(double position);
633         int set_loop_boundaries();         // toggle loop playback and set boundaries for loop playback
634
635
636         Playback3D *playback_3d;
637         SplashGUI *splash_window;
638
639 // Main undo stack
640         MainUndo *undo;
641         int undo_command;
642 // session stack
643         Stack stack;
644
645         BC_Hash *defaults;
646         Assets *assets;
647 // CICaches for drawing timeline only
648         CICache *audio_cache, *video_cache;
649 // Frame cache for drawing timeline only.
650 // Cache drawing doesn't wait for file decoding.
651         FrameCache *frame_cache;
652         WaveCache *wave_cache;
653         Preferences *preferences;
654         PreferencesThread *preferences_thread;
655         MainSession *session;
656         Theme *theme;
657         MainIndexes *mainindexes;
658         MainProgress *mainprogress;
659         BRender *brender;
660         char cin_lang[4];
661         int brender_active;
662         const char *default_standard;
663         static Commercials *commercials;
664         int commercial_active;
665         int has_commercials();
666 // copy of edl created in speed_before, used in speed_after to normalize_speed
667         EDL *speed_edl;
668
669 // Menu items
670         ArrayList<ColormodelItem*> colormodels;
671         ArrayList<InterlacemodeItem*>          interlace_project_modes;
672         ArrayList<InterlacemodeItem*>          interlace_asset_modes;
673
674         int reset_meters();
675         void resync_guis();
676
677         int select_asset(Asset *asset, int vstream, int astream, int delete_tracks);
678         int select_asset(int vtrack, int delete_tracks);
679
680 // Channel DB for playback only.  Record channel DB's are in record.C
681         ChannelDB *channeldb_buz;
682         ChannelDB *channeldb_v4l2jpeg;
683
684 // ====================================== plugins ==============================
685
686 // Contains file descriptors for all the dlopens
687         static ArrayList<PluginServer*> *plugindb;
688 // Currently visible plugins
689         int64_t plugin_visibility;
690         PluginGUIs *plugin_guis;
691 // GUI Plugins to delete
692         ArrayList<PluginServer*> *dead_plugins;
693 // Keyframe editors
694         ArrayList<KeyFrameThread*> *keyframe_threads;
695
696 // Adjust sample position to line up with frames.
697         int fix_timing(int64_t &samples_out,
698                 int64_t &frames_out,
699                 int64_t samples_in);
700
701
702         CreateBD_Thread *create_bd;
703         CreateDVD_Thread *create_dvd;
704         BatchRenderThread *batch_render;
705         Render *render;
706
707         ExportEDL *exportedl;
708
709
710 // Master edl
711         EDL *edl;
712 // Main Window GUI
713         MWindowGUI *gui;
714 // Compositor
715         CWindow *cwindow;
716 // Viewer
717         Mutex *vwindows_lock;
718         ArrayList<VWindow*> vwindows;
719 // Mixer
720         Mutex *zwindows_lock;
721         ArrayList<ZWindow*> zwindows;
722         MixersAlign *mixers_align;
723
724 // Asset manager
725         AWindow *awindow;
726 // Automation window
727         GWindow *gwindow;
728 // Tip of the day
729         TipWindow *twindow;
730 // Warning window
731         WWindow *wwindow;
732         void show_warning(int *do_warning, const char *text);
733         int wait_warning();
734 // Levels
735         LevelWindow *lwindow;
736         Mutex *run_lock;
737 // Lock during creation and destruction of GUI
738         Mutex *plugin_gui_lock;
739         Mutex *dead_plugin_lock;
740         Mutex *keyframe_gui_lock;
741 // Lock during creation and destruction of brender so playback doesn't use it.
742         Mutex *brender_lock;
743 // Initialize shared memory
744         void init_shm(const char *pfn, int64_t min);
745 // Initialize channel DB's for playback
746         void init_channeldb();
747         void init_render();
748         void init_exportedl();
749 // These three happen synchronously with each other
750 // Make sure this is called after synchronizing EDL's.
751         void init_brender();
752 // Restart brender after testing its existence
753         void restart_brender();
754 // Stops brender after testing its existence
755         void stop_brender();
756 // This one happens asynchronously of the others.  Used by playback to
757 // see what frame is background rendered.
758         int brender_available(int position);
759         void set_brender_active(int v, int update=1);
760         int put_commercial();
761         void activate_commercial() { commercial_active = 1; }
762         void commit_commercial();
763         void undo_commercial();
764         void cut_commercials();
765         void update_gui(int changed_edl);
766         int paste_subtitle_text(char *text, double start, double end);
767
768         void init_error();
769         void finit_error();
770         static void init_defaults(BC_Hash* &defaults, char *config_path);
771         void check_language();
772         const char *default_std();
773         void fill_preset_defaults(const char *preset, EDLSession *session);
774         const char *get_preset_name(int index);
775         void init_edl();
776         void init_awindow();
777         void init_gwindow();
778         void init_tipwindow();
779 // Used by MWindow and RenderFarmClient
780         static void get_plugin_path(char *path, const char *plug_dir, const char *fs_path);
781         static int init_plugins(MWindow *mwindow, Preferences *preferences);
782         static int init_ladspa_plugins(MWindow *mwindow, Preferences *preferences);
783         static void init_plugin_tips(ArrayList<PluginServer*> &plugins, const char *lang);
784         static int check_plugin_index(ArrayList<PluginServer*> &plugins,
785                 const char *plug_dir, const char *plug_path);
786         static void init_plugin_index(MWindow *mwindow, Preferences *preferences,
787                 FILE *fp, const char *plugin_dir);
788         static int init_ladspa_index(MWindow *mwindow, Preferences *preferences,
789                 FILE *fp, const char *plugin_dir);
790         static void scan_plugin_index(MWindow *mwindow, Preferences *preferences,
791                 FILE *fp, const char *plug_dir, const char *plug_path, int &idx);
792         static void init_ffmpeg();
793         static void init_ffmpeg_index(MWindow *mwindow, Preferences *preferences, FILE *fp);
794         static int load_plugin_index(MWindow *mwindow, FILE *fp, const char *plugin_dir);
795         static PluginServer *new_ffmpeg_server(MWindow *mwindow, const char *name);
796         static int init_lv2_index(MWindow *mwindow, Preferences *preferences, FILE *fp);
797         static PluginServer *new_lv2_server(MWindow *mwindow, const char *name);
798         static void remove_plugin_index();
799
800         void init_preferences();
801         void init_signals();
802         void init_shuttle();
803         void init_wintv();
804         void init_x10tv();
805         void init_theme();
806         void init_compositor();
807         void init_levelwindow();
808 // Called when creating a new viewer to view footage
809         VWindow* get_viewer(int start_it, int idx=-1);
810         void init_cache();
811         void init_menus();
812         void init_indexes();
813         void init_gui();
814         void init_3d();
815         void init_playbackcursor();
816         void init_commercials();
817         static void add_plugins(ArrayList<PluginServer*> &plugins);
818         static void delete_plugins();
819         void speed_before();
820         int speed_after(int done);
821         int normalize_speed(EDL *old_edl, EDL *new_edl);
822         int get_cpus(int out_w, int out_h);
823         int get_cpus();
824 //
825         void clean_indexes();
826 //      TimeBomb timebomb;
827         SigHandler *sighandler;
828         int restart_status;
829         int screens;
830         int in_destructor;
831         Shuttle *shuttle;
832         WinTV *wintv;
833         X10TV *x10tv;
834 };
835
836 #endif