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