1eec0d4179c1dcae49829432aa7027c5c4666e6a
[goodguy/history.git] / cinelerra-5.1 / cinelerra / tracks.C
1 /*
2  * CINELERRA
3  * Copyright (C) 2010 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 #include "atrack.h"
22 #include "automation.h"
23 #include "clip.h"
24 #include "bchash.h"
25 #include "edit.h"
26 #include "edits.h"
27 #include "edl.h"
28 #include "edlsession.h"
29 #include "file.h"
30 #include "filexml.h"
31 #include "intauto.h"
32 #include "intautos.h"
33 #include "localsession.h"
34 #include "module.h"
35 #include "panauto.h"
36 #include "panautos.h"
37 #include "patchbay.h"
38 #include "mainsession.h"
39 #include "strack.h"
40 #include "theme.h"
41 #include "track.h"
42 #include "trackcanvas.h"
43 #include "tracks.h"
44 #include "transportque.inc"
45 #include "vtrack.h"
46 #include <string.h>
47
48 Tracks::Tracks(EDL *edl)
49  : List<Track>()
50 {
51         this->edl = edl;
52 }
53
54 Tracks::Tracks()
55  : List<Track>()
56 {
57 }
58
59
60 Tracks::~Tracks()
61 {
62         delete_all_tracks();
63 }
64
65
66
67
68
69 void Tracks::equivalent_output(Tracks *tracks, double *result)
70 {
71         if(total_playable_vtracks() != tracks->total_playable_vtracks())
72         {
73                 *result = 0;
74         }
75         else
76         {
77                 Track *current = first;
78                 Track *that_current = tracks->first;
79                 while(current || that_current)
80                 {
81 // Get next video track
82                         while(current && current->data_type != TRACK_VIDEO)
83                                 current = NEXT;
84
85                         while(that_current && that_current->data_type != TRACK_VIDEO)
86                                 that_current = that_current->next;
87
88 // One doesn't exist but the other does
89                         if((!current && that_current) ||
90                                 (current && !that_current))
91                         {
92                                 *result = 0;
93                                 break;
94                         }
95                         else
96 // Both exist
97                         if(current && that_current)
98                         {
99                                 current->equivalent_output(that_current, result);
100                                 current = NEXT;
101                                 that_current = that_current->next;
102                         }
103                 }
104         }
105 }
106
107
108
109
110 void Tracks::get_affected_edits(ArrayList<Edit*> *drag_edits, double position, Track *start_track)
111 {
112         drag_edits->remove_all();
113
114         for(Track *track = start_track;
115                 track;
116                 track = track->next)
117         {
118 //printf("Tracks::get_affected_edits 1 %p %d %d\n", track, track->data_type, track->record);
119                 if(track->record)
120                 {
121                         for(Edit *edit = track->edits->first; edit; edit = edit->next)
122                         {
123                                 double startproject = track->from_units(edit->startproject);
124 //printf("Tracks::get_affected_edits 1 %d\n", edl->equivalent(startproject, position));
125                                 if(edl->equivalent(startproject, position))
126                                 {
127                                         drag_edits->append(edit);
128                                         break;
129                                 }
130                         }
131                 }
132         }
133
134 }
135
136 void Tracks::get_automation_extents(float *min,
137         float *max,
138         double start,
139         double end,
140         int autogrouptype)
141 {
142         *min = 0;
143         *max = 0;
144         int coords_undefined = 1;
145         for(Track *current = first; current; current = NEXT)
146         {
147                 if(current->record)
148                 {
149                         current->automation->get_extents(min,
150                                 max,
151                                 &coords_undefined,
152                                 current->to_units(start, 0),
153                                 current->to_units(end, 1),
154                                 autogrouptype);
155                 }
156         }
157 }
158
159
160 void Tracks::copy_from(Tracks *tracks)
161 {
162         Track *new_track = 0;
163
164         delete_all_tracks();
165         for(Track *current = tracks->first; current; current = NEXT)
166         {
167                 switch(current->data_type)
168                 {
169                 case TRACK_AUDIO:
170                         new_track = add_audio_track(0, 0);
171                         break;
172                 case TRACK_VIDEO:
173                         new_track = add_video_track(0, 0);
174                         break;
175                 case TRACK_SUBTITLE:
176                         new_track = add_subttl_track(0, 0);
177                         break;
178                 default:
179                         continue;
180                 }
181                 new_track->copy_from(current);
182         }
183 }
184
185 Tracks& Tracks::operator=(Tracks &tracks)
186 {
187 printf("Tracks::operator= 1\n");
188         copy_from(&tracks);
189         return *this;
190 }
191
192 int Tracks::load(FileXML *xml,
193         int &track_offset,
194         uint32_t load_flags)
195 {
196 // add the appropriate type of track
197         char string[BCTEXTLEN];
198         Track *track = 0;
199         string[0] = 0;
200
201         xml->tag.get_property("TYPE", string);
202
203         if((load_flags & LOAD_ALL) == LOAD_ALL ||
204                 (load_flags & LOAD_EDITS))
205         {
206                 if(!strcmp(string, "VIDEO"))
207                 {
208                         add_video_track(0, 0);
209                 }
210                 else
211                 if(!strcmp(string, "SUBTTL"))
212                 {
213                         add_subttl_track(0, 0);
214                 }
215                 else
216                 {
217                         add_audio_track(0, 0);    // default to audio
218                 }
219                 track = last;
220         }
221         else
222         {
223                 track = get_item_number(track_offset);
224                 track_offset++;
225         }
226
227 // load it
228         if(track) track->load(xml, track_offset, load_flags);
229
230         return 0;
231 }
232
233 Track* Tracks::add_audio_track(int above, Track *dst_track)
234 {
235         ATrack* new_track = new ATrack(edl, this);
236         if(!dst_track)
237         {
238                 dst_track = (above ? first : last);
239         }
240
241         if(above)
242         {
243                 insert_before(dst_track, (Track*)new_track);
244         }
245         else
246         {
247                 insert_after(dst_track, (Track*)new_track);
248 // Shift effects referenced below the destination track
249         }
250
251 // Shift effects referenced below the new track
252         for(Track *track = last;
253                 track && track != new_track;
254                 track = track->previous)
255         {
256                 change_modules(number_of(track) - 1, number_of(track), 0);
257         }
258
259
260         new_track->create_objects();
261         new_track->set_default_title();
262
263         int current_pan = 0;
264         for(Track *current = first;
265                 current != (Track*)new_track;
266                 current = NEXT)
267         {
268                 if(current->data_type == TRACK_AUDIO) current_pan++;
269                 if(current_pan >= edl->session->audio_channels) current_pan = 0;
270         }
271
272
273
274         PanAuto* pan_auto =
275                 (PanAuto*)new_track->automation->autos[AUTOMATION_PAN]->default_auto;
276         pan_auto->values[current_pan] = 1.0;
277
278         BC_Pan::calculate_stick_position(edl->session->audio_channels,
279                 edl->session->achannel_positions,
280                 pan_auto->values,
281                 MAX_PAN,
282                 PAN_RADIUS,
283                 pan_auto->handle_x,
284                 pan_auto->handle_y);
285         return new_track;
286 }
287
288 Track* Tracks::add_video_track(int above, Track *dst_track)
289 {
290 const int debug = 0;
291 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
292         VTrack* new_track = new VTrack(edl, this);
293 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
294         if(!dst_track)
295                 dst_track = (above ? first : last);
296
297 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
298         if(above)
299         {
300                 insert_before(dst_track, (Track*)new_track);
301         }
302         else
303         {
304                 insert_after(dst_track, (Track*)new_track);
305         }
306 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
307
308
309
310 // Shift effects referenced below the new track
311         for(Track *track = last;
312                 track && track != new_track;
313                 track = track->previous)
314         {
315                 change_modules(number_of(track) - 1, number_of(track), 0);
316         }
317
318 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
319
320
321         new_track->create_objects();
322 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
323         new_track->set_default_title();
324 if(debug) printf("Tracks::add_video_track %d\n", __LINE__);
325         return new_track;
326 }
327
328
329 Track* Tracks::add_subttl_track(int above, Track *dst_track)
330 {
331 const int debug = 0;
332 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
333         STrack* new_track = new STrack(edl, this);
334 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
335         if(!dst_track)
336                 dst_track = (above ? first : last);
337
338 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
339         if(above)
340         {
341                 insert_before(dst_track, (Track*)new_track);
342         }
343         else
344         {
345                 insert_after(dst_track, (Track*)new_track);
346         }
347 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
348
349
350
351 // Shift effects referenced below the new track
352         for(Track *track = last;
353                 track && track != new_track;
354                 track = track->previous)
355         {
356                 change_modules(number_of(track) - 1, number_of(track), 0);
357         }
358
359 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
360
361
362         new_track->create_objects();
363 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
364         new_track->set_default_title();
365 if(debug) printf("Tracks::add_subttl_track %d\n", __LINE__);
366
367 //      new_track->paste_silence(0,total_length(),0);
368         return new_track;
369 }
370
371
372 int Tracks::delete_track(Track *track)
373 {
374         if (!track)
375                 return 0;
376
377         int old_location = number_of(track);
378         detach_shared_effects(old_location);
379
380 // Shift effects referencing effects below the deleted track
381         for(Track *current = track;
382                 current;
383                 current = NEXT)
384         {
385                 change_modules(number_of(current), number_of(current) - 1, 0);
386         }
387         if(track) delete track;
388
389         return 0;
390 }
391
392 int Tracks::detach_shared_effects(int module)
393 {
394         for(Track *current = first; current; current = NEXT)
395         {
396                 current->detach_shared_effects(module);
397         }
398
399         return 0;
400  }
401
402 int Tracks::total_of(int type)
403 {
404         int result = 0;
405
406         for(Track *current = first; current; current = NEXT)
407         {
408                 long unit_start = current->to_units(edl->local_session->get_selectionstart(1), 0);
409                 Auto *mute_keyframe = 0;
410                 current->automation->autos[AUTOMATION_MUTE]->
411                         get_prev_auto(unit_start, PLAY_FORWARD, mute_keyframe);
412                 IntAuto *mute_auto = (IntAuto *)mute_keyframe;
413
414                 result +=
415                         (current->play && type == PLAY) ||
416                         (current->record && type == RECORD) ||
417                         (current->gang && type == GANG) ||
418                         (current->draw && type == DRAW) ||
419                         (mute_auto->value && type == MUTE) ||
420                         (current->expand_view && type == EXPAND);
421         }
422         return result;
423 }
424
425 int Tracks::recordable_audio_tracks()
426 {
427         int result = 0;
428         for(Track *current = first; current; current = NEXT)
429                 if(current->data_type == TRACK_AUDIO && current->record) result++;
430         return result;
431 }
432
433 int Tracks::recordable_video_tracks()
434 {
435         int result = 0;
436         for(Track *current = first; current; current = NEXT)
437         {
438                 if(current->data_type == TRACK_VIDEO && current->record) result++;
439         }
440         return result;
441 }
442
443
444 int Tracks::playable_audio_tracks()
445 {
446         int result = 0;
447
448         for(Track *current = first; current; current = NEXT)
449         {
450                 if(current->data_type == TRACK_AUDIO && current->play)
451                 {
452                         result++;
453                 }
454         }
455
456         return result;
457 }
458
459 int Tracks::playable_video_tracks()
460 {
461         int result = 0;
462
463         for(Track *current = first; current; current = NEXT)
464         {
465                 if(current->data_type == TRACK_VIDEO && current->play)
466                 {
467                         result++;
468                 }
469         }
470         return result;
471 }
472
473 int Tracks::total_audio_tracks()
474 {
475         int result = 0;
476         for(Track *current = first; current; current = NEXT)
477                 if(current->data_type == TRACK_AUDIO) result++;
478         return result;
479 }
480
481 int Tracks::total_video_tracks()
482 {
483         int result = 0;
484         for(Track *current = first; current; current = NEXT)
485                 if(current->data_type == TRACK_VIDEO) result++;
486         return result;
487 }
488
489 double Tracks::total_playable_length()
490 {
491         double total = 0;
492         for(Track *current = first; current; current = NEXT)
493         {
494                 if( current->play )
495                 {
496                         double length = current->get_length();
497                         if(length > total) total = length;
498                 }
499         }
500         return total;
501 }
502
503 double Tracks::total_recordable_length()
504 {
505         double total = -1;
506         for(Track *current = first; current; current = NEXT)
507         {
508                 if(current->record)
509                 {
510                         double length = current->get_length();
511                         if(length > total) total = length;
512                 }
513         }
514         return total;
515 }
516
517 double Tracks::total_length()
518 {
519         double total = 0;
520         for(Track *current = first; current; current = NEXT)
521         {
522                 double length = current->get_length();
523                 if(length > total) total = length;
524         }
525         return total;
526 }
527
528 double Tracks::total_audio_length()
529 {
530         double total = 0;
531         for(Track *current = first; current; current = NEXT)
532         {
533                 if(current->data_type == TRACK_AUDIO &&
534                         current->get_length() > total) total = current->get_length();
535         }
536         return total;
537 }
538
539 double Tracks::total_video_length()
540 {
541         double total = 0;
542         for(Track *current = first; current; current = NEXT)
543         {
544                 if(current->data_type == TRACK_VIDEO &&
545                         current->get_length() > total) total = current->get_length();
546         }
547         return total;
548 }
549
550 double Tracks::total_length_framealigned(double fps)
551 {
552         if (total_audio_tracks() && total_video_tracks())
553                 return MIN(floor(total_audio_length() * fps), floor(total_video_length() * fps)) / fps;
554
555         if (total_audio_tracks())
556                 return floor(total_audio_length() * fps) / fps;
557
558         if (total_video_tracks())
559                 return floor(total_video_length() * fps) / fps;
560
561         return 0;
562 }
563
564 void Tracks::translate_projector(float offset_x, float offset_y)
565 {
566         for(Track *current = first; current; current = NEXT)
567         {
568                 if(current->data_type == TRACK_VIDEO)
569                 {
570                         ((VTrack*)current)->translate(offset_x, offset_y, 0);
571                 }
572         }
573 }
574
575 void Tracks::update_y_pixels(Theme *theme)
576 {
577 //      int y = -edl->local_session->track_start;
578         int y = 0;
579         for(Track *current = first; current; current = NEXT)
580         {
581 //printf("Tracks::update_y_pixels %d\n", y);
582                 current->y_pixel = y;
583                 y += current->vertical_span(theme);
584         }
585 }
586
587 int Tracks::dump(FILE *fp)
588 {
589         for(Track* current = first; current; current = NEXT)
590         {
591                 fprintf(fp,"  Track: %p\n", current);
592                 current->dump(fp);
593                 fprintf(fp,"\n");
594         }
595         return 0;
596 }
597
598 void Tracks::select_all(int type,
599                 int value)
600 {
601         for(Track* current = first; current; current = NEXT)
602         {
603                 double position = edl->local_session->get_selectionstart(1);
604
605                 if(type == PLAY) current->play = value;
606                 if(type == RECORD) current->record = value;
607                 if(type == GANG) current->gang = value;
608                 if(type == DRAW) current->draw = value;
609
610                 if(type == MUTE)
611                 {
612                         ((IntAuto*)current->automation->autos[AUTOMATION_MUTE]->get_auto_for_editing(position))->value = value;
613                 }
614
615                 if(type == EXPAND) current->expand_view = value;
616         }
617 }
618
619 // ===================================== file operations
620
621 int Tracks::popup_transition(int cursor_x, int cursor_y)
622 {
623         int result = 0;
624         for(Track* current = first; current && !result; current = NEXT)
625         {
626                 result = current->popup_transition(cursor_x, cursor_y);
627         }
628         return result;
629 }
630
631
632 int Tracks::change_channels(int oldchannels, int newchannels)
633 {
634         for(Track *current = first; current; current = NEXT)
635         { current->change_channels(oldchannels, newchannels); }
636         return 0;
637 }
638
639
640
641 int Tracks::totalpixels()
642 {
643         int result = 0;
644         for(Track* current = first; current; current = NEXT)
645         {
646                 result += edl->local_session->zoom_track;
647         }
648         return result;
649 }
650
651 int Tracks::number_of(Track *track)
652 {
653         int i = 0;
654         for(Track *current = first; current && current != track; current = NEXT)
655         {
656                 i++;
657         }
658         return i;
659 }
660
661 Track* Tracks::number(int number)
662 {
663         Track *current;
664         int i = 0;
665         for(current = first; current && i < number; current = NEXT)
666         {
667                 i++;
668         }
669         return current;
670 }
671
672
673 int Tracks::total_playable_vtracks()
674 {
675         int result = 0;
676         for(Track *current = first; current; current = NEXT)
677         {
678                 if(current->data_type == TRACK_VIDEO && current->play) result++;
679         }
680         return result;
681 }
682
683 int Tracks::plugin_exists(Plugin *plugin)
684 {
685         for(Track *track = first; track; track = track->next)
686         {
687                 if(track->plugin_exists(plugin)) return 1;
688         }
689         return 0;
690 }
691
692 int Tracks::track_exists(Track *track)
693 {
694         for(Track *current = first; current; current = NEXT)
695         {
696                 if(current == track) return 1;
697         }
698         return 0;
699 }
700
701
702 Track *Tracks::get(int idx, int data_type)
703 {
704         for(Track *current = first; current; current = NEXT)
705         {
706                 if( current->data_type != data_type ) continue;
707                 if( --idx < 0 ) return current;
708         }
709         return 0;
710 }
711
712