X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fedl.C;h=fc47bb3cf33ea38b4f4e503ededa1124f89e2850;hp=102c975bc3139520e45b884fa69c864bafe4482f;hb=ac8f3979437fb45effb135a1bb6bee871f52d635;hpb=6fa206c4d00a5bb7418289064dd8466ff477f787

diff --git a/cinelerra-5.1/cinelerra/edl.C b/cinelerra-5.1/cinelerra/edl.C
index 102c975b..fc47bb3c 100644
--- a/cinelerra-5.1/cinelerra/edl.C
+++ b/cinelerra-5.1/cinelerra/edl.C
@@ -38,8 +38,9 @@
 #include "floatauto.h"
 #include "floatautos.h"
 #include "guicast.h"
+#include "keyframe.h"
+#include "keyframes.h"
 #include "indexstate.h"
-#include "interlacemodes.h"
 #include "labels.h"
 #include "localsession.h"
 #include "maskautos.h"
@@ -336,7 +337,7 @@ int EDL::read_xml(FileXML *file, uint32_t load_flags)
 // The string is not terminated in this call.
 int EDL::save_xml(FileXML *file, const char *output_path)
 {
-	copy(1, file, output_path, 0);
+	copy(COPY_EDL, file, output_path, 0);
 	return 0;
 }
 
@@ -416,11 +417,8 @@ void EDL::copy_session(EDL *edl, int session_only)
 	}
 }
 
-int EDL::copy_assets(double start,
-	double end,
-	FileXML *file,
-	int all,
-	const char *output_path)
+int EDL::copy_assets(int copy_flags, double start, double end,
+		FileXML *file, const char *output_path)
 {
 	ArrayList<Asset*> asset_list;
 	Track* current;
@@ -430,12 +428,12 @@ int EDL::copy_assets(double start,
 	file->append_newline();
 
 // Copy everything for a save
-	if( all ) {
+	if( (copy_flags & COPY_ALL_ASSETS) ) {
 		for( Asset *asset=assets->first; asset; asset=asset->next ) {
 			asset_list.append(asset);
 		}
 	}
-	else {
+	if( (copy_flags & COPY_USED_ASSETS) ) {
 // Copy just the ones being used.
 		for( current = tracks->first; current; current = NEXT ) {
 			if( !current->record ) continue;
@@ -456,67 +454,66 @@ int EDL::copy_assets(double start,
 }
 
 
-int EDL::copy(double start, double end, int all,
+int EDL::copy(int copy_flags, double start, double end,
 	FileXML *file, const char *output_path, int rewind_it)
 {
 	file->tag.set_title("EDL");
 	file->tag.set_property("VERSION", CINELERRA_VERSION);
 // Save path for restoration of the project title from a backup.
 	if( this->path[0] ) file->tag.set_property("PATH", path);
-	return copy(start, end, all,
-		"/EDL", file, output_path, rewind_it);
+	return copy_xml(copy_flags, start, end, file, "/EDL", output_path, rewind_it);
 }
-int EDL::copy(int all, FileXML *file, const char *output_path, int rewind_it)
+int EDL::copy(int copy_flags, FileXML *file, const char *output_path, int rewind_it)
 {
-	return copy(0, tracks->total_length(), all, file, output_path, rewind_it);
+	return copy(copy_flags, 0., tracks->total_length(),
+		file, output_path, rewind_it);
 }
 
-int EDL::copy_clip(double start, double end, int all,
+int EDL::copy_clip(int copy_flags, double start, double end,
 	FileXML *file, const char *output_path, int rewind_it)
 {
 	file->tag.set_title("CLIP_EDL");
-	return copy(start, end, all,
-		"/CLIP_EDL", file, output_path, rewind_it);
+	return copy_xml(copy_flags, start, end, file, "/CLIP_EDL", output_path, rewind_it);
 }
-int EDL::copy_clip(int all, FileXML *file, const char *output_path, int rewind_it)
+int EDL::copy_clip(int copy_flags, FileXML *file, const char *output_path, int rewind_it)
 {
-	return copy_clip(0, tracks->total_length(), all, file, output_path, rewind_it);
+	return copy_clip(copy_flags, 0., tracks->total_length(),
+		file, output_path, rewind_it);
 }
 
-int EDL::copy_nested_edl(double start, double end, int all,
+int EDL::copy_nested(int copy_flags, double start, double end,
 	FileXML *file, const char *output_path, int rewind_it)
 {
 	file->tag.set_title("NESTED_EDL");
 	if( this->path[0] ) file->tag.set_property("PATH", path);
-	return copy(start, end, all,
-		"/NESTED_EDL", file, output_path, rewind_it);
+	return copy_xml(copy_flags, start, end, file, "/NESTED_EDL", output_path, rewind_it);
 }
-int EDL::copy_nested_edl(int all, FileXML *file, const char *output_path, int rewind_it)
+int EDL::copy_nested(int copy_flags, FileXML *file, const char *output_path, int rewind_it)
 {
-	return copy_nested_edl(0, tracks->total_length(), all, file, output_path, rewind_it);
+	return copy_nested(copy_flags, 0., tracks->total_length(),
+		file, output_path, rewind_it);
 }
 
-int EDL::copy_vwindow_edl(double start, double end, int all,
+int EDL::copy_vwindow(int copy_flags, double start, double end,
 	FileXML *file, const char *output_path, int rewind_it)
 {
 	file->tag.set_title("VWINDOW_EDL");
-	return copy(start, end, all,
-		"/VWINDOW_EDL", file, output_path, rewind_it);
+	return copy_xml(copy_flags, start, end, file, "/VWINDOW_EDL", output_path, rewind_it);
 }
-int EDL::copy_vwindow_edl(int all, FileXML *file, const char *output_path, int rewind_it)
+int EDL::copy_vwindow(int copy_flags, FileXML *file, const char *output_path, int rewind_it)
 {
-	return copy_vwindow_edl(0, tracks->total_length(), all, file, output_path, rewind_it);
+	return copy_vwindow(copy_flags, 0., tracks->total_length(),
+		file, output_path, rewind_it);
 }
 
-
-int EDL::copy(double start, double end, int all,
-	const char *closer, FileXML *file,
-	const char *output_path, int rewind_it)
+int EDL::copy_xml(int copy_flags, double start, double end,
+	 FileXML *file, const char *closer, const char *output_path,
+	int rewind_it)
 {
 	file->append_tag();
 	file->append_newline();
 // Set clipboard samples only if copying to clipboard
-	if( !all ) {
+	if( (copy_flags & COPY_LENGTH) ) {
 		file->tag.set_title("CLIPBOARD");
 		file->tag.set_property("LENGTH", end - start);
 		file->append_tag();
@@ -528,45 +525,54 @@ int EDL::copy(double start, double end, int all,
 //printf("EDL::copy 1\n");
 
 // Sessions
-	local_session->save_xml(file, start);
-
-//printf("EDL::copy 1\n");
+	if( (copy_flags & COPY_LOCAL_SESSION) )
+		local_session->save_xml(file, start);
 
 // Top level stuff.
-//	if(!parent_edl)
-	{
 // Need to copy all this from child EDL if pasting is desired.
-// Session
+
+	if( (copy_flags & COPY_SESSION) )
 		session->save_xml(file);
+
+	if( (copy_flags & COPY_VIDEO_CONFIG) )
 		session->save_video_config(file);
+
+	if( (copy_flags & COPY_AUDIO_CONFIG) )
 		session->save_audio_config(file);
+
+	if( (copy_flags & COPY_FOLDERS) )
 		folders.save_xml(file);
 
-		if( !parent_edl )
-			copy_assets(start, end, file, all, output_path);
+	if( (copy_flags & (COPY_ALL_ASSETS | COPY_USED_ASSETS)) )
+		copy_assets(copy_flags, start, end, file, output_path);
 
+	if( (copy_flags & COPY_NESTED_EDL) ) {
 		for( int i=0; i<nested_edls.size(); ++i )
-			nested_edls[i]->copy_nested_edl(0, tracks->total_length(), 1,
+			nested_edls[i]->copy_nested(copy_flags,
 				file, output_path, 0);
-
+	}
 // Clips
-// Don't want this if using clipboard
-		if( all ) {
-			for( int i=0; i<total_vwindow_edls(); ++i )
-				get_vwindow_edl(i)->copy_vwindow_edl(1, file, output_path, 0);
+	if( (copy_flags & COPY_CLIPS) ) {
+		for( int i=0; i<clips.size(); ++i )
+			clips[i]->copy_clip(copy_flags, file, output_path, 0);
+	}
 
-			for( int i=0; i<clips.size(); ++i )
-				clips[i]->copy_clip(1, file, output_path, 0);
+	if( (copy_flags & COPY_VWINDOWS) ) {
+		for( int i=0; i<total_vwindow_edls(); ++i )
+			get_vwindow_edl(i)->copy_vwindow(copy_flags,
+				file, output_path, 0);
+	}
 
-			mixers.save(file);
-		}
+	if( (copy_flags & COPY_MIXERS) )
+		mixers.save(file);
 
-		file->append_newline();
-		file->append_newline();
-	}
+	file->append_newline();
+	file->append_newline();
+
+	if( (copy_flags & COPY_LABELS) )
+		labels->copy(start, end, file);
 
-	labels->copy(start, end, file);
-	tracks->copy(start, end, all, file, output_path);
+	tracks->copy(copy_flags, start, end, file, output_path);
 
 // terminate file
 	file->tag.set_title(closer);
@@ -795,20 +801,27 @@ int EDL::clear(double start, double end,
 	return 0;
 }
 
-class Zone { public: Track *track; int64_t start, end; };
+int EDL::clear_hard_edges(double start, double end)
+{
+	return tracks->clear_hard_edges(start, end);
+}
+
+static int dead_edit_cmp(Edit**ap, Edit**bp)
+{
+	Edit *a = *ap, *b = *bp;
+	if( a->track != b->track ) return 0;
+	return a->startproject > b->startproject ? -1 : 1;
+}
 
 void EDL::delete_edits(ArrayList<Edit*> *edits, int collapse)
 {
-	if( session->labels_follow_edits )
-		delete_edit_labels(edits, collapse);
-	ArrayList<Zone> zones;
+	edits->sort(dead_edit_cmp);
 	for( int i=0; i<edits->size(); ++i ) {
 		Edit *edit = edits->get(i);
 		Track *track = edit->track;
 		int64_t start = edit->startproject;
-		int64_t end = start + edit->length;
-		Zone &zone = zones.append();
-		zone.track = track;  zone.start = start;  zone.end = end;
+		int64_t length = edit->length;
+		int64_t end = start + length;
 		if( session->autos_follow_edits ) {
 			track->automation->clear(start, end, 0, collapse);
 		}
@@ -817,19 +830,16 @@ void EDL::delete_edits(ArrayList<Edit*> *edits, int collapse)
 				PluginSet *plugin_set = track->plugin_set[k];
 				plugin_set->clear(start, end, 1);
 				if( !collapse )
-					plugin_set->paste_silence(start, end);
+					plugin_set->paste_silence(start, end, 1);
+				plugin_set->optimize();
 			}
 		}
-		track->optimize();
-	}
-	for( int i=0; i<zones.size(); ++i ) {
-		Zone &zone = zones[i];
-		Track *track = zone.track;
-		int64_t start = zone.start, end = zone.end;
-		track->edits->clear(start, end);
-		if( !collapse )
-			track->edits->paste_silence(start, end);
-		track->optimize();
+		Edit *dead_edit = edit;
+		if( collapse ) {
+			while( (edit=edit->next) )
+				edit->startproject -= length;
+		}
+		delete dead_edit;
 	}
 	optimize();
 }
@@ -910,59 +920,31 @@ void EDL::move_edit_labels(ArrayList<Edit*> *edits, double dist)
 	}
 }
 
+void EDL::modify_edithandles(double oldposition, double newposition,
+	int currentend, int handle_mode, int edit_labels,
+	int edit_plugins, int edit_autos, int group_id)
+{
+	tracks->modify_edithandles(oldposition, newposition,
+		currentend, handle_mode, edit_labels,
+		edit_plugins, edit_autos, group_id);
+}
 
-void EDL::modify_edithandles(double oldposition,
-	double newposition,
-	int currentend,
-	int handle_mode,
-	int edit_labels,
-	int edit_plugins,
-	int edit_autos)
+void EDL::modify_pluginhandles(double oldposition, double newposition,
+	int currentend, int handle_mode, int edit_labels,
+	int edit_autos, Edits *trim_edits)
 {
-	tracks->modify_edithandles(oldposition,
-		newposition,
-		currentend,
-		handle_mode,
-		edit_labels,
-		edit_plugins,
-		edit_autos);
-	labels->modify_handles(oldposition,
-		newposition,
-		currentend,
-		handle_mode,
-		edit_labels);
-}
-
-void EDL::modify_pluginhandles(double oldposition,
-	double newposition,
-	int currentend,
-	int handle_mode,
-	int edit_labels,
-	int edit_autos,
-	Edits *trim_edits)
-{
-	tracks->modify_pluginhandles(oldposition,
-		newposition,
-		currentend,
-		handle_mode,
-		edit_labels,
-		edit_autos,
-		trim_edits);
+	tracks->modify_pluginhandles(oldposition, newposition,
+		currentend, handle_mode, edit_labels,
+		edit_autos, trim_edits);
 	optimize();
 }
 
-void EDL::paste_silence(double start,
-	double end,
-	int edit_labels,
-	int edit_plugins,
-	int edit_autos)
+void EDL::paste_silence(double start, double end,
+	int edit_labels, int edit_plugins, int edit_autos)
 {
 	if( edit_labels )
 		labels->paste_silence(start, end);
-	tracks->paste_silence(start,
-		end,
-		edit_plugins,
-		edit_autos);
+	tracks->paste_silence(start, end, edit_plugins, edit_autos);
 }
 
 
@@ -1454,14 +1436,7 @@ if( debug ) printf("EDL::get_use_vconsole %d\n", __LINE__);
 	    asset->height != session->output_h )
 		return 1;
 
-
 if( debug ) printf("EDL::get_use_vconsole %d\n", __LINE__);
-// Asset and output device must have same resulting de-interlacing method
-	if( ilaceautofixmethod2(session->interlace_mode,
-	    asset->interlace_autofixoption, asset->interlace_mode,
-	    asset->interlace_fixmethod) != ILACE_FIXMETHOD_NONE )
-		return 1;
-
 // If we get here the frame is going to be directly copied.  Whether it is
 // decompressed in hardware depends on the colormodel.
 	return 0;
@@ -1606,6 +1581,21 @@ double EDL::prev_edit(double position)
 	return new_position;
 }
 
+double EDL::skip_silence(double position)
+{
+	double result = position, nearest = DBL_MAX;
+	for( Track *track=tracks->first; track; track=track->next ) {
+		if( !track->play ) continue;
+		Edit *edit = track->edits->editof(position, PLAY_FORWARD, 0);
+		while( edit && edit->silence() ) edit = edit->next;
+		if( !edit ) continue;
+		double pos = track->from_units(edit->startproject);
+		if( pos > position && pos < nearest )
+			nearest = result = pos;
+        }
+	return result;
+}
+
 void EDL::rescale_proxy(int orig_scale, int new_scale)
 {
 	if( orig_scale == new_scale ) return;
@@ -1637,39 +1627,31 @@ void EDL::rescale_proxy(int orig_scale, int new_scale)
 	}
 }
 
-void EDL::set_proxy(int new_scale, int use_scaler,
+void EDL::set_proxy(int new_scale, int new_use_scaler,
 	ArrayList<Indexable*> *orig_assets, ArrayList<Indexable*> *proxy_assets)
 {
 	int orig_scale = session->proxy_scale;
-	int orig_use_scaler = session->proxy_use_scaler;
-
-// rescale to full size asset in read_frame
 	session->proxy_scale = new_scale;
-	session->proxy_use_scaler = use_scaler;
-
-	if( use_scaler ) {
-		for( int i=0; i<proxy_assets->size(); ++i ) {
-			Asset *proxy_asset = (Asset *)proxy_assets->get(i);
-			proxy_asset->width = orig_assets->get(i)->get_w();
-			proxy_asset->height = orig_assets->get(i)->get_h();
-		}
-		new_scale = 1;
-	}
-
-	if( !orig_use_scaler )
-		rescale_proxy(orig_scale, new_scale);
-
+	int orig_use_scaler = session->proxy_use_scaler;
+	session->proxy_use_scaler = new_use_scaler;
+	if( orig_use_scaler ) orig_scale = 1;
+	int scale = new_use_scaler ? new_scale : 1;
+	int asset_scale = new_scale == 1 && !new_use_scaler ? 0 : scale;
 // change original assets to proxy assets
-	int folder_no = use_scaler || new_scale != 1 ? AW_PROXY_FOLDER : AW_MEDIA_FOLDER;
+	int folder_no = new_use_scaler || new_scale != 1 ? AW_PROXY_FOLDER : AW_MEDIA_FOLDER;
 	for( int i=0,n=proxy_assets->size(); i<n; ++i ) {
 		Indexable *proxy_idxbl = proxy_assets->get(i);
 		proxy_idxbl->folder_no = folder_no;
 		if( !proxy_idxbl->is_asset ) continue;
 		Asset *proxy_asset = assets->update((Asset *)proxy_idxbl);
-		if( proxy_asset == (Asset *)proxy_idxbl ) continue;
-		proxy_asset->width = proxy_idxbl->get_w();
-		proxy_asset->height = proxy_idxbl->get_h();
+		proxy_asset->width = proxy_asset->actual_width * scale;
+		proxy_asset->height = proxy_asset->actual_height * scale;
+		proxy_asset->proxy_scale = asset_scale;
 	}
+// rescale to full size asset in read_frame
+	if( new_use_scaler ) new_scale = 1;
+	rescale_proxy(orig_scale, new_scale);
+
 // replace track contents
 	for( Track *track=tracks->first; track; track=track->next ) {
 		if( track->data_type != TRACK_VIDEO ) continue;
@@ -1716,15 +1698,17 @@ void EDL::set_proxy(int new_scale, int use_scaler,
 	}
 }
 
-void EDL::add_proxy(int use_scaler,
-	ArrayList<Indexable*> *orig_assets, ArrayList<Indexable*> *proxy_assets)
+void EDL::add_proxy(ArrayList<Indexable*> *orig_assets, ArrayList<Indexable*> *proxy_assets)
 {
-	if( use_scaler ) {
-		for( int i=0,n=proxy_assets->size(); i<n; ++i ) {
-			Asset *proxy_asset = (Asset *)proxy_assets->get(i);
-			proxy_asset->width = orig_assets->get(i)->get_w();
-			proxy_asset->height = orig_assets->get(i)->get_h();
-		}
+	int asset_scale = session->proxy_scale;
+	if( asset_scale == 1 ) asset_scale = 0;
+	int scale = !asset_scale ? 1 : asset_scale;
+// update proxy geom using scale
+	for( int i=0; i<proxy_assets->size(); ++i ) {
+		Asset *proxy_asset = (Asset *)proxy_assets->get(i);
+		proxy_asset->proxy_scale = asset_scale;
+		proxy_asset->width = proxy_asset->actual_width * scale;
+		proxy_asset->height = proxy_asset->actual_height * scale;
 	}
 
 // change original assets to proxy assets
@@ -1824,3 +1808,314 @@ int EDL::regroup(int next_id)
 	return new_groups.size();
 }
 
+EDL *EDL::selected_edits_to_clip(int packed,
+		double *start_position, Track **start_track,
+		int edit_labels, int edit_autos, int edit_plugins)
+{
+	double start = DBL_MAX, end = DBL_MIN;
+	Track *first_track=0, *last_track = 0;
+	for( Track *track=tracks->first; track; track=track->next ) {
+		if( !track->record ) continue;
+		int empty = 1;
+		for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+			if( !edit->is_selected || edit->silence() ) continue;
+			double edit_pos = track->from_units(edit->startproject);
+			if( start > edit_pos ) start = edit_pos;
+			if( end < (edit_pos+=edit->length) ) end = edit_pos;
+			empty = 0;
+		}
+		if( empty ) continue;
+		if( !first_track ) first_track = track;
+		last_track = track;
+	}
+	if( start_position ) *start_position = start;
+	if( start_track ) *start_track = first_track;
+	if( !first_track ) return 0;
+	EDL *new_edl = new EDL();
+	new_edl->create_objects();
+	new_edl->copy_session(this);
+	const char *text = _("new_edl edit");
+	new_edl->set_path(text);
+	strcpy(new_edl->local_session->clip_title, text);
+	strcpy(new_edl->local_session->clip_notes, text);
+	new_edl->session->video_tracks = 0;
+	new_edl->session->audio_tracks = 0;
+	for( Track *track=tracks->first; track; track=track->next ) {
+		if( !track->record ) continue;
+		if( first_track ) {
+			if( first_track != track ) continue;
+			first_track = 0;
+		}
+		Track *new_track = 0;
+		if( !packed )
+			new_track = new_edl->add_new_track(track->data_type);
+		int64_t start_pos = track->to_units(start, 0);
+		int64_t end_pos = track->to_units(end, 0);
+		int64_t startproject = 0;
+		Edit *edit = track->edits->first;
+		for( ; edit; edit=edit->next ) {
+			if( !edit->is_selected || edit->silence() ) continue;
+			if( edit->startproject < start_pos ) continue;
+			if( edit->startproject >= end_pos ) break;
+			int64_t edit_start_pos = edit->startproject;
+			int64_t edit_end_pos = edit->startproject + edit->length;
+			if( !new_track )
+				new_track = new_edl->add_new_track(track->data_type);
+			int64_t edit_pos = edit_start_pos - start_pos;
+			if( !packed && edit_pos > startproject ) {
+				Edit *silence = new Edit(new_edl, new_track);
+				silence->startproject = startproject;
+				silence->length = edit_pos - startproject;
+				new_track->edits->append(silence);
+				startproject = edit_pos;
+			}
+			int64_t clip_start_pos = startproject;
+			Edit *clip_edit = new Edit(new_edl, new_track);
+			clip_edit->copy_from(edit);
+			clip_edit->startproject = startproject;
+			startproject += clip_edit->length;
+			new_track->edits->append(clip_edit);
+			if( edit_labels ) {
+				double edit_start = track->from_units(edit_start_pos);
+				double edit_end = track->from_units(edit_end_pos);
+				double clip_start = new_track->from_units(clip_start_pos);
+				Label *label = labels->first;
+				for( ; label; label=label->next ) {
+					if( label->position < edit_start ) continue;
+					if( label->position >= edit_end ) break;
+					double clip_position = label->position - edit_start + clip_start;
+					Label *clip_label = new_edl->labels->first;
+					while( clip_label && clip_label->position<clip_position )
+						clip_label = clip_label->next;
+					if( clip_label && clip_label->position == clip_position ) continue;
+					Label *new_label = new Label(new_edl,
+						new_edl->labels, clip_position, label->textstr);
+					new_edl->labels->insert_before(clip_label, new_label);
+				}
+			}
+			if( edit_autos ) {
+				Automation *automation = track->automation;
+				Automation *new_automation = new_track->automation;
+				for( int i=0; i<AUTOMATION_TOTAL; ++i ) {
+					Autos *autos = automation->autos[i];
+					if( !autos ) continue;
+					Autos *new_autos = new_automation->autos[i];
+					new_autos->default_auto->copy_from(autos->default_auto);
+					Auto *aut0 = autos->first;
+					for( ; aut0; aut0=aut0->next ) {
+						if( aut0->position < edit_start_pos ) continue;
+						if( aut0->position >= edit_end_pos ) break;
+						Auto *new_auto = new_autos->new_auto();
+						new_auto->copy_from(aut0);
+						int64_t clip_position = aut0->position - edit_start_pos + clip_start_pos;
+						new_auto->position = clip_position;
+						new_autos->append(new_auto);
+					}
+				}
+			}
+			if( edit_plugins ) {
+				while( new_track->plugin_set.size() < track->plugin_set.size() )
+					new_track->plugin_set.append(0);
+				for( int i=0; i<track->plugin_set.total; ++i ) {
+					PluginSet *plugin_set = track->plugin_set[i];
+					if( !plugin_set ) continue;
+					PluginSet *new_plugin_set = new_track->plugin_set[i];
+					if( !new_plugin_set ) {
+						new_plugin_set = new PluginSet(new_edl, new_track);
+						new_track->plugin_set[i] = new_plugin_set;
+					}
+					Plugin *plugin = (Plugin*)plugin_set->first;
+					int64_t startplugin = new_plugin_set->length();
+					for( ; plugin ; plugin=(Plugin*)plugin->next ) {
+						if( plugin->silence() ) continue;
+						int64_t plugin_start_pos = plugin->startproject;
+						int64_t plugin_end_pos = plugin_start_pos + plugin->length;
+						if( plugin_end_pos < start_pos ) continue;
+						if( plugin_start_pos > end_pos ) break;
+						if( plugin_start_pos < edit_start_pos )
+							plugin_start_pos = edit_start_pos;
+						if( plugin_end_pos > edit_end_pos )
+							plugin_end_pos = edit_end_pos;
+						if( plugin_start_pos >= plugin_end_pos ) continue;
+						int64_t plugin_pos = plugin_start_pos - start_pos;
+						if( !packed && plugin_pos > startplugin ) {
+							Plugin *silence = new Plugin(new_edl, new_track, "");
+							silence->startproject = startplugin;
+							silence->length = plugin_pos - startplugin;
+							new_plugin_set->append(silence);
+							startplugin = plugin_pos;
+						}
+						Plugin *new_plugin = new Plugin(new_edl, new_track, plugin->title);
+						new_plugin->copy_base(plugin);
+						new_plugin->startproject = startplugin;
+						new_plugin->length = plugin_end_pos - plugin_start_pos;
+						startplugin += new_plugin->length;
+						new_plugin_set->append(new_plugin);
+						KeyFrames *keyframes = plugin->keyframes;
+						KeyFrames *new_keyframes = new_plugin->keyframes;
+						new_keyframes->default_auto->copy_from(keyframes->default_auto);
+						new_keyframes->default_auto->position = new_plugin->startproject;
+						KeyFrame *keyframe = (KeyFrame*)keyframes->first;
+						for( ; keyframe; keyframe=(KeyFrame*)keyframe->next ) {
+							if( keyframe->position < edit_start_pos ) continue;
+							if( keyframe->position >= edit_end_pos ) break;
+							KeyFrame *clip_keyframe = new KeyFrame(new_edl, new_keyframes);
+							clip_keyframe->copy_from(keyframe);
+							int64_t key_position = keyframe->position - start_pos;
+							if( packed )
+								key_position += new_plugin->startproject - plugin_pos;
+							clip_keyframe->position = key_position;
+							new_keyframes->append(clip_keyframe);
+						}
+					}
+				}
+			}
+		}
+		if( last_track == track ) break;
+	}
+	return new_edl;
+}
+
+EDL *EDL::selected_edits_to_clip(int packed, double *start_position, Track **start_track)
+{
+	return selected_edits_to_clip(packed, start_position, start_track,
+		session->labels_follow_edits,
+		session->autos_follow_edits,
+		session->plugins_follow_edits);
+}
+
+void EDL::paste_edits(EDL *clip, Track *first_track, double position, int overwrite,
+		int edit_edits, int edit_labels, int edit_autos, int edit_plugins)
+{
+	if( !first_track )
+		first_track = tracks->first;
+	Track *src = clip->tracks->first;
+	for( Track *track=first_track; track && src; track=track->next ) {
+		if( !track->record ) continue;
+		int64_t pos = track->to_units(position, 0);
+		if( edit_edits ) {
+			for( Edit *edit=src->edits->first; edit; edit=edit->next ) {
+				if( edit->silence() ) continue;
+				int64_t start = pos + edit->startproject;
+				int64_t len = edit->length, end = start + len;
+				if( overwrite )
+					track->edits->clear(start, end);
+				Edit *dst = track->edits->insert_new_edit(start);
+				dst->copy_from(edit);
+				dst->startproject = start;
+				dst->is_selected = 1;
+				while( (dst=dst->next) != 0 )
+					dst->startproject += edit->length;
+				if( overwrite ) continue;
+				if( edit_labels && track == first_track ) {
+					double dst_pos = track->from_units(start);
+					double dst_len = track->from_units(len);
+					for( Label *label=labels->first; label; label=label->next ) {
+						if( label->position >= dst_pos )
+							label->position += dst_len;
+					}
+				}
+				if( edit_autos ) {
+					for( int i=0; i<AUTOMATION_TOTAL; ++i ) {
+						Autos *autos = track->automation->autos[i];
+						if( !autos ) continue;
+						for( Auto *aut0=autos->first; aut0; aut0=aut0->next ) {
+							if( aut0->position >= start )
+								aut0->position += edit->length;
+						}
+					}
+				}
+				if( edit_plugins ) {
+					for( int i=0; i<track->plugin_set.size(); ++i ) {
+						PluginSet *plugin_set = track->plugin_set[i];
+						Plugin *plugin = (Plugin *)plugin_set->first;
+						for( ; plugin; plugin=(Plugin *)plugin->next ) {
+							if( plugin->startproject >= start )
+								plugin->startproject += edit->length;
+							else if( plugin->startproject+plugin->length > end )
+								plugin->length += edit->length;
+							Auto *default_keyframe = plugin->keyframes->default_auto;
+							if( default_keyframe->position >= start )
+								default_keyframe->position += edit->length;
+							KeyFrame *keyframe = (KeyFrame*)plugin->keyframes->first;
+							for( ; keyframe; keyframe=(KeyFrame*)keyframe->next ) {
+								if( keyframe->position >= start )
+									keyframe->position += edit->length;
+							}
+						}
+						plugin_set->optimize();
+					}
+				}
+			}
+		}
+		if( edit_autos ) {
+			for( int i=0; i<AUTOMATION_TOTAL; ++i ) {
+				Autos *src_autos = src->automation->autos[i];
+				if( !src_autos ) continue;
+				Autos *autos = track->automation->autos[i];
+				for( Auto *aut0=src_autos->first; aut0; aut0=aut0->next ) {
+					int64_t auto_pos = pos + aut0->position;
+					autos->insert_auto(auto_pos, aut0);
+				}
+			}
+		}
+		if( edit_plugins ) {
+			for( int i=0; i<src->plugin_set.size(); ++i ) {
+				PluginSet *plugin_set = src->plugin_set[i];
+				if( !plugin_set ) continue;
+				while( i >= track->plugin_set.size() )
+					track->plugin_set.append(0);
+				PluginSet *dst_plugin_set = track->plugin_set[i];
+				if( !dst_plugin_set ) {
+					dst_plugin_set = new PluginSet(this, track);
+					track->plugin_set[i] = dst_plugin_set;
+				}
+				Plugin *plugin = (Plugin *)plugin_set->first;
+				if( plugin ) track->expand_view = 1;
+				for( ; plugin; plugin=(Plugin *)plugin->next ) {
+					int64_t start = pos + plugin->startproject;
+					int64_t end = start + plugin->length;
+					if( overwrite || edit_edits )
+						dst_plugin_set->clear(start, end, 1);
+					Plugin *new_plugin = dst_plugin_set->insert_plugin(plugin->title,
+						start, end-start, plugin->plugin_type, &plugin->shared_location,
+						(KeyFrame*)plugin->keyframes->default_auto, 0);
+					KeyFrame *keyframe = (KeyFrame*)plugin->keyframes->first;
+					for( ; keyframe; keyframe=(KeyFrame*)keyframe->next ) {
+						int64_t keyframe_pos = pos + keyframe->position;
+						new_plugin->keyframes->insert_auto(keyframe_pos, keyframe);
+					}
+					while( (new_plugin=(Plugin *)new_plugin->next) ) {
+						KeyFrame *keyframe = (KeyFrame*)new_plugin->keyframes->first;
+						for( ; keyframe; keyframe=(KeyFrame*)keyframe->next )
+							keyframe->position += plugin->length;
+					}
+				}
+			}
+		}
+		src = src->next;
+	}
+	if( edit_labels ) {
+		Label *edl_label = labels->first;
+		for( Label *label=clip->labels->first; label; label=label->next ) {
+			double label_pos = position + label->position;
+			int exists = 0;
+			while( edl_label &&
+				!(exists=equivalent(edl_label->position, label_pos)) &&
+				edl_label->position < position ) edl_label = edl_label->next;
+			if( exists ) continue;
+			labels->insert_before(edl_label,
+				new Label(this, labels, label_pos, label->textstr));
+		}
+	}
+	optimize();
+}
+
+void EDL::paste_edits(EDL *clip, Track *first_track, double position, int overwrite)
+{
+	paste_edits(clip, first_track, position, overwrite, 1,
+		session->labels_follow_edits,
+		session->autos_follow_edits,
+		session->plugins_follow_edits);
+}
+