#include "edits.h"
#include "edl.h"
#include "edlsession.h"
+#include "file.h"
#include "filexml.h"
#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"
#include "playbackconfig.h"
#include "playabletracks.h"
#include "plugin.h"
+#include "pluginset.h"
#include "preferences.h"
#include "recordconfig.h"
#include "recordlabel.h"
file->tag.title_is("/CLIP_EDL") ||
file->tag.title_is("/NESTED_EDL") ||
file->tag.title_is("/VWINDOW_EDL") ) {
- result = 1;
+ break;
}
else
if( file->tag.title_is("CLIPBOARD") ) {
// 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;
}
}
}
-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;
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;
}
-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();
//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();
- labels->copy(start, end, file);
- tracks->copy(start, end, all, file, output_path);
+ if( (copy_flags & COPY_LABELS) )
+ labels->copy(start, end, file);
+
+ tracks->copy(copy_flags, start, end, file, output_path);
// terminate file
file->tag.set_title(closer);
}
}
-EDL *EDL::new_nested(EDL *edl, const char *path)
+EDL *EDL::new_nested_edl(EDL *edl, const char *path)
{
EDL *nested = new EDL; // no parent for nested edl
nested->create_objects();
return nested;
}
+EDL *EDL::get_nested_edl()
+{
+ Track *track = tracks->first;
+ Edit *edit = track ? track->edits->first : 0;
+ EDL *nested = edit && !edit->next && !edit->asset ? edit->nested_edl : 0;
+ while( nested && (track=track->next)!=0 ) {
+ Edit *edit = track->edits->first;
+ if( !edit || edit->next ||
+ ( edit->nested_edl != nested &&
+ strcmp(edit->nested_edl->path, nested->path) ) )
+ nested = 0;
+ }
+ return nested;
+}
+
+
EDL *EDL::create_nested_clip(EDL *nested)
{
EDL *new_edl = new EDL(this); // parent for clip edl
void EDL::create_nested(EDL *nested)
{
+ int video_tracks = 0, audio_tracks = 0;
+ for( Track *track=nested->tracks->first; track!=0; track=track->next ) {
+ if( track->data_type == TRACK_VIDEO && track->record ) ++video_tracks;
+ if( track->data_type == TRACK_AUDIO && track->record ) ++audio_tracks;
+ }
+// renderengine properties
+ if( video_tracks > 0 )
+ video_tracks = 1;
+ if( audio_tracks > 0 )
+ audio_tracks = nested->session->audio_channels;
+
// Keep frame rate, sample rate, and output size unchanged.
// Nest all video & audio outputs
+ session->video_channels = video_tracks;
+ session->audio_channels = audio_tracks;
session->video_tracks = 1;
- session->audio_tracks = nested->session->audio_channels;
+ session->audio_tracks = audio_tracks;
create_default_tracks();
insert_asset(0, nested, 0, 0, 0);
}
+void EDL::overwrite_clip(EDL *clip)
+{
+ int folder = folder_no;
+ char clip_title[BCTEXTLEN], clip_notes[BCTEXTLEN], clip_icon[BCSTRLEN];
+ if( parent_edl ) {
+ strcpy(clip_title, local_session->clip_title);
+ strcpy(clip_notes, local_session->clip_notes);
+ strcpy(clip_icon, local_session->clip_icon);
+ }
+ copy_all(clip);
+ folder_no = folder;
+ if( parent_edl ) {
+ strcpy(local_session->clip_title, clip_title);
+ strcpy(local_session->clip_notes, clip_notes);
+ strcpy(local_session->clip_icon, clip_icon);
+ }
+ if( !clip_icon[0] ) return;
+// discard old clip icon to reconstruct
+ char clip_icon_path[BCTEXTLEN];
+ snprintf(clip_icon_path, sizeof(clip_icon_path),
+ "%s/%s", File::get_config_path(), clip_icon);
+ remove(clip_icon_path);
+}
+
void EDL::retrack()
{
int min_w = session->output_w, min_h = session->output_h;
return 0;
}
-void EDL::modify_edithandles(double oldposition,
- double newposition,
- int currentend,
- int handle_mode,
- int edit_labels,
- int edit_plugins,
- int edit_autos)
+int EDL::clear_hard_edges(double start, double end)
{
- 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);
+ 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)
+{
+ 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 length = edit->length;
+ int64_t end = start + length;
+ if( session->autos_follow_edits ) {
+ track->automation->clear(start, end, 0, collapse);
+ }
+ if( session->plugins_follow_edits ) {
+ for( int k=0; k<track->plugin_set.size(); ++k ) {
+ PluginSet *plugin_set = track->plugin_set[k];
+ plugin_set->clear(start, end, 1);
+ if( !collapse )
+ plugin_set->paste_silence(start, end, 1);
+ plugin_set->optimize();
+ }
+ }
+ Edit *dead_edit = edit;
+ if( collapse ) {
+ while( (edit=edit->next) )
+ edit->startproject -= length;
+ }
+ delete dead_edit;
+ }
optimize();
}
-void EDL::paste_silence(double start,
- double end,
- int edit_labels,
- int edit_plugins,
- int edit_autos)
+class Range {
+public:
+ static int cmp(Range *ap, Range *bp);
+ double start, end;
+ bool operator ==(Range &that) { return this->start == that.start; }
+ bool operator >(Range &that) { return this->start > that.start; }
+};
+int Range::cmp(Range *ap, Range *bp) {
+ return ap->start < bp->start ? -1 : ap->start == bp->start ? 0 : 1;
+}
+
+static void get_edit_regions(ArrayList<Edit*> *edits, ArrayList<Range> ®ions)
+{
+// move edit inclusive labels by regions
+ for( int i=0; i<edits->size(); ++i ) {
+ Edit *edit = edits->get(i);
+ double pos = edit->track->from_units(edit->startproject);
+ double end = edit->track->from_units(edit->startproject + edit->length);
+ int n = regions.size(), k = n;
+ while( --k >= 0 ) {
+ Range &range = regions[k];
+ if( pos >= range.end ) continue;
+ if( range.start >= end ) continue;
+ int expand = 0;
+ if( range.start > pos ) { range.start = pos; expand = 1; }
+ if( range.end < end ) { range.end = end; expand = 1; }
+ if( !expand ) break;
+ k = n;
+ }
+ if( k < 0 ) {
+ Range &range = regions.append();
+ range.start = pos; range.end = end;
+ }
+ }
+ regions.sort(Range::cmp);
+}
+
+void EDL::delete_edit_labels(ArrayList<Edit*> *edits, int collapse)
+{
+ ArrayList<Range> regions;
+ get_edit_regions(edits, regions);
+ int n = regions.size(), k = n;
+ while( --k >= 0 ) {
+ Range &range = regions[k];
+ labels->clear(range.start, range.end, collapse);
+ }
+}
+
+void EDL::move_edit_labels(ArrayList<Edit*> *edits, double dist)
+{
+ ArrayList<Range> regions;
+ get_edit_regions(edits, regions);
+ int n = regions.size(), k = n;
+ Labels moved(this, 0);
+ while( --k >= 0 ) {
+ Range &range = regions[k];
+ Label *label = labels->label_of(range.start);
+ for( Label *next=0; label && label->position <= range.end; label=next ) {
+ next = label->next;
+ labels->remove_pointer(label);
+ label->position += dist;
+ moved.append(label);
+ }
+ Label *current = labels->first;
+ while( (label=moved.first) ) {
+ moved.remove_pointer(label);
+ while( current && current->position < label->position )
+ current = current->next;
+ if( current && current->position == label->position ) {
+ delete label; continue;
+ }
+ labels->insert_before(current, label);
+ }
+ }
+}
+
+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_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);
+ optimize();
+}
+
+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);
}
if( new_nested_edl ) {
length = new_nested_edl->tracks->total_length();
- layers = 1;
+ layers = new_nested_edl->session->video_channels;
channels = new_nested_edl->session->audio_channels;
}
}
}
-// aligned frame time
+// aligned frame time, account for sample truncation
double EDL::frame_align(double position, int round)
{
- double frame_pos = position * session->frame_rate;
- frame_pos = (int64_t)(frame_pos + (round ? 0.5 : 1e-6));
- position = frame_pos / session->frame_rate;
- return position;
+ if( !round && session->sample_rate > 0 ) {
+ int64_t sample_pos = position * session->sample_rate;
+ position = (sample_pos+2.) / session->sample_rate;
+ }
+ int64_t frame_pos = (position * session->frame_rate + (round ? 0.5 : 1e-6));
+ return frame_pos / session->frame_rate;
}
// Convert position to frames if alignment is enabled.
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;
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;
}
}
-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;
}
}
-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
tracks->first->edits->first->asset : 0;
}
+Track *EDL::add_new_track(int data_type)
+{
+ Track *new_track = 0;
+ switch( data_type ) {
+ case TRACK_VIDEO:
+ ++session->video_tracks;
+ new_track = tracks->add_video_track(0, 0);
+ break;
+ case TRACK_AUDIO:
+ ++session->audio_tracks;
+ new_track = tracks->add_audio_track(0, 0);
+ break;
+ case TRACK_SUBTITLE:
+ new_track = tracks->add_subttl_track(0, 0);
+ break;
+ }
+ return new_track;
+}
+
double EDL::get_cursor_position(int cursor_x, int pane_no)
{
return (double)cursor_x * local_session->zoom_sample / session->sample_rate +
(double)local_session->view_start[pane_no] *
local_session->zoom_sample / session->sample_rate;
}
+int64_t EDL::get_position_cursorx(double position, int pane_no)
+{
+ return (int64_t)(position * session->sample_rate / local_session->zoom_sample)
+ - local_session->view_start[pane_no];
+}
int EDL::in_use(Indexable *indexable)
{
return 0;
}
+int EDL::regroup(int next_id)
+{
+ ArrayList<int> new_groups;
+ for( Track *track=tracks->first; track; track=track->next ) {
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( !edit->group_id ) continue;
+ int k = new_groups.size();
+ while( --k >= 0 && new_groups[k] != edit->group_id );
+ if( k >= 0 ) continue;
+ new_groups.append(edit->group_id);
+ }
+ }
+ for( Track *track=tracks->first; track; track=track->next ) {
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( !edit->group_id ) continue;
+ int k = new_groups.size();
+ while( --k >= 0 && new_groups[k] != edit->group_id );
+ if( k < 0 ) continue;
+ edit->group_id = k + 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->clone_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->clone_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);
+ new_plugin->on = plugin->on;
+ 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);
+}
+
+void EDL::replace_assets(ArrayList<Indexable*> &orig_idxbls, ArrayList<Asset*> &new_assets)
+{
+ for( Track *track=tracks->first; track; track=track->next ) {
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ Indexable *idxbl = (Indexable *)edit->asset;
+ if( !idxbl ) continue;
+ int i = orig_idxbls.size();
+ while( --i>=0 && strcmp(orig_idxbls[i]->path, idxbl->path) );
+ if( i < 0 ) continue;
+ Asset *new_asset = new_assets[i];
+ if( track->data_type == TRACK_VIDEO && !new_asset->video_data ) continue;
+ if( track->data_type == TRACK_AUDIO && !new_asset->audio_data ) continue;
+ edit->asset = assets->update(new_assets[i]);
+ }
+ }
+ if( !parent_edl ) {
+ for( int j=0,n=clips.size(); j<n; ++j )
+ clips[j]->replace_assets(orig_idxbls, new_assets);
+ }
+}
+