add missing GPL information in guicast program files
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / mixersalign.h
1 /*
2  * CINELERRA
3  * Copyright (C) 2008-2015 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 __MIXERSALIGN_H__
22 #define __MIXERSALIGN_H__
23
24 #include "edl.h"
25 #include "edit.inc"
26 #include "fourier.h"
27 #include "guicast.h"
28 #include "language.h"
29 #include "loadbalance.h"
30 #include "mainprogress.inc"
31 #include "mixersalign.inc"
32 #include "mwindow.inc"
33 #include "renderengine.h"
34 #include "samples.inc"
35 #include "track.inc"
36 #include "zwindow.inc"
37
38 class MixersAlignMixer
39 {
40 public:
41         MixersAlignMixer(Mixer *mix);
42         ~MixersAlignMixer();
43         Mixer *mixer;
44         double nudge;
45         double mx;
46         int64_t mi;
47         double *br, *bi;
48         int aidx;
49 };
50
51 class MixersAlignMixers : public ArrayList<MixersAlignMixer*>
52 {
53 public:
54         MixersAlignMixers() {}
55         ~MixersAlignMixers() { clear(); }
56         void clear() { remove_all_objects(); }
57 };
58
59 class MixersAlignMixerList : public BC_ListBox
60 {
61         enum { MIX_MIXER, MIX_NUDGE, MIX_SZ };
62         static const char *mix_titles[MIX_SZ];
63         static int mix_widths[MIX_SZ];
64 public:
65         MixersAlignMixerList(MixersAlignWindow *gui,
66                 MixersAlign *dialog, int x, int y, int w, int h);
67         ~MixersAlignMixerList();
68
69         void clear();
70
71         void add_mixer(MixersAlignMixer *mixer);
72         void load_list();
73         void update();
74         int selection_changed();
75
76         MixersAlignWindow *gui;
77         MixersAlign *dialog;
78         MixersAlignMixers mixers;
79
80         const char *col_titles[MIX_SZ];
81         int col_widths[MIX_SZ];
82         ArrayList<BC_ListBoxItem*> cols[MIX_SZ];
83
84         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
85         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
86         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
87 };
88
89
90 class MixersAlignMTrack
91 {
92 public:
93         MixersAlignMTrack(Track *trk, int no);
94
95         Track *track;
96         int no;
97 };
98
99 class MixersAlignMTracks : public ArrayList<MixersAlignMTrack*>
100 {
101 public:
102         MixersAlignMTracks() {}
103         ~MixersAlignMTracks() { clear(); }
104         void clear() { remove_all_objects(); }
105 };
106
107
108 class MixersAlignMTrackList : public BC_ListBox
109 {
110         enum { MTK_NO, MTK_MIXER, MTK_TRACK, MTK_SZ };
111         static const char *mtk_titles[MTK_SZ];
112         static int mtk_widths[MTK_SZ];
113 public:
114         MixersAlignMTrackList(MixersAlignWindow *gui,
115                 MixersAlign *dialog, int x, int y, int w, int h);
116         ~MixersAlignMTrackList();
117
118         void clear();
119         void add_mtrack(MixersAlignMTrack *mtrk);
120         void load_list();
121         void update();
122
123         MixersAlignWindow *gui;
124         MixersAlign *dialog;
125
126         ArrayList<BC_ListBoxItem*> cols[MTK_SZ];
127         const char *col_titles[MTK_SZ];
128         int col_widths[MTK_SZ];
129
130         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
131         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
132         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
133 };
134
135
136 class MixersAlignATrack
137 {
138 public:
139         MixersAlignATrack(Track *trk, int no);
140         ~MixersAlignATrack();
141
142         Track *track;
143         int no;
144         double nudge;
145         double ss;
146         double mx;
147         int64_t mi;
148 };
149
150 class MixersAlignATracks : public ArrayList<MixersAlignATrack*>
151 {
152 public:
153         MixersAlignATracks() {}
154         ~MixersAlignATracks() { clear(); }
155         void clear() { remove_all_objects(); }
156 };
157
158 class MixersAlignATrackList : public BC_ListBox
159 {
160         enum { ATK_TRACK, ATK_AUDIO, ATK_NUDGE, ATK_MX, ATK_MI, ATK_SZ };
161         static const char *atk_titles[ATK_SZ];
162         static int atk_widths[ATK_SZ];
163 public:
164         MixersAlignATrackList(MixersAlignWindow *gui,
165                 MixersAlign *dialog, int x, int y, int w, int h);
166         ~MixersAlignATrackList();
167
168         void clear();
169         void add_atrack(MixersAlignATrack *track);
170         void load_list();
171         void update();
172         int selection_changed();
173
174         MixersAlignWindow *gui;
175         MixersAlign *dialog;
176
177         ArrayList<BC_ListBoxItem*> cols[ATK_SZ];
178         const char *col_titles[ATK_SZ];
179         int col_widths[ATK_SZ];
180
181         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
182         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
183         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
184 };
185
186 class MixersAlignReset : public BC_GenericButton
187 {
188 public:
189         MixersAlignReset(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
190         int handle_event();
191         static int calculate_width(BC_WindowBase *gui);
192
193         MixersAlign *dialog;
194         MixersAlignWindow *gui;
195 };
196
197 class MixersAlignThread : public Thread
198 {
199 public:
200         MixersAlignThread(MixersAlign *dialog);
201         ~MixersAlignThread();
202         void start(int fwd);
203         void run();
204
205         MixersAlign *dialog;
206         int fwd;
207 };
208
209 class MixersAlignMatch : public BC_GenericButton
210 {
211 public:
212         MixersAlignMatch(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
213         int handle_event();
214
215         MixersAlign *dialog;
216         MixersAlignWindow *gui;
217 };
218
219 class MixersAlignMatchAll : public BC_GenericButton
220 {
221 public:
222         MixersAlignMatchAll(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
223         int handle_event();
224
225         MixersAlign *dialog;
226         MixersAlignWindow *gui;
227 };
228
229 class MixersAlignNudgeTracks : public BC_GenericButton
230 {
231 public:
232         MixersAlignNudgeTracks(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
233         int handle_event();
234         static int calculate_width(BC_WindowBase *gui);
235
236         MixersAlign *dialog;
237         MixersAlignWindow *gui;
238 };
239
240 class MixersAlignNudgeSelected : public BC_GenericButton
241 {
242 public:
243         MixersAlignNudgeSelected(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
244         int handle_event();
245         static int calculate_width(BC_WindowBase *gui);
246
247         MixersAlign *dialog;
248         MixersAlignWindow *gui;
249 };
250
251 class MixersAlignCheckPoint : public BC_GenericButton
252 {
253 public:
254         MixersAlignCheckPoint(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
255         int handle_event();
256
257         MixersAlign *dialog;
258         MixersAlignWindow *gui;
259 };
260
261 class MixersAlignUndoEDLs : public ArrayList<EDL *>
262 {
263 public:
264         MixersAlignUndoEDLs() {}
265         ~MixersAlignUndoEDLs() { clear(); }
266         void clear() {
267                 for( int i=size(); --i>=0; ) get(i)->remove_user();
268                 remove_all();
269         }
270 };
271
272 class MixersAlignUndoItem : public BC_MenuItem
273 {
274 public:
275         MixersAlignUndoItem(const char *text, int no);
276         ~MixersAlignUndoItem();
277         int handle_event();
278
279         int no;
280 };
281
282 class MixersAlignUndo : public BC_PopupMenu
283 {
284 public:
285         MixersAlignUndo(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
286         ~MixersAlignUndo();
287         void create_objects();
288         void add_undo_item(int no);
289
290         MixersAlign *dialog;
291         MixersAlignWindow *gui;
292 };
293
294
295 class MixersAlignWindow : public BC_Window
296 {
297 public:
298         MixersAlignWindow(MixersAlign *dialog, int x, int y);
299         ~MixersAlignWindow();
300
301         void create_objects();
302         int resize_event(int w, int h);
303         void load_lists();
304         void default_selection();
305         void update_gui();
306
307         MixersAlign *dialog;
308         BC_Title *mixer_title, *mtrack_title, *atrack_title;
309
310         MixersAlignMixerList *mixer_list;
311         MixersAlignMTrackList *mtrack_list;
312         MixersAlignATrackList *atrack_list;
313         MixersAlignMatch *match;
314         MixersAlignMatchAll *match_all;
315         MixersAlignReset *reset;
316         MixersAlignNudgeTracks *nudge_tracks;
317         MixersAlignNudgeSelected *nudge_selected;
318         MixersAlignCheckPoint *check_point;
319         MixersAlignUndo *undo;
320 };
321
322
323 class MixersAlignARender : public RenderEngine
324 {
325 public:
326         MixersAlignARender(MWindow *mwindow, EDL *edl);
327         ~MixersAlignARender();
328
329         int render(Samples **samples, int64_t len, int64_t pos);
330 };
331
332
333 class MixersAlignScanPackage : public LoadPackage
334 {
335 public:
336         MixersAlignScanPackage(MixersAlignScanFarm *farm);
337         ~MixersAlignScanPackage();
338
339         MixersAlignMixer *mixer;
340 };
341
342 class MixersAlignScanClient : public LoadClient
343 {
344 public:
345         MixersAlignScanClient(MixersAlignScanFarm *farm);
346         ~MixersAlignScanClient();
347         void process_package(LoadPackage *package);
348
349         MixersAlignScanFarm *farm;
350         MixersAlignScanPackage *pkg;
351         int64_t pos;
352         int len1;
353 };
354
355 class MixersAlignScanFarm : public LoadServer
356 {
357 public:
358         MixersAlignScanFarm(MixersAlign *dialog, int cpus, int n);
359         ~MixersAlignScanFarm();
360         void init_packages();
361         LoadClient *new_client();
362         LoadPackage *new_package();
363
364         MixersAlign *dialog;
365         Samples *samples;
366         int len;
367 };
368
369
370 class MixersAlignMatchFwdPackage : public LoadPackage
371 {
372 public:
373         MixersAlignMatchFwdPackage();
374         ~MixersAlignMatchFwdPackage();
375
376         MixersAlignMixer *mixer;
377 };
378
379 class MixersAlignMatchFwdClient : public LoadClient
380 {
381 public:
382         MixersAlignMatchFwdClient(MixersAlignMatchFwdFarm *farm);
383         ~MixersAlignMatchFwdClient();
384
385         void process_package(LoadPackage *package);
386         MixersAlignMatchFwdPackage *pkg;
387 };
388
389 class MixersAlignMatchFwdFarm : public LoadServer
390 {
391 public:
392         MixersAlignMatchFwdFarm(MixersAlign *dialog, int n);
393         ~MixersAlignMatchFwdFarm();
394         void init_packages();
395         LoadClient *new_client();
396         LoadPackage *new_package();
397
398         MixersAlign *dialog;
399 };
400
401
402 class MixersAlignMatchRevPackage : public LoadPackage
403 {
404 public:
405         MixersAlignMatchRevPackage();
406         ~MixersAlignMatchRevPackage();
407
408         MixersAlignMixer *mix;
409 };
410
411 class MixersAlignMatchRevClient : public LoadClient
412 {
413 public:
414         MixersAlignMatchRevClient(MixersAlignMatchRevFarm *farm);
415         ~MixersAlignMatchRevClient();
416
417         void process_package(LoadPackage *package);
418         MixersAlignMatchRevPackage *pkg;
419         double *re, *im;
420 };
421
422 class MixersAlignMatchRevFarm : public LoadServer
423 {
424 public:
425         MixersAlignMatchRevFarm(int n, int cpus,
426                 MixersAlign *dialog, double *ar, double *ai, int len);
427         ~MixersAlignMatchRevFarm();
428         void init_packages();
429         LoadClient *new_client();
430         LoadPackage *new_package();
431
432         MixersAlign *dialog;
433         Mutex *mixer_lock;
434         double *ar, *ai;
435         int len;
436         int64_t pos;
437 };
438
439
440 class MixersAlignTargetPackage : public LoadPackage
441 {
442 public:
443         MixersAlignTargetPackage(MixersAlignTarget *pfft);
444         ~MixersAlignTargetPackage();
445
446         double ss, sd2;
447         int64_t pos;
448         double *best;
449 };
450
451 class MixersAlignTargetClient : public LoadClient
452 {
453 public:
454         MixersAlignTargetClient();
455         ~MixersAlignTargetClient();
456
457         void process_package(LoadPackage *package);
458         MixersAlignTargetPackage *pkg;
459 };
460
461 class MixersAlignTarget : public LoadServer
462 {
463 public:
464         MixersAlignTarget(int n, int cpus,
465                 MixersAlignScanClient *scan, Samples **samples, int len);
466         ~MixersAlignTarget();
467         void init_packages();
468         LoadClient *new_client();
469         LoadPackage *new_package();
470
471         MixersAlignScanClient *scan;
472         Samples **samples;
473         int len;
474 };
475
476
477 class MixersAlign : public BC_DialogThread, public FFT
478 {
479 public:
480         MixersAlign(MWindow *mwindow);
481         ~MixersAlign();
482
483         void start_dialog(int wx, int wy);
484         BC_Window *new_gui();
485         void load_mixers();
486         void load_mtracks();
487         void load_atracks();
488         void handle_done_event(int result);
489         void handle_close_event(int result);
490
491         int atrack_of(MixersAlignMixer *mix, int ch);
492         int mixer_of(Track *track, int &midx);
493         int mixer_of(Track *track) { int midx = -1; return mixer_of(track, midx); }
494         int mmixer_of(int mi) {
495                 return mi>=0 && mi<mtracks.size() ? mixer_of(mtracks[mi]->track) : -1;
496         }
497         int amixer_of(int ai) {
498                 return ai>=0 && ai<atracks.size() ? mixer_of(atracks[ai]->track) : -1;
499         }
500
501         EDL *mixer_audio_clip(Mixer *mixer);
502         EDL *mixer_master_clip(Track *track);
503         int64_t mixer_tracks_total(int midx);
504         void load_master_audio(Track *track);
505         void scan_mixer_audio();
506         void start_progress(int64_t total_len);
507         void stop_progress(const char *msg);
508         void update_progress(int64_t len);
509         void match_fwd();
510         void match_rev();
511         void update_fwd();
512         void update_rev();
513         void update();
514         void apply_undo(int no);
515         void nudge_tracks();
516         void nudge_selected();
517         void clear_mixer_nudge();
518         void check_point();
519         void reset_targets();
520         void scan_targets();
521         void scan_master(Track *track);
522
523         MixersAlignWindow *ma_gui;
524         int wx, wy;
525         MixersAlignMixers mixers;
526         MixersAlignMTracks mtracks;
527         MixersAlignATracks atracks;
528         MWindow *mwindow;
529
530         MixersAlignUndoEDLs undo_edls;
531         Mutex *farming;
532         MainProgressBar *progress;
533         MixersAlignThread *thread;
534         Mutex *total_lock;
535         int64_t total_rendered;
536         int failed;
537         int64_t master_len, sample_len;
538         double *master_r, *master_i;
539         double master_start, master_end, master_ss;
540         double audio_start, audio_end;
541 };
542
543 #endif