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.inc"
  25 #include "fourier.h"
  26 #include "guicast.h"
  27 #include "language.h"
  28 #include "loadbalance.h"
  29 #include "mainprogress.inc"
  30 #include "mixersalign.inc"
  31 #include "mwindow.inc"
  32 #include "renderengine.h"
  33 #include "samples.inc"
  34 #include "track.inc"
  35 #include "zwindow.inc"
  36
  37 class MixersAlignMixer
  38 {
  39 public:
  40         MixersAlignMixer(Mixer *mix);
  41         Mixer *mixer;
  42         double nudge;
  43         double mx;
  44         int64_t mi;
  45         int aidx;
  46 };
  47
  48 class MixersAlignMixers : public ArrayList<MixersAlignMixer*>
  49 {
  50 public:
  51         MixersAlignMixers() {}
  52         ~MixersAlignMixers() { remove_all_objects(); }
  53 };
  54
  55 class MixersAlignMixerList : public BC_ListBox
  56 {
  57         enum { MIX_MIXER, MIX_NUDGE, MIX_SZ };
  58         static const char *mix_titles[MIX_SZ];
  59         static int mix_widths[MIX_SZ];
  60 public:
  61         MixersAlignMixerList(MixersAlignWindow *gui,
  62                 MixersAlign *dialog, int x, int y, int w, int h);
  63         ~MixersAlignMixerList();
  64
  65         void clear();
  66
  67         void add_mixer(MixersAlignMixer *mixer);
  68         void load_list();
  69         void update();
  70         int selection_changed();
  71
  72         MixersAlignWindow *gui;
  73         MixersAlign *dialog;
  74         MixersAlignMixers mixers;
  75
  76         const char *col_titles[MIX_SZ];
  77         int col_widths[MIX_SZ];
  78         ArrayList<BC_ListBoxItem*> cols[MIX_SZ];
  79
  80         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
  81         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
  82         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
  83 };
  84
  85
  86 class MixersAlignMTrack
  87 {
  88 public:
  89         MixersAlignMTrack(Track *trk, int no);
  90
  91         Track *track;
  92         int no;
  93 };
  94
  95 class MixersAlignMTracks : public ArrayList<MixersAlignMTrack*>
  96 {
  97 public:
  98         MixersAlignMTracks() {}
  99         ~MixersAlignMTracks() { remove_all_objects(); }
 100 };
 101
 102
 103 class MixersAlignMTrackList : public BC_ListBox
 104 {
 105         enum { MTK_NO, MTK_MIXER, MTK_TRACK, MTK_SZ };
 106         static const char *mtk_titles[MTK_SZ];
 107         static int mtk_widths[MTK_SZ];
 108 public:
 109         MixersAlignMTrackList(MixersAlignWindow *gui,
 110                 MixersAlign *dialog, int x, int y, int w, int h);
 111         ~MixersAlignMTrackList();
 112
 113         void clear();
 114         void add_mtrack(MixersAlignMTrack *mtrk);
 115         void load_list();
 116         void update();
 117
 118         MixersAlignWindow *gui;
 119         MixersAlign *dialog;
 120
 121         ArrayList<BC_ListBoxItem*> cols[MTK_SZ];
 122         const char *col_titles[MTK_SZ];
 123         int col_widths[MTK_SZ];
 124
 125         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
 126         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
 127         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
 128 };
 129
 130
 131 class MixersAlignATrack
 132 {
 133 public:
 134         MixersAlignATrack(Track *trk, int no);
 135         Track *track;
 136         int no;
 137         double nudge;
 138         double mx;
 139         int64_t mi;
 140 };
 141
 142 class MixersAlignATracks : public ArrayList<MixersAlignATrack*>
 143 {
 144 public:
 145         MixersAlignATracks() {}
 146         ~MixersAlignATracks() { remove_all_objects(); }
 147 };
 148
 149 class MixersAlignATrackList : public BC_ListBox
 150 {
 151         enum { ATK_TRACK, ATK_AUDIO, ATK_NUDGE, ATK_MX, ATK_MI, ATK_SZ };
 152         static const char *atk_titles[ATK_SZ];
 153         static int atk_widths[ATK_SZ];
 154 public:
 155         MixersAlignATrackList(MixersAlignWindow *gui,
 156                 MixersAlign *dialog, int x, int y, int w, int h);
 157         ~MixersAlignATrackList();
 158
 159         void clear();
 160         void add_atrack(MixersAlignATrack *track);
 161         void load_list();
 162         void update();
 163         int selection_changed();
 164
 165         MixersAlignWindow *gui;
 166         MixersAlign *dialog;
 167
 168         ArrayList<BC_ListBoxItem*> cols[ATK_SZ];
 169         const char *col_titles[ATK_SZ];
 170         int col_widths[ATK_SZ];
 171
 172         void set_all_selected(int v) { BC_ListBox::set_all_selected(cols, v); }
 173         void set_selected(int idx, int v) { BC_ListBox::set_selected(cols, idx, v); }
 174         bool is_selected(int idx) { return cols[0][idx]->get_selected() != 0; }
 175 };
 176
 177 class MixersAlignReset : public BC_GenericButton
 178 {
 179 public:
 180         MixersAlignReset(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
 181         int handle_event();
 182         static int calculate_width(BC_WindowBase *gui);
 183
 184         MixersAlign *dialog;
 185         MixersAlignWindow *gui;
 186 };
 187
 188 class MixersAlignThread : public Thread
 189 {
 190 public:
 191         MixersAlignThread(MixersAlign *dialog);
 192         ~MixersAlignThread();
 193         void run();
 194
 195         MixersAlign *dialog;
 196 };
 197
 198 class MixersAlignMatch : public BC_GenericButton
 199 {
 200 public:
 201         MixersAlignMatch(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
 202         int handle_event();
 203
 204         MixersAlign *dialog;
 205         MixersAlignWindow *gui;
 206 };
 207
 208 class MixersAlignApply : public BC_GenericButton
 209 {
 210 public:
 211         MixersAlignApply(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
 212         int handle_event();
 213         static int calculate_width(BC_WindowBase *gui);
 214
 215         MixersAlign *dialog;
 216         MixersAlignWindow *gui;
 217 };
 218
 219 class MixersAlignUndo : public BC_GenericButton
 220 {
 221 public:
 222         MixersAlignUndo(MixersAlignWindow *gui, MixersAlign *dialog, int x, int y);
 223         int handle_event();
 224
 225         MixersAlign *dialog;
 226         MixersAlignWindow *gui;
 227 };
 228
 229
 230 class MixersAlignWindow : public BC_Window
 231 {
 232 public:
 233         MixersAlignWindow(MixersAlign *dialog, int x, int y);
 234         ~MixersAlignWindow();
 235
 236         void create_objects();
 237         int resize_event(int w, int h);
 238         void load_lists();
 239         void default_selection();
 240         void update_gui();
 241
 242         MixersAlign *dialog;
 243         BC_Title *mixer_title, *mtrack_title, *atrack_title;
 244
 245         MixersAlignMixerList *mixer_list;
 246         MixersAlignMTrackList *mtrack_list;
 247         MixersAlignATrackList *atrack_list;
 248         MixersAlignMatch *match;
 249         MixersAlignReset *reset;
 250         MixersAlignApply *apply;
 251         MixersAlignUndo *undo;
 252 };
 253
 254
 255 class MixersAlignARender : public RenderEngine
 256 {
 257 public:
 258         MixersAlignARender(MWindow *mwindow, EDL *edl);
 259         ~MixersAlignARender();
 260
 261         int render(Samples **samples, int64_t len, int64_t pos);
 262 };
 263
 264 class MixersAlignPackage : public LoadPackage
 265 {
 266 public:
 267         MixersAlignPackage();
 268         ~MixersAlignPackage();
 269
 270         MixersAlignMixer *mixer;
 271 };
 272
 273 class MixersAlignClient : public LoadClient
 274 {
 275 public:
 276         MixersAlignClient(MixersAlignFarm *farm);
 277         ~MixersAlignClient();
 278
 279         void process_package(LoadPackage *pkg);
 280 };
 281
 282 class MixersAlignFarm : public LoadServer
 283 {
 284 public:
 285         MixersAlignFarm(MixersAlign *dialog, int n);
 286         ~MixersAlignFarm();
 287         void init_packages();
 288         LoadClient *new_client();
 289         LoadPackage *new_package();
 290
 291         MixersAlign *dialog;
 292 };
 293
 294 class MixersAlign : public BC_DialogThread, public FFT
 295 {
 296 public:
 297         MixersAlign(MWindow *mwindow);
 298         ~MixersAlign();
 299
 300         void start_dialog(int wx, int wy);
 301         BC_Window *new_gui();
 302         void load_mixers();
 303         void load_mtracks();
 304         void load_atracks();
 305         void handle_done_event(int result);
 306         void handle_close_event(int result);
 307
 308         int mixer_of(Track *track, int &midx);
 309         int mixer_of(Track *track) { int midx = -1; return mixer_of(track, midx); }
 310         int mmixer_of(int mi) {
 311                 return mi>=0 && mi<mtracks.size() ? mixer_of(mtracks[mi]->track) : -1;
 312         }
 313         int amixer_of(int ai) {
 314                 return ai>=0 && ai<atracks.size() ? mixer_of(atracks[ai]->track) : -1;
 315         }
 316
 317         EDL *mixer_audio_clip(Mixer *mixer);
 318         EDL *mixer_master_clip(Track *track);
 319         int64_t mixer_tracks_total();
 320         void load_master_audio(Track *track);
 321         void scan_mixer_audio();
 322         void update_progress(int64_t len);
 323         void update_match();
 324         void update();
 325         void process_package(MixersAlignFarm *farm, MixersAlignPackage *package);
 326         void apply();
 327
 328         MixersAlignWindow *ma_gui;
 329         int wx, wy;
 330         MixersAlignMixers mixers;
 331         MixersAlignMTracks mtracks;
 332         MixersAlignATracks atracks;
 333         MWindow *mwindow;
 334
 335         EDL *undo_edl;
 336         Mutex *farming;
 337         MainProgressBar *progress;
 338         MixersAlignThread *thread;
 339         Mutex *total_lock;
 340         int64_t total_rendered;
 341         int failed;
 342         int64_t master_len;
 343         double *master_r, *master_i;
 344         double master_start, master_end, master_ss;
 345         double audio_start, audio_end;
 346 };
 347
 348 #endif