3 * Copyright (C) 2008-2015 Adam Williams <broadcast at earthling dot net>
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.
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.
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
21 #include "mixersalign.h"
29 #include "edlsession.h"
30 #include "localsession.h"
31 #include "mainerror.h"
32 #include "mainprogress.h"
34 #include "mwindowgui.h"
37 #include "preferences.h"
40 #include "renderengine.h"
43 #include "transportque.h"
46 // c = corr(a,b): A=fft(a),B=fft(b) C=A*conj(B) c=ifft(C)
47 static inline void conj_product(int n, double *rp, double *ip,
48 double *arp, double *aip, double *brp, double *bip)
50 for( int i=0; i<n; ++i ) {
51 double ar = arp[i], ai = aip[i];
52 double br = brp[i], bi = -bip[i];
53 rp[i] = ar*br - ai*bi;
54 ip[i] = ar*bi + ai*br;
58 MixersAlignMixer::MixersAlignMixer(Mixer *mix)
66 MixersAlignMixer::~MixersAlignMixer()
72 const char *MixersAlignMixerList::mix_titles[MIX_SZ] = {
73 N_("Mixer"), N_("Nudge"),
76 int MixersAlignMixerList::mix_widths[MIX_SZ] = {
80 MixersAlignMixerList::MixersAlignMixerList(MixersAlignWindow *gui,
81 MixersAlign *dialog, int x, int y, int w, int h)
82 : BC_ListBox(x, y, w, h, LISTBOX_TEXT)
84 set_selection_mode(LISTBOX_MULTIPLE);
85 this->dialog = dialog;
87 for( int i=MIX_SZ; --i>=0; ) {
88 col_widths[i] = mix_widths[i];
89 col_titles[i] = _(mix_titles[i]);
93 MixersAlignMixerList::~MixersAlignMixerList()
98 void MixersAlignMixerList::clear()
100 for( int i=MIX_SZ; --i>=0; )
101 cols[i].remove_all_objects();
104 void MixersAlignMixerList::add_mixer(MixersAlignMixer *mixer)
106 char mixer_text[BCSTRLEN];
107 snprintf(mixer_text, sizeof(mixer_text), "%d: %s",
108 mixer->mixer->idx, mixer->mixer->title);
109 cols[MIX_MIXER].append(new BC_ListBoxItem(mixer_text));
110 char nudge_text[BCSTRLEN];
111 sprintf(nudge_text, _("%0.4f"), mixer->nudge);
112 cols[MIX_NUDGE].append(new BC_ListBoxItem(nudge_text));
115 void MixersAlignMixerList::load_list()
118 for( int i=0,sz=dialog->mixers.size(); i<sz; ++i )
119 add_mixer(dialog->mixers[i]);
122 void MixersAlignMixerList::update()
124 int xpos = get_xposition(), ypos = get_yposition();
125 BC_ListBox::update(&cols[0], &col_titles[0],&col_widths[0],MIX_SZ, xpos,ypos);
128 int MixersAlignMixerList::selection_changed()
130 for( int m=0; m<dialog->mixers.size(); ++m ) {
131 MixersAlignMixer *mix = dialog->mixers[m];
132 if( !is_selected(m) ) {
133 for( int i=0; i<dialog->atracks.size(); ++i ) {
134 if( m != dialog->amixer_of(i) ) continue;
135 gui->atrack_list->set_selected(i, 0);
142 else if( mix->aidx < 0 ) {
143 MixersAlignATrack *best = 0; int idx = -1;
144 for( int i=0; i<dialog->atracks.size(); ++i ) {
145 if( m != dialog->amixer_of(i) ) continue;
146 MixersAlignATrack *atrk = dialog->atracks[i];
147 if( atrk->mi < 0 ) continue;
148 gui->atrack_list->set_selected(i, 0);
149 if( best && best->mx >= atrk->mx ) continue;
150 best = atrk; idx = i;
152 if( idx >= 0 && best ) {
153 gui->atrack_list->set_selected(idx, 1);
154 MixersAlignMixer *mix = dialog->mixers[m];
158 mix->nudge = best->nudge;
161 for( int i=0; i<dialog->atracks.size(); ++i ) {
162 if( m != dialog->amixer_of(i) ) continue;
163 gui->atrack_list->set_selected(i, 1);
168 gui->atrack_list->update();
171 for( int i=0; i<dialog->atracks.size(); ++i ) {
172 if( !gui->atrack_list->is_selected(i) ) continue;
173 int m = dialog->amixer_of(i);
174 if( m >= 0 ) set_selected(m, 1);
180 MixersAlignMTrack::MixersAlignMTrack(Track *trk, int no)
187 const char *MixersAlignMTrackList::mtk_titles[MTK_SZ] = {
188 N_("No"), N_("Mixer"), N_("Track"),
191 int MixersAlignMTrackList::mtk_widths[MTK_SZ] = {
195 MixersAlignMTrackList::MixersAlignMTrackList(MixersAlignWindow *gui,
196 MixersAlign *dialog, int x, int y, int w, int h)
197 : BC_ListBox(x, y, w, h, LISTBOX_TEXT)
199 set_selection_mode(LISTBOX_SINGLE);
200 this->dialog = dialog;
202 for( int i=MTK_SZ; --i>=0; ) {
203 col_widths[i] = mtk_widths[i];
204 col_titles[i] = _(mtk_titles[i]);
208 MixersAlignMTrackList::~MixersAlignMTrackList()
213 void MixersAlignMTrackList::clear()
215 for( int i=MTK_SZ; --i>=0; )
216 cols[i].remove_all_objects();
219 void MixersAlignMTrackList::add_mtrack(MixersAlignMTrack *mtrk)
221 char no_text[BCSTRLEN];
222 snprintf(no_text, sizeof(no_text),"%d", mtrk->no+1);
223 cols[MTK_NO].append(new BC_ListBoxItem(no_text));
224 char mixer_text[BCSTRLEN];
225 Track *track = mtrk->track;
226 int k = -1, m = dialog->mixer_of(track, k);
227 snprintf(mixer_text, sizeof(mixer_text),"%d:%d", m+1,k);
228 cols[MTK_MIXER].append(new BC_ListBoxItem(mixer_text));
229 cols[MTK_TRACK].append(new BC_ListBoxItem(track->title));
232 void MixersAlignMTrackList::load_list()
235 for( int i=0,sz=dialog->mtracks.size(); i<sz; ++i )
236 add_mtrack(dialog->mtracks[i]);
239 void MixersAlignMTrackList::update()
241 int xpos = get_xposition(), ypos = get_yposition();
242 BC_ListBox::update(&cols[0], &col_titles[0],&col_widths[0],MTK_SZ, xpos,ypos);
246 MixersAlignATrack::MixersAlignATrack(Track *trk, int no)
255 MixersAlignATrack::~MixersAlignATrack()
260 const char *MixersAlignATrackList::atk_titles[ATK_SZ] = {
261 N_("Track"), N_("Audio"), N_("Nudge"), N_("R"), N_("pos"),
264 int MixersAlignATrackList::atk_widths[ATK_SZ] = {
268 MixersAlignATrackList::MixersAlignATrackList(MixersAlignWindow *gui,
269 MixersAlign *dialog, int x, int y, int w, int h)
270 : BC_ListBox(x, y, w, h, LISTBOX_TEXT)
272 set_selection_mode(LISTBOX_MULTIPLE);
273 this->dialog = dialog;
275 for( int i=ATK_SZ; --i>=0; ) {
276 col_widths[i] = atk_widths[i];
277 col_titles[i] = _(atk_titles[i]);
281 MixersAlignATrackList::~MixersAlignATrackList()
286 void MixersAlignATrackList::clear()
288 for( int i=ATK_SZ; --i>=0; )
289 cols[i].remove_all_objects();
292 void MixersAlignATrackList::add_atrack(MixersAlignATrack *atrack)
294 char atrack_text[BCSTRLEN];
295 Track *track = atrack->track;
296 int m = dialog->mixer_of(track);
297 snprintf(atrack_text, sizeof(atrack_text), "%d/%d", atrack->no+1,m+1);
298 cols[ATK_TRACK].append(new BC_ListBoxItem(atrack_text));
299 cols[ATK_AUDIO].append(new BC_ListBoxItem(track->title));
300 char nudge_text[BCSTRLEN];
301 sprintf(nudge_text, "%0.4f", atrack->nudge);
302 cols[ATK_NUDGE].append(new BC_ListBoxItem(nudge_text));
303 char mx_text[BCSTRLEN];
304 sprintf(mx_text, "%0.4f", atrack->mx);
305 cols[ATK_MX].append(new BC_ListBoxItem(mx_text));
306 char mi_text[BCSTRLEN];
307 sprintf(mi_text, "%jd", atrack->mi);
308 cols[ATK_MI].append(new BC_ListBoxItem(mi_text));
312 void MixersAlignATrackList::load_list()
315 for( int i=0,sz=dialog->atracks.size(); i<sz; ++i )
316 add_atrack(dialog->atracks[i]);
319 void MixersAlignATrackList::update()
321 int xpos = get_xposition(), ypos = get_yposition();
322 BC_ListBox::update(&cols[0], &col_titles[0],&col_widths[0],ATK_SZ, xpos,ypos);
325 int MixersAlignATrackList::selection_changed()
327 int idx = get_buttonpress() == LEFT_BUTTON ? get_highlighted_item() : -1;
328 int m = idx >= 0 ? dialog->amixer_of(idx) : -1;
331 MixersAlignMixer *mix = dialog->mixers[m];
332 for( int i=0; i<dialog->atracks.size(); ++i ) {
333 int k = dialog->amixer_of(i);
334 if( k < 0 ) { set_selected(i, 0); continue; }
335 if( m != k ) continue;
336 MixersAlignATrack *atrk = dialog->atracks[i];
337 if( atrk->mi < 0 ) continue;
338 int is_sel = is_selected(i);
340 if( i != idx ) continue;
345 mix->nudge = atrk->nudge;
356 set_selected(idx, 1);
360 gui->mixer_list->load_list();
361 for( int i=0; i<dialog->atracks.size(); ++i ) {
362 if( !is_selected(i) ) continue;
363 int m = dialog->amixer_of(i);
364 if( m < 0 ) continue;
365 gui->mixer_list->set_selected(m, 1);
367 gui->mixer_list->update();
371 MixersAlignReset::MixersAlignReset(MixersAlignWindow *gui,
372 MixersAlign *dialog, int x, int y)
373 : BC_GenericButton(x, y, _("Reset"))
376 this->dialog = dialog;
379 int MixersAlignReset::calculate_width(BC_WindowBase *gui)
381 return BC_GenericButton::calculate_w(gui, _("Reset"));
384 int MixersAlignReset::handle_event()
386 dialog->load_mixers();
387 dialog->load_mtracks();
388 dialog->load_atracks();
390 gui->default_selection();
394 MixersAlignMatch::MixersAlignMatch(MixersAlignWindow *gui,
395 MixersAlign *dialog, int x, int y)
396 : BC_GenericButton(x, y, _("Match"))
399 this->dialog = dialog;
402 int MixersAlignMatch::handle_event()
404 if( !dialog->thread->running() ) {
405 dialog->thread->start(1);
410 MixersAlignMatchAll::MixersAlignMatchAll(MixersAlignWindow *gui,
411 MixersAlign *dialog, int x, int y)
412 : BC_GenericButton(x, y, _("Match All"))
415 this->dialog = dialog;
418 int MixersAlignMatchAll::handle_event()
420 if( !dialog->thread->running() ) {
421 dialog->thread->start(0);
426 MixersAlignNudgeTracks::MixersAlignNudgeTracks(MixersAlignWindow *gui,
427 MixersAlign *dialog, int x, int y)
428 : BC_GenericButton(x, y, _("Apply"))
431 this->dialog = dialog;
434 int MixersAlignNudgeTracks::calculate_width(BC_WindowBase *gui)
436 return BC_GenericButton::calculate_w(gui, _("Apply"));
439 int MixersAlignNudgeTracks::handle_event()
441 dialog->nudge_tracks();
445 MixersAlignNudgeSelected::MixersAlignNudgeSelected(MixersAlignWindow *gui,
446 MixersAlign *dialog, int x, int y)
447 : BC_GenericButton(x, y, _("Move"))
450 this->dialog = dialog;
453 int MixersAlignNudgeSelected::calculate_width(BC_WindowBase *gui)
455 return BC_GenericButton::calculate_w(gui, _("Move"));
458 int MixersAlignNudgeSelected::handle_event()
460 dialog->nudge_selected();
464 MixersAlignUndoItem::MixersAlignUndoItem(const char *text, int no)
469 MixersAlignUndoItem::~MixersAlignUndoItem()
473 int MixersAlignUndoItem::handle_event()
475 MixersAlignUndo *undo = (MixersAlignUndo *)get_popup_menu();
476 undo->dialog->apply_undo(no);
480 MixersAlignUndo::MixersAlignUndo(MixersAlignWindow *gui,
481 MixersAlign *dialog, int x, int y)
482 : BC_PopupMenu(x, y, 100, _("Undo"))
485 this->dialog = dialog;
487 MixersAlignUndo::~MixersAlignUndo()
491 void MixersAlignUndo::create_objects()
496 void MixersAlignUndo::add_undo_item(int no)
500 sprintf(text, _("chkpt %d"), no);
502 sprintf(text, _("start over"));
503 add_item(new MixersAlignUndoItem(text, no));
506 MixersAlignCheckPoint::MixersAlignCheckPoint(MixersAlignWindow *gui,
507 MixersAlign *dialog, int x, int y)
508 : BC_GenericButton(x, y, 100, _("CheckPoint"))
511 this->dialog = dialog;
514 int MixersAlignCheckPoint::handle_event()
516 dialog->check_point();
520 MixersAlignWindow::MixersAlignWindow(MixersAlign *dialog, int x, int y)
521 : BC_Window(_("Align Mixers"), x, y, 880, 380, 880, 380, 1)
523 this->dialog = dialog;
525 MixersAlignWindow::~MixersAlignWindow()
529 void MixersAlignWindow::create_objects()
531 int x = 10, y = 10, w4 = (get_w()-x-10)/4, lw = w4 + 20;
532 int x1 = x, x2 = x1 + lw , x3 = x2 + lw, x4 = get_w()-x;
533 mixer_title = new BC_Title(x1,y, _("Mixers:"), MEDIUMFONT, YELLOW);
534 add_subwindow(mixer_title);
535 mtrack_title = new BC_Title(x2,y, _("Master Track:"), MEDIUMFONT, YELLOW);
536 add_subwindow(mtrack_title);
537 atrack_title = new BC_Title(x3,y, _("Audio Tracks:"), MEDIUMFONT, YELLOW);
538 add_subwindow(atrack_title);
539 y += mixer_title->get_h() + 10;
540 int y1 = y, y2 = get_h() - BC_OKButton::calculate_h() - 32;
542 mixer_list = new MixersAlignMixerList(this, dialog, x1, y, x2-x1-20, lh);
543 add_subwindow(mixer_list);
544 mtrack_list = new MixersAlignMTrackList(this, dialog, x2, y, x3-x2-20, lh);
545 add_subwindow(mtrack_list);
546 atrack_list = new MixersAlignATrackList(this, dialog, x3, y, x4-x3-20, lh);
547 add_subwindow(atrack_list);
548 int xr = x2-10 - MixersAlignReset::calculate_width(this);
550 add_subwindow(reset = new MixersAlignReset(this, dialog, xr, y1));
551 add_subwindow(match = new MixersAlignMatch(this, dialog, x2+10, y1));
552 int xa = x3-10 - MixersAlignNudgeTracks::calculate_width(this);
553 add_subwindow(nudge_tracks = new MixersAlignNudgeTracks(this, dialog, xa, y1));
554 y2 = y1 + nudge_tracks->get_h() + 10;
555 add_subwindow(match_all = new MixersAlignMatchAll(this, dialog, xr, y2));
556 add_subwindow(nudge_selected = new MixersAlignNudgeSelected(this, dialog, xa, y2));
558 add_subwindow(check_point = new MixersAlignCheckPoint(this, dialog, xu, y1));
559 add_subwindow(undo = new MixersAlignUndo(this, dialog, xu, y2));
560 undo->create_objects();
562 add_subwindow(new BC_OKButton(this));
563 add_subwindow(new BC_CancelButton(this));
566 int MixersAlignWindow::resize_event(int w, int h)
568 int x = 10, y = 10, w4 = (w-x-10)/4, lw = w4 + 20;
569 int x1 = x, x2 = x1 + lw , x3 = x2 + lw, x4 = w-x;
570 mixer_title->reposition_window(x1, y);
571 mtrack_title->reposition_window(x2, y);
572 atrack_title->reposition_window(x3, y);
573 y += mixer_title->get_h() + 10;
574 int y1 = y, y2 = h - BC_OKButton::calculate_h() - 32;
576 mixer_list->reposition_window(x1, y, x2-x1-20, lh);
577 mtrack_list->reposition_window(x2, y, x3-x2-20, lh);
578 atrack_list->reposition_window(x3, y, x4-x3-20, lh);
579 int xr = x2-10 - MixersAlignReset::calculate_width(this);
581 reset->reposition_window(xr, y1);
582 match->reposition_window(x2+10, y1);
583 int xa = x3-10 - MixersAlignNudgeTracks::calculate_width(this);
584 nudge_tracks->reposition_window(xa, y1);
585 y2 = y1 + nudge_tracks->get_h() + 10;
586 match_all->reposition_window(xr, y2);
587 nudge_selected->reposition_window(xa, y2);
589 check_point->reposition_window(xu, y1);
590 undo->reposition_window(xu, y2);
594 void MixersAlignWindow::load_lists()
596 mixer_list->load_list();
597 mtrack_list->load_list();
598 atrack_list->load_list();
601 void MixersAlignWindow::default_selection()
603 // mixers selects all mixers
604 mixer_list->set_all_selected(1);
605 // master selects first mixer audio track
606 for( int i=0; i<dialog->mtracks.size(); ++i ) {
607 if( dialog->mmixer_of(i) >= 0 ) {
608 mtrack_list->set_selected(i, 1);
612 // audio selects all mixer audio tracks
613 for( int i=0; i<dialog->atracks.size(); ++i ) {
614 if( dialog->amixer_of(i) >= 0 )
615 atrack_list->set_selected(i, 1);
620 void MixersAlignWindow::update_gui()
622 mixer_list->update();
623 mtrack_list->update();
624 atrack_list->update();
628 MixersAlign::MixersAlign(MWindow *mwindow)
630 this->mwindow = mwindow;
632 farming = new Mutex("MixersAlign::farming");
633 total_lock = new Mutex("MixersAlign::total_lock");
634 thread = new MixersAlignThread(this);
639 sample_len = 0x10000;
642 master_start = master_end = 0;
643 audio_start = audio_end = 0;
646 MixersAlign::~MixersAlign()
649 farming->lock("MixersAlign::~MixersAlign");
659 void MixersAlign::start_dialog(int wx, int wy)
663 EDL *start_over = new EDL();
664 start_over->create_objects();
665 start_over->copy_all(mwindow->edl);
666 undo_edls.append(start_over);
670 BC_Window *MixersAlign::new_gui()
675 ma_gui = new MixersAlignWindow(this, wx, wy);
676 ma_gui->lock_window("MixersAlign::new_gui");
677 ma_gui->create_objects();
678 ma_gui->load_lists();
679 ma_gui->default_selection();
680 ma_gui->show_window(1);
681 ma_gui->unlock_window();
685 // shift armed mixer tracks by nudge
686 void MixersAlign::nudge_tracks()
688 mwindow->gui->lock_window("MixersAlign::apply_tracks");
689 int idx = ma_gui->mtrack_list->get_selection_number(0, 0);
690 int midx = mmixer_of(idx);
691 EDL *edl = mwindow->edl;
693 for( int m, i=0; (m=ma_gui->mixer_list->get_selection_number(0,i))>=0; ++i ) {
694 if( m == midx ) continue; // master does not move
695 MixersAlignMixer *mix = mixers[m];
696 Mixer *mixer = mix->mixer;
697 for( int i=0; i<mixer->mixer_ids.size(); ++i ) {
698 int id = mixer->mixer_ids[i];
699 Track *track = edl->tracks->first;
700 while( track && track->mixer_id != id ) track = track->next;
701 if( !track ) continue;
702 double nudge = mix->nudge;
703 int record = track->record; track->record = 1;
705 track->clear(0, -nudge, 1,
706 edl->session->labels_follow_edits,
707 edl->session->plugins_follow_edits,
708 edl->session->autos_follow_edits, 0);
710 else if( nudge > 0 ) {
711 track->paste_silence(0, nudge,
712 edl->session->plugins_follow_edits,
713 edl->session->autos_follow_edits);
715 track->record = record;
720 mwindow->update_gui(1);
721 mwindow->gui->unlock_window();
725 // move selected mixer edits by nudge
726 void MixersAlign::nudge_selected()
728 mwindow->gui->lock_window("MixersAlign::apply_selected");
729 int idx = ma_gui->mtrack_list->get_selection_number(0, 0);
730 int midx = mmixer_of(idx);
731 EDL *edl = mwindow->edl;
733 ArrayList<int> track_arms; // ugly
734 for( Track *track=edl->tracks->first; track; track=track->next ) {
735 track_arms.append(track->record);
738 for( int m, i=0; (m=ma_gui->mixer_list->get_selection_number(0,i))>=0; ++i ) {
739 if( m == midx ) continue; // master does not move
740 MixersAlignMixer *mix = mixers[m];
741 Mixer *mixer = mix->mixer;
742 for( int i=0; i<mixer->mixer_ids.size(); ++i ) {
743 int id = mixer->mixer_ids[i];
744 Track *track = edl->tracks->first;
745 while( track && track->mixer_id != id ) track = track->next;
746 if( !track ) continue;
747 double nudge = mix->nudge;
749 double position = 0; Track *first_track = 0;
750 EDL *clip = edl->selected_edits_to_clip(0, &position, &first_track);
752 Track *clip_track = clip->tracks->first;
753 Track *edl_track = first_track;
754 while( clip_track && edl_track ) {
755 Edit *edit = clip_track->edits->first;
756 for( ; edit; edit=edit->next ) {
757 double start = clip_track->from_units(edit->startproject);
758 double end = clip_track->from_units(edit->startproject+edit->length);
759 start += position; end += position;
760 edl_track->clear(start, end, 1,
761 edl->session->labels_follow_edits,
762 edl->session->plugins_follow_edits,
763 edl->session->autos_follow_edits, 0);
764 edl_track->paste_silence(start, end,
765 edl->session->plugins_follow_edits,
766 edl->session->autos_follow_edits);
768 clip_track = clip_track->next;
769 edl_track = edl_track->next;
772 edl->paste_edits(clip, first_track, position, 1);
778 for( Track *track=edl->tracks->first; track; track=track->next )
779 track->record = track_arms[i++];
782 mwindow->update_gui(1);
783 mwindow->gui->unlock_window();
788 void MixersAlign::clear_mixer_nudge()
790 // so pressing apply twice does not damage the result
791 for( int m=0; m<mixers.size(); ++m )
792 mixers[m]->nudge = 0;
793 ma_gui->mixer_list->load_list();
794 ma_gui->lock_window("MixersAlign::clear_mixer_nudge");
795 ma_gui->mixer_list->update();
796 ma_gui->unlock_window();
799 void MixersAlign::check_point()
801 mwindow->gui->lock_window("MixersAlign::check_point");
802 ma_gui->undo->add_undo_item(undo_edls.size());
803 EDL *undo_edl = new EDL();
804 undo_edl->create_objects();
805 undo_edl->copy_all(mwindow->edl);
806 undo_edls.append(undo_edl);
807 mwindow->gui->unlock_window();
811 MixersAlignThread::MixersAlignThread(MixersAlign *dialog)
814 this->dialog = dialog;
816 MixersAlignThread::~MixersAlignThread()
821 void MixersAlignThread::start(int fwd)
824 MixersAlignWindow *gui = dialog->ma_gui;
825 gui->reset->disable();
826 gui->match->disable();
827 gui->match_all->disable();
828 gui->nudge_tracks->disable();
829 gui->nudge_selected->disable();
830 gui->check_point->disable();
831 // gui->undo->disable();
835 void MixersAlignThread::run()
841 MixersAlignWindow *gui = dialog->ma_gui;
842 gui->lock_window("MixersAlignThread::run");
843 gui->reset->enable();
844 gui->match->enable();
845 gui->match_all->enable();
846 gui->nudge_tracks->enable();
847 gui->nudge_selected->enable();
848 gui->check_point->enable();
849 // gui->undo->enable();
850 gui->unlock_window();
854 void MixersAlign::handle_done_event(int result)
856 if( thread->running() ) {
861 mwindow->gui->lock_window("MixersAlign::handle_done_event");
862 EDL *edl = mwindow->edl;
863 mwindow->edl = undo_edls[0];
864 mwindow->undo_before();
866 mwindow->undo_after(_("align mixers"), LOAD_ALL);
867 mwindow->gui->unlock_window();
871 void MixersAlign::handle_close_event(int result)
880 void MixersAlign::load_mixers()
883 Mixers &edl_mixers = mwindow->edl->mixers;
884 for( int i=0; i<edl_mixers.size(); ++i )
885 mixers.append(new MixersAlignMixer(edl_mixers[i]));
888 void MixersAlign::load_mtracks()
891 Track *track=mwindow->edl->tracks->first;
892 for( int no=0; track; ++no, track=track->next ) {
893 if( track->data_type != TRACK_AUDIO ) continue;
894 mtracks.append(new MixersAlignMTrack(track, no));
898 void MixersAlign::load_atracks()
901 Track *track=mwindow->edl->tracks->first;
902 for( int no=0; track; ++no, track=track->next ) {
903 if( track->data_type != TRACK_AUDIO ) continue;
904 if( mixer_of(track) < 0 ) continue;
905 atracks.append(new MixersAlignATrack(track, no));
910 int MixersAlign::atrack_of(MixersAlignMixer *mix, int ch)
913 Mixer *mixer = mix->mixer;
914 for( int i=0,n=mixer->mixer_ids.size(); i<n; ++i ) {
915 int id = mixer->mixer_ids[i]; k = atracks.size();
916 while( --k >= 0 && atracks[k]->track->mixer_id != id );
917 if( k < 0 ) continue;
918 if( --ch < 0 ) break;
923 int MixersAlign::mixer_of(Track *track, int &midx)
925 int id = track->mixer_id, k = mixers.size(), idx = -1;
926 while( idx < 0 && --k >= 0 )
927 idx = mixers[k]->mixer->mixer_ids.number_of(id);
933 EDL *MixersAlign::mixer_audio_clip(Mixer *mixer)
935 EDL *edl = new EDL(mwindow->edl);
936 edl->create_objects();
937 Track *track = mwindow->edl->tracks->first;
938 for( int ch=0; track && ch<MAX_CHANNELS; track=track->next ) {
939 int id = track->mixer_id;
940 if( track->data_type != TRACK_AUDIO ) continue;
941 if( mixer->mixer_ids.number_of(id) < 0 ) continue;
942 Track *mixer_audio = edl->tracks->add_audio_track(0, 0);
943 mixer_audio->copy_settings(track);
944 mixer_audio->play = 1;
945 mixer_audio->edits->copy_from(track->edits);
946 PanAuto* pan_auto = (PanAuto*)mixer_audio->automation->
947 autos[AUTOMATION_PAN]->default_auto;
948 pan_auto->values[ch++] = 1.0;
953 EDL *MixersAlign::mixer_master_clip(Track *track)
955 EDL *edl = new EDL(mwindow->edl);
956 edl->create_objects();
957 Track *master_audio = edl->tracks->add_audio_track(0, 0);
958 master_audio->copy_settings(track);
959 master_audio->play = 1;
960 master_audio->edits->copy_from(track->edits);
961 PanAuto* pan_auto = (PanAuto*)master_audio->automation->
962 autos[AUTOMATION_PAN]->default_auto;
963 pan_auto->values[0] = 1.0;
967 int64_t MixersAlign::mixer_tracks_total(int midx)
969 int64_t total_len = 0;
970 int64_t sample_rate = mwindow->edl->get_sample_rate();
972 for( int i=0; (m=ma_gui->mixer_list->get_selection_number(0, i))>=0 ; ++i ) {
973 if( m == midx ) continue;
974 Mixer *mixer = mixers[m]->mixer;
975 double render_end = 0;
976 Track *track = mwindow->edl->tracks->first;
977 for( ; track; track=track->next ) {
978 int id = track->mixer_id;
979 if( track->data_type != TRACK_AUDIO ) continue;
980 if( mixer->mixer_ids.number_of(id) < 0 ) continue;
981 double track_end = track->get_length();
982 if( render_end < track_end ) render_end = track_end;
984 if( render_end > audio_end ) render_end = audio_end;
985 double len = render_end - audio_start;
986 if( len > 0 ) total_len += len * sample_rate;
991 void MixersAlign::apply_undo(int no)
993 if( thread->running() ) {
997 mwindow->gui->lock_window("MixersAlignUndo::handle_event");
998 EDL *undo_edl = undo_edls[no];
999 mwindow->edl->copy_all(undo_edl);
1000 mwindow->update_gui(1);
1001 mwindow->gui->unlock_window();
1002 ma_gui->reset->handle_event();
1005 MixersAlignARender::MixersAlignARender(MWindow *mwindow, EDL *edl)
1006 : RenderEngine(0, mwindow->preferences, 0, 0)
1008 TransportCommand command;
1009 command.command = NORMAL_FWD;
1010 command.get_edl()->copy_all(edl);
1011 command.change_type = CHANGE_ALL;
1012 command.realtime = 0;
1013 set_vcache(mwindow->video_cache);
1014 set_acache(mwindow->audio_cache);
1015 arm_command(&command);
1018 MixersAlignARender::~MixersAlignARender()
1022 int MixersAlignARender::render(Samples **samples, int64_t len, int64_t pos)
1024 return arender ? arender->process_buffer(samples, len, pos) : -1;
1027 // scan mixer tracks for best target
1028 MixersAlignScanFarm::MixersAlignScanFarm(MixersAlign *dialog, int cpus, int n)
1029 : LoadServer(cpus, n)
1031 dialog->farming->lock("MixersAlignScanFarm::MixersAlignScanFarm");
1032 this->dialog = dialog;
1035 MixersAlignScanFarm::~MixersAlignScanFarm()
1037 dialog->farming->unlock();
1040 MixersAlignScanPackage::MixersAlignScanPackage(MixersAlignScanFarm *farm)
1044 MixersAlignScanPackage::~MixersAlignScanPackage()
1048 LoadPackage* MixersAlignScanFarm::new_package()
1050 return new MixersAlignScanPackage(this);
1053 void MixersAlignScanFarm::init_packages()
1055 int idx = dialog->ma_gui->mtrack_list->get_selection_number(0, 0);
1056 int midx = dialog->mmixer_of(idx);
1057 for( int i=0, k=0; i<get_total_packages(); ++k ) {
1058 int m = dialog->ma_gui->mixer_list->get_selection_number(0, k);
1059 if( m == midx ) continue;
1060 MixersAlignScanPackage *pkg = (MixersAlignScanPackage *)get_package(i++);
1061 pkg->mixer = dialog->mixers[m];
1065 MixersAlignScanClient::MixersAlignScanClient(MixersAlignScanFarm *farm)
1072 MixersAlignScanClient::~MixersAlignScanClient()
1076 LoadClient* MixersAlignScanFarm::new_client()
1078 return new MixersAlignScanClient(this);
1081 void MixersAlignScanClient::process_package(LoadPackage *package)
1083 MixersAlignScanFarm *farm = (MixersAlignScanFarm *)server;
1084 MixersAlign *dialog = farm->dialog;
1085 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1086 if( dialog->failed ) return;
1087 pkg = (MixersAlignScanPackage *)package;
1088 MixersAlignMixer *mix = pkg->mixer;
1090 EDL *edl = dialog->mixer_audio_clip(mix->mixer);
1091 MixersAlignARender audio(dialog->mwindow, edl);
1092 double start = edl->skip_silence(0);
1093 int channels = edl->get_audio_channels();
1094 int64_t sample_rate = edl->get_sample_rate();
1095 int64_t cur_pos = start * sample_rate;
1096 int64_t end_pos = edl->get_audio_samples();
1097 int len = dialog->sample_len, len2 = len/2;
1098 cur_pos &= ~(len2-1);
1099 if( cur_pos ) dialog->update_progress(cur_pos);
1102 Samples *samples[MAX_CHANNELS];
1103 for( int i=0; i<MAX_CHANNELS; ++i )
1104 samples[i] = i<channels ? new Samples(len2) : 0;
1105 int cpus = bmin(dialog->mwindow->preferences->processors, channels);
1106 MixersAlignTarget targ(channels, cpus, this, samples, len2);
1108 while( !ret && !dialog->failed && cur_pos < end_pos ) {
1110 int64_t nxt_pos = pos + len2;
1111 if( nxt_pos > end_pos ) nxt_pos = end_pos;
1112 len1 = nxt_pos - cur_pos;
1113 ret = audio.render(samples, len1, pos);
1115 targ.process_packages();
1116 dialog->update_progress(len1);
1117 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1121 if( !ret && !dialog->failed ) {
1124 MixersAlignMixer *mix = pkg->mixer;
1125 MixersAlignTargetPackage *best_pkg = 0;
1126 for( int i=0,n=targ.get_total_packages(); i<n; ++i ) {
1127 MixersAlignTargetPackage *targ_pkg =
1128 (MixersAlignTargetPackage *) targ.get_package(i);
1129 if( sd2 >= targ_pkg->sd2 ) continue;
1130 sd2 = targ_pkg->sd2;
1131 int k = dialog->atrack_of(mix, i);
1132 if( k < 0 ) continue;
1133 MixersAlignATrack *atrk = dialog->atracks[k];
1134 atrk->mi = targ_pkg->pos;
1135 atrk->ss = targ_pkg->ss;
1136 idx = k; best_pkg = targ_pkg;
1139 mix->br = new double[len];
1140 mix->bi = new double[len];
1141 double *br = mix->br;
1142 double *bp = best_pkg->best;
1144 while( i < len2 ) br[i++] = *bp++;
1145 while( i < len ) br[i++] = 0;
1147 fft.do_fft(len, 0, mix->br, 0, mix->br, mix->bi);
1152 if( ret && !dialog->failed ) {
1153 eprintf("Audio render failed:\n%s", edl->path);
1157 for( int i=channels; --i>=0; ) delete samples[i];
1161 // scan mixer channels for best target
1162 MixersAlignTarget::MixersAlignTarget(int n, int cpus,
1163 MixersAlignScanClient *scan, Samples **samples, int len)
1164 : LoadServer(n, cpus)
1167 this->samples = samples;
1170 MixersAlignTarget::~MixersAlignTarget()
1174 MixersAlignTargetClient::MixersAlignTargetClient()
1178 MixersAlignTargetClient::~MixersAlignTargetClient()
1182 LoadClient* MixersAlignTarget::new_client()
1184 return new MixersAlignTargetClient();
1187 MixersAlignTargetPackage::MixersAlignTargetPackage(MixersAlignTarget *targ)
1191 best = new double[targ->len];
1193 MixersAlignTargetPackage::~MixersAlignTargetPackage()
1198 LoadPackage* MixersAlignTarget::new_package()
1200 return new MixersAlignTargetPackage(this);
1203 void MixersAlignTarget::init_packages()
1207 void MixersAlignTargetClient::process_package(LoadPackage *package)
1209 MixersAlignTarget *targ = (MixersAlignTarget *)server;
1210 MixersAlignScanClient *scan = targ->scan;
1211 MixersAlignScanFarm *farm = (MixersAlignScanFarm *)scan->server;
1212 MixersAlign *dialog = farm->dialog;
1213 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1214 if( dialog->failed ) return;
1215 pkg = (MixersAlignTargetPackage *)package;
1217 int ch = get_package_number();
1218 double *data = targ->samples[ch]->get_data();
1219 int len1 = scan->len1;
1220 // computes sum(s**2), sum(d2**2) d2=discrete 2nd deriv
1221 // d0=s[i+0]-s[i+1], d1=s[i+1]-s[i+2], d2=d0-d1
1222 // d = s[i+0] - 2*s[i+1] + s[i+2]
1223 double ss = 0, sd2 = 0;
1224 double a = 0, b = 0, c = 0;
1225 for( int i=0; i<len1; ++i ) {
1226 a = b; b = c; c = data[i];
1227 double d = a - 2*b + c;
1228 ss += c*c; sd2 += d*d;
1230 //best is highest sd2
1231 if( pkg->sd2 < sd2 ) {
1234 pkg->pos = scan->pos;
1235 //printf("targ %s:%d at %jd,ss=%f sd2=%f\n",
1236 // scan->pkg->mixer->mixer->title, ch, scan->pos, ss, sd2);
1237 double *best = pkg->best;
1238 int i = 0, len = targ->len;
1239 while( i < len1 ) best[i++] = *data++;
1240 while( i < len ) best[i++] = 0;
1244 void MixersAlign::scan_master(Track *track)
1246 EDL *edl = mixer_master_clip(track);
1247 MixersAlignARender audio(mwindow, edl);
1249 int channels = edl->get_audio_channels();
1250 int64_t sample_rate = edl->get_sample_rate();
1251 int64_t audio_samples = edl->get_audio_samples();
1252 int64_t cur_pos = audio_start * sample_rate;
1253 int64_t end_pos = audio_end * sample_rate;
1254 if( end_pos > audio_samples ) end_pos = audio_samples;
1255 if( cur_pos >= end_pos ) {
1256 eprintf(_("scan master track empty"));
1260 int len = sample_len, len2 = len/2;
1261 double *audio_r = new double[len];
1262 double *audio_i = new double[len];
1263 Samples *samples[2][MAX_CHANNELS];
1264 for( int k=0; k<2; ++k ) {
1265 for( int i=0; i<MAX_CHANNELS; ++i )
1266 samples[k][i] = i<channels ? new Samples(len2) : 0;
1270 for( int i=0,n=mixers.size(); i<n; ++i )
1271 if( mixers[i]->br ) ++m;
1272 int cpus = bmin(mwindow->preferences->processors, m);
1273 MixersAlignMatchRevFarm farm(m, cpus, this, audio_r, audio_i, len);
1277 start_progress(end_pos - cur_pos);
1280 int64_t pos = cur_pos, nxt_pos = cur_pos+len2;
1281 if( nxt_pos > end_pos ) nxt_pos = end_pos;
1282 int len1 = nxt_pos - pos;
1283 int ret = audio.render(samples[k], len1, pos);
1284 while( !ret && !failed && cur_pos < end_pos ) {
1286 cur_pos = nxt_pos; nxt_pos += len2;
1287 if( nxt_pos > end_pos ) nxt_pos = end_pos;
1288 len1 = nxt_pos - cur_pos;
1289 ret = audio.render(samples[1-k], len1, cur_pos);
1291 update_progress(len2);
1293 double *lp = samples[k][0]->get_data();
1294 for( int j=0; j<len2; ++j ) audio_r[i++] = *lp++;
1295 double *np = samples[k=1-k][0]->get_data();
1296 for( int j=0; j<len1; ++j ) audio_r[i++] = *np++;
1297 while( i < len ) audio_r[i++] = 0;
1298 fft.do_fft(len, 0, audio_r, 0, audio_r, audio_i);
1300 farm.process_packages();
1301 if( progress->is_cancelled() ) failed = -1;
1304 if( ret && !failed ) {
1305 eprintf("Audio render failed:\n%s", edl->path);
1309 char text[BCSTRLEN];
1310 double secs = timer.get_difference()/1000.;
1311 sprintf(text, _("Match mixer done: %0.3f secs"), secs);
1312 stop_progress(text);
1316 for( int k=0; k<2; ++k ) {
1317 for( int i=channels; --i>=0; )
1318 delete samples[k][i];
1323 MixersAlignMatchFwdPackage::MixersAlignMatchFwdPackage()
1328 MixersAlignMatchFwdPackage::~MixersAlignMatchFwdPackage()
1332 MixersAlignMatchFwdFarm::MixersAlignMatchFwdFarm(MixersAlign *dialog, int n)
1333 : LoadServer(bmin(dialog->mwindow->preferences->processors, n), n)
1335 this->dialog = dialog;
1336 dialog->farming->lock("MixersAlignMatchFwdFarm::MixersAlignMatchFwdFarm");
1338 MixersAlignMatchFwdFarm::~MixersAlignMatchFwdFarm()
1340 dialog->farming->unlock();
1343 LoadPackage* MixersAlignMatchFwdFarm::new_package()
1345 return new MixersAlignMatchFwdPackage();
1348 void MixersAlignMatchFwdFarm::init_packages()
1350 for( int i = 0; i < get_total_packages(); ++i ) {
1351 int m = dialog->ma_gui->mixer_list->get_selection_number(0, i);
1352 MixersAlignMatchFwdPackage *package = (MixersAlignMatchFwdPackage *)get_package(i);
1353 package->mixer = dialog->mixers[m];
1357 LoadClient* MixersAlignMatchFwdFarm::new_client()
1359 return new MixersAlignMatchFwdClient(this);
1362 MixersAlignMatchFwdClient::MixersAlignMatchFwdClient(MixersAlignMatchFwdFarm *farm)
1367 MixersAlignMatchFwdClient::~MixersAlignMatchFwdClient()
1371 void MixersAlignMatchFwdClient::process_package(LoadPackage *package)
1373 MixersAlignMatchFwdFarm *farm = (MixersAlignMatchFwdFarm *)server;
1374 MixersAlign *dialog = farm->dialog;
1375 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1376 if( dialog->failed ) return;
1377 pkg = (MixersAlignMatchFwdPackage *)package;
1379 MixersAlignMixer *amix = pkg->mixer;
1380 EDL *edl = dialog->mixer_audio_clip(amix->mixer);
1381 MixersAlignARender audio(dialog->mwindow, edl);
1382 int channels = edl->get_audio_channels();
1383 int64_t sample_rate = edl->get_sample_rate();
1384 int64_t audio_samples = edl->get_audio_samples();
1385 int64_t cur_pos = dialog->audio_start * sample_rate;
1386 int64_t end_pos = dialog->audio_end * sample_rate;
1387 if( end_pos > audio_samples ) end_pos = audio_samples;
1388 int len = dialog->master_len, len2 = len/2;
1389 double *audio_r = new double[len];
1390 double *audio_i = new double[len];
1392 Samples *samples[2][MAX_CHANNELS];
1393 for( int k=0; k<2; ++k ) {
1394 for( int i=0; i<MAX_CHANNELS; ++i )
1395 samples[k][i] = i<channels ? new Samples(len2) : 0;
1400 int64_t pos = cur_pos, nxt_pos = cur_pos+len2;
1401 if( nxt_pos > end_pos ) nxt_pos = end_pos;
1402 int len1 = nxt_pos - pos;
1403 int ret = audio.render(samples[k], len1, pos);
1404 while( !ret && !dialog->failed && cur_pos < end_pos ) {
1405 dialog->update_progress(len1);
1409 if( nxt_pos > end_pos ) nxt_pos = end_pos;
1410 len1 = nxt_pos - cur_pos;
1411 ret = audio.render(samples[1-k], len1, cur_pos);
1413 Track *track = edl->tracks->first;
1414 for( int ch=0; ch<channels && track; ++ch, track=track->next ) {
1415 int id = track->mixer_id, atk = dialog->atracks.size();
1416 while( --atk >= 0 && id != dialog->atracks[atk]->track->mixer_id );
1417 if( atk < 0 ) continue;
1419 double *lp = samples[k][ch]->get_data();
1420 for( int j=0; j<len2; ++j ) audio_r[i++] = *lp++;
1421 double *np = samples[1-k][ch]->get_data();
1422 for( int j=0; j<len1; ++j ) audio_r[i++] = *np++;
1423 while( i < len ) audio_r[i++] = 0;
1424 fft.do_fft(len, 0, audio_r, 0, audio_r, audio_i);
1425 conj_product(len, audio_r, audio_i, audio_r, audio_i,
1426 dialog->master_r, dialog->master_i);
1427 fft.do_fft(len, 1, audio_r, audio_i);
1428 double mx = 0; int64_t mi = -1;
1429 for( int i=0; i<len2; ++i ) {
1430 double v = fabs(audio_r[i]);
1431 if( mx < v ) { mx = v; mi = i + pos; }
1433 mx /= dialog->master_ss;
1434 MixersAlignATrack *atrack= dialog->atracks[atk];
1435 if( atrack->mx < mx ) {
1441 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1443 if( ret && !dialog->failed ) {
1444 eprintf("Audio render failed:\n%s", edl->path);
1449 for( int k=0; k<2; ++k ) {
1450 for( int i=channels; --i>=0; )
1451 delete samples[k][i];
1457 MixersAlignMatchRevFarm::MixersAlignMatchRevFarm(int n, int cpus,
1458 MixersAlign *dialog, double *ar, double *ai, int len)
1459 : LoadServer(n, cpus)
1461 this->dialog = dialog;
1465 mixer_lock = new Mutex("MixersAlignMatchRevFarm::mixer_lock");
1468 MixersAlignMatchRevFarm::~MixersAlignMatchRevFarm()
1473 MixersAlignMatchRevPackage::MixersAlignMatchRevPackage()
1477 MixersAlignMatchRevPackage::~MixersAlignMatchRevPackage()
1481 void MixersAlignMatchRevFarm::init_packages()
1483 for( int i=0,m=0,n=dialog->mixers.size(); m<n; ++m ) {
1484 if( !dialog->mixers[m]->br ) continue;
1485 MixersAlignMatchRevPackage *pkg = (MixersAlignMatchRevPackage *)get_package(i++);
1486 pkg->mix = dialog->mixers[m];
1490 LoadClient *MixersAlignMatchRevFarm::new_client()
1492 return new MixersAlignMatchRevClient(this);
1494 LoadPackage *MixersAlignMatchRevFarm::new_package()
1496 return new MixersAlignMatchRevPackage();
1499 void MixersAlignMatchRevClient::process_package(LoadPackage *package)
1501 MixersAlignMatchRevFarm *farm = (MixersAlignMatchRevFarm *)server;
1502 MixersAlign *dialog = farm->dialog;
1503 if( dialog->progress->is_cancelled() ) dialog->failed = -1;
1504 if( dialog->failed ) return;
1505 pkg = (MixersAlignMatchRevPackage *)package;
1506 MixersAlignMixer *mix = pkg->mix;
1507 if( mix->aidx < 0 ) return;
1508 int64_t ss = dialog->atracks[mix->aidx]->ss;
1510 conj_product(farm->len, re, im, farm->ar, farm->ai, mix->br, mix->bi);
1512 fft.do_fft(farm->len, 1, re, im);
1513 double mx = 0; int64_t mi = -1;
1514 for( int i=0,n=farm->len/2; i<n; ++i ) {
1515 double r = fabs(re[i]) / ss;
1521 farm->mixer_lock->lock("MixersAlignMatchRevFarm::process_package");
1522 if( mix->mx < mx ) {
1525 //printf("best %d: %f at %jd\n", get_package_number(), mx, mi);
1527 farm->mixer_lock->unlock();
1530 MixersAlignMatchRevClient::MixersAlignMatchRevClient(MixersAlignMatchRevFarm *farm)
1532 re = new double[farm->len];
1533 im = new double[farm->len];
1535 MixersAlignMatchRevClient::~MixersAlignMatchRevClient()
1541 void MixersAlign::start_progress(int64_t total_len)
1544 mwindow->gui->lock_window("MixersAlign::start_progress");
1545 progress = mwindow->mainprogress->
1546 start_progress(_("match mixer audio"), total_len);
1547 mwindow->gui->unlock_window();
1549 void MixersAlign::stop_progress(const char *msg)
1551 mwindow->gui->lock_window("MixersAlign::stop_progress");
1552 progress->update(0);
1553 mwindow->mainprogress->end_progress(progress);
1555 if( msg ) mwindow->gui->show_message(msg);
1556 mwindow->gui->unlock_window();
1559 void MixersAlign::reset_targets()
1561 for( int m=0,n=mixers.size(); m<n; ++m ) {
1562 MixersAlignMixer *mix = mixers[m];
1563 delete mix->br; mix->br = 0;
1564 delete mix->bi; mix->bi = 0;
1568 for( int i=0,n=atracks.size(); i<n; ++i ) {
1569 MixersAlignATrack *atrk = atracks[i];
1570 atrk->nudge = 0; atrk->ss = 0;
1571 atrk->mx = 0; atrk->mi = -1;
1575 void MixersAlign::scan_targets()
1577 int idx = ma_gui->mtrack_list->get_selection_number(0, 0);
1578 int midx = mmixer_of(idx);
1579 int64_t total_len = mixer_tracks_total(midx);
1580 start_progress(total_len);
1581 int m = mixers.size();
1582 if( midx >= 0 ) --m;
1583 int cpus = bmin(mwindow->preferences->processors, m);
1584 MixersAlignScanFarm scan(this, cpus, m);
1585 scan.process_packages();
1589 void MixersAlign::update_progress(int64_t len)
1592 total_rendered += len;
1593 total_lock->unlock();
1594 progress->update(total_rendered);
1597 static inline uint64_t high_bit_mask(uint64_t n)
1599 n |= n >> 1; n |= n >> 2;
1600 n |= n >> 4; n |= n >> 8;
1601 n |= n >> 16; n |= n >> 32;
1605 void MixersAlign::load_master_audio(Track *track)
1607 EDL *edl = mixer_master_clip(track);
1608 MixersAlignARender audio(mwindow, edl);
1609 int channels = edl->get_audio_channels();
1610 int64_t sample_rate = edl->get_sample_rate();
1611 int64_t audio_samples = edl->get_audio_samples();
1612 int64_t cur_pos = master_start * sample_rate;
1613 int64_t end_pos = master_end * sample_rate;
1614 if( end_pos > audio_samples ) end_pos = audio_samples;
1615 if( cur_pos >= end_pos ) {
1616 eprintf(_("master audio track empty"));
1620 int64_t audio_len = end_pos - cur_pos;
1621 if( audio_len > sample_rate * 60 ) {
1622 eprintf(_("master audio track length > 60 seconds"));
1626 int64_t fft_len = (high_bit_mask(audio_len)+1) << 1;
1627 if( master_len != fft_len ) {
1628 master_len = fft_len;
1629 delete [] master_r; master_r = new double[master_len];
1630 delete [] master_i; master_i = new double[master_len];
1633 Samples *samples[MAX_CHANNELS];
1634 for( int i=0; i<MAX_CHANNELS; ++i )
1635 samples[i] = i<channels ? new Samples(audio_len) : 0;
1636 int ret = audio.render(samples, audio_len, cur_pos);
1637 if( ret ) failed = 1;
1640 double *dp = samples[0]->get_data();
1641 int i = 0; double ss = 0;
1642 for( ; i<audio_len; ++i ) { ss += *dp * *dp; master_r[i] = *dp++; }
1644 for( ; i<fft_len; ++i ) master_r[i] = 0;
1645 for( int i=channels; --i>=0; ) delete samples[i];
1647 do_fft(fft_len, 0, master_r, 0, master_r, master_i);
1650 void MixersAlign::scan_mixer_audio()
1652 for( int i=0; i<mixers.size(); ++i ) mixers[i]->aidx = -1;
1654 while( ma_gui->mixer_list->get_selection_number(0, n) >= 0 ) ++n;
1656 eprintf(_("no mixers selected"));
1661 MixersAlignMatchFwdFarm farm(this, n);
1662 int64_t total_len = mixer_tracks_total(-1);
1663 start_progress(total_len);
1665 farm.process_packages();
1666 if( progress->is_cancelled() ) failed = -1;
1668 char text[BCSTRLEN];
1669 double secs = timer.get_difference()/1000.;
1670 sprintf(text, _("Render mixer done: %0.3f secs"), secs);
1671 stop_progress(text);
1674 void MixersAlign::match_fwd()
1676 int idx = ma_gui->mtrack_list->get_selection_number(0, 0);
1678 eprintf(_("selection (master) not set"));
1681 master_start = mwindow->edl->local_session->get_inpoint();
1682 if( master_start < 0 ) {
1683 eprintf(_("in point selection (master start) must be set"));
1686 master_end = mwindow->edl->local_session->get_outpoint();
1687 if( master_end < 0 ) {
1688 eprintf(_("out point selection (master end) must be set"));
1691 if( master_start >= master_end ) {
1692 eprintf(_("in/out point selection (master start/end) invalid"));
1695 audio_start = mwindow->edl->local_session->get_selectionstart();
1696 audio_end = mwindow->edl->local_session->get_selectionend();
1697 if( audio_start >= audio_end ) {
1698 eprintf(_("selection (audio start/end) invalid"));
1704 load_master_audio(mtracks[idx]->track);
1710 mwindow->gui->lock_window("MixersAlign::update_match_fwd");
1711 mwindow->gui->show_message(_("mixer selection match canceled"));
1712 mwindow->gui->unlock_window();
1714 else if( failed > 0 )
1715 eprintf(_("Error in match render."));
1718 void MixersAlign::match_rev()
1720 int midx = ma_gui->mtrack_list->get_selection_number(0, 0);
1722 eprintf(_("selection (master) not set"));
1725 Track *track = mtracks[midx]->track;
1726 audio_start = mwindow->edl->local_session->get_selectionstart();
1727 audio_end = mwindow->edl->local_session->get_selectionend();
1728 if( audio_start >= audio_end ) {
1729 eprintf(_("selection (audio start/end) invalid"));
1744 mwindow->gui->lock_window("MixersAlign::update_match_rev");
1745 mwindow->gui->show_message(_("mixer selection match canceled"));
1746 mwindow->gui->unlock_window();
1748 else if( failed > 0 )
1749 eprintf(_("Error in match render."));
1752 void MixersAlign::update_fwd()
1754 double sample_rate = mwindow->edl->get_sample_rate();
1755 int64_t mi = master_start * sample_rate;
1756 // mixer best matches
1757 for( int m=0; m<mixers.size(); ++m ) {
1758 MixersAlignMixer *mix = mixers[m];
1759 Mixer *mixer = mix->mixer;
1760 mix->mx = 0; mix->mi = -1; mix->aidx = -1;
1761 for( int i=0; i<mixer->mixer_ids.size(); ++i ) {
1762 int id = mixer->mixer_ids[i], k = atracks.size();
1763 while( --k >= 0 && atracks[k]->track->mixer_id != id );
1764 if( k < 0 ) continue;
1765 MixersAlignATrack *atrk = atracks[k];
1766 atrk->nudge = atrk->mi < 0 ? -1 :
1767 (mi - atrk->mi) / sample_rate;
1768 if( mix->mx >= atrk->mx ) continue;
1772 mix->nudge = atrk->nudge;
1778 void MixersAlign::update_rev()
1780 int idx = ma_gui->mtrack_list->get_selection_number(0, 0);
1781 int midx = mmixer_of(idx);
1782 double sample_rate = mwindow->edl->get_sample_rate();
1783 for( int m=0,n=mixers.size(); m<n; ++m ) {
1784 if( m == midx ) continue;
1785 if( !ma_gui->mixer_list->is_selected(m) ) continue;
1786 MixersAlignMixer *mix = mixers[m];
1787 if( mix->aidx < 0 ) continue;
1788 MixersAlignATrack *atrk = atracks[mix->aidx];
1789 mix->nudge = atrk->mi < 0 ? -1 :
1790 (mix->mi - atrk->mi) / sample_rate;
1796 void MixersAlign::update()
1798 ma_gui->lock_window("MixersAlign::update");
1799 ma_gui->mixer_list->load_list();
1800 ma_gui->mixer_list->set_all_selected(1);
1801 ma_gui->mixer_list->update();
1803 ma_gui->atrack_list->load_list();
1804 for( int m=0; m<mixers.size(); ++m ) {
1805 int aidx = mixers[m]->aidx;
1806 if( aidx >= 0 ) ma_gui->atrack_list->set_selected(aidx, 1);
1808 ma_gui->atrack_list->update();
1809 ma_gui->unlock_window();