add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / autos.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "autos.h"
23 #include "clip.h"
24 #include "edl.h"
25 #include "edlsession.h"
26 #include "floatauto.h"
27 #include "localsession.h"
28 #include "filexml.h"
29 #include "track.h"
30 #include "transportque.inc"
31
32
33 Autos::Autos(EDL *edl, Track *track)
34  : List<Auto>()
35 {
36         this->edl = edl;
37         this->track = track;
38         type = -1;
39         autoidx = -1;
40         autogrouptype = -1;
41 }
42
43
44
45 Autos::~Autos()
46 {
47         while(last) delete last;
48         delete default_auto;
49 }
50
51 void Autos::create_objects()
52 {
53 // Default
54         default_auto = new_auto();
55         default_auto->is_default = 1;
56 }
57
58 int Autos::get_type()
59 {
60         return type;
61 }
62
63 Auto* Autos::append_auto()
64 {
65         return append(new_auto());
66 }
67
68
69 Auto* Autos::new_auto()
70 {
71         return new Auto(edl, this);
72 }
73
74 void Autos::resample(double old_rate, double new_rate)
75 {
76         for(Auto *current = first; current; current = NEXT)
77         {
78                 current->position = (int64_t)((double)current->position *
79                         new_rate /
80                         old_rate +
81                         0.5);
82         }
83 }
84
85 void Autos::equivalent_output(Autos *autos, int64_t startproject, int64_t *result)
86 {
87 // Default keyframe differs
88         if(!total() && !(*default_auto == *autos->default_auto))
89         {
90                 if(*result < 0 || *result > startproject) *result = startproject;
91         }
92         else
93 // Search for difference
94         {
95                 for(Auto *current = first, *that_current = autos->first;
96                         current || that_current;
97                         current = NEXT,
98                         that_current = that_current->next)
99                 {
100 // Total differs
101                         if(current && !that_current)
102                         {
103                                 int64_t position1 = (autos->last ? autos->last->position : startproject);
104                                 int64_t position2 = current->position;
105                                 if(*result < 0 || *result > MIN(position1, position2))
106                                         *result = MIN(position1, position2);
107                                 break;
108                         }
109                         else
110                         if(!current && that_current)
111                         {
112                                 int64_t position1 = (last ? last->position : startproject);
113                                 int64_t position2 = that_current->position;
114                                 if(*result < 0 || *result > MIN(position1, position2))
115                                         *result = MIN(position1, position2);
116                                 break;
117                         }
118                         else
119 // Keyframes differ
120                         if(!(*current == *that_current) ||
121                                 current->position != that_current->position)
122                         {
123                                 int64_t position1 = (current->previous ?
124                                         current->previous->position :
125                                         startproject);
126                                 int64_t position2 = (that_current->previous ?
127                                         that_current->previous->position :
128                                         startproject);
129                                 if(*result < 0 || *result > MIN(position1, position2))
130                                         *result = MIN(position1, position2);
131                                 break;
132                         }
133                 }
134         }
135 }
136
137 void Autos::copy_from(Autos *autos)
138 {
139         Auto *current = autos->first, *this_current = first;
140
141         default_auto->copy_from(autos->default_auto);
142
143 // Detect common memory leak bug
144         if(autos->first && !autos->last)
145         {
146                 printf("Autos::copy_from inconsistent pointers\n");
147                 exit(1);
148         }
149
150         for(current = autos->first; current; current = NEXT)
151         {
152 //printf("Autos::copy_from 1 %p\n", current);
153 //sleep(1);
154                 if(!this_current)
155                 {
156                         append(this_current = new_auto());
157                 }
158                 this_current->copy_from(current);
159                 this_current = this_current->next;
160         }
161
162         for( ; this_current; )
163         {
164                 Auto *next_current = this_current->next;
165                 delete this_current;
166                 this_current = next_current;
167         }
168 }
169
170
171 // We don't replace it in pasting but
172 // when inserting the first EDL of a load operation we need to replace
173 // the default keyframe.
174 void Autos::insert_track(Autos *automation,
175         int64_t start_unit,
176         int64_t length_units,
177         int replace_default)
178 {
179 // Insert silence
180         insert(start_unit, start_unit + length_units);
181
182         if(replace_default) default_auto->copy_from(automation->default_auto);
183         for(Auto *current = automation->first; current; current = NEXT)
184         {
185 // fill new auto with values from current (template), interpolate values if possible
186                 Auto *new_auto = insert_auto(start_unit + current->position, current);
187 // Override copy_from
188                 new_auto->position = current->position + start_unit;
189         }
190 }
191
192 Auto* Autos::get_prev_auto(int64_t position,
193         int direction,
194         Auto* &current,
195         int use_default)
196 {
197 // Get on or before position
198         if(direction == PLAY_FORWARD)
199         {
200 // Try existing result
201                 if(current)
202                 {
203                         while(current && current->position < position) current = NEXT;
204                         while(current && current->position > position) current = PREVIOUS;
205                 }
206
207                 if(!current)
208                 {
209                         for(current = last;
210                                 current && current->position > position;
211                                 current = PREVIOUS) ;
212                 }
213                 if(!current && use_default) current = (first ? first : default_auto);
214         }
215         else
216 // Get on or after position
217         if(direction == PLAY_REVERSE)
218         {
219                 if(current)
220                 {
221                         while(current && current->position > position) current = PREVIOUS;
222                         while(current && current->position < position) current = NEXT;
223                 }
224
225                 if(!current)
226                 {
227                         for(current = first;
228                                 current && current->position < position;
229                                 current = NEXT) ;
230                 }
231
232                 if(!current && use_default) current = (last ? last : default_auto);
233         }
234
235         return current;
236 }
237
238 Auto* Autos::get_prev_auto(int direction, Auto* &current)
239 {
240         double position_double = edl->local_session->get_selectionstart(1);
241         position_double = edl->align_to_frame(position_double, 0);
242         int64_t position = track->to_units(position_double, 0);
243
244         return get_prev_auto(position, direction, current);
245 }
246
247 int Autos::auto_exists_for_editing(double position)
248 {
249         int result = 0;
250
251         if(edl->session->auto_keyframes)
252         {
253                 double unit_position = position;
254                 unit_position = edl->align_to_frame(unit_position, 0);
255                 if (get_auto_at_position(unit_position))
256                         result = 1;
257         }
258         else
259         {
260                 result = 1;
261         }
262
263         return result;
264 }
265
266 Auto* Autos::get_auto_at_position(double position)
267 {
268         int64_t unit_position = track->to_units(position, 0);
269
270         for(Auto *current = first;
271                 current;
272                 current = NEXT)
273         {
274                 if(edl->equivalent(current->position, unit_position))
275                 {
276                         return current;
277                 }
278         }
279         return 0;
280 }
281
282
283 Auto* Autos::get_auto_for_editing(double position)
284 {
285         if(position < 0) {
286                 position = edl->local_session->get_selectionstart(1);
287         }
288
289         Auto *result = 0;
290         get_prev_auto(track->to_units(position, 0), PLAY_FORWARD, result);
291 //printf("Autos::get_auto_for_editing %p %p %p\n", default_auto, first, result);
292         if( !result || !EQUIV(track->from_units(result->position), position) ) {
293                 if( edl->session->auto_keyframes ) {
294                         position = edl->align_to_frame(position, 0);
295                         result = insert_auto(track->to_units(position, 0));
296                 }
297         }
298 //printf("Autos::get_auto_for_editing %p %p\n", first, default_auto);
299
300         return result;
301 }
302
303
304 Auto* Autos::get_next_auto(int64_t position, int direction, Auto* &current, int use_default)
305 {
306         if(direction == PLAY_FORWARD)
307         {
308                 if(current)
309                 {
310                         while(current && current->position > position) current = PREVIOUS;
311                         while(current && current->position < position) current = NEXT;
312                 }
313
314                 if(!current)
315                 {
316                         for(current = first;
317                                 current && current->position <= position;
318                                 current = NEXT)
319                                 ;
320                 }
321
322                 if(!current && use_default) current = (last ? last : default_auto);
323         }
324         else
325         if(direction == PLAY_REVERSE)
326         {
327                 if(current)
328                 {
329                         while(current && current->position < position) current = NEXT;
330                         while(current && current->position > position) current = PREVIOUS;
331                 }
332
333                 if(!current)
334                 {
335                         for(current = last;
336                                 current && current->position > position;
337                                 current = PREVIOUS)
338                                 ;
339                 }
340
341                 if(!current && use_default) current = (first ? first : default_auto);
342         }
343
344         return current;
345 }
346 Auto* Autos::insert_auto(int64_t position, Auto *templ)
347 {
348         Auto *current, *result;
349
350 // Test for existence
351         for(current = first;
352                 current && !edl->equivalent(current->position, position);
353                 current = NEXT)
354         {
355                 ;
356         }
357
358 // Insert new
359         if(!current)
360         {
361 // Get first one on or before as a template
362                 for(current = last;
363                         current && current->position > position;
364                         current = PREVIOUS)
365                 {
366                         ;
367                 }
368
369                 if(current)
370                 {
371                         insert_after(current, result = new_auto());
372                 }
373                 else
374                 {
375                         current = first;
376                         if(!current) current = default_auto;
377
378                         insert_before(first, result = new_auto());
379                 }
380
381 // interpolate if possible, else copy from template
382                 result->interpolate_from(0, 0, position, templ);
383 // Set curve mode
384                 if( !templ && result->is_floatauto() ) {
385                         FloatAuto *floatauto = (FloatAuto *)result;
386                         floatauto->curve_mode =
387                                 edl->local_session->playback_start >= 0 &&
388                                 edl->local_session->playback_end < 0 ? FloatAuto::SMOOTH :
389                                         (FloatAuto::t_mode) edl->local_session->floatauto_type;
390                 }
391         }
392         else
393         {
394                 result = current;
395         }
396
397         return result;
398 }
399
400 int Autos::clear_all()
401 {
402         Auto *current_, *current;
403
404         for(current = first; current; current = current_)
405         {
406                 current_ = NEXT;
407                 remove(current);
408         }
409         append_auto();
410         return 0;
411 }
412
413 int Autos::insert(int64_t start, int64_t end)
414 {
415         int64_t length;
416         Auto *current = first;
417
418         for( ; current && current->position < start; current = NEXT)
419                 ;
420
421         length = end - start;
422
423         for(; current; current = NEXT)
424         {
425                 current->position += length;
426         }
427         return 0;
428 }
429
430 void Autos::paste(int64_t start,
431         int64_t length,
432         double scale,
433         FileXML *file,
434         int default_only,
435         int active_only)
436 {
437         int total = 0;
438         int result = 0;
439
440 //printf("Autos::paste %d start=%jd\n", __LINE__, start);
441         do{
442                 result = file->read_tag();
443
444                 if(!result && !file->tag.title_is("/AUTO"))
445                 {
446 // End of list
447                         if(file->tag.get_title()[0] == '/')
448                         {
449                                 result = 1;
450                         }
451                         else
452                         if(!strcmp(file->tag.get_title(), "AUTO"))
453                         {
454                                 Auto *current = 0;
455
456 // Paste first auto into default
457                                 if(default_only && total == 0)
458                                 {
459                                         current = default_auto;
460                                 }
461                                 else
462 // Paste default auto into default
463                                 if(!default_only)
464                                 {
465                                         int64_t position = Units::to_int64(
466                                                 (double)file->tag.get_property("POSITION", 0) *
467                                                         scale +
468                                                         start);
469 // Paste active auto into track
470                                         current = insert_auto(position);
471                                 }
472
473                                 if(current)
474                                 {
475                                         current->load(file);
476                                 }
477                                 total++;
478                         }
479                 }
480         } while( !result );
481 }
482
483
484 int Autos::paste_silence(int64_t start, int64_t end)
485 {
486         insert(start, end);
487         return 0;
488 }
489
490 int Autos::copy(int64_t start,
491         int64_t end,
492         FileXML *file,
493         int default_only,
494         int active_only)
495 {
496 // First auto always loaded with default
497 //printf("Autos::copy %d %d %d\n", __LINE__, default_only, active_only);
498         if(default_only || (!active_only && !default_only))
499         {
500                 default_auto->copy(0, 0, file, default_only);
501         }
502
503 //printf("Autos::copy 10 %d %d %p\n", default_only, start, autoof(start));
504         if(active_only || (!default_only && !active_only))
505         {
506                 for(Auto* current = autoof(start);
507                         current && current->position <= end;
508                         current = NEXT)
509                 {
510 // Want to copy single keyframes by putting the cursor on them
511                         if(current->position >= start && current->position <= end)
512                         {
513                                 current->copy(start, end, file, default_only);
514                         }
515                 }
516         }
517 // Copy default auto again to make it the active auto on the clipboard
518 //      else
519 //      {
520 // Need to force position to 0 for the case of plugins
521 // and default status to 0.
522 //              default_auto->copy(0, 0, file, default_only);
523 //      }
524 //printf("Autos::copy 20\n");
525
526         return 0;
527 }
528
529 // Remove 3 consecutive autos with the same value
530 // Remove autos which are out of order
531 void Autos::optimize()
532 {
533         int done = 0;
534
535
536 // Default auto should always be at 0
537         default_auto->position = 0;
538         while(!done)
539         {
540                 int consecutive = 0;
541                 done = 1;
542
543
544                 for(Auto *current = first; current; current = NEXT)
545                 {
546 // Get 3rd consecutive auto of equal value
547                         if(current != first)
548                         {
549                                 if(*current == *PREVIOUS)
550                                 {
551                                         consecutive++;
552                                         if(consecutive >= 3)
553                                         {
554                                                 delete PREVIOUS;
555                                                 break;
556                                         }
557                                 }
558                                 else
559                                         consecutive = 0;
560
561                                 if(done && current->position <= PREVIOUS->position)
562                                 {
563                                         delete current;
564                                         break;
565                                 }
566                         }
567                 }
568         }
569 }
570
571
572 void Autos::remove_nonsequential(Auto *keyframe)
573 {
574         if((keyframe->next && keyframe->next->position <= keyframe->position) ||
575                 (keyframe->previous && keyframe->previous->position >= keyframe->position))
576         {
577                 delete keyframe;
578         }
579 }
580
581
582 void Autos::set_automation_mode(int64_t start, int64_t end, int mode)
583 {
584 }
585
586 void Autos::clear(int64_t start,
587         int64_t end,
588         int shift_autos)
589 {
590         int64_t length;
591         Auto *next, *current;
592         length = end - start;
593
594
595         current = autoof(start);
596
597 // If a range is selected don't delete the ending keyframe but do delete
598 // the beginning keyframe because shifting end handle forward shouldn't
599 // delete the first keyframe of the next edit.
600
601         while(current &&
602                 ((end != start && current->position < end) ||
603                 (end == start && current->position <= end)))
604         {
605                 next = NEXT;
606                 remove(current);
607                 current = next;
608         }
609
610         while(current && shift_autos)
611         {
612                 current->position -= length;
613                 current = NEXT;
614         }
615 }
616
617 int Autos::clear_auto(int64_t position)
618 {
619         Auto *current;
620         current = autoof(position);
621         return current->position==position ? (remove(current), 1) : 0;
622 }
623
624
625 int Autos::load(FileXML *file)
626 {
627         while(last)
628                 remove(last);    // remove any existing autos
629
630         int result = 0, first_auto = 1;
631         Auto *current;
632
633         do{
634                 result = file->read_tag();
635
636                 if(!result && !file->tag.title_is("/AUTO"))
637                 {
638 // First tag with leading / is taken as end of autos
639                         if(/* strstr(file->tag.get_title(), "AUTOS") && */
640
641                                 file->tag.get_title()[0] == '/')
642                         {
643                                 result = 1;
644                         }
645                         else
646                         if(!strcmp(file->tag.get_title(), "AUTO"))
647                         {
648                                 if(first_auto)
649                                 {
650                                         default_auto->load(file);
651                                         default_auto->position = 0;
652                                         first_auto = 0;
653                                 }
654                                 else
655                                 {
656                                         current = append(new_auto());
657                                         current->position = file->tag.get_property("POSITION", (int64_t)0);
658                                         current->load(file);
659                                 }
660                         }
661                 }
662         } while( !result );
663         return 0;
664 }
665
666
667
668
669
670
671 int Autos::slope_adjustment(int64_t ax, double slope)
672 {
673         return (int)(ax * slope);
674 }
675
676
677 int Autos::scale_time(float rate_scale, int scale_edits, int scale_autos, int64_t start, int64_t end)
678 {
679         Auto *current;
680
681         for(current = first; current && scale_autos; current = NEXT)
682         {
683 //              if(current->position >= start && current->position <= end)
684 //              {
685                         current->position = (int64_t)((current->position - start) * rate_scale + start + 0.5);
686 //              }
687         }
688         return 0;
689 }
690
691 Auto* Autos::autoof(int64_t position)
692 {
693         Auto *current;
694
695         for(current = first;
696                 current && current->position < position;
697                 current = NEXT)
698         {
699                 ;
700         }
701         return current;     // return 0 on failure
702 }
703
704 Auto* Autos::nearest_before(int64_t position)
705 {
706         Auto *current;
707
708         for(current = last; current && current->position >= position; current = PREVIOUS)
709         { ; }
710
711
712         return current;     // return 0 on failure
713 }
714
715 Auto* Autos::nearest_after(int64_t position)
716 {
717         Auto *current;
718
719         for(current = first; current && current->position <= position; current = NEXT)
720         { ; }
721
722
723         return current;     // return 0 on failure
724 }
725
726 int Autos::get_neighbors(int64_t start, int64_t end, Auto **before, Auto **after)
727 {
728         if(*before == 0) *before = first;
729         if(*after == 0) *after = last;
730
731         while(*before && (*before)->next && (*before)->next->position <= start)
732                 *before = (*before)->next;
733
734         while(*after && (*after)->previous && (*after)->previous->position >= end)
735                 *after = (*after)->previous;
736
737         while(*before && (*before)->position > start) *before = (*before)->previous;
738
739         while(*after && (*after)->position < end) *after = (*after)->next;
740         return 0;
741 }
742
743 int Autos::automation_is_constant(int64_t start, int64_t end)
744 {
745         return 0;
746 }
747
748 double Autos::get_automation_constant(int64_t start, int64_t end)
749 {
750         return 0;
751 }
752
753
754 int Autos::init_automation(int64_t &buffer_position,
755                                 int64_t &input_start,
756                                 int64_t &input_end,
757                                 int &automate,
758                                 double &constant,
759                                 int64_t input_position,
760                                 int64_t buffer_len,
761                                 Auto **before,
762                                 Auto **after,
763                                 int reverse)
764 {
765         buffer_position = 0;
766
767 // set start and end boundaries for automation info
768         input_start = reverse ? input_position - buffer_len : input_position;
769         input_end = reverse ? input_position : input_position + buffer_len;
770
771 // test automation for constant value
772 // and set up *before and *after
773         if(automate)
774         {
775                 if(automation_is_constant(input_start, input_end))
776                 {
777                         constant += get_automation_constant(input_start, input_end);
778                         automate = 0;
779                 }
780         }
781         return automate;
782 }
783
784
785 int Autos::init_slope(Auto **current_auto,
786                                 double &slope_start,
787                                 double &slope_value,
788                                 double &slope_position,
789                                 int64_t &input_start,
790                                 int64_t &input_end,
791                                 Auto **before,
792                                 Auto **after,
793                                 int reverse)
794 {
795 // apply automation
796         *current_auto = reverse ? *after : *before;
797 // no auto before start so use first auto in range
798 // already know there is an auto since automation isn't constant
799         if(!*current_auto)
800         {
801                 *current_auto = reverse ? last : first;
802 //              slope_value = (*current_auto)->value;
803                 slope_start = input_start;
804                 slope_position = 0;
805         }
806         else
807         {
808 // otherwise get the first slope point and advance auto
809 //              slope_value = (*current_auto)->value;
810                 slope_start = (*current_auto)->position;
811                 slope_position = reverse ? slope_start - input_end : input_start - slope_start;
812                 (*current_auto) = reverse ? (*current_auto)->previous : (*current_auto)->next;
813         }
814         return 0;
815 }
816
817
818 int Autos::get_slope(Auto **current_auto,
819                                 double &slope_start,
820                                 double &slope_end,
821                                 double &slope_value,
822                                 double &slope,
823                                 int64_t buffer_len,
824                                 int64_t buffer_position,
825                                 int reverse)
826 {
827 // get the slope
828         if(*current_auto)
829         {
830                 slope_end = reverse ? slope_start - (*current_auto)->position : (*current_auto)->position - slope_start;
831                 if(slope_end)
832 //                      slope = ((*current_auto)->value - slope_value) / slope_end;
833 //              else
834                         slope = 0;
835         }
836         else
837         {
838                 slope = 0;
839                 slope_end = buffer_len - buffer_position;
840         }
841         return 0;
842 }
843
844 int Autos::advance_slope(Auto **current_auto,
845                                 double &slope_start,
846                                 double &slope_value,
847                                 double &slope_position,
848                                 int reverse)
849 {
850         if(*current_auto)
851         {
852                 slope_start = (*current_auto)->position;
853 //              slope_value = (*current_auto)->value;
854                 (*current_auto) = reverse ? (*current_auto)->previous : (*current_auto)->next;
855                 slope_position = 0;
856         }
857         return 0;
858 }
859
860 int64_t Autos::get_length()
861 {
862         if(last)
863                 return last->position + 1;
864         else
865                 return 0;
866 }
867
868 void Autos::get_extents(float *min,
869         float *max,
870         int *coords_undefined,
871         int64_t unit_start,
872         int64_t unit_end)
873 {
874
875 }
876
877
878 void Autos::dump(FILE *fp)
879 {
880 }
881
882
883
884
885
886
887
888
889
890