4 * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
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.
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.
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
25 #include "automation.h"
26 #include "bcsignals.h"
33 #include "edlsession.h"
36 #include "filesystem.h"
37 #include "localsession.h"
39 #include "strategies.inc"
41 #include "transition.h"
42 #include "transportque.inc"
46 Edits::Edits(EDL *edl, Track *track)
58 void Edits::equivalent_output(Edits *edits, int64_t *result)
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;
66 that_current = that_current->next)
68 //printf("Edits::equivalent_output 1 %d\n", *result);
69 if(!current && that_current)
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);
78 if(current && !that_current)
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);
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);
95 void Edits::copy_from(Edits *edits)
97 while(last) delete last;
98 for(Edit *current = edits->first; current; current = NEXT)
100 Edit *new_edit = append(create_edit());
101 new_edit->copy_from(current);
106 Edits& Edits::operator=(Edits& edits)
108 printf("Edits::operator= 1\n");
114 void Edits::insert_asset(Asset *asset, EDL *nested_edl,
115 int64_t length, int64_t position, int track_number)
117 Edit *new_edit = insert_new_edit(position);
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;
127 if(track->data_type == TRACK_AUDIO)
128 new_edit->channel = track_number % nested_edl->session->audio_channels;
130 new_edit->channel = 0;
133 if(asset && !nested_edl)
135 if(asset->audio_data)
136 new_edit->channel = track_number % asset->channels;
138 if(asset->video_data)
139 new_edit->channel = track_number % asset->layers;
142 //printf("Edits::insert_asset %d %d\n", new_edit->channel, new_edit->length);
143 for(Edit *current = new_edit->next; current; current = NEXT)
145 current->startproject += length;
149 void Edits::insert_edits(Edits *source_edits,
154 //int64_t clipboard_end = position + min_length;
155 // Length pasted so far
156 int64_t source_len = 0;
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())
162 paste_silence(length(), position);
166 for(Edit *source_edit = source_edits->first;
168 source_edit = source_edit->next)
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);
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);
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;
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);
192 // Shift following edits and keyframes in following edits by length
193 // in current source edit.
194 for(Edit *future_edit = dest_edit->next;
196 future_edit = future_edit->next)
198 future_edit->startproject += dest_edit->length;
199 future_edit->shift_keyframes(dest_edit->length);
202 source_len += source_edit->length;
208 // Fill remaining clipboard length with silence
209 if(source_len < min_length)
211 //printf("Edits::insert_edits %d\n", __LINE__);
212 paste_silence(position + source_len, position + min_length);
218 // Can't paste silence in here because it's used by paste_silence.
219 Edit* Edits::insert_new_edit(int64_t position)
221 //printf("Edits::insert_new_edit 1\n");
222 Edit *current = split_edit(position);
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");
236 Edit* Edits::split_edit(int64_t position)
238 // Get edit containing position
239 Edit *edit = editof(position, PLAY_FORWARD, 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
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;
253 // Decide what to do with the transition
254 if(edit->length && edit->transition) {
255 delete new_edit->transition;
256 new_edit->transition = 0;
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;
266 int Edits::save(FileXML *xml, const char *output_path)
268 copy(0, length(), xml, output_path);
272 void Edits::resample(double old_rate, double new_rate)
274 for(Edit *current = first; current; current = NEXT)
276 current->startproject = Units::to_int64((double)current->startproject /
279 if(PREVIOUS) PREVIOUS->length = current->startproject - PREVIOUS->startproject;
280 current->startsource = Units::to_int64((double)current->startsource /
283 if(!NEXT) current->length = Units::to_int64((double)current->length /
286 if(current->transition)
288 current->transition->length = Units::to_int64(
289 (double)current->transition->length /
293 current->resample(old_rate, new_rate);
297 int Edits::is_glitch(Edit *edit)
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;
306 int Edits::optimize()
311 //printf("Edits::optimize %d\n", __LINE__);
312 // Sort edits by starting point
317 for(current = first; current; current = NEXT)
319 Edit *next_edit = NEXT;
321 if(next_edit && next_edit->startproject < current->startproject)
323 swap(next_edit, current);
329 // Insert silence between edits which aren't consecutive
330 for(current = last; current; current = current->previous)
332 if(current->previous)
334 Edit *previous_edit = current->previous;
335 if(current->startproject -
336 previous_edit->startproject -
337 previous_edit->length > 0)
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;
348 if(current->startproject > 0)
350 Edit *new_edit = create_edit();
351 insert_before(current, new_edit);
352 new_edit->length = current->startproject;
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;
376 // merge same files or transitions, and deglitch
377 if( !result && track->data_type != TRACK_SUBTITLE ) {
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
384 current->nested_edl = 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) )
393 // both edits are silence & not a plugin
394 if( !current->is_plugin && current->silence() &&
395 !next_edit->is_plugin && next_edit->silence() )
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)) )
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;
420 if( last && last->silence() &&
421 !last->transition && !last->hard_left && !last->hard_right ) {
431 // ===================================== file operations
433 void Edits::load(FileXML *file, int track_offset)
435 int64_t startproject = 0;
437 while( last ) delete last;
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);
444 else if(!strcmp(file->tag.get_title(), "/EDITS"))
452 int Edits::load_edit(FileXML *file, int64_t &startproject, int track_offset)
454 Edit* current = append_new_edit();
455 current->load_properties(file, startproject);
457 startproject += current->length;
459 while( !file->read_tag() ) {
460 if(file->tag.title_is("NESTED_EDL")) {
461 char path[BCTEXTLEN];
463 file->tag.get_property("SRC", path);
464 //printf("Edits::load_edit %d path=%s\n", __LINE__, path);
466 current->nested_edl = edl->nested_edls.load(path);
468 // printf("Edits::load_edit %d nested_edl->path=%s\n",
469 // __LINE__, current->nested_edl->path);
471 else if(file->tag.title_is("FILE")) {
472 char filename[BCTEXTLEN];
474 file->tag.get_property("SRC", filename);
476 if(filename[0] != 0) {
477 char directory[BCTEXTLEN], edl_directory[BCTEXTLEN];
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);
486 current->asset = edl->assets->get_asset(filename);
491 //printf("Edits::load_edit 5\n");
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);
498 else if(file->tag.title_is("/EDIT"))
502 //printf("Edits::load_edit %d\n", __LINE__);
504 //printf("Edits::load_edit %d\n", __LINE__);
508 // ============================================= accounting
510 int64_t Edits::length()
512 return last ? last->startproject + last->length : 0;
517 Edit* Edits::editof(int64_t position, int direction, int use_nudge)
520 if(use_nudge && track) position += track->nudge;
522 if(direction == PLAY_FORWARD) {
523 for(current = last; current; current = PREVIOUS) {
524 if(current->startproject <= position && current->startproject + current->length > position)
529 if(direction == PLAY_REVERSE) {
530 for(current = first; current; current = NEXT) {
531 if(current->startproject < position && current->startproject + current->length >= position)
536 return 0; // return 0 on failure
539 Edit* Edits::get_playable_edit(int64_t position, int use_nudge)
542 if(track && use_nudge) position += track->nudge;
544 // Get the current edit
545 for(current = first; current; current = NEXT) {
546 if(current->startproject <= position &&
547 current->startproject + current->length > position)
551 // Get the edit's asset
552 // TODO: descend into nested EDLs
558 return current; // return 0 on failure
561 // ================================================ editing
565 int Edits::copy(int64_t start, int64_t end, FileXML *file, const char *output_path)
569 file->tag.set_title("EDITS");
571 file->append_newline();
573 for(current_edit = first; current_edit; current_edit = current_edit->next)
575 current_edit->copy(start, end, file, output_path);
578 file->tag.set_title("/EDITS");
580 file->append_newline();
586 void Edits::clear(int64_t start, int64_t end)
588 if( start >= end ) return;
590 Edit* edit1 = editof(start, PLAY_FORWARD, 0);
591 Edit* edit2 = editof(end, PLAY_FORWARD, 0);
594 if(end == start) return; // nothing selected
595 if(!edit1 && !edit2) return; // nothing selected
598 if(!edit2) { // edit2 beyond end of track
600 end = this->length();
603 if( edit1 && edit2 && edit1 != edit2)
605 // in different edits
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;
614 for(current_edit = edit1->next; current_edit && current_edit != edit2;) {
615 Edit* next = current_edit->next;
616 remove(current_edit);
620 for(current_edit = edit2; current_edit; current_edit = current_edit->next) {
621 current_edit->startproject -= end - start;
625 // in same edit. paste_edit depends on this
627 current_edit = split_edit(start);
629 current_edit->length -= end - start;
630 current_edit->startsource += end - start;
632 while( (current_edit=current_edit->next) != 0 ) {
633 current_edit->startproject -= end - start;
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,
647 //printf("Edits::clear_recursive 1\n");
648 track->clear(start, end,
649 edit_edits, edit_labels, edit_plugins, edit_autos, trim_edits);
653 int Edits::clear_handle(double start, double end,
654 int edit_plugins, int edit_autos, double &distance)
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) {
665 if(current_edit->asset && current_edit->next->asset) {
667 if(current_edit->asset->equivalent(*current_edit->next->asset, 0, 0, edl)) {
669 // Got two consecutive edits in same source
670 if(edl->equivalent(track->from_units(current_edit->next->startproject),
673 int length = -current_edit->length;
674 current_edit->length = current_edit->next->startsource - current_edit->startsource;
675 length += current_edit->length;
677 // Lengthen automation
679 track->automation->paste_silence(current_edit->next->startproject,
680 current_edit->next->startproject + length);
684 track->shift_effects(current_edit->next->startproject,
688 for(current_edit = current_edit->next; current_edit; current_edit = current_edit->next)
690 current_edit->startproject += length;
693 distance = track->from_units(length);
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)
710 Edit *left = 0, *right = 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; }
722 //printf("Edits::modify_handles 1 %d %f %f\n", currentend, newposition, oldposition);
723 if(currentend == 0) {
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),
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;
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),
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),
762 if(!result) current_edit = current_edit->next;
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;
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),
789 //printf("Edits::modify_handle 5\n");
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),
803 //printf("Edits::modify_handle 7\n");
807 if(!result) current_edit = current_edit->next;
808 //printf("Edits::modify_handle 8\n");
816 void Edits::paste_silence(int64_t start, int64_t end)
818 Edit *new_edit = editof(start, PLAY_FORWARD, 0);
819 if (!new_edit) return;
821 if( !new_edit->silence() || new_edit->hard_right ) {
822 new_edit = insert_new_edit(start);
823 new_edit->length = end - start;
826 new_edit->length += end - start;
828 for(Edit *current = new_edit->next; current; current = NEXT) {
829 current->startproject += end - start;
835 Edit *Edits::create_silence(int64_t start, int64_t end)
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;
845 Edit* Edits::shift(int64_t position, int64_t difference)
847 Edit *new_edit = split_edit(position);
849 for(Edit *current = first; current; current = NEXT) {
850 if(current->startproject >= position) {
851 current->shift(difference);
858 void Edits::shift_keyframes_recursive(int64_t position, int64_t length)
860 track->shift_keyframes(position, length);
863 void Edits::shift_effects_recursive(int64_t position, int64_t length, int edit_autos)
865 track->shift_effects(position, length, edit_autos);