Credit Andrew - improve in-tree documentation
[goodguy/cinelerra.git] / cinelerra / edits.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008-2017 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 "aedit.h"
23 #include "asset.h"
24 #include "assets.h"
25 #include "automation.h"
26 #include "bcsignals.h"
27 #include "cache.h"
28 #include "clip.h"
29 #include "clipedls.h"
30 #include "edit.h"
31 #include "edits.h"
32 #include "edl.h"
33 #include "edlsession.h"
34 #include "file.h"
35 #include "filexml.h"
36 #include "filesystem.h"
37 #include "localsession.h"
38 #include "plugin.h"
39 #include "strategies.inc"
40 #include "track.h"
41 #include "transition.h"
42 #include "transportque.inc"
43
44 #include <string.h>
45
46 Edits::Edits(EDL *edl, Track *track)
47  : List<Edit>()
48 {
49         this->edl = edl;
50         this->track = track;
51 }
52
53 Edits::~Edits()
54 {
55 }
56
57
58 void Edits::equivalent_output(Edits *edits, int64_t *result)
59 {
60 // For the case of plugin sets, a new plugin set may be created with
61 // plugins only starting after 0.  We only want to restart brender at
62 // the first plugin in this case.
63         for(Edit *current = first, *that_current = edits->first;
64                 current || that_current;
65                 current = NEXT,
66                 that_current = that_current->next)
67         {
68 //printf("Edits::equivalent_output 1 %d\n", *result);
69                 if(!current && that_current)
70                 {
71                         int64_t position1 = length();
72                         int64_t position2 = that_current->startproject;
73                         if(*result < 0 || *result > MIN(position1, position2))
74                                 *result = MIN(position1, position2);
75                         break;
76                 }
77                 else
78                 if(current && !that_current)
79                 {
80                         int64_t position1 = edits->length();
81                         int64_t position2 = current->startproject;
82                         if(*result < 0 || *result > MIN(position1, position2))
83                                 *result = MIN(position1, position2);
84                         break;
85                 }
86                 else
87                 {
88 //printf("Edits::equivalent_output 2 %d\n", *result);
89                         current->equivalent_output(that_current, result);
90 //printf("Edits::equivalent_output 3 %d\n", *result);
91                 }
92         }
93 }
94
95 void Edits::copy_from(Edits *edits)
96 {
97         while(last) delete last;
98         for(Edit *current = edits->first; current; current = NEXT)
99         {
100                 Edit *new_edit = append(create_edit());
101                 new_edit->copy_from(current);
102         }
103 }
104
105
106 Edits& Edits::operator=(Edits& edits)
107 {
108 printf("Edits::operator= 1\n");
109         copy_from(&edits);
110         return *this;
111 }
112
113
114 void Edits::insert_asset(Asset *asset, EDL *nested_edl,
115         int64_t length, int64_t position, int track_number)
116 {
117         Edit *new_edit = insert_new_edit(position);
118
119         new_edit->nested_edl = nested_edl;
120         new_edit->asset = asset;
121         new_edit->startsource = 0;
122         new_edit->startproject = position;
123         new_edit->length = length;
124
125         if(nested_edl)
126         {
127                 if(track->data_type == TRACK_AUDIO)
128                         new_edit->channel = track_number % nested_edl->session->audio_channels;
129                 else
130                         new_edit->channel = 0;
131         }
132
133         if(asset && !nested_edl)
134         {
135                 if(asset->audio_data)
136                         new_edit->channel = track_number % asset->channels;
137                 else
138                 if(asset->video_data)
139                         new_edit->channel = track_number % asset->layers;
140         }
141
142 //printf("Edits::insert_asset %d %d\n", new_edit->channel, new_edit->length);
143         for(Edit *current = new_edit->next; current; current = NEXT)
144         {
145                 current->startproject += length;
146         }
147 }
148
149 void Edits::insert_edits(Edits *source_edits,
150         int64_t position,
151         int64_t min_length,
152         int edit_autos)
153 {
154         //int64_t clipboard_end = position + min_length;
155 // Length pasted so far
156         int64_t source_len = 0;
157
158 // Fill region between end of edit table and beginning of pasted segment
159 // with silence.  Can't call from insert_new_edit because it's recursive.
160         if(position > length())
161         {
162                 paste_silence(length(), position);
163         }
164
165
166         for(Edit *source_edit = source_edits->first;
167                 source_edit;
168                 source_edit = source_edit->next)
169         {
170                 EDL *dest_nested_edl = 0;
171                 if(source_edit->nested_edl)
172                         dest_nested_edl = edl->nested_edls.get_nested(source_edit->nested_edl);
173
174 // Update Assets
175                 Asset *dest_asset = 0;
176                 if(source_edit->asset)
177                         dest_asset = edl->assets->update(source_edit->asset);
178 // Open destination area
179                 Edit *dest_edit = insert_new_edit(position + source_edit->startproject);
180
181                 dest_edit->copy_from(source_edit);
182                 dest_edit->asset = dest_asset;
183                 dest_edit->nested_edl = dest_nested_edl;
184                 dest_edit->startproject = position + source_edit->startproject;
185
186
187
188 // Shift keyframes in source edit to their position in the
189 // destination edit for plugin case
190                 if(edit_autos) dest_edit->shift_keyframes(position);
191
192 // Shift following edits and keyframes in following edits by length
193 // in current source edit.
194                 for(Edit *future_edit = dest_edit->next;
195                         future_edit;
196                         future_edit = future_edit->next)
197                 {
198                         future_edit->startproject += dest_edit->length;
199                         future_edit->shift_keyframes(dest_edit->length);
200                 }
201
202                 source_len += source_edit->length;
203         }
204
205
206
207
208 // Fill remaining clipboard length with silence
209         if(source_len < min_length)
210         {
211 //printf("Edits::insert_edits %d\n", __LINE__);
212                 paste_silence(position + source_len, position + min_length);
213         }
214 }
215
216
217 // Native units
218 // Can't paste silence in here because it's used by paste_silence.
219 Edit* Edits::insert_new_edit(int64_t position)
220 {
221 //printf("Edits::insert_new_edit 1\n");
222         Edit *current = split_edit(position);
223
224 //printf("Edits::insert_new_edit 1\n");
225         Edit *new_edit = create_edit();
226         if( current ) new_edit->hard_right = current->hard_left;
227         if( current ) current = PREVIOUS;
228         if( current ) new_edit->hard_left = current->hard_right;
229 //printf("Edits::insert_new_edit 1\n");
230         insert_after(current, new_edit);
231         new_edit->startproject = position;
232 //printf("Edits::insert_new_edit 2\n");
233         return new_edit;
234 }
235
236 Edit* Edits::split_edit(int64_t position)
237 {
238 // Get edit containing position
239         Edit *edit = editof(position, PLAY_FORWARD, 0);
240         if(!edit) return 0;
241 // Split would have created a 0 length
242 //      if(edit->startproject == position) return edit;
243 // Create anyway so the return value comes before position
244
245         Edit *new_edit = create_edit();
246         insert_after(edit, new_edit);
247         new_edit->copy_from(edit);
248         new_edit->length = new_edit->startproject + new_edit->length - position;
249         edit->length = position - edit->startproject;
250         new_edit->startproject = position;
251         new_edit->startsource += edit->length;
252
253 // Decide what to do with the transition
254         if(edit->length && edit->transition) {
255                 delete new_edit->transition;
256                 new_edit->transition = 0;
257         }
258
259         if(edit->transition && edit->transition->length > edit->length)
260                 edit->transition->length = edit->length;
261         if(new_edit->transition && new_edit->transition->length > new_edit->length)
262                 new_edit->transition->length = new_edit->length;
263         return new_edit;
264 }
265
266 int Edits::save(FileXML *xml, const char *output_path)
267 {
268         copy(0, length(), xml, output_path);
269         return 0;
270 }
271
272 void Edits::resample(double old_rate, double new_rate)
273 {
274         for(Edit *current = first; current; current = NEXT)
275         {
276                 current->startproject = Units::to_int64((double)current->startproject /
277                         old_rate *
278                         new_rate);
279                 if(PREVIOUS) PREVIOUS->length = current->startproject - PREVIOUS->startproject;
280                 current->startsource = Units::to_int64((double)current->startsource /
281                         old_rate *
282                         new_rate);
283                 if(!NEXT) current->length = Units::to_int64((double)current->length /
284                         old_rate *
285                         new_rate);
286                 if(current->transition)
287                 {
288                         current->transition->length = Units::to_int64(
289                                 (double)current->transition->length /
290                                 old_rate *
291                                 new_rate);
292                 }
293                 current->resample(old_rate, new_rate);
294         }
295 }
296
297 int Edits::is_glitch(Edit *edit)
298 {
299         if( track->data_type != TRACK_AUDIO ) return 0;
300         int64_t threshold = edl->session->frame_rate > 0 ?
301                 0.5 * edl->session->sample_rate / edl->session->frame_rate : 0;
302 // audio edit shorter than .5 frames is a glitch
303         return edit->length < threshold ? 1 : 0;
304 }
305
306 int Edits::optimize()
307 {
308         int result = 1;
309         Edit *current;
310
311 //printf("Edits::optimize %d\n", __LINE__);
312 // Sort edits by starting point
313         while(result)
314         {
315                 result = 0;
316
317                 for(current = first; current; current = NEXT)
318                 {
319                         Edit *next_edit = NEXT;
320
321                         if(next_edit && next_edit->startproject < current->startproject)
322                         {
323                                 swap(next_edit, current);
324                                 result = 1;
325                         }
326                 }
327         }
328
329 // Insert silence between edits which aren't consecutive
330         for(current = last; current; current = current->previous)
331         {
332                 if(current->previous)
333                 {
334                         Edit *previous_edit = current->previous;
335                         if(current->startproject -
336                                 previous_edit->startproject -
337                                 previous_edit->length > 0)
338                         {
339                                 Edit *new_edit = create_edit();
340                                 insert_before(current, new_edit);
341                                 new_edit->startproject = previous_edit->startproject + previous_edit->length;
342                                 new_edit->length = current->startproject -
343                                         previous_edit->startproject -
344                                         previous_edit->length;
345                         }
346                 }
347                 else
348                 if(current->startproject > 0)
349                 {
350                         Edit *new_edit = create_edit();
351                         insert_before(current, new_edit);
352                         new_edit->length = current->startproject;
353                 }
354         }
355
356         result = 1;
357         while(result) {
358                 result = 0;
359
360 // delete 0 length edits
361                 for( current = first; !result && current; ) {
362                         Edit* next = current->next;
363                         if( current->length == 0 ) {
364                                 if( next && current->transition && !next->transition) {
365                                         next->transition = current->transition;
366                                         next->transition->edit = next;
367                                         current->transition = 0;
368                                 }
369                                 delete current;
370                                 result = 1;
371                                 break;
372                         }
373                         current = next;
374                 }
375
376 // merge same files or transitions, and deglitch
377                 if( !result && track->data_type != TRACK_SUBTITLE ) {
378                         current = first;
379                         if( current && !current->hard_right &&
380                             current->next && !current->next->hard_left &&
381                             is_glitch(current) ) {
382 // if the first edit is a glitch, change it to silence
383                                 current->asset = 0;
384                                 current->nested_edl = 0;
385                         }
386                         Edit *next_edit = 0;
387                         for( ; current && (next_edit=current->next); current=NEXT ) {
388 // both edges are not hard edges
389                                 if( current->hard_right || next_edit->hard_left ) continue;
390 // next edit is a glitch
391                                 if( is_glitch(next_edit) )
392                                         break;
393 // both edits are silence & not a plugin
394                                 if( !current->is_plugin && current->silence() &&
395                                     !next_edit->is_plugin && next_edit->silence() )
396                                         break;
397 // source channels are identical & assets are identical
398                                 if( !result && current->channel == next_edit->channel &&
399                                     current->asset == next_edit->asset &&
400                                     current->nested_edl == next_edit->nested_edl ) {
401 //  and stop and start in the same frame
402                                         int64_t current_end = current->startsource + current->length;
403                                         int64_t next_start = next_edit->startsource;
404                                         if( current_end == next_start ||
405                                             EQUIV(edl->frame_align(track->from_units(current_end), 1),
406                                                   edl->frame_align(track->from_units(next_start), 1)) )
407                                                 break;
408                                 }
409                         }
410                         if( next_edit ) {
411                                 int64_t current_start = current->startproject;
412                                 int64_t next_end = next_edit->startproject + next_edit->length;
413                                 current->length = next_end - current_start;
414                                 current->hard_right = next_edit->hard_right;
415                                 remove(next_edit);
416                                 result = 1;
417                         }
418                 }
419
420                 if( last && last->silence() &&
421                     !last->transition && !last->hard_left && !last->hard_right ) {
422                         delete last;
423                         result = 1;
424                 }
425         }
426
427         return 0;
428 }
429
430
431 // ===================================== file operations
432
433 void Edits::load(FileXML *file, int track_offset)
434 {
435         int64_t startproject = 0;
436
437         while( last ) delete last;
438
439         while( !file->read_tag() ) {
440 //printf("Edits::load 1 %s\n", file->tag.get_title());
441                 if(!strcmp(file->tag.get_title(), "EDIT")) {
442                         load_edit(file, startproject, track_offset);
443                 }
444                 else if(!strcmp(file->tag.get_title(), "/EDITS"))
445                         break;
446         }
447
448 //track->dump();
449         optimize();
450 }
451
452 int Edits::load_edit(FileXML *file, int64_t &startproject, int track_offset)
453 {
454         Edit* current = append_new_edit();
455         current->load_properties(file, startproject);
456
457         startproject += current->length;
458
459         while( !file->read_tag() ) {
460                 if(file->tag.title_is("NESTED_EDL")) {
461                         char path[BCTEXTLEN];
462                         path[0] = 0;
463                         file->tag.get_property("SRC", path);
464 //printf("Edits::load_edit %d path=%s\n", __LINE__, path);
465                         if(path[0] != 0) {
466                                 current->nested_edl = edl->nested_edls.load(path);
467                         }
468 // printf("Edits::load_edit %d nested_edl->path=%s\n",
469 // __LINE__, current->nested_edl->path);
470                 }
471                 else if(file->tag.title_is("FILE")) {
472                         char filename[BCTEXTLEN];
473                         filename[0] = 0;
474                         file->tag.get_property("SRC", filename);
475 // Extend path
476                         if(filename[0] != 0) {
477                                 char directory[BCTEXTLEN], edl_directory[BCTEXTLEN];
478                                 FileSystem fs;
479                                 fs.set_current_dir("");
480                                 fs.extract_dir(directory, filename);
481                                 if(!strlen(directory)) {
482                                         fs.extract_dir(edl_directory, file->filename);
483                                         fs.join_names(directory, edl_directory, filename);
484                                         strcpy(filename, directory);
485                                 }
486                                 current->asset = edl->assets->get_asset(filename);
487                         }
488                         else {
489                                 current->asset = 0;
490                         }
491 //printf("Edits::load_edit 5\n");
492                 }
493                 else if(file->tag.title_is("TRANSITION")) {
494                         current->transition = new Transition(edl, current, "",
495                                 track->to_units(edl->session->default_transition_length, 1));
496                                 current->transition->load_xml(file);
497                 }
498                 else if(file->tag.title_is("/EDIT"))
499                         break;
500         }
501
502 //printf("Edits::load_edit %d\n", __LINE__);
503 //track->dump();
504 //printf("Edits::load_edit %d\n", __LINE__);
505         return 0;
506 }
507
508 // ============================================= accounting
509
510 int64_t Edits::length()
511 {
512         return last ? last->startproject + last->length : 0;
513 }
514
515
516
517 Edit* Edits::editof(int64_t position, int direction, int use_nudge)
518 {
519         Edit *current = 0;
520         if(use_nudge && track) position += track->nudge;
521
522         if(direction == PLAY_FORWARD) {
523                 for(current = last; current; current = PREVIOUS) {
524                         if(current->startproject <= position && current->startproject + current->length > position)
525                                 return current;
526                 }
527         }
528         else
529         if(direction == PLAY_REVERSE) {
530                 for(current = first; current; current = NEXT) {
531                         if(current->startproject < position && current->startproject + current->length >= position)
532                                 return current;
533                 }
534         }
535
536         return 0;     // return 0 on failure
537 }
538
539 Edit* Edits::get_playable_edit(int64_t position, int use_nudge)
540 {
541         Edit *current;
542         if(track && use_nudge) position += track->nudge;
543
544 // Get the current edit
545         for(current = first; current; current = NEXT) {
546                 if(current->startproject <= position &&
547                         current->startproject + current->length > position)
548                         break;
549         }
550
551 // Get the edit's asset
552 // TODO: descend into nested EDLs
553         if(current) {
554                 if(!current->asset)
555                         current = 0;
556         }
557
558         return current;     // return 0 on failure
559 }
560
561 // ================================================ editing
562
563
564
565 int Edits::copy(int64_t start, int64_t end, FileXML *file, const char *output_path)
566 {
567         Edit *current_edit;
568
569         file->tag.set_title("EDITS");
570         file->append_tag();
571         file->append_newline();
572
573         for(current_edit = first; current_edit; current_edit = current_edit->next)
574         {
575                 current_edit->copy(start, end, file, output_path);
576         }
577
578         file->tag.set_title("/EDITS");
579         file->append_tag();
580         file->append_newline();
581         return 0;
582 }
583
584
585
586 void Edits::clear(int64_t start, int64_t end)
587 {
588         if( start >= end ) return;
589
590         Edit* edit1 = editof(start, PLAY_FORWARD, 0);
591         Edit* edit2 = editof(end, PLAY_FORWARD, 0);
592         Edit* current_edit;
593
594         if(end == start) return;        // nothing selected
595         if(!edit1 && !edit2) return;       // nothing selected
596
597
598         if(!edit2) {                // edit2 beyond end of track
599                 edit2 = last;
600                 end = this->length();
601         }
602
603         if( edit1 && edit2 && edit1 != edit2)
604         {
605 // in different edits
606
607 //printf("Edits::clear 3.5 %d %d %d %d\n", edit1->startproject, edit1->length, edit2->startproject, edit2->length);
608                 edit1->length = start - edit1->startproject;
609                 edit2->length -= end - edit2->startproject;
610                 edit2->startsource += end - edit2->startproject;
611                 edit2->startproject += end - edit2->startproject;
612
613 // delete
614                 for(current_edit = edit1->next; current_edit && current_edit != edit2;) {
615                         Edit* next = current_edit->next;
616                         remove(current_edit);
617                         current_edit = next;
618                 }
619 // shift
620                 for(current_edit = edit2; current_edit; current_edit = current_edit->next) {
621                         current_edit->startproject -= end - start;
622                 }
623         }
624         else {
625 // in same edit. paste_edit depends on this
626 // create a new edit
627                 current_edit = split_edit(start);
628                 if( current_edit ) {
629                         current_edit->length -= end - start;
630                         current_edit->startsource += end - start;
631 // shift
632                         while( (current_edit=current_edit->next) != 0 ) {
633                                 current_edit->startproject -= end - start;
634                         }
635                 }
636         }
637
638         optimize();
639 }
640
641 // Used by edit handle and plugin handle movement but plugin handle movement
642 // can only effect other plugins.
643 void Edits::clear_recursive(int64_t start, int64_t end,
644         int edit_edits, int edit_labels, int edit_plugins, int edit_autos,
645         Edits *trim_edits)
646 {
647 //printf("Edits::clear_recursive 1\n");
648         track->clear(start, end,
649                 edit_edits, edit_labels, edit_plugins, edit_autos, trim_edits);
650 }
651
652
653 int Edits::clear_handle(double start, double end,
654         int edit_plugins, int edit_autos, double &distance)
655 {
656         Edit *current_edit;
657
658         distance = 0.0; // if nothing is found, distance is 0!
659         for(current_edit = first;
660                 current_edit && current_edit->next;
661                 current_edit = current_edit->next) {
662
663
664
665                 if(current_edit->asset && current_edit->next->asset) {
666
667                         if(current_edit->asset->equivalent(*current_edit->next->asset, 0, 0, edl)) {
668
669 // Got two consecutive edits in same source
670                                 if(edl->equivalent(track->from_units(current_edit->next->startproject),
671                                         start)) {
672 // handle selected
673                                         int length = -current_edit->length;
674                                         current_edit->length = current_edit->next->startsource - current_edit->startsource;
675                                         length += current_edit->length;
676
677 // Lengthen automation
678                                         if(edit_autos)
679                                                 track->automation->paste_silence(current_edit->next->startproject,
680                                                         current_edit->next->startproject + length);
681
682 // Lengthen effects
683                                         if(edit_plugins)
684                                                 track->shift_effects(current_edit->next->startproject,
685                                                         length,
686                                                         edit_autos);
687
688                                         for(current_edit = current_edit->next; current_edit; current_edit = current_edit->next)
689                                         {
690                                                 current_edit->startproject += length;
691                                         }
692
693                                         distance = track->from_units(length);
694                                         optimize();
695                                         break;
696                                 }
697                         }
698                 }
699         }
700
701         return 0;
702 }
703
704 int Edits::modify_handles(double oldposition, double newposition, int currentend,
705         int edit_mode, int edit_edits, int edit_labels, int edit_plugins, int edit_autos,
706         Edits *trim_edits, int group_id)
707 {
708         int result = 0;
709         Edit *current_edit;
710         Edit *left = 0, *right = 0;
711         if( group_id > 0 ) {
712                 double start = DBL_MAX, end = DBL_MIN;
713                 for( Edit *edit=first; edit; edit=edit->next ) {
714                         if( edit->group_id != group_id ) continue;
715                         double edit_start = edit->track->from_units(edit->startproject);
716                         if( edit_start < start ) { start = edit_start;  left = edit; }
717                         double edit_end = edit->track->from_units(edit->startproject+edit->length);
718                         if( edit_end > end ) { end = edit_end;  right = edit; }
719                 }
720         }
721
722 //printf("Edits::modify_handles 1 %d %f %f\n", currentend, newposition, oldposition);
723         if(currentend == 0) {
724 // left handle
725                 for(current_edit = first; current_edit && !result;) {
726                         if( group_id > 0 ? current_edit == left :
727                             edl->equivalent(track->from_units(current_edit->startproject),
728                                 oldposition) ) {
729 // edit matches selection
730 //printf("Edits::modify_handles 3 %f %f\n", newposition, oldposition);
731                                 double delta = newposition - oldposition;
732                                 oldposition = track->from_units(current_edit->startproject);
733                                 if( group_id > 0 ) newposition = oldposition + delta;
734                                 result = 1;
735
736                                 if( newposition >= oldposition ) {
737 //printf("Edits::modify_handle 1 %s %f %f\n", track->title, oldposition, newposition);
738 // shift start of edit in
739                                         current_edit->shift_start_in(edit_mode,
740                                                 track->to_units(newposition, 0),
741                                                 track->to_units(oldposition, 0),
742                                                 edit_edits,
743                                                 edit_labels,
744                                                 edit_plugins,
745                                                 edit_autos,
746                                                 trim_edits);
747                                 }
748                                 else {
749 //printf("Edits::modify_handle 2 %s\n", track->title);
750 // move start of edit out
751                                         current_edit->shift_start_out(edit_mode,
752                                                 track->to_units(newposition, 0),
753                                                 track->to_units(oldposition, 0),
754                                                 edit_edits,
755                                                 edit_labels,
756                                                 edit_plugins,
757                                                 edit_autos,
758                                                 trim_edits);
759                                 }
760                         }
761
762                         if(!result) current_edit = current_edit->next;
763                 }
764         }
765         else {
766 // right handle selected
767                 for(current_edit = first; current_edit && !result;) {
768                         if( group_id > 0 ? current_edit == right :
769                             edl->equivalent(track->from_units(current_edit->startproject) +
770                                         track->from_units(current_edit->length), oldposition) ) {
771                                 double delta = newposition - oldposition;
772                                 oldposition = track->from_units(current_edit->startproject) +
773                                         track->from_units(current_edit->length);
774                                 if( group_id > 0 ) newposition = oldposition + delta;
775                                 result = 1;
776
777 //printf("Edits::modify_handle 3\n");
778                                 if(newposition <= oldposition) {
779 // shift end of edit in
780 //printf("Edits::modify_handle 4\n");
781                                         current_edit->shift_end_in(edit_mode,
782                                                 track->to_units(newposition, 0),
783                                                 track->to_units(oldposition, 0),
784                                                 edit_edits,
785                                                 edit_labels,
786                                                 edit_plugins,
787                                                 edit_autos,
788                                                 trim_edits);
789 //printf("Edits::modify_handle 5\n");
790                                 }
791                                 else
792                                 {
793 // move end of edit out
794 //printf("Edits::modify_handle %d edit_mode=%d\n", __LINE__, edit_mode);
795                                         current_edit->shift_end_out(edit_mode,
796                                                 track->to_units(newposition, 0),
797                                                 track->to_units(oldposition, 0),
798                                                 edit_edits,
799                                                 edit_labels,
800                                                 edit_plugins,
801                                                 edit_autos,
802                                                 trim_edits);
803 //printf("Edits::modify_handle 7\n");
804                                 }
805                         }
806
807                         if(!result) current_edit = current_edit->next;
808 //printf("Edits::modify_handle 8\n");
809                 }
810         }
811
812         optimize();
813         return 0;
814 }
815
816 void Edits::paste_silence(int64_t start, int64_t end)
817 {
818         Edit *new_edit = editof(start, PLAY_FORWARD, 0);
819         if (!new_edit) return;
820
821         if( !new_edit->silence() || new_edit->hard_right ) {
822                 new_edit = insert_new_edit(start);
823                 new_edit->length = end - start;
824         }
825         else
826                 new_edit->length += end - start;
827
828         for(Edit *current = new_edit->next; current; current = NEXT) {
829                 current->startproject += end - start;
830         }
831
832         return;
833 }
834
835 Edit *Edits::create_silence(int64_t start, int64_t end)
836 {
837         Edit *new_edit = insert_new_edit(start);
838         new_edit->length = end - start;
839         for(Edit *current = new_edit->next; current; current = NEXT) {
840                 current->startproject += end - start;
841         }
842         return new_edit;
843 }
844
845 Edit* Edits::shift(int64_t position, int64_t difference)
846 {
847         Edit *new_edit = split_edit(position);
848
849         for(Edit *current = first; current; current = NEXT) {
850                 if(current->startproject >= position) {
851                         current->shift(difference);
852                 }
853         }
854         return new_edit;
855 }
856
857
858 void Edits::shift_keyframes_recursive(int64_t position, int64_t length)
859 {
860         track->shift_keyframes(position, length);
861 }
862
863 void Edits::shift_effects_recursive(int64_t position, int64_t length, int edit_autos)
864 {
865         track->shift_effects(position, length, edit_autos);
866 }
867