rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[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 && first && first->position <= position)
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 && last && last->position >= position)
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         if( edl->session->auto_keyframes && (!result || result->is_default ||
292               !EQUIV(track->from_units(result->position), position)) ) {
293 //printf("Autos::get_auto_for_editing %p %p %p\n", default_auto, first, result);
294                 position = edl->align_to_frame(position, 0);
295                 result = insert_auto(track->to_units(position, 0));
296         }
297 //printf("Autos::get_auto_for_editing %p %p\n", first, default_auto);
298
299         return result;
300 }
301
302
303 Auto* Autos::get_next_auto(int64_t position, int direction, Auto* &current, int use_default)
304 {
305         if(direction == PLAY_FORWARD)
306         {
307                 if(current)
308                 {
309                         while(current && current->position > position) current = PREVIOUS;
310                         while(current && current->position < position) current = NEXT;
311                 }
312
313                 if(!current && last && last->position > position)
314                 {
315                         for(current = first;
316                                 current && current->position <= position;
317                                 current = NEXT)
318                                 ;
319                 }
320
321                 if(!current && use_default) current = (last ? last : default_auto);
322         }
323         else
324         if(direction == PLAY_REVERSE)
325         {
326                 if(current)
327                 {
328                         while(current && current->position < position) current = NEXT;
329                         while(current && current->position > position) current = PREVIOUS;
330                 }
331
332                 if(!current && first && first->position <= position)
333                 {
334                         for(current = last;
335                                 current && current->position > position;
336                                 current = PREVIOUS)
337                                 ;
338                 }
339
340                 if(!current && use_default) current = (first ? first : default_auto);
341         }
342
343         return current;
344 }
345 Auto* Autos::insert_auto(int64_t position, Auto *templ)
346 {
347         Auto *current, *result;
348
349 // Test for existence
350         for(current = first;
351                 current && !edl->equivalent(current->position, position);
352                 current = NEXT)
353         {
354                 ;
355         }
356
357 // Insert new
358         if(!current)
359         {
360 // Get first one on or before as a template
361                 for(current = last;
362                         current && current->position > position;
363                         current = PREVIOUS)
364                 {
365                         ;
366                 }
367
368                 if(current)
369                 {
370                         insert_after(current, result = new_auto());
371                 }
372                 else
373                 {
374                         current = first;
375                         if(!current) current = default_auto;
376
377                         insert_before(first, result = new_auto());
378                 }
379
380 // interpolate if possible, else copy from template
381                 result->interpolate_from(0, 0, position, templ);
382 // Set curve mode
383                 if( !templ && result->is_floatauto() ) {
384                         FloatAuto *floatauto = (FloatAuto *)result;
385                         floatauto->curve_mode =
386                                 edl->local_session->playback_start >= 0 &&
387                                 edl->local_session->playback_end < 0 ? FloatAuto::SMOOTH :
388                                         (FloatAuto::t_mode) edl->local_session->floatauto_type;
389                 }
390         }
391         else
392         {
393                 result = current;
394         }
395
396         return result;
397 }
398
399 int Autos::clear_all()
400 {
401         Auto *current_, *current;
402
403         for(current = first; current; current = current_)
404         {
405                 current_ = NEXT;
406                 remove(current);
407         }
408         append_auto();
409         return 0;
410 }
411
412 int Autos::insert(int64_t start, int64_t end)
413 {
414         int64_t length;
415         Auto *current = first;
416
417         for( ; current && current->position < start; current = NEXT)
418                 ;
419
420         length = end - start;
421
422         for(; current; current = NEXT)
423         {
424                 current->position += length;
425         }
426         return 0;
427 }
428
429 void Autos::paste(int64_t start,
430         int64_t length,
431         double scale,
432         FileXML *file,
433         int default_only,
434         int active_only)
435 {
436         int total = 0;
437         int result = 0;
438
439 //printf("Autos::paste %d start=%jd\n", __LINE__, start);
440         do{
441                 result = file->read_tag();
442
443                 if(!result && !file->tag.title_is("/AUTO"))
444                 {
445 // End of list
446                         if(file->tag.get_title()[0] == '/')
447                         {
448                                 result = 1;
449                         }
450                         else
451                         if(!strcmp(file->tag.get_title(), "AUTO"))
452                         {
453                                 Auto *current = 0;
454
455 // Paste first auto into default
456                                 if(default_only && total == 0)
457                                 {
458                                         current = default_auto;
459                                 }
460                                 else
461 // Paste default auto into default
462                                 if(!default_only)
463                                 {
464                                         int64_t position = Units::to_int64(
465                                                 (double)file->tag.get_property("POSITION", 0) *
466                                                         scale +
467                                                         start);
468 // Paste active auto into track
469                                         current = insert_auto(position);
470                                 }
471
472                                 if(current)
473                                 {
474                                         current->load(file);
475                                 }
476                                 total++;
477                         }
478                 }
479         } while( !result );
480 }
481
482
483 int Autos::paste_silence(int64_t start, int64_t end)
484 {
485         insert(start, end);
486         return 0;
487 }
488
489 int Autos::copy(int64_t start,
490         int64_t end,
491         FileXML *file,
492         int default_only,
493         int active_only)
494 {
495 // First auto always loaded with default
496 //printf("Autos::copy %d %d %d\n", __LINE__, default_only, active_only);
497         if(default_only || (!active_only && !default_only))
498         {
499                 default_auto->copy(0, 0, file, default_only);
500         }
501
502 //printf("Autos::copy 10 %d %d %p\n", default_only, start, autoof(start));
503         if(active_only || (!default_only && !active_only))
504         {
505                 Auto *current = autoof(start);
506 // need the last one if past the end
507                 if( !current && last )
508                         last->copy(start, end, file, default_only);
509
510                 while( current && current->position <= end ) {
511 // Want to copy single keyframes by putting the cursor on them
512                         if( current->position >= start && current->position <= end ) {
513                                 current->copy(start, end, file, default_only);
514                         }
515                         current = NEXT;
516                 }
517         }
518 // Copy default auto again to make it the active auto on the clipboard
519 //      else
520 //      {
521 // Need to force position to 0 for the case of plugins
522 // and default status to 0.
523 //              default_auto->copy(0, 0, file, default_only);
524 //      }
525 //printf("Autos::copy 20\n");
526
527         return 0;
528 }
529
530 // Remove 3 consecutive autos with the same value
531 // Remove autos which are out of order
532 void Autos::optimize()
533 {
534         int done = 0;
535
536
537 // Default auto should always be at 0
538         default_auto->position = 0;
539         while(!done)
540         {
541                 int consecutive = 0;
542                 done = 1;
543
544
545                 for(Auto *current = first; current; current = NEXT)
546                 {
547 // Get 3rd consecutive auto of equal value
548                         if(current != first)
549                         {
550                                 if(*current == *PREVIOUS)
551                                 {
552                                         consecutive++;
553                                         if(consecutive >= 3)
554                                         {
555                                                 delete PREVIOUS;
556                                                 break;
557                                         }
558                                 }
559                                 else
560                                         consecutive = 0;
561
562                                 if(done && current->position <= PREVIOUS->position)
563                                 {
564                                         delete current;
565                                         break;
566                                 }
567                         }
568                 }
569         }
570 }
571
572
573 void Autos::remove_nonsequential(Auto *keyframe)
574 {
575         if((keyframe->next && keyframe->next->position <= keyframe->position) ||
576                 (keyframe->previous && keyframe->previous->position >= keyframe->position))
577         {
578                 delete keyframe;
579         }
580 }
581
582
583 void Autos::set_automation_mode(int64_t start, int64_t end, int mode)
584 {
585 }
586
587 void Autos::clear(int64_t start,
588         int64_t end,
589         int shift_autos)
590 {
591         int64_t length;
592         Auto *next, *current;
593         length = end - start;
594
595
596         current = autoof(start);
597
598 // If a range is selected don't delete the ending keyframe but do delete
599 // the beginning keyframe because shifting end handle forward shouldn't
600 // delete the first keyframe of the next edit.
601
602         while(current &&
603                 ((end != start && current->position < end) ||
604                 (end == start && current->position <= end)))
605         {
606                 next = NEXT;
607                 remove(current);
608                 current = next;
609         }
610
611         while(current && shift_autos)
612         {
613                 current->position -= length;
614                 current = NEXT;
615         }
616 }
617
618 int Autos::clear_auto(int64_t position)
619 {
620         Auto *current;
621         current = autoof(position);
622         return current->position==position ? (remove(current), 1) : 0;
623 }
624
625
626 int Autos::load(FileXML *file)
627 {
628         while(last)
629                 remove(last);    // remove any existing autos
630
631         int result = 0, first_auto = 1;
632         Auto *current;
633
634         do{
635                 result = file->read_tag();
636
637                 if(!result && !file->tag.title_is("/AUTO"))
638                 {
639 // First tag with leading / is taken as end of autos
640                         if(/* strstr(file->tag.get_title(), "AUTOS") && */
641
642                                 file->tag.get_title()[0] == '/')
643                         {
644                                 result = 1;
645                         }
646                         else
647                         if(!strcmp(file->tag.get_title(), "AUTO"))
648                         {
649                                 if(first_auto)
650                                 {
651                                         default_auto->load(file);
652                                         default_auto->position = 0;
653                                         first_auto = 0;
654                                 }
655                                 else
656                                 {
657                                         current = append(new_auto());
658                                         current->position = file->tag.get_property("POSITION", (int64_t)0);
659                                         current->load(file);
660                                 }
661                         }
662                 }
663         } while( !result );
664         return 0;
665 }
666
667
668
669
670
671
672 int Autos::slope_adjustment(int64_t ax, double slope)
673 {
674         return (int)(ax * slope);
675 }
676
677
678 int Autos::scale_time(float rate_scale, int scale_edits, int scale_autos, int64_t start, int64_t end)
679 {
680         Auto *current;
681
682         for(current = first; current && scale_autos; current = NEXT)
683         {
684 //              if(current->position >= start && current->position <= end)
685 //              {
686                         current->position = (int64_t)((current->position - start) * rate_scale + start + 0.5);
687 //              }
688         }
689         return 0;
690 }
691
692 Auto* Autos::autoof(int64_t position)
693 {
694         Auto *current;
695
696         for(current = first;
697                 current && current->position < position;
698                 current = NEXT)
699         {
700                 ;
701         }
702         return current;     // return 0 on failure
703 }
704
705 Auto* Autos::nearest_before(int64_t position)
706 {
707         Auto *current;
708         for(current = last; current && current->position >= position; current = PREVIOUS);
709         return current;     // return 0 on failure
710 }
711
712 Auto* Autos::nearest_after(int64_t position)
713 {
714         Auto *current;
715         for(current = first; current && current->position <= position; current = NEXT);
716         return current;     // return 0 on failure
717 }
718
719 int Autos::get_neighbors(int64_t start, int64_t end, Auto **before, Auto **after)
720 {
721         if(*before == 0) *before = first;
722         if(*after == 0) *after = last;
723
724         while(*before && (*before)->next && (*before)->next->position <= start)
725                 *before = (*before)->next;
726
727         while(*after && (*after)->previous && (*after)->previous->position >= end)
728                 *after = (*after)->previous;
729
730         while(*before && (*before)->position > start) *before = (*before)->previous;
731
732         while(*after && (*after)->position < end) *after = (*after)->next;
733         return 0;
734 }
735
736 int Autos::automation_is_constant(int64_t start, int64_t end)
737 {
738         return 0;
739 }
740
741 double Autos::get_automation_constant(int64_t start, int64_t end)
742 {
743         return 0;
744 }
745
746
747 int Autos::init_automation(int64_t &buffer_position,
748                                 int64_t &input_start,
749                                 int64_t &input_end,
750                                 int &automate,
751                                 double &constant,
752                                 int64_t input_position,
753                                 int64_t buffer_len,
754                                 Auto **before,
755                                 Auto **after,
756                                 int reverse)
757 {
758         buffer_position = 0;
759
760 // set start and end boundaries for automation info
761         input_start = reverse ? input_position - buffer_len : input_position;
762         input_end = reverse ? input_position : input_position + buffer_len;
763
764 // test automation for constant value
765 // and set up *before and *after
766         if(automate)
767         {
768                 if(automation_is_constant(input_start, input_end))
769                 {
770                         constant += get_automation_constant(input_start, input_end);
771                         automate = 0;
772                 }
773         }
774         return automate;
775 }
776
777
778 int Autos::init_slope(Auto **current_auto,
779                                 double &slope_start,
780                                 double &slope_value,
781                                 double &slope_position,
782                                 int64_t &input_start,
783                                 int64_t &input_end,
784                                 Auto **before,
785                                 Auto **after,
786                                 int reverse)
787 {
788 // apply automation
789         *current_auto = reverse ? *after : *before;
790 // no auto before start so use first auto in range
791 // already know there is an auto since automation isn't constant
792         if(!*current_auto)
793         {
794                 *current_auto = reverse ? last : first;
795 //              slope_value = (*current_auto)->value;
796                 slope_start = input_start;
797                 slope_position = 0;
798         }
799         else
800         {
801 // otherwise get the first slope point and advance auto
802 //              slope_value = (*current_auto)->value;
803                 slope_start = (*current_auto)->position;
804                 slope_position = reverse ? slope_start - input_end : input_start - slope_start;
805                 (*current_auto) = reverse ? (*current_auto)->previous : (*current_auto)->next;
806         }
807         return 0;
808 }
809
810
811 int Autos::get_slope(Auto **current_auto,
812                                 double &slope_start,
813                                 double &slope_end,
814                                 double &slope_value,
815                                 double &slope,
816                                 int64_t buffer_len,
817                                 int64_t buffer_position,
818                                 int reverse)
819 {
820 // get the slope
821         if(*current_auto)
822         {
823                 slope_end = reverse ? slope_start - (*current_auto)->position : (*current_auto)->position - slope_start;
824                 if(slope_end)
825 //                      slope = ((*current_auto)->value - slope_value) / slope_end;
826 //              else
827                         slope = 0;
828         }
829         else
830         {
831                 slope = 0;
832                 slope_end = buffer_len - buffer_position;
833         }
834         return 0;
835 }
836
837 int Autos::advance_slope(Auto **current_auto,
838                                 double &slope_start,
839                                 double &slope_value,
840                                 double &slope_position,
841                                 int reverse)
842 {
843         if(*current_auto)
844         {
845                 slope_start = (*current_auto)->position;
846 //              slope_value = (*current_auto)->value;
847                 (*current_auto) = reverse ? (*current_auto)->previous : (*current_auto)->next;
848                 slope_position = 0;
849         }
850         return 0;
851 }
852
853 int64_t Autos::get_length()
854 {
855         if(last)
856                 return last->position + 1;
857         else
858                 return 0;
859 }
860
861 void Autos::get_extents(float *min,
862         float *max,
863         int *coords_undefined,
864         int64_t unit_start,
865         int64_t unit_end)
866 {
867
868 }
869
870
871 void Autos::dump(FILE *fp)
872 {
873 }
874
875
876
877
878
879
880
881
882
883