r1053: Add Russian translation.
[cinelerra_cv.git] / cinelerra / tracksedit.C
blob7114d6fd3b3e472f7b5c1afbb3eb4769610c623e
1 #include "assets.h"
2 #include "atrack.h"
3 #include "automation.h"
4 #include "aedits.h"
5 #include "edit.h"
6 #include "edits.h"
7 #include "edl.h"
8 #include "edlsession.h"
9 #include "filexml.h"
10 #include "intauto.h"
11 #include "intautos.h"
12 #include "localsession.h"
13 #include "mainundo.h"
14 #include "module.h"
15 #include "mainsession.h"
16 #include "pluginserver.h"
17 #include "pluginset.h"
18 #include "timebar.h"
19 #include "trackcanvas.h"
20 #include "tracks.h"
21 #include "trackscroll.h"
22 #include "transition.h"
23 #include "transportque.h"
24 #include "vtrack.h"
25 #include <string.h>
27 int Tracks::clear(double start, double end, int clear_plugins)
29         Track *current_track;
31         for(current_track = first; 
32                 current_track; 
33                 current_track = current_track->next)
34         {
35                 if(current_track->record) 
36                 {
37                         current_track->clear(start, 
38                                 end, 
39                                 1, 
40                                 1, 
41                                 clear_plugins, 
42                                 1,
43                                 0); 
44                 }
45         }
46         return 0;
49 void Tracks::clear_automation(double selectionstart, double selectionend)
51         Track* current_track;
53         for(current_track = first; current_track; current_track = current_track->next)
54         {
55                 if(current_track->record)
56                 {
57                         current_track->clear_automation(selectionstart, 
58                                 selectionend, 
59                                 0,
60                                 0); 
61                 }
62         }
65 void Tracks::straighten_automation(double selectionstart, double selectionend)
67         Track* current_track;
69         for(current_track = first; current_track; current_track = current_track->next)
70         {
71                 if(current_track->record)
72                 {
73                         current_track->straighten_automation(selectionstart, 
74                                 selectionend); 
75                 }
76         }
79 int Tracks::clear_default_keyframe()
81         for(Track *current = first; current; current = NEXT)
82         {
83                 if(current->record)
84                         current->clear_automation(0, 0, 0, 1);
85         }
86         return 0;
89 int Tracks::clear_handle(double start, 
90         double end,
91         double &longest_distance,
92         int clear_labels,
93         int clear_plugins)
95         Track* current_track;
96         double distance;
98         for(current_track = first; current_track; current_track = current_track->next)
99         {
100                 if(current_track->record)
101                 {
102                         current_track->clear_handle(start, 
103                                 end, 
104                                 clear_labels,
105                                 clear_plugins, 
106                                 distance);
107                         if(distance > longest_distance) longest_distance = distance;
108                 }
109         }
111         return 0;
114 int Tracks::copy_automation(double selectionstart, 
115         double selectionend, 
116         FileXML *file,
117         int default_only,
118         int autos_only)
120 // called by MWindow::copy_automation for copying automation alone
121         Track* current_track;
123         file->tag.set_title("AUTO_CLIPBOARD");
124         file->tag.set_property("LENGTH", selectionend - selectionstart);
125         file->tag.set_property("FRAMERATE", edl->session->frame_rate);
126         file->tag.set_property("SAMPLERATE", edl->session->sample_rate);
127         file->append_tag();
128         file->append_newline();
129         file->append_newline();
131         for(current_track = first; 
132                 current_track; 
133                 current_track = current_track->next)
134         {
135                 if(current_track->record)
136                 {
137                         current_track->copy_automation(selectionstart, 
138                                 selectionend, 
139                                 file,
140                                 default_only,
141                                 autos_only);
142                 }
143         }
145         file->tag.set_title("/AUTO_CLIPBOARD");
146         file->append_tag();
147         file->append_newline();
148         file->terminate_string();
149         return 0;
152 int Tracks::copy_default_keyframe(FileXML *file)
154         copy_automation(0, 0, file, 1, 0);
155         return 0;
158 int Tracks::delete_tracks()
160         int total_deleted = 0;
161         int done = 0;
163         while(!done)
164         {
165                 done = 1;
166                 for (Track* current = first;
167                         current && done;
168                         current = NEXT)
169                 {
170                         if(current->record)
171                         {
172                                 delete_track(current);
173                                 total_deleted++;
174                                 done = 0;
175                         }
176                 }
177         }
178         return total_deleted;
181 void Tracks::move_edits(ArrayList<Edit*> *edits, 
182         Track *track,
183         double position,
184         int edit_labels,  // Ignored
185         int edit_plugins,  // Ignored
186         int behaviour)
188 //printf("Tracks::move_edits 1\n");
189         for(Track *dest_track = track; dest_track; dest_track = dest_track->next)
190         {
191                 if(dest_track->record)
192                 {
193 // Need a local copy of the source edit since the original source edit may
194 // change in the editing operation.
195                         Edit *source_edit = 0;
196                         Track *source_track = 0;
199 // Get source track
200                         if(dest_track->data_type == TRACK_AUDIO)
201                         {
202                                 int current_aedit = 0;
204                                 while(current_aedit < edits->total &&
205                                         edits->values[current_aedit]->track->data_type != TRACK_AUDIO)
206                                         current_aedit++;
208                                 if(current_aedit < edits->total)
209                                 {
210                                         source_edit = edits->values[current_aedit];
211                                         source_track = source_edit->track;
212                                         edits->remove_number(current_aedit);
213                                 }
214                         }
215                         else
216                         if(dest_track->data_type == TRACK_VIDEO)
217                         {
218                                 int current_vedit = 0;
219                                 while(current_vedit < edits->total &&
220                                         edits->values[current_vedit]->track->data_type != TRACK_VIDEO)
221                                         current_vedit++;
223                                 if(current_vedit < edits->total)
224                                 {
225                                         source_edit = edits->values[current_vedit];
226                                         source_track = source_edit->track;
227                                         edits->remove_number(current_vedit);
228                                 }
229                         }
231 //printf("Tracks::move_edits 2 %s %s %d\n", source_track->title, dest_track->title, source_edit->length);
232                         if(source_edit)
233                         {
234                                 int64_t position_i = source_track->to_units(position, 0);
235 // Source edit changes
236                                 int64_t source_length = source_edit->length;
237                                 int64_t source_startproject = source_edit->startproject;
239                                 if (behaviour == 0)
240                                 {
241                                 // This works like this: CUT edit, INSERT edit at final position, keyframes also follow
242                                 // FIXME: there should be a GUI way to tell whenever user also wants to move autos or not
243 // Copy keyframes
244                                         FileXML temp;
245                                         AutoConf temp_autoconf;
247                                         temp_autoconf.set_all(1);
249                                         source_track->automation->copy(source_edit->startproject, 
250                                                 source_edit->startproject + source_edit->length, 
251                                                 &temp, 
252                                                 0,
253                                                 0);
254                                         temp.terminate_string();
255                                         temp.rewind();
256 // Insert new keyframes
257 //printf("Tracks::move_edits 2 %d %p\n", result->startproject, result->asset);
258                                         source_track->automation->clear(source_edit->startproject,
259                                                 source_edit->startproject + source_edit->length, 
260                                                 &temp_autoconf,
261                                                 1);
262                                         int64_t position_a = position_i;
263                                         if (dest_track == source_track)
264                                         {
265                                                 if (position_a > source_edit->startproject)
266                                                         position_a -= source_length;
267                                         }               
269                                         dest_track->automation->paste_silence(position_a, 
270                                                 position_a + source_length);
271                                         while(!temp.read_tag())
272                                                 dest_track->automation->paste(position_a, 
273                                                         source_length, 
274                                                         1.0, 
275                                                         &temp, 
276                                                         0,
277                                                         &temp_autoconf);
279 // Insert new edit
280                                         Edit *dest_edit = dest_track->edits->shift(position_i, 
281                                                 source_length);
282                                         Edit *result = dest_track->edits->insert_before(dest_edit, 
283                                                 dest_track->edits->create_edit());
284                                         result->copy_from(source_edit);
285                                         result->startproject = position_i;
286                                         result->length = source_length;
288 // Clear source
289                                         source_track->edits->clear(source_edit->startproject, 
290                                                 source_edit->startproject + source_length);
292         /*
293 //this is outline for future thinking how it is supposed to be done trough C&P mechanisms
294                                         temp.reset_tag();
295                                         source_track->cut(source_edit->startproject, 
296                                                 source_edit->startproject + source_edit->length, 
297                                                 &temp, 
298                                                 NULL);
299                                         temp.terminate_string();
300                                         temp.rewind();
301                                         dest_track->paste_silence(position_a, 
302                                                 position_a + source_length,
303                                                 edit_plugins);
304                                         while(!temp.read_tag())
305                                                 dest_track->paste(position_a,          // MISSING PIECE OF FUNCTIONALITY 
306                                                         source_length, 
307                                                         1.0, 
308                                                         &temp, 
309                                                         0,
310                                                         &temp_autoconf);
311         */
314                                 } else
315                                 if (behaviour == 1)
316                                 // ONLY edit is moved, all other edits stay where they are
317                                 {
318                                         // Copy edit to temp, delete the edit, insert the edit
319                                         Edit *temp_edit = dest_track->edits->create_edit(); 
320                                         temp_edit->copy_from(source_edit);
321                                         // we call the edits directly since we do not want to move keyframes or anything else
322                                         source_track->edits->clear(source_startproject, 
323                                                 source_startproject + source_length);
324                                         source_track->edits->paste_silence(source_startproject, 
325                                                 source_startproject + source_length); 
327                                         dest_track->edits->clear(position_i, 
328                                                 position_i + source_length);
329                                         Edit *dest_edit = dest_track->edits->shift(position_i,  source_length);
330                                         Edit *result = dest_track->edits->insert_before(dest_edit, 
331                                                 dest_track->edits->create_edit());
332                                         result->copy_from(temp_edit);
333                                         result->startproject = position_i;
334                                         result->length = source_length;
335                                         delete temp_edit;
336                                 }
337                                 source_track->optimize();
338                                 dest_track->optimize();
339                         }
340                 }
341         }
344 void Tracks::move_effect(Plugin *plugin,
345         PluginSet *dest_plugin_set,
346         Track *dest_track, 
347         int64_t dest_position)
349         Track *source_track = plugin->track;
350         Plugin *result = 0;
352 // Insert on an existing plugin set
353         if(!dest_track && dest_plugin_set)
354         {
355                 Track *dest_track = dest_plugin_set->track;
358 // Assume this operation never splits a plugin
359 // Shift destination plugins back
360                 dest_plugin_set->shift(dest_position, plugin->length);
362 // Insert new plugin
363                 Plugin *current = 0;
364                 for(current = (Plugin*)dest_plugin_set->first; current; current = (Plugin*)NEXT)
365                         if(current->startproject >= dest_position) break;
367                 result = (Plugin*)dest_plugin_set->insert_before(current, 
368                         new Plugin(edl, dest_plugin_set, ""));
369         }
370         else
371 // Create a new plugin set
372         {
373                 double start = dest_track->from_units(dest_position);
374                 double length = dest_track->from_units(plugin->length);
376                 result = dest_track->insert_effect("", 
377                                 &plugin->shared_location, 
378                                 0,
379                                 0,
380                                 start,
381                                 length,
382                                 plugin->plugin_type);
384         }
387         result->copy_from(plugin);
388         result->shift(dest_position - plugin->startproject);
390 // Clear new plugin from old set
391         plugin->plugin_set->clear(plugin->startproject, plugin->startproject + plugin->length);
394         source_track->optimize();
399 int Tracks::concatenate_tracks(int edit_plugins)
401         Track *output_track, *first_output_track, *input_track;
402         int i, data_type = TRACK_AUDIO;
403         double output_start;
404         FileXML *clipboard;
405         int result = 0;
406         IntAuto *play_keyframe = 0;
408 // Relocate tracks
409         for(i = 0; i < 2; i++)
410         {
411 // Get first output track
412                 for(output_track = first; 
413                         output_track; 
414                         output_track = output_track->next)
415                         if(output_track->data_type == data_type && 
416                                 output_track->record) break;
418                 first_output_track = output_track;
420 // Get first input track
421                 for(input_track = first;
422                         input_track;
423                         input_track = input_track->next)
424                 {
425                         if(input_track->data_type == data_type &&
426                                 input_track->play && 
427                                 !input_track->record) break;
428                 }
431                 if(output_track && input_track)
432                 {
433 // Transfer input track to end of output track one at a time
434                         while(input_track)
435                         {
436                                 output_start = output_track->get_length();
437                                 output_track->insert_track(input_track, 
438                                         output_start, 
439                                         0,
440                                         edit_plugins);
442 // Get next source and destination
443                                 for(input_track = input_track->next; 
444                                         input_track; 
445                                         input_track = input_track->next)
446                                 {
448                                         if(input_track->data_type == data_type && 
449                                                 !input_track->record && 
450                                                 input_track->play) break;
451                                 }
453                                 for(output_track = output_track->next; 
454                                         output_track; 
455                                         output_track = output_track->next)
456                                 {
457                                         if(output_track->data_type == data_type && 
458                                                 output_track->record) break;
459                                 }
461                                 if(!output_track)
462                                 {
463                                         output_track = first_output_track;
464                                 }
465                         }
466                         result = 1;
467                 }
469                 if(data_type == TRACK_AUDIO) data_type = TRACK_VIDEO;
470         }
472         return result;
475 int Tracks::delete_all_tracks()
477         while(last) delete last;
478         return 0;
482 void Tracks::change_modules(int old_location, int new_location, int do_swap)
484         for(Track* current = first ; current; current = current->next)
485         {
486                 current->change_modules(old_location, new_location, do_swap);
487         }
490 void Tracks::change_plugins(SharedLocation &old_location, SharedLocation &new_location, int do_swap)
492         for(Track* current = first ; current; current = current->next)
493         {
494                 current->change_plugins(old_location, new_location, do_swap);
495         }
500 // =========================================== EDL editing
503 int Tracks::copy(double start, 
504         double end, 
505         int all, 
506         FileXML *file, 
507         char *output_path)
509 // nothing selected
510         if(start == end && !all) return 1;
512         Track* current;
514         for(current = first; 
515                 current; 
516                 current = NEXT)
517         {
518                 if(current->record || all)
519                 {
520                         current->copy(start, end, file,output_path);
521                 }
522         }
524         return 0;
529 int Tracks::move_track_up(Track *track)
531         Track *next_track = track->previous;
532         if(!next_track) next_track = last;
534         change_modules(number_of(track), number_of(next_track), 1);
536 // printf("Tracks::move_track_up 1 %p %p\n", track, next_track);
537 // int count = 0;
538 // for(Track *current = first; current && count < 5; current = NEXT, count++)
539 //      printf("Tracks::move_track_up %p %p %p\n", current->previous, current, current->next);
540 // printf("Tracks::move_track_up 2\n");
541 // 
542         swap(track, next_track);
544 // count = 0;
545 // for(Track *current = first; current && count < 5; current = NEXT, count++)
546 //      printf("Tracks::move_track_up %p %p %p\n", current->previous, current, current->next);
547 // printf("Tracks::move_track_up 3\n");
549         return 0;
552 int Tracks::move_track_down(Track *track)
554         Track *next_track = track->next;
555         if(!next_track) next_track = first;
557         change_modules(number_of(track), number_of(next_track), 1);
558         swap(track, next_track);
559         return 0;
563 int Tracks::move_tracks_up()
565         Track *track, *next_track;
566         int result = 0;
568         for(track = first;
569                 track; 
570                 track = next_track)
571         {
572                 next_track = track->next;
574                 if(track->record)
575                 {
576                         if(track->previous)
577                         {
578                                 change_modules(number_of(track->previous), number_of(track), 1);
580                                 swap(track->previous, track);
581                                 result = 1;
582                         }
583                 }
584         }
586         return result;
589 int Tracks::move_tracks_down()
591         Track *track, *previous_track;
592         int result = 0;
593         
594         for(track = last;
595                 track; 
596                 track = previous_track)
597         {
598                 previous_track = track->previous;
600                 if(track->record)
601                 {
602                         if(track->next)
603                         {
604                                 change_modules(number_of(track), number_of(track->next), 1);
606                                 swap(track, track->next);
607                                 result = 1;
608                         }
609                 }
610         }
611         
612         return result;
617 void Tracks::paste_audio_transition(PluginServer *server)
619         for(Track *current = first; current; current = NEXT)
620         {
621                 if(current->data_type == TRACK_AUDIO &&
622                         current->record)
623                 {
624                         int64_t position = current->to_units(
625                                 edl->local_session->get_selectionstart(), 0);
626                         Edit *current_edit = current->edits->editof(position, 
627                                 PLAY_FORWARD,
628                                 0);
629                         if(current_edit)
630                         {
631                                 paste_transition(server, current_edit);
632                         }
633                 }
634         }
637 void Tracks::loaded_lengths_to_tracklengths(int includerecordtracks)
639         Track *current_track;
640         
641         for(current_track = first; 
642             current_track; 
643             current_track = current_track->next)
644         {
645                 if(current_track->record || includerecordtracks) 
646                 {
647 // Reset the loaded_length value. (the last edit should always be a silence going to infinityish)
648                         current_track->edits->loaded_length = current_track->edits->last->startproject;
649                 }
650         }
653 void Tracks::paste_automation(double selectionstart, 
654         FileXML *file,
655         int default_only)
657         Track* current_atrack = 0;
658         Track* current_vtrack = 0;
659         int result = 0;
660         double length;
661         double frame_rate = edl->session->frame_rate;
662         int64_t sample_rate = edl->session->sample_rate;
663         char string[BCTEXTLEN];
664         sprintf(string, "");
666 // Search for start
667         do{
668           result = file->read_tag();
669         }while(!result && 
670                 !file->tag.title_is("AUTO_CLIPBOARD"));
672         if(!result)
673         {
674                 length = file->tag.get_property("LENGTH", 0);
675                 frame_rate = file->tag.get_property("FRAMERATE", frame_rate);
676                 sample_rate = file->tag.get_property("SAMPLERATE", sample_rate);
679                 do
680                 {
681                         result = file->read_tag();
683                         if(!result)
684                         {
685                                 if(file->tag.title_is("/AUTO_CLIPBOARD"))
686                                 {
687                                         result = 1;
688                                 }
689                                 else
690                                 if(file->tag.title_is("TRACK"))
691                                 {
692                                         file->tag.get_property("TYPE", string);
693                                         
694                                         if(!strcmp(string, "AUDIO"))
695                                         {
696 // Get next audio track
697                                                 if(!current_atrack)
698                                                         current_atrack = first;
699                                                 else
700                                                         current_atrack = current_atrack->next;
702                                                 while(current_atrack && 
703                                                         (current_atrack->data_type != TRACK_AUDIO ||
704                                                         !current_atrack->record))
705                                                         current_atrack = current_atrack->next;
707 // Paste it
708                                                 if(current_atrack)
709                                                 {
710                                                         current_atrack->paste_automation(selectionstart,
711                                                                 length,
712                                                                 frame_rate,
713                                                                 sample_rate,
714                                                                 file,
715                                                                 default_only);
716                                                 }
717                                         }
718                                         else
719                                         {
720 // Get next video track
721                                                 if(!current_vtrack)
722                                                         current_vtrack = first;
723                                                 else
724                                                         current_vtrack = current_vtrack->next;
726                                                 while(current_vtrack && 
727                                                         (current_vtrack->data_type != TRACK_VIDEO ||
728                                                         !current_vtrack->record))
729                                                         current_vtrack = current_vtrack->next;
731 // Paste it
732                                                 if(current_vtrack)
733                                                 {
734 //printf("Tracks::paste_automation 1 %s %d\n", current_vtrack->title, current_vtrack->record);
735                                                         current_vtrack->paste_automation(selectionstart,
736                                                                 length,
737                                                                 frame_rate,
738                                                                 sample_rate,
739                                                                 file,
740                                                                 default_only);
741                                                 }
742                                         }
743                                 }
744                         }
745                 }while(!result);
746         }
749 int Tracks::paste_default_keyframe(FileXML *file)
751         paste_automation(0, file, 1);
752         return 0;
755 void Tracks::paste_transition(PluginServer *server, Edit *dest_edit)
757         dest_edit->insert_transition(server->title);
760 void Tracks::paste_video_transition(PluginServer *server, int first_track)
762         for(Track *current = first; current; current = NEXT)
763         {
764                 if(current->data_type == TRACK_VIDEO &&
765                         current->record)
766                 {
767                         int64_t position = current->to_units(
768                                 edl->local_session->get_selectionstart(), 0);
769                         Edit *current_edit = current->edits->editof(position, 
770                                 PLAY_FORWARD,
771                                 0);
772                         if(current_edit)
773                         {
774                                 paste_transition(server, current_edit);
775                         }
776                         if(first_track) break;
777                 }
778         }
782 int Tracks::paste_silence(double start, double end, int edit_plugins)
784         Track* current_track;
786         for(current_track = first; 
787                 current_track; 
788                 current_track = current_track->next)
789         {
790                 if(current_track->record) 
791                 { 
792                         current_track->paste_silence(start, end, edit_plugins); 
793                 }
794         }
795         return 0;
800 int Tracks::select_auto(int cursor_x, int cursor_y)
802         int result = 0;
803         for(Track* current = first; current && !result; current = NEXT) { result = current->select_auto(&auto_conf, cursor_x, cursor_y); }
804         return result;
807 int Tracks::move_auto(int cursor_x, int cursor_y, int shift_down)
809         int result = 0;
811         for(Track* current = first; current && !result; current = NEXT) 
812         {
813                 result = current->move_auto(&auto_conf, cursor_x, cursor_y, shift_down); 
814         }
815         return 0;
818 int Tracks::modify_edithandles(double &oldposition, 
819         double &newposition, 
820         int currentend, 
821         int handle_mode,
822         int edit_labels,
823         int edit_plugins)
825         Track *current;
827         for(current = first; current; current = NEXT)
828         {
829                 if(current->record)
830                 {
831                         current->modify_edithandles(oldposition, 
832                                 newposition, 
833                                 currentend,
834                                 handle_mode,
835                                 edit_labels,
836                                 edit_plugins);
837                 }
838         }
839         return 0;
842 int Tracks::modify_pluginhandles(double &oldposition, 
843         double &newposition, 
844         int currentend, 
845         int handle_mode,
846         int edit_labels,
847         Edits *trim_edits)
849         Track *current;
851         for(current = first; current; current = NEXT)
852         {
853                 if(current->record)
854                 {
855                         current->modify_pluginhandles(oldposition, 
856                                 newposition, 
857                                 currentend, 
858                                 handle_mode,
859                                 edit_labels,
860                                 trim_edits);
861                 }
862         }
863         return 0;
868 int Tracks::purge_asset(Asset *asset)
870         Track *current_track;
871         int result = 0;
872         
873         for(current_track = first; current_track; current_track = current_track->next)
874         {
875                 result += current_track->purge_asset(asset); 
876         }
877         return result;
880 int Tracks::asset_used(Asset *asset)
882         Track *current_track;
883         int result = 0;
884         
885         for(current_track = first; current_track; current_track = current_track->next)
886         {
887                 result += current_track->asset_used(asset); 
888         }
889         return result;
892 int Tracks::scale_time(float rate_scale, int ignore_record, int scale_edits, int scale_autos, int64_t start, int64_t end)
894         Track *current_track;
896         for(current_track = first; 
897                 current_track; 
898                 current_track = current_track->next)
899         {
900                 if((current_track->record || ignore_record) && 
901                         current_track->data_type == TRACK_VIDEO)
902                 {
903                         current_track->scale_time(rate_scale, scale_edits, scale_autos, start, end);
904                 }
905         }
906         return 0;