static bool
_gdk_pixbuf_get_module (const guchar *buffer, guint size)
{
GSList *formats, *format_ptr;
gint score, best = 0;
GdkPixbufFormat *selected = NULL;
format_ptr = gdk_pixbuf_get_formats ();
for (formats = format_ptr; formats; formats = g_slist_next (formats)) {
GdkPixbufFormat *info = (GdkPixbufFormat *)formats->data;
#if 0
if (info->disabled)
continue;
#endif
score = format_check (info, buffer, size);
if (score > best) {
best = score;
selected = info;
}
if (score >= 100)
break;
}
g_slist_free(format_ptr);
if (selected != NULL)
return true;
return false;
}
void Render::handle_close_event(int result)
{
int format_error = 0;
const int debug = 0;
if(!result)
{
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
// Check the asset format for errors.
FormatCheck format_check(asset);
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
format_error = format_check.check_format();
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
}
PRINT_TRACE
save_defaults(asset);
PRINT_TRACE
mwindow->save_defaults();
PRINT_TRACE
if(!format_error && !result)
{
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
if(!result) start_render();
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
}
PRINT_TRACE
}
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer,
GstPad *pad, gpointer user_data)
{
struct ausrc_st *st = user_data;
(void)fakesink;
(void)pad;
format_check(st, gst_caps_get_structure(GST_BUFFER_CAPS(buffer), 0));
packet_handler(st, buffer);
}
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer,
GstPad *pad, gpointer user_data)
{
struct ausrc_st *st = user_data;
GstCaps *caps;
(void)fakesink;
caps = gst_pad_get_current_caps(pad);
format_check(st, gst_caps_get_structure(caps, 0));
packet_handler(st, buffer);
}
static void
sanity_check(const gchar *filename)
{
GdkPixbufLoader *loader;
GSList *formats, *l;
GError *err = NULL;
GdkPixbuf *pixbuf;
gchar *buf = NULL;
gsize size;
FILE *fh;
gboolean ok, fileok = TRUE;
g_printerr("Performing sanity check for %s.\n", filename);
fileok &= ok = g_file_test(filename, G_FILE_TEST_EXISTS);
g_printerr("Does it exist: %s\n", ok ? "YES" : "NO");
fileok &= ok = g_file_test(filename, G_FILE_TEST_IS_REGULAR);
g_printerr("Is it a regular file: %s\n", ok ? "YES" : "NO");
fh = fopen(filename, "rb");
fileok &= ok = !!fh;
g_printerr("Can we open it for reading: %s\n", ok ? "YES" : "NO");
if (fh)
fclose(fh);
else
g_printerr("fopen() fails with: %s\n", g_strerror(errno));
fileok &= ok = g_file_get_contents(filename, &buf, &size, &err);
g_printerr("Can we use g_file_get_contents(): %s\n", ok ? "YES" : "NO");
if (!ok) {
g_printerr("g_file_get_contents() fails with: %s\n", err->message);
g_clear_error(&err);
}
if (!fileok) {
if (buf)
g_free(buf);
g_printerr("The file does not seem OK. No point continuing.\n");
return;
}
g_printerr("The file seems OK, continuing checks.\n");
pixbuf = gdk_pixbuf_new_from_file(filename, &err);
if (pixbuf) {
g_printerr("Apparently we can load the pixbuf (%dx%d) now?!\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
g_printerr("What has changed?\n");
g_printerr("This is completely f****d up.\n");
g_object_unref(pixbuf);
}
else {
g_printerr("gdk_pixbuf_new_from_file() fails with: %s\n", err->message);
g_clear_error(&err);
}
g_printerr("Checking the pixbuf loaders.\n");
formats = gdk_pixbuf_get_formats();
for (l = formats; l; l = g_slist_next(l)) {
GdkPixbufFormat *pixbuf_format = (GdkPixbufFormat*)l->data;
gchar **ext;
gchar *fmtname, *desc, *exts;
fmtname = gdk_pixbuf_format_get_name(pixbuf_format);
desc = gdk_pixbuf_format_get_description(pixbuf_format);
ext = gdk_pixbuf_format_get_extensions(pixbuf_format);
exts = g_strjoinv(" ", ext);
g_printerr("Found format %s: %s (%s)\n", fmtname, desc, exts);
g_free(exts);
g_strfreev(ext);
g_free(desc);
format_check(pixbuf_format, buf, size);
loader = gdk_pixbuf_loader_new_with_type(fmtname, &err);
if (!loader) {
g_printerr(" Cannot create loader for %s: %s\n",
fmtname, err->message);
g_clear_error(&err);
g_free(fmtname);
continue;
}
ok = gdk_pixbuf_loader_write(loader, buf, size, &err);
if (ok) {
g_printerr(" Loader %s accepts the file content.\n", fmtname);
ok = gdk_pixbuf_loader_close(loader, &err);
if (ok) {
g_printerr(" Loader %s accepts the entire file.\n", fmtname);
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf) {
g_printerr(" Obtained pixbuf %dx%d from the loader.\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
}
else {
g_printerr(" Cannot obtain pixbuf from the loader.\n");
}
}
else {
g_printerr(" Loader %s fails at close(): %s.\n",
fmtname, err->message);
g_clear_error(&err);
}
}
else {
g_printerr(" Loader %s does not accept the file content: %s\n",
fmtname, err->message);
g_clear_error(&err);
}
g_object_unref(loader);
g_free(fmtname);
}
g_slist_free(formats);
}
// for recent effect menu items and running new effects
// prompts for an effect if title is blank
void MenuEffectThread::run()
{
for(int i = 0; i < dead_plugins->size(); i++)
{
delete dead_plugins->get(i);
}
dead_plugins->remove_all();
// get stuff from main window
ArrayList<PluginServer*> *plugindb = mwindow->plugindb;
BC_Hash *defaults = mwindow->defaults;
ArrayList<BC_ListBoxItem*> plugin_list;
ArrayList<PluginServer*> local_plugindb;
char string[1024];
int i;
int result = 0;
// Default configuration
Asset *default_asset = new Asset;
// Output
ArrayList<Indexable*> assets;
// check for recordable tracks
if(!get_recordable_tracks(default_asset))
{
sprintf(string, _("No recordable tracks specified."));
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(string);
error.run_window();
default_asset->Garbage::remove_user();
return;
}
// check for plugins
if(!plugindb->total)
{
sprintf(string, _("No plugins available."));
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(string);
error.run_window();
default_asset->Garbage::remove_user();
return;
}
// get default attributes for output file
// used after completion
get_derived_attributes(default_asset, defaults);
// to_tracks = defaults->get("RENDER_EFFECT_TO_TRACKS", 1);
load_mode = defaults->get("RENDER_EFFECT_LOADMODE", LOADMODE_PASTE);
strategy = defaults->get("RENDER_EFFECT_STRATEGY", SINGLE_PASS);
// get plugin information
int need_plugin;
if(!strlen(title))
need_plugin = 1;
else
need_plugin = 0;
// generate a list of plugins for the window
if(need_plugin)
{
mwindow->search_plugindb(default_asset->audio_data,
default_asset->video_data,
-1,
0,
0,
local_plugindb);
for(int i = 0; i < local_plugindb.total; i++)
{
plugin_list.append(new BC_ListBoxItem(_(local_plugindb.values[i]->title)));
}
}
// find out which effect to run and get output file
int plugin_number, format_error = 0;
do
{
{
MenuEffectWindow window(mwindow,
this,
need_plugin ? &plugin_list : 0,
default_asset);
window.create_objects();
result = window.run_window();
plugin_number = window.result;
}
if(!result)
{
FormatCheck format_check(default_asset);
format_error = format_check.check_format();
}
}while(format_error && !result);
// save defaults
save_derived_attributes(default_asset, defaults);
defaults->update("RENDER_EFFECT_LOADMODE", load_mode);
defaults->update("RENDER_EFFECT_STRATEGY", strategy);
mwindow->save_defaults();
// get plugin server to use and delete the plugin list
PluginServer *plugin_server = 0;
PluginServer *plugin = 0;
if(need_plugin)
{
plugin_list.remove_all_objects();
if(plugin_number > -1)
{
plugin_server = local_plugindb.values[plugin_number];
strcpy(title, plugin_server->title);
}
}
else
{
for(int i = 0; i < plugindb->total && !plugin_server; i++)
{
if(!strcmp(plugindb->values[i]->title, title))
{
plugin_server = plugindb->values[i];
plugin_number = i;
}
}
}
// Update the most recently used effects and copy the plugin server.
if(plugin_server)
{
plugin = new PluginServer(*plugin_server);
fix_menu(title);
}
if(!result && !strlen(default_asset->path))
{
result = 1; // no output path given
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(_("No output file specified."));
error.run_window();
}
if(!result && plugin_number < 0)
{
result = 1; // no output path given
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(_("No effect selected."));
error.run_window();
}
// Configuration for realtime plugins.
KeyFrame plugin_data;
// get selection to render
// Range
double total_start, total_end;
total_start = mwindow->edl->local_session->get_selectionstart();
if(mwindow->edl->local_session->get_selectionend() ==
mwindow->edl->local_session->get_selectionstart())
total_end = mwindow->edl->tracks->total_playable_length();
else
total_end = mwindow->edl->local_session->get_selectionend();
// get native units for range
total_start = to_units(total_start, 0);
total_end = to_units(total_end, 1);
// Trick boundaries in case of a non-realtime synthesis plugin
if(plugin &&
!plugin->realtime &&
total_end == total_start) total_end = total_start + 1;
// Units are now in the track's units.
int64_t total_length = (int64_t)total_end - (int64_t)total_start;
// length of output file
int64_t output_start, output_end;
if(!result && total_length <= 0)
{
result = 1; // no output path given
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(_("No selected range to process."));
error.run_window();
}
// ========================= get keyframe from user
if(!result)
{
// ========================= realtime plugin
// no get_parameters
if(plugin->realtime)
{
// Open a prompt GUI
MenuEffectPrompt prompt(mwindow);
prompt.create_objects();
char title[BCTEXTLEN];
sprintf(title, PROGRAM_NAME ": %s", plugin->title);
// Open the plugin GUI
plugin->set_mwindow(mwindow);
plugin->set_keyframe(&plugin_data);
plugin->set_prompt(&prompt);
plugin->open_plugin(0, mwindow->preferences, mwindow->edl, 0, -1);
// Must set parameters since there is no plugin object to draw from.
plugin->get_parameters((int64_t)total_start,
(int64_t)total_end,
1);
plugin->show_gui();
// wait for user input
result = prompt.run_window();
// Close plugin.
plugin->save_data(&plugin_data);
plugin->hide_gui();
// Can't delete here.
dead_plugins->append(plugin);
default_asset->sample_rate = mwindow->edl->session->sample_rate;
default_asset->frame_rate = mwindow->edl->session->frame_rate;
realtime = 1;
}
else
// ============================non realtime plugin
{
plugin->set_mwindow(mwindow);
plugin->open_plugin(0, mwindow->preferences, mwindow->edl, 0, -1);
result = plugin->get_parameters((int64_t)total_start,
(int64_t)total_end,
get_recordable_tracks(default_asset));
// some plugins can change the sample rate and the frame rate
if(!result)
{
default_asset->sample_rate = plugin->get_samplerate();
default_asset->frame_rate = plugin->get_framerate();
}
delete plugin;
realtime = 0;
}
// Should take from first recordable track
default_asset->width = mwindow->edl->session->output_w;
default_asset->height = mwindow->edl->session->output_h;
}
// Process the total length in fragments
ArrayList<MenuEffectPacket*> packets;
if(!result)
{
Label *current_label = mwindow->edl->labels->first;
mwindow->stop_brender();
int current_number;
int number_start;
int total_digits;
Render::get_starting_number(default_asset->path,
current_number,
number_start,
total_digits);
// Construct all packets for single overwrite confirmation
for(int64_t fragment_start = (int64_t)total_start, fragment_end;
fragment_start < (int64_t)total_end;
fragment_start = fragment_end)
{
// Get fragment end
if(strategy == FILE_PER_LABEL || strategy == FILE_PER_LABEL_FARM)
{
while(current_label &&
to_units(current_label->position, 0) <= fragment_start)
current_label = current_label->next;
if(!current_label)
fragment_end = (int64_t)total_end;
else
fragment_end = to_units(current_label->position, 0);
}
else
{
fragment_end = (int64_t)total_end;
}
// Get path
char path[BCTEXTLEN];
if(strategy == FILE_PER_LABEL || strategy == FILE_PER_LABEL_FARM)
Render::create_filename(path,
default_asset->path,
current_number,
total_digits,
number_start);
else
strcpy(path, default_asset->path);
current_number++;
MenuEffectPacket *packet = new MenuEffectPacket(path,
fragment_start,
fragment_end);
packets.append(packet);
}
// Test existence of files
ArrayList<char*> paths;
for(int i = 0; i < packets.total; i++)
{
paths.append(packets.values[i]->path);
}
result = ConfirmSave::test_files(mwindow, &paths);
paths.remove_all();
}
for(int current_packet = 0;
current_packet < packets.total && !result;
current_packet++)
{
Asset *asset = new Asset(*default_asset);
MenuEffectPacket *packet = packets.values[current_packet];
int64_t fragment_start = packet->start;
int64_t fragment_end = packet->end;
strcpy(asset->path, packet->path);
assets.append(asset);
File *file = new File;
// Open the output file after getting the information because the sample rate
// is needed here.
if(!result)
{
// open output file in write mode
file->set_processors(mwindow->preferences->processors);
file->set_cache(mwindow->preferences->cache_size);
if(file->open_file(mwindow->preferences,
asset,
0,
1))
{
// open failed
sprintf(string, _("Couldn't open %s"), asset->path);
ErrorBox error(PROGRAM_NAME ": Error");
error.create_objects(string);
error.run_window();
result = 1;
}
else
{
mwindow->sighandler->push_file(file);
IndexFile::delete_index(mwindow->preferences,
asset);
}
}
// run plugins
if(!result)
{
// position file
output_start = 0;
PluginArray *plugin_array;
plugin_array = create_plugin_array();
plugin_array->start_plugins(mwindow,
mwindow->edl,
plugin_server,
&plugin_data,
fragment_start,
fragment_end,
file);
plugin_array->run_plugins();
plugin_array->stop_plugins();
mwindow->sighandler->pull_file(file);
file->close_file();
asset->audio_length = file->asset->audio_length;
asset->video_length = file->asset->video_length;
delete plugin_array;
}
delete file;
}
packets.remove_all_objects();
// paste output to tracks
if(!result && load_mode != LOADMODE_NOTHING)
{
mwindow->gui->lock_window("MenuEffectThread::run");
mwindow->undo->update_undo_before("", 0);
if(load_mode == LOADMODE_PASTE)
mwindow->clear(0);
mwindow->load_assets(&assets,
-1,
load_mode,
0,
0,
mwindow->edl->session->labels_follow_edits,
mwindow->edl->session->plugins_follow_edits,
mwindow->edl->session->autos_follow_edits);
mwindow->save_backup();
mwindow->undo->update_undo_after(title, LOAD_ALL);
mwindow->restart_brender();
mwindow->update_plugin_guis();
mwindow->gui->update(1,
2,
1,
1,
1,
1,
0);
mwindow->sync_parameters(CHANGE_ALL);
mwindow->gui->unlock_window();
mwindow->awindow->gui->lock_window("MenuEffectThread::run");
mwindow->awindow->gui->update_assets();
mwindow->awindow->gui->flush();
mwindow->awindow->gui->unlock_window();
}
for(int i = 0; i < assets.total; i++)
assets.values[i]->Garbage::remove_user();
assets.remove_all();
default_asset->Garbage::remove_user();
}
void Render::run()
{
int format_error;
result = 0;
if(mode == Render::INTERACTIVE)
{
// Fix the asset for rendering
printf("Render::run 1\n");
Asset *asset = new Asset;
load_defaults(asset);
printf("Render::run 2\n");
check_asset(mwindow->edl, *asset);
printf("Render::run 3\n");
// Get format from user
if(!result)
{
printf("Render::run 4\n");
do
{
format_error = 0;
result = 0;
{
printf("Render::run 5\n");
RenderWindow window(mwindow, this, asset);
printf("Render::run 6\n");
window.create_objects();
printf("Render::run 7\n");
result = window.run_window();
printf("Render::run 8\n");
if (! result) {
// add to recentlist only on OK
window.format_tools->path_recent->add_item(FILE_FORMAT_PREFIX(asset->format), asset->path);
}
}
if(!result)
{
printf("Render::run 8.1\n");
// Check the asset format for errors.
FormatCheck format_check(asset);
printf("Render::run 8.2\n");
format_error = format_check.check_format();
printf("Render::run 8.3\n");
}
}while(format_error && !result);
}
printf("Render::run 9\n");
save_defaults(asset);
mwindow->save_defaults();
printf("Render::run 10\n");
if(!result) render(1, asset, mwindow->edl, strategy, range_type);
printf("Render::run 11\n");
Garbage::delete_object(asset);
printf("Render::run 12\n");
}
else
if(mode == Render::BATCH)
{
for(int i = 0; i < jobs->total && !result; i++)
{
BatchRenderJob *job = jobs->values[i];
if(job->enabled)
{
if(mwindow)
{
mwindow->batch_render->update_active(i);
}
else
{
printf("Render::run: %s\n", job->edl_path);
}
FileXML *file = new FileXML;
EDL *edl = new EDL;
edl->create_objects();
file->read_from_file(job->edl_path);
if(!plugindb && mwindow)
plugindb = mwindow->plugindb;
edl->load_xml(plugindb, file, LOAD_ALL);
check_asset(edl, *job->asset);
render(0, job->asset, edl, job->strategy, RANGE_BACKCOMPAT);
delete edl;
delete file;
if(!result)
{
if(mwindow)
mwindow->batch_render->update_done(i, 1, elapsed_time);
else
{
char string[BCTEXTLEN];
elapsed_time =
(double)progress_timer->get_scaled_difference(1);
Units::totext(string,
elapsed_time,
TIME_HMS2);
printf("Render::run: done in %s\n", string);
}
}
else
{
if(mwindow)
mwindow->batch_render->update_active(-1);
else
printf("Render::run: failed\n");
}
}
}
if(mwindow)
{
mwindow->batch_render->update_active(-1);
mwindow->batch_render->update_done(-1, 0, 0);
}
}
printf("Render::run 100\n");
}
