#include "awindowgui.h"
#include "awindow.h"
#include "batchrender.h"
+#include "bccmodels.h"
#include "bcdisplayinfo.h"
#include "bcprogressbox.h"
#include "bcsignals.h"
#include "channelinfo.h"
#include "clip.h"
#include "clipedls.h"
-#include "bccmodels.h"
#include "commercials.h"
#include "confirmsave.h"
+#include "convert.h"
#include "cplayback.h"
#include "ctimebar.h"
#include "cwindowgui.h"
#include "vwindowgui.h"
#include "vwindow.h"
#include "wavecache.h"
+#include "wintv.h"
#include "wwindow.h"
+#include "x10tv.h"
#include "zoombar.h"
#include "zwindow.h"
#include "zwindowgui.h"
}
-
extern long cin_timezone;
ArrayList<PluginServer*>* MWindow::plugindb = 0;
create_bd = 0;
create_dvd = 0;
batch_render = 0;
+ convert_render = 0;
render = 0;
edl = 0;
gui = 0;
screens = 1;
in_destructor = 0;
speed_edl = 0;
- proxy_beep = 0;
+ beeper = 0;
shuttle = 0;
+ wintv = 0;
+ x10tv = 0;
mixers_align = 0;
}
#ifdef HAVE_DVB
gui->channel_info->stop();
#endif
- delete proxy_beep;
+ delete beeper;
delete create_bd; create_bd = 0;
delete create_dvd; create_dvd = 0;
+#ifdef HAVE_SHUTTLE
delete shuttle; shuttle = 0;
+#endif
+#ifdef HAVE_WINTV
+ delete wintv; wintv = 0;
+#endif
+#ifdef HAVE_X10TV
+ delete x10tv; x10tv = 0;
+#endif
delete batch_render; batch_render = 0;
+ delete convert_render; convert_render = 0;
delete render; render = 0;
delete mixers_align; mixers_align = 0;
commit_commercial();
int MWindow::init_ladspa_plugins(MWindow *mwindow, Preferences *preferences)
{
+#ifdef HAVE_LADSPA
char *path = getenv("LADSPA_PATH");
char ladspa_path[BCTEXTLEN];
if( !path ) {
}
fclose(fp);
}
+#endif
return 1;
}
char plugin_path[BCTEXTLEN];
sprintf(plugin_path, "%s/%s", plug_dir, plug_path);
FileSystem fs;
- fs.set_filter( "[*.plugin][*.so]" );
+ fs.set_filter( "[*.plugin][*.so][*.dll]" );
int result = fs.update(plugin_path);
if( result || !fs.dir_list.total ) return;
int vis_id = idx++;
}
}
-void MWindow::close_mixers(int destroy)
+void MWindow::close_mixers(int result)
{
ArrayList<ZWindow*> closed;
zwindows_lock->lock("MWindow::close_mixers");
ZWindow *zwindow = zwindows[i];
if( zwindow->idx < 0 ) continue;
zwindow->idx = -1;
- zwindow->destroy = destroy;
ZWindowGUI *zgui = zwindow->zgui;
zgui->lock_window("MWindow::select_zwindow 0");
- zgui->set_done(0);
+ zgui->set_done(result);
zgui->unlock_window();
closed.append(zwindow);
}
exportedl = new ExportEDL(this);
}
+
void MWindow::init_shuttle()
{
#ifdef HAVE_SHUTTLE
}
#endif
}
+void MWindow::init_wintv()
+{
+#ifdef HAVE_WINTV
+ wintv = WinTV::probe(this);
+ if( wintv )
+ wintv->start();
+#endif
+}
+void MWindow::init_x10tv()
+{
+#ifdef HAVE_X10TV
+ x10tv = X10TV::probe(this);
+ if( x10tv )
+ x10tv->start();
+#endif
+}
+
void MWindow::init_brender()
{
void MWindow::beep(double freq, double secs, double gain)
{
- if( !proxy_beep ) proxy_beep = new ProxyBeep(this);
- proxy_beep->tone(freq, secs, gain);
+ if( !beeper ) beeper = new Beeper(this);
+ beeper->tone(freq, secs, gain);
+}
+
+Beeper::Beeper(MWindow *mwindow)
+ : Thread(1, 0, 0)
+{
+ this->mwindow = mwindow;
+ audio = new AudioDevice(mwindow);
+ playing_audio = 0;
+ interrupted = -1;
+}
+
+Beeper::~Beeper()
+{
+ stop(0);
+ delete audio;
+}
+
+void Beeper::run()
+{
+ int channels = 2;
+ int64_t bfrsz = BEEP_SAMPLE_RATE;
+ EDL *edl = mwindow->edl;
+ EDLSession *session = edl->session;
+ AudioOutConfig *aconfig = session->playback_config->aconfig;
+ audio->open_output(aconfig, BEEP_SAMPLE_RATE, bfrsz, channels, 0);
+ audio->start_playback();
+
+ double out0[bfrsz], out1[bfrsz], *out[2] = { out0, out1 };
+ const double two_pi = 2*M_PI;
+ int64_t audio_len = BEEP_SAMPLE_RATE * secs;
+ const double dt = two_pi * freq/BEEP_SAMPLE_RATE;
+ double th = 0;
+
+ audio_pos = 0;
+ playing_audio = 1;
+ while( !interrupted ) {
+ int len = audio_len - audio_pos;
+ if( len <= 0 ) break;
+ if( len > bfrsz ) len = bfrsz;
+ int k = audio_pos;
+ for( int i=0; i<len; ++i,++k,th+=dt ) {
+ double t = th - two_pi;
+ if( t >= 0 ) th = t;
+ out0[i] = out1[i] = sin(th) * gain;
+ }
+ audio->write_buffer(out, channels, len);
+ audio_pos = k;
+ }
+
+ if( !interrupted )
+ audio->set_last_buffer();
+ audio->stop_audio(interrupted ? 0 : 1);
+ playing_audio = 0;
+
+ audio->close_all();
+}
+
+void Beeper::start()
+{
+ if( running() ) return;
+ audio_pos = -1;
+ interrupted = 0;
+ Thread::start();
+}
+
+void Beeper::stop(int wait)
+{
+ if( running() && !interrupted ) {
+ interrupted = 1;
+ audio->stop_audio(wait);
+ }
+ Thread::join();
}
+void Beeper::tone(double freq, double secs, double gain)
+{
+ stop(0);
+ this->freq = freq;
+ this->secs = secs;
+ this->gain = gain;
+ start();
+}
+
+
int MWindow::load_filenames(ArrayList<char*> *filenames,
- int load_mode,
- int update_filename)
+ int load_mode, int edl_mode, int update_filename)
{
ArrayList<EDL*> new_edls;
ArrayList<Asset*> new_assets;
ArrayList<File*> new_files;
- const int debug = 0;
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
// save_defaults();
gui->start_hourglass();
gui->unlock_window();
stop_playback(1);
gui->lock_window("MWindow::load_filenames 0");
-
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
undo_before();
-
+const int debug = 0;
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
// Define new_edls and new_assets to load
File *new_file = new File;
Asset *new_asset = new Asset(filenames->get(i));
EDL *new_edl = new EDL;
- char string[BCTEXTLEN];
-
new_edl->create_objects();
new_edl->copy_session(edl, -1);
new_file->set_program(edl->session->program_no);
+ char string[BCTEXTLEN];
sprintf(string, _("Loading %s"), new_asset->path);
gui->show_message(string);
result = 1;
switch( ftype ) {
// Convert media file to EDL
- case FILE_OK:
+ case FILE_OK: {
// Warn about odd image dimensions
if( new_asset->video_data &&
((new_asset->width % 2) || (new_asset->height % 2)) ) {
- char string[BCTEXTLEN];
- sprintf(string, _("%s's resolution is %dx%d.\n"
+ eprintf(_("%s's resolution is %dx%d.\n"
"Images with odd dimensions may not decode properly."),
new_asset->path, new_asset->width, new_asset->height);
- MainError::show_error(string);
}
if( new_asset->program >= 0 &&
edl->session->program_no != new_asset->program ) {
- char string[BCTEXTLEN];
- sprintf(string, _("%s's index was built for program number %d\n"
+ eprintf(_("%s's index was built for program number %d\n"
"Playback preference is %d.\n Using program %d."),
new_asset->path, new_asset->program,
edl->session->program_no, new_asset->program);
- MainError::show_error(string);
}
- if( load_mode != LOADMODE_RESOURCESONLY ) {
- RecordLabels *labels = edl->session->label_cells ?
- new RecordLabels(new_file) : 0;
- asset_to_edl(new_edl, new_asset, labels);
- new_edls.append(new_edl);
- new_edl->add_user();
- delete labels;
- }
- else {
+ if( load_mode == LOADMODE_RESOURCESONLY ) {
new_assets.append(new_asset);
new_asset->add_user();
+ result = 0;
+ break;
}
-// Set filename to nothing for assets since save EDL would overwrite them.
+ RecordLabels *labels = edl->session->label_cells ?
+ new RecordLabels(new_file) : 0;
+ asset_to_edl(new_edl, new_asset, labels);
+ new_edls.append(new_edl);
+ new_edl->add_user();
+ delete labels;
+
if( load_mode == LOADMODE_REPLACE ||
load_mode == LOADMODE_REPLACE_CONCATENATE ) {
+// Set filename to nothing for assets since save EDL would overwrite them.
set_filename("");
// Reset timeline position
for( int i=0; i<TOTAL_PANES; ++i ) {
new_edl->local_session->track_start[i] = 0;
}
}
-
result = 0;
- break;
+ break; }
-// File not found
- case FILE_NOT_FOUND:
+ case FILE_NOT_FOUND: {
+ eprintf(_("Failed to open %s"), new_asset->path);
sprintf(string, _("Failed to open %s"), new_asset->path);
gui->show_message(string, theme->message_error);
gui->update_default_message();
- break;
+ break; }
// Unknown format
case FILE_UNRECOGNIZED_CODEC: {
// Prompt user
if( result ) {
- char string[BCTEXTLEN];
- FileSystem fs;
- fs.extract_name(string, new_asset->path);
-
- strcat(string, _("'s format couldn't be determined."));
new_asset->audio_data = 1;
new_asset->format = FILE_PCM;
new_asset->channels = defaults->get("AUDIO_CHANNELS", 2);
new_asset->signed_ = defaults->get("SIGNED_", 1);
new_asset->header = defaults->get("HEADER", 0);
+ FileSystem fs;
+ fs.extract_name(string, new_asset->path);
+ strcat(string, _("'s format couldn't be determined."));
FileFormat fwindow(this);
fwindow.create_objects(new_asset, string);
result = fwindow.run_window();
defaults->update("HEADER", new_asset->header);
save_defaults();
}
-
// Append to list
if( !result ) {
// Recalculate length
new_asset->add_user();
}
}
- else {
- result = 1;
- }
break; }
case FILE_IS_XML: {
FileXML xml_file;
- xml_file.read_from_file(filenames->get(i));
+ const char *filename = filenames->get(i);
+ if( xml_file.read_from_file(filename, 1) ) {
+ eprintf(_("Error: unable to open:\n %s"), filename);
+ break;
+ }
const char *cin_version = 0;
while( !xml_file.read_tag() ) {
if( xml_file.tag.title_is("EDL") ) {
}
xml_file.rewind();
if( !cin_version ) {
- eprintf(_("XML file %s\n not from cinelerra."),filenames->get(i));
+ eprintf(_("XML file %s\n not from cinelerra."),filename);
char string[BCTEXTLEN];
- sprintf(string,_("Unknown %s"), filenames->get(i));
+ sprintf(string,_("Unknown %s"), filename);
gui->show_message(string);
- result = 1;
break;
}
if( strcmp(cin_version, CINELERRA_VERSION) &&
strcmp(cin_version, "Unify") &&
strcmp(cin_version, "5.1") ) {
- char string[BCTEXTLEN];
- snprintf(string, sizeof(string),
- _("Warning: XML from cinelerra version %s\n"
+ eprintf(_("Warning: XML from cinelerra version %s\n"
"Session data may be incompatible."), cin_version);
- show_warning(&preferences->warn_version, string);
}
- if( load_mode == LOADMODE_NESTED ) {
-// Load temporary EDL for nesting.
- EDL *nested_edl = new EDL;
- nested_edl->create_objects();
- nested_edl->load_xml(&xml_file, LOAD_ALL);
- int groups = nested_edl->regroup(session->group_number);
- session->group_number += groups;
- new_edl->create_nested(nested_edl);
- new_edl->set_path(filenames->get(i));
- nested_edl->Garbage::remove_user();
+ if( new_edl->load_xml(&xml_file, LOAD_ALL) ) {
+ eprintf(_("Error: unable to load:\n %s"), filename);
+ break;
}
- else {
-// Load EDL for pasting
- new_edl->load_xml(&xml_file, LOAD_ALL);
- int groups = new_edl->regroup(session->group_number);
- session->group_number += groups;
- test_plugins(new_edl, filenames->get(i));
-
- if( load_mode == LOADMODE_REPLACE ||
- load_mode == LOADMODE_REPLACE_CONCATENATE ) {
- strcpy(session->filename, filenames->get(i));
- strcpy(new_edl->local_session->clip_title,
- filenames->get(i));
- if(update_filename)
- set_filename(new_edl->local_session->clip_title);
- }
- else if( load_mode == LOADMODE_RESOURCESONLY ) {
- strcpy(new_edl->local_session->clip_title,
- filenames->get(i));
- struct stat st;
- time_t t = !stat(filenames->get(i),&st) ?
- st.st_mtime : time(&t);
- ctime_r(&t, new_edl->local_session->clip_notes);
+ test_plugins(new_edl, filename);
+ int groups = new_edl->regroup(session->group_number);
+ session->group_number += groups;
+ switch( edl_mode ) {
+ case LOADMODE_EDL_CLIP: {
+ strcpy(new_edl->local_session->clip_title,
+ filenames->get(i));
+ struct stat st;
+ time_t t = !stat(filenames->get(i),&st) ?
+ st.st_mtime : time(&t);
+ ctime_r(&t, new_edl->local_session->clip_notes);
+ switch( load_mode ) {
+ case LOADMODE_REPLACE:
+ case LOADMODE_REPLACE_CONCATENATE:
+ strcpy(session->filename, filename);
+ if( update_filename ) set_filename(filename);
+ break;
}
+ result = 0;
+ break; }
+ case LOADMODE_EDL_NESTED: {
+ EDL *nested_edl = new EDL;
+ nested_edl->create_objects();
+ nested_edl->copy_session(edl, -1);
+ nested_edl->create_nested(new_edl);
+ nested_edl->set_path(filename);
+ new_edl->remove_user();
+ new_edl = nested_edl;
+ result = 0;
+ break; }
+ case LOADMODE_EDL_FILEREF: {
+ result = create_ref(new_asset, new_edl);
+ if( result ) break;
+ new_assets.append(new_asset);
+ new_asset->add_user();
+ new_edl->remove_user();
+ new_edl = new EDL;
+ new_edl->create_objects();
+ new_edl->copy_session(edl, -1);
+ asset_to_edl(new_edl, new_asset);
+ delete new_file;
+ new_file = new File;
+ result = new_file->open_file(preferences, new_asset, 1, 0);
+ break; }
}
-
- new_edls.append(new_edl);
- new_edl->add_user();
- result = 0;
+ if( !result ) {
+ new_edls.append(new_edl);
+ new_edl->add_user();
+ }
+ else
+ eprintf(_("Error: Unable to load xml:\n %s"), new_asset->path);
break; }
}
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
-
if(!result) {
gui->reset_default_message();
gui->default_message();
}
-
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
// Paste them.
// Don't back up here.
if( new_edls.size() ) {
// For pasting, clear the active region
- if( load_mode == LOADMODE_PASTE ||
- load_mode == LOADMODE_NESTED ) {
+ if( load_mode == LOADMODE_PASTE ) {
double start = edl->local_session->get_selectionstart();
double end = edl->local_session->get_selectionend();
if(!EQUIV(start, end))
edl->session->autos_follow_edits,
0); // overwrite
}
- else
+ else if( load_mode == LOADMODE_NEW_TRACKS &&
+ edl_mode != LOADMODE_EDL_CLIP )
+ paste_edls(&new_edls, load_mode, 0, -1, 0, 0, 0, 0);
+ else if( load_mode != LOADMODE_RESOURCESONLY ||
+ edl_mode == LOADMODE_EDL_CLIP )
paste_edls(&new_edls, load_mode, 0, -1, 1, 1, 1, 0);
+ else
+ paste_edls(&new_edls, LOADMODE_NOTHING, 0, -1, 0, 0, 0, 0);
+
}
// Add new assets to EDL and schedule assets for index building.
for( int i=0; i<new_edls.size(); ++i ) {
EDL *new_edl = new_edls[i];
for( int j=0; j<new_edl->nested_edls.size(); ++j ) {
- mainindexes->add_next_asset(0, new_edl->nested_edls[j]);
+ mainindexes->add_indexable(new_edl->nested_edls[j]);
edl->nested_edls.update_index(new_edl->nested_edls[j]);
got_indexes = 1;
}
for( int i=0; i<new_assets.size(); ++i ) {
Asset *new_asset = new_assets[i];
-
- File *new_file = 0;
- int got_it = 0;
- for( int j=0; j<new_files.size(); ++j ) {
- new_file = new_files[j];
- if( !strcmp(new_file->asset->path, new_asset->path) ) {
- got_it = 1;
- break;
- }
- }
-
- mainindexes->add_next_asset(got_it ? new_file : 0, new_asset);
+ mainindexes->add_indexable(new_asset);
edl->assets->update(new_asset);
got_indexes = 1;
}
if(got_indexes) mainindexes->start_build();
// Open plugin GUIs
- Track *track = edl->tracks->first;
- while( track ) {
- for( int j = 0; j < track->plugin_set.size(); j++ ) {
- PluginSet *plugins = track->plugin_set[j];
- Plugin *plugin = plugins->get_first_plugin();
+ show_plugins();
- while(plugin) {
- if( load_mode == LOADMODE_REPLACE ||
- load_mode == LOADMODE_REPLACE_CONCATENATE ) {
- if( plugin->plugin_type == PLUGIN_STANDALONE &&
- plugin->show ) {
- show_plugin(plugin);
- }
- }
-
- plugin = (Plugin*)plugin->next;
- }
- }
-
- track = track->next;
- }
-
- // if just opening one new resource in replace mode
- if( ftype != FILE_IS_XML &&
- ( load_mode == LOADMODE_REPLACE ||
- load_mode == LOADMODE_REPLACE_CONCATENATE ) ) {
+ // opening new session
+ if( ( load_mode == LOADMODE_REPLACE ||
+ load_mode == LOADMODE_REPLACE_CONCATENATE ) &&
+ (ftype != FILE_IS_XML || edl_mode != LOADMODE_EDL_CLIP) ) {
select_asset(0, 0);
edl->session->proxy_scale = 1;
edl->session->proxy_disabled_scale = 1;
gui->unlock_window(); // to update progress bar
int ret = render_proxy(orig_idxbls);
gui->lock_window("MWindow::load_filenames");
- if( ret >= 0 && edl->session->proxy_beep ) {
+ float gain = edl->session->proxy_beep;
+ if( ret >= 0 && gain > 0 ) {
if( ret > 0 )
- beep(2000., 1.5, 0.5);
+ beep(2000., 1.5, gain);
else
- beep(4000., 0.25, 0.5);
+ beep(4000., 0.25, gain);
}
}
edl->session->proxy_disabled_scale != 1 ) {
int new_scale = edl->session->proxy_disabled_scale;
int new_use_scaler = edl->session->proxy_use_scaler;
- edl->session->proxy_disabled_scale = 1;
Asset *asset = new Asset;
asset->format = FILE_FFMPEG;
asset->load_defaults(defaults, "PROXY_", 1, 1, 0, 0, 0);
ret = to_proxy(asset, new_scale, new_use_scaler);
asset->remove_user();
- if( ret > 0 )
- beep(2000., 1.5, 0.5);
+ if( ret > 0 ) {
+ float gain = edl->session->proxy_beep;
+ beep(2000., 1.5, gain);
+ }
+ edl->session->proxy_disabled_scale = 1;
+ gui->lock_window("MWindow::to_proxy");
+ update_project(LOADMODE_REPLACE);
+ gui->unlock_window();
}
return 1;
}
{
if( edl->session->proxy_scale != 1 &&
edl->session->proxy_disabled_scale == 1 ) {
- int new_scale = 1;
+ int old_scale = edl->session->proxy_scale, new_scale = 1;
int new_use_scaler = edl->session->proxy_use_scaler;
- edl->session->proxy_disabled_scale = edl->session->proxy_scale;
Asset *asset = new Asset;
asset->format = FILE_FFMPEG;
asset->load_defaults(defaults, "PROXY_", 1, 1, 0, 0, 0);
to_proxy(asset, new_scale, new_use_scaler);
asset->remove_user();
+ edl->session->proxy_disabled_scale = old_scale;
+ gui->lock_window("MWindow::to_proxy");
+ update_project(LOADMODE_REPLACE);
+ gui->unlock_window();
}
return 1;
}
edl->Garbage::remove_user();
restart_brender();
- gui->lock_window("MWindow::to_proxy");
- update_project(LOADMODE_REPLACE);
- gui->unlock_window();
-
return !result ? proxy_render.needed_proxies.size() : -1;
}
-void MWindow::test_plugins(EDL *new_edl, char *path)
+void MWindow::test_plugins(EDL *new_edl, const char *path)
{
char string[BCTEXTLEN];
strcat(string, "/" FONT_SEARCHPATH);
BC_Resources::init_fontconfig(string);
if(debug) PRINT_TRACE
+// use if plugged
+ init_x10tv();
+ if( !x10tv )
+ init_wintv();
// Default project created here
init_edl();
gui->mbuttons->edit_panel->keyframe->update(value);
gui->flush();
cwindow->gui->lock_window("MWindow::set_auto_keyframes");
- cwindow->gui->edit_panel->keyframe->update(value);
cwindow->gui->flush();
cwindow->gui->unlock_window();
}
gui->mbuttons->edit_panel->span_keyframe->update(value);
gui->flush();
cwindow->gui->lock_window("MWindow::set_span_keyframes");
- cwindow->gui->edit_panel->span_keyframe->update(value);
cwindow->gui->flush();
cwindow->gui->unlock_window();
}
{
keyframe_gui_lock->lock("MWindow::show_keyframe_gui");
// Find existing thread
- for(int i = 0; i < keyframe_threads->size(); i++)
- {
- if(keyframe_threads->get(i)->plugin == plugin)
- {
+ for( int i=0; i<keyframe_threads->size(); ++i ) {
+ int plugin_id = keyframe_threads->get(i)->plugin_id;
+ if( plugin_id == plugin->orig_id ) {
keyframe_threads->get(i)->start_window(plugin, 0);
keyframe_gui_lock->unlock();
return;
}
// Find unused thread
- for(int i = 0; i < keyframe_threads->size(); i++)
- {
- if(!keyframe_threads->get(i)->plugin)
- {
+ for( int i=0; i<keyframe_threads->size(); ++i ) {
+ if( keyframe_threads->get(i)->plugin_id < 0 ) {
keyframe_threads->get(i)->start_window(plugin, 0);
keyframe_gui_lock->unlock();
return;
KeyFrameThread *thread = new KeyFrameThread(this);
keyframe_threads->append(thread);
thread->start_window(plugin, 0);
-
keyframe_gui_lock->unlock();
}
//printf("MWindow::show_plugin %d\n", __LINE__);
SET_TRACE
-
plugin_gui_lock->lock("MWindow::show_plugin");
- for(int i = 0; i < plugin_guis->total; i++)
- {
-// Pointer comparison
- if(plugin_guis->get(i)->plugin == plugin)
- {
- plugin_guis->get(i)->raise_window();
+ for( int i=0; i<plugin_guis->total; ++i ) {
+// Pointer/id comparison
+ PluginServer *plugin_gui = plugin_guis->get(i);
+ if( plugin_gui->plugin_id == plugin->orig_id ) {
+ plugin_gui->raise_window();
done = 1;
break;
}
void MWindow::hide_plugin(Plugin *plugin, int lock)
{
plugin->show = 0;
+ return hide_plugin(plugin->orig_id, lock);
+}
+
+void MWindow::hide_plugin(int plugin_id, int lock)
+{
// Update the toggle
gui->lock_window("MWindow::hide_plugin");
gui->update(0, NORMAL_DRAW, 0, 0, 0, 0, 0);
gui->unlock_window();
if(lock) plugin_gui_lock->lock("MWindow::hide_plugin");
- for(int i = 0; i < plugin_guis->total; i++)
- {
- if(plugin_guis->get(i)->plugin == plugin)
- {
- PluginServer *ptr = plugin_guis->get(i);
- plugin_guis->remove(ptr);
+ for( int i=0; i<plugin_guis->total; ++i ) {
+ PluginServer *plugin_gui = plugin_guis->get(i);
+ if( plugin_gui->plugin_id == plugin_id ) {
+ plugin_guis->remove(plugin_gui);
if(lock) plugin_gui_lock->unlock();
// Last command executed in client side close
// Schedule for deletion
- ptr->hide_gui();
- delete_plugin(ptr);
+ plugin_gui->hide_gui();
+ delete_plugin(plugin_gui);
//sleep(1);
return;
}
void MWindow::hide_keyframe_gui(Plugin *plugin)
{
keyframe_gui_lock->lock("MWindow::hide_keyframe_gui");
- for(int i = 0; i < keyframe_threads->size(); i++)
- {
- if(keyframe_threads->get(i)->plugin == plugin)
- {
- keyframe_threads->get(i)->close_window();
+ for( int i = 0; i < keyframe_threads->size(); i++) {
+ KeyFrameThread *keyframe_gui = keyframe_threads->get(i);
+ if( keyframe_gui->plugin_id == plugin->orig_id ) {
+ keyframe_gui->close_window();
break;
}
}
{
// Send new configuration to keyframe GUI's
keyframe_gui_lock->lock("MWindow::update_keyframe_guis");
- for(int i = 0; i < keyframe_threads->size(); i++)
- {
- KeyFrameThread *ptr = keyframe_threads->get(i);
- if(edl->tracks->plugin_exists(ptr->plugin))
- ptr->update_gui(1);
+ for( int i=0; i<keyframe_threads->size(); ++i ) {
+ KeyFrameThread *keyframe_gui = keyframe_threads->get(i);
+ Plugin *plugin = edl->tracks->plugin_exists(keyframe_gui->plugin_id);
+ if( plugin )
+ keyframe_gui->update_gui(1);
else
- {
- ptr->close_window();
- }
+ keyframe_gui->close_window();
}
keyframe_gui_lock->unlock();
}
// Send new configuration to plugin GUI's
plugin_gui_lock->lock("MWindow::update_plugin_guis");
- for(int i = 0; i < plugin_guis->size(); i++)
- {
- PluginServer *ptr = plugin_guis->get(i);
- if(edl->tracks->plugin_exists(ptr->plugin))
- ptr->update_gui();
- else
- {
-// Schedule for deletion if no plugin
- plugin_guis->remove_number(i);
- i--;
-
- ptr->hide_gui();
- delete_plugin(ptr);
+ for( int i=0; i<plugin_guis->size(); ++i ) {
+ PluginServer *plugin_gui = plugin_guis->get(i);
+ Plugin *plugin = edl->tracks->plugin_exists(plugin_gui->plugin_id);
+ if( plugin && plugin->show )
+ plugin_gui->update_gui();
+ else {
+// Schedule for deletion if no plugin or not shown
+ plugin_guis->remove_number(i--);
+ plugin_gui->hide_gui();
+ delete_plugin(plugin_gui);
}
}
// Change plugin variable if not visible
Track *track = edl->tracks->first;
- while(track)
- {
- for(int i = 0; i < track->plugin_set.size(); i++)
- {
+ for( ; track; track=track->next ) {
+ for( int i=0; i < track->plugin_set.size(); ++i ) {
Plugin *plugin = (Plugin*)track->plugin_set[i]->first;
- while(plugin)
- {
+ for( ; plugin; plugin = (Plugin*)plugin->next ) {
int got_it = 0;
- for(int i = 0; i < plugin_guis->size(); i++)
- {
+ for( int i=0; i<plugin_guis->size(); ++i ) {
PluginServer *server = plugin_guis->get(i);
- if(server->plugin == plugin)
- {
+ if( server->plugin_id == plugin->orig_id ) {
got_it = 1;
break;
}
}
-
- if(!got_it) plugin->show = 0;
- plugin = (Plugin*)plugin->next;
+ if( !got_it ) plugin->show = 0;
}
}
-
- track = track->next;
}
plugin_gui_lock->unlock();
+ if( do_keyframe_guis )
+ update_keyframe_guis();
+}
+void MWindow::stop_plugin_guis()
+{
+// Send new configuration to plugin GUI's
+ plugin_gui_lock->lock("MWindow::stop_plugin_guis");
- if(do_keyframe_guis) update_keyframe_guis();
+ for( int i=0; i<plugin_guis->size(); ++i ) {
+ PluginServer *plugin_gui = plugin_guis->get(i);
+ plugin_gui->render_stop();
+ }
+ plugin_gui_lock->unlock();
}
int MWindow::plugin_gui_open(Plugin *plugin)
return result;
}
+
void MWindow::render_plugin_gui(void *data, Plugin *plugin)
{
int gui_id = plugin->gui_id;
if( gui_id < 0 ) return;
- plugin_gui_lock->lock("MWindow::render_plugin_gui");
+ plugin_gui_lock->lock("MWindow::render_plugin_gui 0");
PluginServer *plugin_server = plugin_guis->gui_server(gui_id);
if( plugin_server )
plugin_server->render_gui(data);
{
int gui_id = plugin->gui_id;
if( gui_id < 0 ) return;
- plugin_gui_lock->lock("MWindow::render_plugin_gui");
+ plugin_gui_lock->lock("MWindow::render_plugin_gui 1");
PluginServer *plugin_server = plugin_guis->gui_server(gui_id);
if( plugin_server )
plugin_server->render_gui(data, size);
plugin_gui_lock->unlock();
}
+void MWindow::reset_plugin_gui_frames(Plugin *plugin)
+{
+ int gui_id = plugin->gui_id;
+ if( gui_id < 0 ) return;
+ plugin_gui_lock->lock("MWindow::reset_plugin_gui_frames");
+ PluginServer *plugin_server = plugin_guis->gui_server(gui_id);
+ if( plugin_server )
+ plugin_server->reset_plugin_gui_frames();
+ plugin_gui_lock->unlock();
+}
+
+void MWindow::render_plugin_gui_frames(PluginClientFrames *frames, Plugin *plugin)
+{
+ int gui_id = plugin->gui_id;
+ if( gui_id < 0 ) return;
+ plugin_gui_lock->lock("MWindow::render_plugin_gui_frames");
+ PluginServer *plugin_server = plugin_guis->gui_server(gui_id);
+ if( plugin_server )
+ plugin_server->render_plugin_gui_frames(frames);
+ plugin_gui_lock->unlock();
+}
+
+double MWindow::get_tracking_position()
+{
+ return edl->local_session->get_selectionstart(1);
+}
+
+int MWindow::get_tracking_direction()
+{
+ return cwindow->playback_engine->get_direction();
+}
void MWindow::update_plugin_states()
{
plugin_gui_lock->lock("MWindow::update_plugin_states");
- for(int i = 0; i < plugin_guis->total; i++)
- {
- int result = 0;
+ for( int i=0; i<plugin_guis->total; ++i ) {
// Get a plugin GUI
- Plugin *src_plugin = plugin_guis->get(i)->plugin;
PluginServer *src_plugingui = plugin_guis->get(i);
-
-// Search for plugin in EDL. Only the master EDL shows plugin GUIs.
- for(Track *track = edl->tracks->first;
- track && !result;
- track = track->next)
- {
- for(int j = 0;
- j < track->plugin_set.total && !result;
- j++)
- {
- PluginSet *plugin_set = track->plugin_set[j];
- for(Plugin *plugin = (Plugin*)plugin_set->first;
- plugin && !result;
- plugin = (Plugin*)plugin->next)
- {
- if(plugin == src_plugin &&
- !strcmp(plugin->title, src_plugingui->title)) result = 1;
- }
- }
- }
-
-
+ int plugin_id = src_plugingui->plugin_id;
+ Plugin *src_plugin = edl->tracks->plugin_exists(plugin_id);
// Doesn't exist anymore
- if(!result)
- {
- hide_plugin(src_plugin, 0);
- i--;
+ if( !src_plugin ) {
+ hide_plugin(plugin_id, 0);
+ --i;
}
}
plugin_gui_lock->unlock();
void MWindow::update_plugin_titles()
{
- for(int i = 0; i < plugin_guis->total; i++)
- {
+ for( int i=0; i<plugin_guis->total; ++i )
plugin_guis->get(i)->update_title();
- }
}
int MWindow::asset_to_edl(EDL *new_edl,
zwindow->set_title(mixer->title);
zwindow->start();
}
+ cwindow->gui->canvas->set_zoom(edl, 0);
}
update_vwindow();
Track *track = cwindow->calculate_affected_track();
cwindow->mask_track_id = track ? track->get_id() : -1;
cwindow->gui->tool_panel->raise_tool();
+ cwindow->gui->update_canvas(0);
cwindow->gui->unlock_window();
if(debug) PRINT_TRACE
if(debug) PRINT_TRACE
}
+void MWindow::stack_push(EDL *new_edl, Indexable *idxbl)
+{
+ int got_indexes = 0;
+ for( int i=0; i<new_edl->nested_edls.size(); ++i ) {
+ EDL *nested_edl = new_edl->nested_edls[i];
+ mainindexes->add_indexable(nested_edl);
+ edl->nested_edls.update_index(nested_edl);
+ got_indexes = 1;
+ }
+ for( Asset *asset=new_edl->assets->first; asset; asset=asset->next ) {
+ mainindexes->add_indexable(asset);
+ edl->assets->update(asset);
+ got_indexes = 1;
+ }
+// Start examining next batch of index files
+ if( got_indexes )
+ mainindexes->start_build();
+
+// needs gui lock
+ gui->lock_window("MWindow::stack_push");
+ if( stack.size() < 9 ) {
+ save_backup();
+ hide_plugins();
+ undo_before();
+ StackItem &item = stack.append();
+ item.edl = edl;
+ item.new_edl = new_edl;
+ item.undo = undo;
+ item.idxbl = idxbl;
+ item.mtime = 0;
+ if( idxbl && idxbl->is_asset ) {
+ struct stat st;
+ Asset *asset = (Asset *)idxbl;
+ if( asset->format == FILE_REF &&
+ !stat(asset->path, &st) )
+ item.mtime = st.st_mtime;
+ }
+ edl = new_edl;
+ edl->add_user();
+ strcpy(session->filename, edl->path);
+ undo = new MainUndo(this);
+ gui->stack_button->update();
+ update_project(LOADMODE_REPLACE);
+ }
+ gui->unlock_window();
+ show_plugins();
+}
+
+void MWindow::stack_pop()
+{
+ if( !stack.size() ) return;
+// writes on config_path/backup%d.xml
+ save_backup();
+ hide_plugins();
+// already have gui lock
+ StackItem &item = stack.last();
+// session edl replaced, overwrite and save clip data
+ if( item.new_edl != edl )
+ item.new_edl->overwrite_clip(edl);
+ edl->remove_user();
+ edl = item.edl;
+ delete undo;
+ undo = item.undo;
+ Indexable *idxbl = item.idxbl;
+ int64_t mtime = item.mtime;
+ stack.remove();
+ if( idxbl ) {
+ gui->unlock_window();
+ remove_from_caches(idxbl);
+ remove_indexfile(idxbl);
+ mainindexes->add_indexable(idxbl);
+ mainindexes->start_build();
+ awindow->gui->async_update_assets();
+ gui->lock_window("MWindow::stack_pop");
+ }
+ strcpy(session->filename, edl->path);
+ update_project(LOADMODE_REPLACE);
+ undo_after(_("open edl"), LOAD_ALL);
+ show_plugins();
+ gui->stack_button->update();
+ if( mtime && idxbl && idxbl->is_asset ) {
+ struct stat st;
+ Asset *asset = (Asset *)idxbl;
+ if( asset->format == FILE_REF && !stat(asset->path, &st) &&
+ item.mtime == st.st_mtime ) {
+ char text[BCTEXTLEN];
+ snprintf(text, sizeof(text),
+ _("Warning: Asset not updated: %s"), asset->path);
+ show_warning(&preferences->warn_stack, text);
+ }
+ }
+}
+
+int MWindow::save(EDL *edl, char *filename, int stat)
+{
+ FileXML file;
+ edl->save_xml(&file, filename);
+ file.terminate_string();
+ if( file.write_to_file(filename) ) {
+ eprintf(_("Couldn't open %s"), filename);
+ return 1;
+ }
+ if( stat ) {
+ char string[BCTEXTLEN];
+ char *filename = stack.size() ?
+ stack[0].edl->path : session->filename;
+ sprintf(string, _("\"%s\" %jdC written"),
+ filename, file.length());
+ gui->lock_window("SaveAs::run");
+ gui->show_message(string);
+ gui->unlock_window();
+ }
+ return 0;
+}
+
+int MWindow::save(int save_as)
+{
+ char new_path[BCTEXTLEN]; new_path[0] = 0;
+ char *path = stack.size() ? stack[0].edl->path : session->filename;
+ if( save_as || !path[0] ) {
+ if( ConfirmSave::get_save_path(this, new_path) )
+ return 1;
+ if( stack.size() ) {
+ strcpy(path, new_path);
+ set_titlebar(new_path);
+ }
+ else
+ set_filename(new_path);
+ gui->mainmenu->add_load(new_path);
+ path = new_path;
+ }
+ for( int i=stack.size(); --i>=0; ) {
+ StackItem &item = stack[i];
+ Indexable *idxbl = item.idxbl;
+ if( idxbl->is_asset ) {
+ Asset *asset = (Asset *)idxbl;
+ if( asset->format == FILE_REF ) {
+ if( save(item.new_edl, asset->path, 0) )
+ return 1;
+ }
+ }
+ else if( item.new_edl != item.idxbl )
+ item.new_edl->overwrite_clip((EDL*)item.idxbl);
+ }
+ EDL *new_edl = stack.size() ? stack[0].edl : edl;
+ save(new_edl, path, 1);
+ return 0;
+}
+
+void MWindow::show_plugins()
+{
+ for( Track *track=edl->tracks->first; track; track=track->next ) {
+ for( int i=0; i<track->plugin_set.size(); ++i ) {
+ PluginSet *plugins = track->plugin_set[i];
+ Plugin *plugin = plugins->get_first_plugin();
+ for( ; plugin; plugin=(Plugin*)plugin->next ) {
+ if( plugin->plugin_type == PLUGIN_STANDALONE &&
+ plugin->show )
+ show_plugin(plugin);
+ }
+ }
+ }
+}
+
+void MWindow::clip_to_media()
+{
+ if( edl->session->proxy_scale != 1 ) {
+ eprintf("Nesting not allowed when proxy scale != 1");
+ return;
+ }
+ undo_before();
+ int clips_total = session->drag_clips->total;
+ for( int i=0; i<clips_total; ++i ) {
+ EDL *clip = session->drag_clips->values[i];
+ time_t dt; time(&dt);
+ struct tm dtm; localtime_r(&dt, &dtm);
+ char path[BCTEXTLEN], *cp = path, *ep = cp+sizeof(path)-1;
+// path_basename = "Nested_<date>-<time>_<basename>"
+ cp += snprintf(cp, ep-cp, _("Nested_%02d%02d%02d-%02d%02d%02d_"),
+ dtm.tm_year+1900, dtm.tm_mon+1, dtm.tm_mday,
+ dtm.tm_hour, dtm.tm_min, dtm.tm_sec);
+ char *bp = strrchr(clip->local_session->clip_title, '/');
+ bp = bp ? bp+1 : clip->local_session->clip_title;
+ cp += snprintf(cp, ep-cp, "%s", bp);
+ EDL *nested = edl->new_nested_edl(clip, path);
+ edl->clips.remove(clip);
+ clip->remove_user();
+ mainindexes->add_indexable(nested);
+ }
+ undo_after(_("clip2media"), LOAD_ALL);
+ mainindexes->start_build();
+ awindow->gui->async_update_assets();
+}
+
+void MWindow::media_to_clip()
+{
+ undo_before();
+ int assets_total = session->drag_assets->total;
+ for( int i=0; i<assets_total; ++i ) {
+ Indexable *idxbl = session->drag_assets->values[i];
+ if( idxbl->is_asset ) {
+ eprintf(_("media is not EDL:\n%s"), idxbl->path);
+ continue;
+ }
+ char clip_title[BCSTRLEN];
+ int name_ok = 0;
+ while( !name_ok ) {
+ name_ok = 1;
+ sprintf(clip_title, _("Clip %d"), session->clip_number++);
+ for( int i=0; name_ok && i<edl->clips.size(); ++i ) {
+ char *title = edl->clips[i]->local_session->clip_title;
+ if( !strcasecmp(clip_title, title) ) name_ok = 0;
+ }
+ }
+ EDL *nested = (EDL *)idxbl;
+ EDL *clip = edl->add_clip(nested);
+ strcpy(clip->local_session->clip_title, clip_title);
+ snprintf(clip->local_session->clip_notes,
+ sizeof(clip->local_session->clip_notes),
+ _("From: %s"), nested->path);
+ }
+ undo_after(_("media2clip"), LOAD_ALL);
+ awindow->gui->async_update_assets();
+}
+
+int MWindow::create_ref(Asset *asset, EDL *ref)
+{
+ asset->format = FILE_REF;
+ double secs = ref->tracks->total_length();
+ int audio_channels = ref->session->audio_channels;
+ asset->audio_data = audio_channels > 0 ? 1 : 0;
+ asset->channels = audio_channels;
+ asset->sample_rate = ref->session->sample_rate;
+ asset->audio_length = audio_channels > 0 && secs > 0 ?
+ secs * asset->sample_rate : 0;
+ strcpy(asset->acodec, _("reference"));
+
+ int video_layers = ref->session->video_channels;
+ asset->video_data = video_layers > 0 ? 1 : 0;
+ asset->layers = video_layers > 0 ? 1 : 0;
+ asset->actual_width = ref->session->output_w;
+ asset->actual_height = ref->session->output_h;
+ asset->width = asset->actual_width;
+ asset->height = asset->actual_height;
+ asset->frame_rate = ref->session->frame_rate;
+ asset->video_length = video_layers > 0 && secs > 0 ?
+ secs * asset->frame_rate : 0;
+ strcpy(asset->vcodec, _("reference"));
+ return 0;
+}
+
+void MWindow::update_preferences(Preferences *prefs)
+{
+ if( prefs != preferences )
+ preferences->copy_from(prefs);
+ if( cwindow->playback_engine )
+ cwindow->playback_engine->preferences->copy_from(prefs);
+ for(int i = 0; i < vwindows.size(); i++) {
+ VWindow *vwindow = vwindows[i];
+ if( !vwindow->is_running() ) continue;
+ if( vwindow->playback_engine )
+ vwindow->playback_engine->preferences->copy_from(prefs);
+ }
+ for(int i = 0; i < zwindows.size(); i++) {
+ ZWindow *zwindow = zwindows[i];
+ if( !zwindow->is_running() ) continue;
+ if( zwindow->zgui->playback_engine )
+ zwindow->zgui->playback_engine->preferences->copy_from(prefs);
+ }
+}
+
void MWindow::update_vwindow()
{
for( int i=0; i<vwindows.size(); ++i ) {
//printf("MWindow::rebuild_indices 1 %s\n", indexable->path);
remove_indexfile(indexable);
// Schedule index build
- IndexState *index_state = indexable->index_state;
- index_state->index_status = INDEX_NOTTESTED;
+ indexable->index_state->remove_user();
+ indexable->index_state = new IndexState;
+ IndexFile::delete_index_files(preferences, indexable);
if( indexable->is_asset ) {
Asset *asset = (Asset *)indexable;
if( asset->format != FILE_PCM ) {
asset->reset_audio();
}
asset->reset_video();
- remove_asset_from_caches(asset);
+ remove_from_caches(asset);
// File file; // re-probe the asset
// file.open_file(preferences, asset, 1, 0);
}
- mainindexes->add_next_asset(0, indexable);
+ mainindexes->add_indexable(indexable);
}
+// still in render engine
+ sync_parameters(CHANGE_ALL);
+ awindow->gui->async_update_assets();
mainindexes->start_build();
}
+void MWindow::get_backup_path(char *path, int len)
+{
+ char *cp = path, *ep = cp + len-1;
+ cp += snprintf(cp, ep-cp, "%s/", File::get_config_path());
+ int idx = stack.size();
+ cp += snprintf(cp, ep-cp, idx ? BACKUPn_FILE : BACKUP_FILE, idx);
+}
+
void MWindow::save_backup()
{
FileXML file;
edl->optimize();
edl->set_path(session->filename);
+
char backup_path[BCTEXTLEN], backup_path1[BCTEXTLEN];
- snprintf(backup_path, sizeof(backup_path), "%s/%s",
- File::get_config_path(), BACKUP_FILE);
snprintf(backup_path1, sizeof(backup_path1), "%s/%s",
File::get_config_path(), BACKUP_FILE1);
+ get_backup_path(backup_path, sizeof(backup_path));
rename(backup_path, backup_path1);
edl->save_xml(&file, backup_path);
file.terminate_string();
FileSystem fs;
fs.complete_path(backup_path);
- if(file.write_to_file(backup_path))
- {
+ if(file.write_to_file(backup_path)) {
char string2[256];
sprintf(string2, _("Couldn't open %s for writing."), backup_path);
gui->show_message(string2);
}
+ save_undo_data();
}
void MWindow::load_backup()
path_list.set_array_delete();
char *out_path;
char backup_path[BCTEXTLEN];
- snprintf(backup_path, sizeof(backup_path), "%s/%s",
- File::get_config_path(), BACKUP_FILE);
+ get_backup_path(backup_path, sizeof(backup_path));
FileSystem fs;
fs.complete_path(backup_path);
path_list.append(out_path = new char[strlen(backup_path) + 1]);
strcpy(out_path, backup_path);
- load_filenames(&path_list, LOADMODE_REPLACE, 0);
+ load_filenames(&path_list, LOADMODE_REPLACE, LOADMODE_EDL_CLIP, 0);
edl->local_session->clip_title[0] = 0;
// This is unique to backups since the path of the backup is different than the
// path of the project.
void MWindow::save_undo_data()
{
- undo_before();
- undo_after(_("perpetual session"), LOAD_ALL);
+ if( stack.size() > 0 ) return;
+ if( !preferences->perpetual_session ) return;
char perpetual_path[BCTEXTLEN];
snprintf(perpetual_path, sizeof(perpetual_path), "%s/%s",
File::get_config_path(), PERPETUAL_FILE);
void MWindow::load_undo_data()
{
+ if( stack.size() > 0 ) return;
+ if( !preferences->perpetual_session ) return;
char perpetual_path[BCTEXTLEN];
snprintf(perpetual_path, sizeof(perpetual_path), "%s/%s",
File::get_config_path(), PERPETUAL_FILE);
FILE *fp = fopen(perpetual_path,"r");
if( !fp ) return;
undo->load(fp);
+ undo_before();
+ undo_after(_("perpetual load"), LOAD_ALL);
fclose(fp);
}
+void MWindow::remove_undo_data()
+{
+ if( stack.size() > 0 ) return;
+ char perpetual_path[BCTEXTLEN];
+ snprintf(perpetual_path, sizeof(perpetual_path), "%s/%s",
+ File::get_config_path(), PERPETUAL_FILE);
+ ::remove(perpetual_path);
+}
int MWindow::copy_target(const char *path, const char *target)
{
char progress_title[BCTEXTLEN];
sprintf(progress_title, _("Saving to %s:\n"), dir);
int total_assets = save_edl->assets->total();
+ gui->lock_window("MWindow::save_project");
MainProgressBar *progress = mainprogress->start_progress(progress_title, total_assets);
+ gui->unlock_window();
+
int ret = 0;
Asset *current = save_edl->assets->first;
for( int i=0; !ret && current; ++i, current=NEXT ) {
gui->lock_window("MWindow::save_project");
ArrayList<char*> filenames;
filenames.append(filename);
- load_filenames(&filenames, LOADMODE_REPLACE);
+ load_filenames(&filenames);
gui->unlock_window();
}
}
}
}
-void MWindow::remove_asset_from_caches(Asset *asset)
+void MWindow::remove_from_caches(Indexable *idxbl)
{
- frame_cache->remove_asset(asset);
- wave_cache->remove_asset(asset);
+ frame_cache->remove_item(idxbl);
+ wave_cache->remove_item(idxbl);
+ if( gui->render_engine &&
+ gui->render_engine_id == idxbl->id ) {
+ delete gui->render_engine;
+ gui->render_engine = 0;
+ }
+ if( gui->resource_thread->render_engine_id == idxbl->id ) {
+ gui->resource_thread->render_engine_id = -1;
+ delete gui->resource_thread->render_engine;
+ gui->resource_thread->render_engine = 0;
+ }
+ if( !idxbl->is_asset ) return;
+ Asset *asset = (Asset *)idxbl;
audio_cache->delete_entry(asset);
video_cache->delete_entry(asset);
if( cwindow->playback_engine && cwindow->playback_engine->audio_cache )
if( vwindow->playback_engine->video_cache )
vwindow->playback_engine->video_cache->delete_entry(asset);
}
+ for(int i = 0; i < zwindows.size(); i++) {
+ ZWindow *zwindow = zwindows[i];
+ if( !zwindow->is_running() ) continue;
+ if( zwindow->zgui->playback_engine->audio_cache )
+ zwindow->zgui->playback_engine->audio_cache->delete_entry(asset);
+ if( zwindow->zgui->playback_engine->video_cache )
+ zwindow->zgui->playback_engine->video_cache->delete_entry(asset);
+ }
}
-
-void MWindow::remove_assets_from_project(int push_undo, int redraw,
+void MWindow::remove_assets_from_project(int push_undo, int redraw, int delete_indexes,
ArrayList<Indexable*> *drag_assets, ArrayList<EDL*> *drag_clips)
{
awindow->gui->close_view_popup();
- for(int i = 0; i < drag_assets->total; i++) {
- Indexable *indexable = drag_assets->get(i);
- if(indexable->is_asset) remove_asset_from_caches((Asset*)indexable);
- }
-
// Remove from VWindow.
- for(int i = 0; i < session->drag_clips->total; i++) {
- for(int j = 0; j < vwindows.size(); j++) {
- VWindow *vwindow = vwindows[j];
- if( !vwindow->is_running() ) continue;
- if(session->drag_clips->get(i) == vwindow->get_edl()) {
- vwindow->gui->lock_window("MWindow::remove_assets_from_project 1");
- vwindow->delete_source(1, 1);
- vwindow->gui->unlock_window();
+ if( drag_clips ) {
+ for(int i = 0; i < drag_clips->total; i++) {
+ for(int j = 0; j < vwindows.size(); j++) {
+ VWindow *vwindow = vwindows[j];
+ if( !vwindow->is_running() ) continue;
+ if(drag_clips->get(i) == vwindow->get_edl()) {
+ vwindow->gui->lock_window("MWindow::remove_assets_from_project 1");
+ vwindow->delete_source(1, 1);
+ vwindow->gui->unlock_window();
+ }
}
}
}
- for(int i = 0; i < drag_assets->size(); i++) {
- for(int j = 0; j < vwindows.size(); j++) {
- VWindow *vwindow = vwindows[j];
- if( !vwindow->is_running() ) continue;
- if(drag_assets->get(i) == vwindow->get_source()) {
- vwindow->gui->lock_window("MWindow::remove_assets_from_project 2");
- vwindow->delete_source(1, 1);
- vwindow->gui->unlock_window();
+ if( drag_assets ) {
+ for(int i = 0; i < drag_assets->size(); i++) {
+ for(int j = 0; j < vwindows.size(); j++) {
+ VWindow *vwindow = vwindows[j];
+ if( !vwindow->is_running() ) continue;
+ if(drag_assets->get(i) == vwindow->get_source()) {
+ vwindow->gui->lock_window("MWindow::remove_assets_from_project 2");
+ vwindow->delete_source(1, 1);
+ vwindow->gui->unlock_window();
+ }
}
}
- }
- for(int i = 0; i < drag_assets->size(); i++) {
- Indexable *indexable = drag_assets->get(i);
- remove_indexfile(indexable);
+ for(int i = 0; i < drag_assets->total; i++) {
+ Indexable *indexable = drag_assets->get(i);
+ if(indexable->is_asset) remove_from_caches(indexable);
+ }
+
+ if( delete_indexes ) {
+ for(int i = 0; i < drag_assets->size(); i++) {
+ Indexable *indexable = drag_assets->get(i);
+ remove_indexfile(indexable);
+ }
+ }
}
//printf("MWindow::rebuild_indices 1 %s\n", indexable->path);
void MWindow::remove_assets_from_disk()
{
- remove_assets_from_project(1,
- 1,
- session->drag_assets,
- session->drag_clips);
+ remove_assets_from_project(1, 1, 1,
+ session->drag_assets, session->drag_clips);
// Remove from disk
for(int i = 0; i < session->drag_assets->total; i++)
strcpy(session->filename, filename);
if( filename != edl->path )
strcpy(edl->path, filename);
+ return set_titlebar(filename);
+}
- if(gui)
- {
- if(filename[0] == 0)
- {
- gui->set_title(PROGRAM_NAME);
- }
- else
- {
- FileSystem dir;
- char string[BCTEXTLEN], string2[BCTEXTLEN];
- dir.extract_name(string, filename);
- sprintf(string2, PROGRAM_NAME ": %s", string);
- gui->set_title(string2);
- }
+int MWindow::set_titlebar(const char *filename)
+{
+ if( !gui ) return 0;
+ if( filename[0] ) {
+ FileSystem dir;
+ char string[BCTEXTLEN], string2[BCTEXTLEN];
+ dir.extract_name(string, filename);
+ sprintf(string2, PROGRAM_NAME ": %s", string);
+ gui->set_title(string2);
}
+ else
+ gui->set_title(PROGRAM_NAME);
return 0;
}
-
-
-
-
-
-
int MWindow::set_loop_boundaries()
{
double start = edl->local_session->get_selectionstart();
return patchgui;
}
+int MWindow::get_cpus()
+{
+ int out_w = edl->session->output_w;
+ int out_h = edl->session->output_h;
+ int cpus = out_w*out_h/0x80000 + 1;
+ if( cpus > preferences->processors )
+ cpus = preferences->processors;
+ return cpus;
+}
+
projects / goodguy / cinelerra.git / blobdiff