}
else
if( plugin ) {
- strcpy(name, plugin->title);
+ strcpy(name, _(plugin->title));
set_text(name);
icon_vframe = plugin->get_picon();
if( icon_vframe )
-BatchRenderJob::BatchRenderJob(Preferences *preferences)
+BatchRenderJob::BatchRenderJob(Preferences *preferences, int strategy)
{
this->preferences = preferences;
+ this->strategy = strategy;
+ file_per_label = 0;
asset = new Asset;
edl_path[0] = 0;
- strategy = 0;
enabled = 1;
elapsed = 0;
}
edl_path[0] = 0;
file->tag.get_property("EDL_PATH", edl_path);
- strategy = file->tag.get_property("STRATEGY", strategy);
+ strategy = file->tag.get_property("STRATEGY", get_strategy());
enabled = file->tag.get_property("ENABLED", enabled);
elapsed = file->tag.get_property("ELAPSED", elapsed);
- fix_strategy();
result = file->read_tag();
if(!result)
void BatchRenderJob::save(FileXML *file)
{
file->tag.set_property("EDL_PATH", edl_path);
- file->tag.set_property("STRATEGY", strategy);
+ file->tag.set_property("STRATEGY", get_strategy());
file->tag.set_property("ENABLED", enabled);
file->tag.set_property("ELAPSED", elapsed);
file->append_tag();
file->append_newline();
}
-void BatchRenderJob::fix_strategy()
+int BatchRenderJob::get_strategy()
{
- strategy = Render::fix_strategy(strategy, preferences->use_renderfarm);
+ return strategy >= 0 ? strategy :
+ Render::get_strategy(preferences->use_renderfarm, file_per_label);
}
-
-
-
-
-
-
-
-
BatchRenderThread::BatchRenderThread(MWindow *mwindow)
: BC_DialogThread()
{
{
default_job->asset->load_defaults(defaults,
"BATCHRENDER_", 1, 1, 1, 1, 1);
- default_job->fix_strategy();
}
for(int i = 0; i < BATCHRENDER_COLUMNS; i++)
void BatchRenderThread::save_defaults(BC_Hash *defaults)
{
- if(default_job)
- {
+ if( default_job ) {
default_job->asset->save_defaults(defaults,
"BATCHRENDER_", 1, 1, 1, 1, 1);
- defaults->update("BATCHRENDER_STRATEGY", default_job->strategy);
}
- for(int i = 0; i < BATCHRENDER_COLUMNS; i++)
- {
+ for( int i=0; i<BATCHRENDER_COLUMNS; ++i ) {
char string[BCTEXTLEN];
sprintf(string, "BATCHRENDER_COLUMN%d", i);
defaults->update(string, column_width[i]);
}
// defaults->update("BATCHRENDER_JOB", current_job);
- if(mwindow)
+ if( mwindow )
mwindow->save_defaults();
else
defaults->save();
packages->create_packages(mwindow,
command->get_edl(),
preferences,
- job->strategy,
+ job->get_strategy(),
job->asset,
command->start_position,
command->end_position,
format_tools = new BatchFormat(mwindow, this, thread->get_current_asset());
format_tools->set_w(get_w() / 2);
format_tools->create_objects(x1, y1, 1, 1, 1, 1, 0, 1, 0, 0,
- &thread->get_current_job()->strategy, 0);
+ &thread->get_current_job()->file_per_label, 0);
// input EDL
add_subwindow(edl_path_title = new BC_Title(x2, y2, _("EDL Path:")));
void BatchRenderGUI::change_job()
{
BatchRenderJob *job = thread->get_current_job();
- format_tools->update(job->asset, &job->strategy);
+ format_tools->update(job->asset, &job->file_per_label);
edl_path_text->update(job->edl_path);
}
class BatchRenderJob
{
public:
- BatchRenderJob(Preferences *preferences);
+ BatchRenderJob(Preferences *preferences, int strategy=-1);
~BatchRenderJob();
void copy_from(BatchRenderJob *src);
void load(FileXML *file);
void save(FileXML *file);
- void fix_strategy();
+ int get_strategy();
// Source EDL to render
char edl_path[BCTEXTLEN];
// Destination file for output
Asset *asset;
int strategy;
+ int file_per_label;
int enabled;
// Amount of time elapsed in last render operation
double elapsed;
fprintf(fp,"#!/bin/bash -ex\n");
fprintf(fp,"PATH=$PATH:%s\n",exec_path);
fprintf(fp,"mkdir -p $1/udfs\n");
- fprintf(fp,"sz=`du -sb $1/bd.m2ts | sed -e 's/[ \t].*//'`\n");
+ fprintf(fp,"sz=`du -cb $1/bd.m2ts* | tail -1 | sed -e 's/[ \t].*//'`\n");
fprintf(fp,"blks=$((sz/2048 + 4096))\n");
fprintf(fp,"rm -f %s\n", udfs);
fprintf(fp,"mkudffs %s $blks\n", udfs);
fprintf(fp,"mount %s%s\n", mopts, mntpt);
- fprintf(fp,"bdwrite %s $1/bd.m2ts\n",mntpt);
+ fprintf(fp,"bdwrite %s $1/bd.m2ts*\n",mntpt);
fprintf(fp,"umount %s\n",mntpt);
if( is_usr_mnt )
fprintf(fp,"mv -f %s $1/bd.udfs\n", udfs);
use_scale = Rescale::scaled;
}
for( int i=0; i<trk->plugin_set.size(); ++i ) {
- for(Plugin *plugin = (Plugin*)trk->plugin_set[i]->first;
- plugin;
- plugin = (Plugin*)plugin->next) {
- if( !strcmp(plugin->title, _("Deinterlace")) )
+ for( Plugin *plugin = (Plugin*)trk->plugin_set[i]->first;
+ plugin; plugin=(Plugin*)plugin->next ) {
+ if( !strcmp(plugin->title, "Deinterlace") )
has_deinterlace = 1;
- if( !strcmp(plugin->title, _("Auto Scale")) ||
- !strcmp(plugin->title, _("Scale Ratio")) ||
- !strcmp(plugin->title, _("Scale")) )
+ if( !strcmp(plugin->title, "Auto Scale") ||
+ !strcmp(plugin->title, "Scale Ratio") ||
+ !strcmp(plugin->title, "Scale") )
has_scale = 1;
}
}
#include "mwindowgui.h"
#include "plugin.h"
#include "pluginset.h"
+#include "preferences.h"
#include "rescale.h"
#include "track.h"
#include "tracks.h"
fprintf(fp,"\n");
const char *exec_path = File::get_cinlib_path();
fprintf(fp,"PATH=$PATH:%s\n",exec_path);
+ if( mwindow->preferences->use_renderfarm )
+ fprintf(fp,"cat > $1/dvd.m2v $1/dvd.m2v0*\n");
if( !use_ffmpeg ) {
- fprintf(fp,"mplex -f 8 -o $1/dvd.mpg $1/dvd.m2v $1/dvd.ac3\n");
+ fprintf(fp,"mplex -M -f 8 -o $1/dvd.mpg $1/dvd.m2v $1/dvd.ac3\n");
fprintf(fp,"\n");
}
fprintf(fp,"rm -rf $1/iso\n");
asset->vmpeg_preset = 8;
asset->vmpeg_field_order = 0;
asset->vmpeg_pframe_distance = 0;
- job = new BatchRenderJob(mwindow->preferences);
+ job = new BatchRenderJob(mwindow->preferences, SINGLE_PASS);
jobs->append(job);
strcpy(&job->edl_path[0], xml_filename);
asset = job->asset;
if( !EQUIV(aspect, dvd_aspect) ) use_scale = Rescale::scaled;
}
for( int i=0; i<trk->plugin_set.size(); ++i ) {
- for(Plugin *plugin = (Plugin*)trk->plugin_set[i]->first;
- plugin;
- plugin = (Plugin*)plugin->next) {
- if( !strcmp(plugin->title, _("Deinterlace")) )
+ for( Plugin *plugin = (Plugin*)trk->plugin_set[i]->first;
+ plugin; plugin=(Plugin*)plugin->next ) {
+ if( !strcmp(plugin->title, "Deinterlace") )
has_deinterlace = 1;
- if( !strcmp(plugin->title, _("Auto Scale")) ||
- !strcmp(plugin->title, _("Scale Ratio")) ||
- !strcmp(plugin->title, _("Scale")) )
+ if( !strcmp(plugin->title, "Auto Scale") ||
+ !strcmp(plugin->title, "Scale Ratio") ||
+ !strcmp(plugin->title, "Scale") )
has_scale = 1;
}
}
close_window();
AWindowGUI *gui = awindow->gui;
char string[BCTEXTLEN];
- sprintf(string, _("Effect info: %s"), effect);
+ sprintf(string, _("Effect info: %s"), _(effect));
int effect_w = BC_Title::calculate_w(gui, string);
int text_w = BC_Title::calculate_w(gui, text);
int text_h = BC_Title::calculate_h(gui, text);
prompt_audio_channels = 0;
prompt_video = 0;
prompt_video_compression = 0;
- strategy = 0;
+ file_per_label = 0;
locked_compressor = 0;
video_driver = 0;
}
int prompt_video_compression,
const char *locked_compressor,
int recording,
- int *strategy,
+ int *file_per_label,
int brender,
int horizontal_layout)
{
this->prompt_audio_channels = prompt_audio_channels;
this->prompt_video = prompt_video;
this->prompt_video_compression = prompt_video_compression;
- this->strategy = strategy;
+ this->file_per_label = file_per_label;
//printf("FormatTools::create_objects 1\n");
-// Modify strategy depending on render farm
- if(strategy)
- {
- if(mwindow->preferences->use_renderfarm)
- {
- if(*strategy == FILE_PER_LABEL)
- *strategy = FILE_PER_LABEL_FARM;
- else
- if(*strategy == SINGLE_PASS)
- *strategy = SINGLE_PASS_FARM;
- }
- else
- {
- if(*strategy == FILE_PER_LABEL_FARM)
- *strategy = FILE_PER_LABEL;
- else
- if(*strategy == SINGLE_PASS_FARM)
- *strategy = SINGLE_PASS;
- }
- }
-
if(!recording)
{
int px = x;
//printf("FormatTools::create_objects 11\n");
x = init_x;
- if(strategy)
- {
- window->add_subwindow(multiple_files = new FormatMultiple(mwindow, x, y, strategy));
+ if( file_per_label ) {
+ multiple_files = new FormatMultiple(mwindow, x, y, file_per_label);
+ window->add_subwindow(multiple_files);
y += multiple_files->get_h() + 10;
}
}
}
-void FormatTools::update(Asset *asset, int *strategy)
+void FormatTools::update(Asset *asset, int *file_per_label)
{
this->asset = asset;
- this->strategy = strategy;
-
- if(path_textbox)
- path_textbox->update(asset->path);
+ this->file_per_label = file_per_label;
+ if( file_per_label ) multiple_files->update(file_per_label);
+ if( path_textbox ) path_textbox->update(asset->path);
format_text->update(File::formattostr(asset->format));
update_format();
- if(strategy)
- {
- multiple_files->update(strategy);
- }
close_format_windows();
}
x = init_x;
}
- if(strategy)
- {
+ if( file_per_label ) {
multiple_files->reposition_window(x, y);
y += multiple_files->get_h() + 10;
}
FormatMultiple::FormatMultiple(MWindow *mwindow, int x, int y, int *output)
- : BC_CheckBox(x,
- y,
- (*output == FILE_PER_LABEL) || (*output == FILE_PER_LABEL_FARM),
- _("Create new file at each label"))
+ : BC_CheckBox(x, y, *output, _("Create new file at each label"))
{
this->output = output;
this->mwindow = mwindow;
int FormatMultiple::handle_event()
{
- if(get_value())
- {
- if(mwindow->preferences->use_renderfarm)
- *output = FILE_PER_LABEL_FARM;
- else
- *output = FILE_PER_LABEL;
- }
- else
- {
- if(mwindow->preferences->use_renderfarm)
- *output = SINGLE_PASS_FARM;
- else
- *output = SINGLE_PASS;
- }
+ *output = get_value();
return 1;
}
void FormatMultiple::update(int *output)
{
this->output = output;
- if(*output == FILE_PER_LABEL_FARM ||
- *output ==FILE_PER_LABEL)
- set_value(1);
- else
- set_value(0);
+ set_value(*output ? 1 : 0);
}
int prompt_video_compression,
const char *locked_compressor, // Select compressors to be offered
int recording, // Change captions for recording
- int *strategy, // If nonzero, prompt for insertion strategy
+ int *file_per_label, // prompt if nonzero
int brender, // Supply file formats for background rendering
int horizontal_layout = 0);
// In recording preferences, aspects of the format are locked
void reposition_window(int &init_x, int &init_y);
// Put new asset's parameters in and change asset.
- void update(Asset *asset, int *strategy);
+ void update(Asset *asset, int *file_per_label);
// Update filename extension when format is changed.
void update_extension();
void close_format_windows();
int prompt_audio_channels;
int prompt_video;
int prompt_video_compression;
- int *strategy;
+ int *file_per_label;
int w;
// Determines what the configuration buttons do.
int video_driver;
if( strncmp(ISO_STANDARD_ID,id.id,sizeof(id.id)) ) continue;
// look for volume_id
if( !isalnum(id.volume_id[0]) ) continue;
- char *bp = &id.volume_id[0], *cp = fname;
+ char *bp = (char*)&id.volume_id[0], *cp = fname;
for( int i=0; i<(int)sizeof(id.volume_id); ++i ) *cp++ = *bp++;
while( --cp>=fname && *cp==' ' ) *cp = 0;
if( !*fname ) continue;
// fname = volume_id _ creation_date
- ++cp; *cp++ = '_'; bp = &id.creation_date[0];
+ ++cp; *cp++ = '_'; bp = (char*)&id.creation_date[0];
for( int i=0; i<(int)sizeof(id.creation_date)-1; ++i ) {
if( !isdigit(*bp) ) break;
*cp++ = *bp++;
mwindow->search_plugindb(data_type == TRACK_AUDIO,
data_type == TRACK_VIDEO, 0, 1, 0, plugindb);
for(int i = 0; i < plugindb.total; i++) {
- const char *title = _(plugindb.values[i]->title);
+ const char *title = plugindb.values[i]->title;
if( !strcmp(transition_title, title) ) number = i;
- transition_names.append(new BC_ListBoxItem(title));
+ transition_names.append(new BC_ListBoxItem(_(title)));
}
}
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);
+ file_per_label = defaults->get("RENDER_FILE_PER_LABEL", 0);
// get plugin information
- int need_plugin;
- if(!strlen(title))
- need_plugin = 1;
- else
- need_plugin = 0;
-
+ int need_plugin = !strlen(title) ? 1 : 0;
// generate a list of plugins for the window
- if(need_plugin)
- {
+ 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++)
- {
+ 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)));
}
}
// save defaults
save_derived_attributes(default_asset, defaults);
defaults->update("RENDER_EFFECT_LOADMODE", load_mode);
- defaults->update("RENDER_EFFECT_STRATEGY", strategy);
+ defaults->update("RENDER_EFFECT_FILE_PER_LABEL", file_per_label);
mwindow->save_defaults();
// get plugin server to use and delete the plugin list
default_asset->height = mwindow->edl->session->output_h;
}
+ int strategy = Render::get_strategy(mwindow->preferences->use_renderfarm, file_per_label);
// Process the total length in fragments
ArrayList<MenuEffectPacket*> packets;
if(!result)
add_subwindow(file_title = new BC_Title(
mwindow->theme->menueffect_file_x,
mwindow->theme->menueffect_file_y,
- (char*)((menueffects->strategy == FILE_PER_LABEL || menueffects->strategy == FILE_PER_LABEL_FARM) ?
+ (char*)(menueffects->file_per_label ?
_("Select the first file to render to:") :
_("Select a file to render to:"))));
format_tools = new FormatTools(mwindow,
this,
asset);
- format_tools->create_objects(x,
- y,
- asset->audio_data,
- asset->video_data,
- 0,
- 0,
- 0,
- 1,
- 0,
- 0,
- &menueffects->strategy,
- 0);
+ format_tools->create_objects(x, y, asset->audio_data, asset->video_data,
+ 0, 0, 0, 1, 0, 0, &menueffects->file_per_label, 0);
loadmode = new LoadMode(mwindow, this, x, y, &menueffects->load_mode, 1);
loadmode->create_objects();
MenuEffects *menu_item;
char title[BCTEXTLEN];
int realtime, load_mode;
- int strategy;
+ int file_per_label;
// GUI Plugins to delete
ArrayList<PluginServer*> *dead_plugins;
return 0;
}
+// repair session files with xlated plugin titles
+void MWindow::fix_plugin_title(char *title)
+{
+ for(int i = 0; i < plugindb->total; i++) {
+ PluginServer *server = plugindb->get(i);
+ if( !server->title ) continue;
+ const char *server_title = server->title;
+ if( !bstrcasecmp(title, _(server_title)) ) {
+ strcpy(title, server_title);
+ return;
+ }
+ }
+}
+
int MWindow::plugin_exists(const char *plugin_path, ArrayList<PluginServer*> &plugins)
{
for( int i=0; i<plugins.size(); ++i )
fprintf(stderr, _("MWindow::init_theme: prefered theme %s not found.\n"),
preferences->theme);
- const char *default_theme = _(DEFAULT_THEME);
+ const char *default_theme = DEFAULT_THEME;
if( !theme_plugin && strcasecmp(preferences->theme, default_theme) ) {
fprintf(stderr, _("MWindow::init_theme: trying default theme %s\n"),
default_theme);
{
char string[BCTEXTLEN];
-// Do a check weather plugins exist
- for(Track *track = new_edl->tracks->first; track; track = track->next)
- {
- for(int k = 0; k < track->plugin_set.total; k++)
- {
+// Do a check whether plugins exist
+ for( Track *track=new_edl->tracks->first; track; track=track->next ) {
+ for( int k=0; k<track->plugin_set.total; ++k ) {
PluginSet *plugin_set = track->plugin_set[k];
- for(Plugin *plugin = (Plugin*)plugin_set->first;
- plugin;
- plugin = (Plugin*)plugin->next)
- {
- if(plugin->plugin_type == PLUGIN_STANDALONE)
- {
+ for( Plugin *plugin = (Plugin*)plugin_set->first;
+ plugin; plugin = (Plugin*)plugin->next ) {
+ if( plugin->plugin_type != PLUGIN_STANDALONE ) continue;
// ok we need to find it in plugindb
- int plugin_found = 0;
-
- for(int j = 0; j < plugindb->size(); j++)
- {
- PluginServer *server = plugindb->get(j);
- if(server->title &&
- !strcasecmp(server->title, plugin->title) &&
- ((track->data_type == TRACK_AUDIO && server->audio) ||
- (track->data_type == TRACK_VIDEO && server->video)) &&
- (!server->transition))
- plugin_found = 1;
- }
-
- if (!plugin_found)
- {
- sprintf(string,
+ PluginServer *server =
+ scan_plugindb(plugin->title, track->data_type);
+ if( !server || server->transition ) {
+ sprintf(string,
_("The %s '%s' in file '%s' is not part of your installation of Cinelerra.\n"
"The project won't be rendered as it was meant and Cinelerra might crash.\n"),
- "effect", plugin->title,
- path);
- MainError::show_error(string);
- }
+ "effect", _(plugin->title), path);
+ MainError::show_error(string);
}
}
}
- for(Edit *edit = (Edit*)track->edits->first;
- edit;
- edit = (Edit*)edit->next)
- {
- if (edit->transition)
- {
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( !edit->transition ) continue;
// ok we need to find transition in plugindb
-
- int transition_found = 0;
- for(int j = 0; j < plugindb->size(); j++)
- {
- PluginServer *server = plugindb->get(j);
- if(server->title &&
- !strcasecmp(server->title, edit->transition->title) &&
- ((track->data_type == TRACK_AUDIO && server->audio) ||
- (track->data_type == TRACK_VIDEO && server->video)) &&
- (server->transition))
- transition_found = 1;
- }
-
- if (!transition_found)
- {
- sprintf(string,
+ PluginServer *server =
+ scan_plugindb(edit->transition->title, track->data_type);
+ if( !server || !server->transition ) {
+ sprintf(string,
_("The %s '%s' in file '%s' is not part of your installation of Cinelerra.\n"
"The project won't be rendered as it was meant and Cinelerra might crash.\n"),
- "transition", edit->transition->title,
- path);
- MainError::show_error(string);
- }
+ "transition", _(edit->transition->title), path);
+ MainError::show_error(string);
}
}
}
// Find the plugin whose title matches title and return it
static PluginServer* scan_plugindb(char *title,
int data_type);
+ static void fix_plugin_title(char *title);
static int plugin_exists(const char *plugin_path, ArrayList<PluginServer*> &plugins);
static int plugin_exists(char *plugin_path);
void dump_plugindb(FILE *fp);
1,
0, // Select compressors to be offered
0, // Prompt for recording options
- 0, // If nonzero, prompt for insertion strategy
+ 0, // prompt for file_per_label
1); // Supply file formats for background rendering
x = xmargin1;
PrefsRenderFarmNodes::PrefsRenderFarmNodes(PreferencesWindow *pwindow,
PerformancePrefs *subwindow, int x, int y)
- : BC_ListBox(x, y, 340, 230,
- LISTBOX_TEXT, // Display text list or icons
- subwindow->nodes,
- 0, //default_titles,
- 0, //default_widths,
- PerformancePrefs::TOTAL_COLUMNS)
+ : BC_ListBox(x, y, 340, 230, LISTBOX_TEXT)
{
for( int i=0; i<PerformancePrefs::TOTAL_COLUMNS; ++i ) {
titles[i] = _(default_titles[i]);
widths[i] = default_widths[i];
}
+ update(subwindow->nodes, titles, widths, PerformancePrefs::TOTAL_COLUMNS,
+ 0, 0, -1, 0, 0);
this->subwindow = subwindow;
this->pwindow = pwindow;
}
#include "virtualnode.h"
-Plugin::Plugin(EDL *edl,
- Track *track,
- const char *title)
+Plugin::Plugin(EDL *edl, Track *track, const char *title)
: Edit(edl, track)
{
is_plugin = 1;
}
// Start of plugin changed
- if(
- startproject != plugin->startproject ||
- plugin_type != plugin->plugin_type ||
- on != plugin->on ||
- !(shared_location == plugin->shared_location) ||
- strcmp(title, plugin->title)
- )
- {
- if(*result < 0 || startproject < *result)
+ if( startproject != plugin->startproject || plugin_type != plugin->plugin_type ||
+ on != plugin->on || !(shared_location == plugin->shared_location) ||
+ strcmp(title, plugin->title) ) {
+ if( *result < 0 || startproject < *result )
*result = startproject;
}
void Plugin::calculate_title(char *string, int use_nudge)
{
- if(plugin_type == PLUGIN_STANDALONE || plugin_type == PLUGIN_NONE)
- {
+ switch( plugin_type ) {
+ case PLUGIN_STANDALONE:
+ case PLUGIN_NONE:
strcpy(string, _(title));
+ break;
+ case PLUGIN_SHAREDPLUGIN:
+ case PLUGIN_SHAREDMODULE:
+ shared_location.calculate_title(string, edl,
+ startproject, 0, plugin_type, use_nudge);
+ break;
}
- else
- if(plugin_type == PLUGIN_SHAREDPLUGIN || plugin_type == PLUGIN_SHAREDMODULE)
- {
- shared_location.calculate_title(string,
- edl,
- startproject,
- 0,
- plugin_type,
- use_nudge);
- }
+}
+
+void Plugin::fix_plugin_title(char *title)
+{
+ MWindow::fix_plugin_title(title);
}
void Plugin::dump(FILE *fp)
{
fprintf(fp," PLUGIN: type=%d title=\"%s\" on=%d track=%d plugin=%d\n",
- plugin_type,
- title,
- on,
- shared_location.module,
- shared_location.plugin);
+ plugin_type, title, on, shared_location.module, shared_location.plugin);
fprintf(fp," startproject %jd length %jd\n", startproject, length);
keyframes->dump(fp);
// Shift in time
void shift(int64_t difference);
void dump(FILE *fp=stdout);
+ static void fix_plugin_title(char *title);
// Called by PluginClient sequence to get rendering parameters
KeyFrame* get_prev_keyframe(int64_t position, int direction);
KeyFrame* get_next_keyframe(int64_t position, int direction);
MainProgressBar *progress;
char string[BCTEXTLEN], string2[BCTEXTLEN];
- sprintf(string, "%s...", plugin_server->title);
+ sprintf(string, "%s...", _(plugin_server->title));
progress = mwindow->mainprogress->start_progress(string, end - start);
for(int64_t current_position = start;
progress->stop_progress();
delete progress;
- sprintf(string, _("%s took %s"), plugin_server->title, string2);
+ sprintf(string, _("%s took %s"), _(plugin_server->title), string2);
mwindow->gui->lock_window();
mwindow->gui->show_message(string2);
mwindow->gui->unlock_window();
void PluginDialog::create_objects()
{
// int use_default = 1;
- char string[BCTEXTLEN];
mwindow->theme->get_plugindialog_sizes();
-
lock_window("PluginDialog::create_objects");
- if(thread->plugin)
- {
- strcpy(string, thread->plugin->title);
- //use_default = 0;
- }
- else
- {
-// no plugin
- sprintf(string, _("None"));
- }
-
-
-
-
-
// GET A LIST OF ALL THE PLUGINS AVAILABLE
mwindow->search_plugindb(thread->data_type == TRACK_AUDIO,
PLAY_FORWARD,
1,
0);
- char *plugin_title = plugin->title;
char string[BCTEXTLEN];
-
- snprintf(string, sizeof(string), "%s: %s", track_title, _(plugin_title));
+ const char *plugin_title = _(plugin->title);
+ snprintf(string, sizeof(string), "%s: %s", track_title, plugin_title);
shared_data.append(new BC_ListBoxItem(string));
}
for(int i = 0; i < module_locations.total; i++)
// mwindow->theme->plugindialog_newattach_y));
//
-
-
-
-
-
-
add_subwindow(shared_title = new BC_Title(mwindow->theme->plugindialog_shared_x,
mwindow->theme->plugindialog_shared_y - 20,
_("Shared effects:")));
// mwindow->theme->plugindialog_sharedattach_y));
//
-
-
-
-
-
-
-
add_subwindow(module_title = new BC_Title(mwindow->theme->plugindialog_module_x,
mwindow->theme->plugindialog_module_y - 20,
_("Shared tracks:")));
void PluginServer::set_title(const char *string)
{
- if(title) delete [] title;
+ delete [] title;
title = cstrdup(string);
}
int uses_gui;
// Plugin is a transition
int transition;
-// name/tip of plugin in current locale.
+// name/tip of plugin
char *title, *tip;
int64_t written_samples, written_frames;
char *path; // location of plugin on disk
char title[BCTEXTLEN];
title[0] = 0;
file->tag.get_property("TITLE", title);
+ Plugin::fix_plugin_title(title);
SharedLocation shared_location;
shared_location.load(file);
1,
0, // Select compressors to be offered
1, // Prompt for recording options
- 0, // If nonzero, prompt for insertion strategy
+ 0, // prompt for file_per_label
0); // Supply file formats for background rendering
realtime_toc = new RecordRealtimeTOC(mwindow, pwindow,
render->counter_lock->unlock();
-// This locks the preferences
- if(mwindow) mwindow->preferences->copy_rates_from(preferences);
+ if( mwindow )
+ mwindow->preferences->copy_rates_from(preferences);
}
int MainPackageRenderer::progress_cancelled()
this->mwindow = mwindow;
in_progress = 0;
progress = 0;
- preferences = 0;
elapsed_time = 0.0;
package_lock = new Mutex("Render::package_lock");
counter_lock = new Mutex("Render::counter_lock");
completion = new Condition(0, "Render::completion");
progress_timer = new Timer;
range_type = RANGE_BACKCOMPAT;
+ preferences = new Preferences();
thread = new RenderThread(mwindow, this);
render_window = 0;
asset = 0;
}
void Render::start_batches(ArrayList<BatchRenderJob*> *jobs,
- BC_Hash *boot_defaults,
- Preferences *preferences)
+ BC_Hash *boot_defaults, Preferences *batch_prefs)
{
mode = Render::BATCH;
batch_cancelled = 0;
+ preferences->copy_from(batch_prefs);
this->jobs = jobs;
- this->preferences = new Preferences;
- this->preferences->copy_from(preferences);
completion->reset();
thread->run();
return 0;
}
-int Render::fix_strategy(int strategy, int use_renderfarm)
+int Render::get_strategy(int use_renderfarm, int file_per_label)
{
- if(use_renderfarm)
- {
- if(strategy == FILE_PER_LABEL)
- strategy = FILE_PER_LABEL_FARM;
- else
- if(strategy == SINGLE_PASS)
- strategy = SINGLE_PASS_FARM;
- }
- else
- {
- if(strategy == FILE_PER_LABEL_FARM)
- strategy = FILE_PER_LABEL;
- else
- if(strategy == SINGLE_PASS_FARM)
- strategy = SINGLE_PASS;
- }
- return strategy;
+ return use_renderfarm ?
+ (file_per_label ? FILE_PER_LABEL_FARM : SINGLE_PASS_FARM) :
+ (file_per_label ? FILE_PER_LABEL : SINGLE_PASS ) ;
+}
+int Render::get_strategy()
+{
+ return get_strategy(preferences->use_renderfarm, file_per_label);
}
void Render::start_progress()
int Render::load_defaults(Asset *asset)
{
- strategy = mwindow->defaults->get("RENDER_STRATEGY", SINGLE_PASS);
+ file_per_label = mwindow->defaults->get("RENDER_FILE_PER_LABEL", 0);
load_mode = mwindow->defaults->get("RENDER_LOADMODE", LOADMODE_NEW_TRACKS);
range_type = mwindow->defaults->get("RENDER_RANGE_TYPE", RANGE_PROJECT);
int Render::load_profile(int profile_slot, Asset *asset)
{
char string_name[100];
- sprintf(string_name, "RENDER_%i_STRATEGY", profile_slot);
- strategy = mwindow->defaults->get(string_name, SINGLE_PASS);
+ sprintf(string_name, "RENDER_%i_FILE_PER_LABEL", profile_slot);
+ file_per_label = mwindow->defaults->get(string_name, 0);
// Load mode is not part of the profile
// printf(string_name, "RENDER_%i_LOADMODE", profile_slot);
// load_mode = mwindow->defaults->get(string_name, LOADMODE_NEW_TRACKS);
int Render::save_defaults(Asset *asset)
{
- mwindow->defaults->update("RENDER_STRATEGY", strategy);
+ mwindow->defaults->update("RENDER_FILE_PER_LABEL", file_per_label);
mwindow->defaults->update("RENDER_LOADMODE", load_mode);
mwindow->defaults->update("RENDER_RANGE_TYPE", range_type);
render->progress = 0;
render->result = 0;
- if( mwindow ) {
- if( !render->preferences )
- render->preferences = new Preferences;
- render->preferences->copy_from(mwindow->preferences);
- }
-
// Create rendering command
TransportCommand *command = new TransportCommand;
command->command = NORMAL_FWD;
if(mwindow) mwindow->stop_brender();
fs.complete_path(render->default_asset->path);
- strategy = Render::fix_strategy(strategy, render->preferences->use_renderfarm);
render->result = render->packages->create_packages(mwindow,
command->get_edl(),
void RenderThread::run()
{
+ if( mwindow )
+ render->preferences->copy_from(mwindow->preferences);
+
if(render->mode == Render::INTERACTIVE)
{
render_single(1, render->asset, mwindow->edl,
- render->strategy, render->range_type);
+ render->get_strategy(), render->range_type);
}
else
if(render->mode == Render::BATCH)
edl->create_objects();
file->read_from_file(job->edl_path);
edl->load_xml(file, LOAD_ALL);
-
//PRINT_TRACE
- render_single(0, job->asset, edl, job->strategy, RANGE_BACKCOMPAT);
+ render_single(0, job->asset, edl, job->get_strategy(), RANGE_BACKCOMPAT);
//PRINT_TRACE
edl->Garbage::remove_user();
{
render->load_profile(profile_slot, asset);
update_range_type(render->range_type);
- render_format->update(asset, &render->strategy);
+ render_format->update(asset, &render->file_per_label);
}
int x = 10, y = 10;
lock_window("RenderWindow::create_objects");
add_subwindow(new BC_Title(x, y,
- (char*)((render->strategy == FILE_PER_LABEL ||
- render->strategy == FILE_PER_LABEL_FARM) ?
+ (char*)(render->file_per_label ?
_("Select the first file to render to:") :
_("Select a file to render to:"))));
y += 25;
render_format = new RenderFormat(mwindow, this, asset);
render_format->create_objects(x, y,
- 1, 1, 1, 1, 0, 1, 0, 0, &render->strategy, 0);
+ 1, 1, 1, 1, 0, 1, 0, 0, &render->file_per_label, 0);
BC_Title *title;
add_subwindow(title = new BC_Title(x, y, _("Render range:")));
void start_batches(ArrayList<BatchRenderJob*> *jobs);
// The batches are processed in the foreground in non interactive mode.
void start_batches(ArrayList<BatchRenderJob*> *jobs,
- BC_Hash *boot_defaults,
- Preferences *preferences);
+ BC_Hash *boot_defaults, Preferences *batch_prefs);
// Called by BatchRender to stop the operation.
void stop_operation();
BC_Window* new_gui();
// force asset parameters regardless of window
// This should be integrated into the Asset Class.
static int check_asset(EDL *edl, Asset &asset);
-// Fix strategy to conform with using renderfarm.
- static int fix_strategy(int strategy, int use_renderfarm);
+// strategy to conform with using renderfarm.
+ static int get_strategy(int use_renderfarm, int file_per_label);
+ int get_strategy();
// Force filename to have a 0 padded number if rendering to a list.
int check_numbering(Asset &asset);
static void create_filename(char *path,
// Background compression must be disabled when direct frame copying and reenabled afterwards
int direct_frame_copying;
-// Copy of mwindow preferences or pointer to another preferences object
Preferences *preferences;
VFrame *compressed_output;
MainProgressBar *progress;
PlayableTracks *playable_tracks;
PackageDispatcher *packages;
Mutex *package_lock, *counter_lock;
- int strategy;
+ int file_per_label;
int range_type;
// Total selection to render in seconds
double total_start, total_end;
sprintf(string_name, "RENDER_%i_PROFILE_NAME", profile_slot);
mwindow->defaults->update(string_name, profile_name);
- sprintf(string_name, "RENDER_%i_STRATEGY", profile_slot);
- mwindow->defaults->update(string_name, rwindow->render->strategy);
+ sprintf(string_name, "RENDER_%i_FILE_PER_LABEL", profile_slot);
+ mwindow->defaults->update(string_name,
+ rwindow->render->file_per_label ? FILE_PER_LABEL : SINGLE_PASS);
sprintf(string_name, "RENDER_%i_LOADMODE", profile_slot);
mwindow->defaults->update(string_name, rwindow->render->load_mode);
sprintf(string_name, "RENDER_%i_RANGE_TYPE", profile_slot);
colormodel = BC_BGR8888;
else {
// file favorite colormodel may mismatch rgb/yuv
- int vstream = playable_edit->channel;
+ int vstream = playable_edit ? playable_edit->channel : -1;
int best_colormodel = file->get_best_colormodel(vconfig->driver, vstream);
if( BC_CModels::is_yuv(best_colormodel) == BC_CModels::is_yuv(colormodel) )
colormodel = best_colormodel;
if(temp) delete temp;
}
-const char* _1080to480Main::plugin_title() { return _("1080 to 480"); }
+const char* _1080to480Main::plugin_title() { return N_("1080 to 480"); }
int _1080to480Main::is_realtime() { return 1; }
NEW_WINDOW_MACRO(_1080to480Main, _1080to480Window)
if(temp) delete temp;
}
-const char* _1080to540Main::plugin_title() { return _("1080 to 540"); }
+const char* _1080to540Main::plugin_title() { return N_("1080 to 540"); }
int _1080to540Main::is_realtime() { return 1; }
NEW_WINDOW_MACRO(_1080to540Main, _1080to540Window)
if(temp) delete temp;
}
-const char* _720to480Main::plugin_title() { return _("720 to 480"); }
+const char* _720to480Main::plugin_title() { return N_("720 to 480"); }
int _720to480Main::is_realtime() { return 0; }
double _720to480Main::get_framerate()
return 1;
}
-const char* C41Effect::plugin_title() { return _("C41"); }
+const char* C41Effect::plugin_title() { return N_("C41"); }
int C41Effect::is_realtime() { return 1; }
int C41Effect::is_synthesis() { return 1; }
if(aging_server) delete aging_server;
}
-const char* AgingMain::plugin_title() { return _("AgingTV"); }
+const char* AgingMain::plugin_title() { return N_("AgingTV"); }
int AgingMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(AgingMain, AgingWindow)
}
-const char* AudioScope::plugin_title() { return _("AudioScope"); }
+const char* AudioScope::plugin_title() { return N_("AudioScope"); }
int AudioScope::is_realtime() { return 1; }
int AudioScope::is_multichannel() { return 1; }
}
-const char* BandSlideMain::plugin_title() { return _("BandSlide"); }
+const char* BandSlideMain::plugin_title() { return N_("BandSlide"); }
int BandSlideMain::is_transition() { return 1; }
int BandSlideMain::uses_gui() { return 1; }
}
-const char* BandWipeMain::plugin_title() { return _("BandWipe"); }
+const char* BandWipeMain::plugin_title() { return N_("BandWipe"); }
int BandWipeMain::is_transition() { return 1; }
int BandWipeMain::uses_gui() { return 1; }
delete engine;
}
-const char* BluebananaMain::plugin_title() { return _("Blue Banana"); }
+const char* BluebananaMain::plugin_title() { return N_("Blue Banana"); }
int BluebananaMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(BluebananaMain, BluebananaWindow)
if(overlayer) delete overlayer;
}
-const char* BlurMain::plugin_title() { return _("Blur"); }
+const char* BlurMain::plugin_title() { return N_("Blur"); }
int BlurMain::is_realtime() { return 1; }
{
}
-char* BlurZoomMain::plugin_title() { return _("RadioacTV"); }
+char* BlurZoomMain::plugin_title() { return N_("RadioacTV"); }
int BlurZoomMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(BlurZoomMain, BlurZoomWindow)
if(engine) delete engine;
}
-const char* BrightnessMain::plugin_title() { return _("Brightness/Contrast"); }
+const char* BrightnessMain::plugin_title() { return N_("Brightness/Contrast"); }
int BrightnessMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(BrightnessMain, BrightnessWindow)
if(effecttv) delete effecttv;
}
-const char* BurnMain::plugin_title() { return _("BurningTV"); }
+const char* BurnMain::plugin_title() { return N_("BurningTV"); }
int BurnMain::is_realtime() { return 1; }
{
}
-const char* CDRipMain::plugin_title() { return _("CD Ripper"); }
+const char* CDRipMain::plugin_title() { return N_("CD Ripper"); }
int CDRipMain::is_realtime() { return 0; }
int CDRipMain::is_multichannel() { return 1; }
return 1;
}
-const char* ChromaKey::plugin_title() { return _("Chroma key"); }
+const char* ChromaKey::plugin_title() { return N_("Chroma key"); }
int ChromaKey::is_realtime() { return 1; }
NEW_WINDOW_MACRO(ChromaKey, ChromaKeyWindow)
return 0;
}
-const char* ChromaKeyHSV::plugin_title() { return _("Chroma key (HSV)"); }
+const char* ChromaKeyHSV::plugin_title() { return N_("Chroma key (HSV)"); }
int ChromaKeyHSV::is_realtime() { return 1; }
delete engine;
}
-const char* Color3WayMain::plugin_title() { return _("Color 3 Way"); }
+const char* Color3WayMain::plugin_title() { return N_("Color 3 Way"); }
int Color3WayMain::is_realtime() { return 1; }
}
}
-const char* ColorBalanceMain::plugin_title() { return _("Color Balance"); }
+const char* ColorBalanceMain::plugin_title() { return N_("Color Balance"); }
int ColorBalanceMain::is_realtime() { return 1; }
current_value = 1.0;
}
-const char* CompressorEffect::plugin_title() { return _("Compressor"); }
+const char* CompressorEffect::plugin_title() { return N_("Compressor"); }
int CompressorEffect::is_realtime() { return 1; }
int CompressorEffect::is_multichannel() { return 1; }
}
}
-const char* CriKey::plugin_title() { return _("CriKey"); }
+const char* CriKey::plugin_title() { return N_("CriKey"); }
int CriKey::is_realtime() { return 1; }
NEW_WINDOW_MACRO(CriKey, CriKeyWindow);
{
}
-const char* CrossfadeMain::plugin_title() { return _("Crossfade"); }
+const char* CrossfadeMain::plugin_title() { return N_("Crossfade"); }
int CrossfadeMain::is_transition() { return 1; }
int CrossfadeMain::uses_gui() { return 0; }
DBXEffect(PluginServer *server);
~DBXEffect();
- char* plugin_title();
+ const char* plugin_title();
int is_multichannel();
int is_realtime();
void read_data(KeyFrame *keyframe);
delete reference;
}
-const char* DCOffset::plugin_title() { return _("DC Offset"); }
+const char* DCOffset::plugin_title() { return N_("DC Offset"); }
int DCOffset::is_realtime() { return 1; }
-const char* Decimate::plugin_title() { return _("Decimate"); }
+const char* Decimate::plugin_title() { return N_("Decimate"); }
int Decimate::is_realtime() { return 1; }
NEW_WINDOW_MACRO(Decimate, DecimateWindow)
if(temp_prevframe) delete temp_prevframe;
}
-const char* DeInterlaceMain::plugin_title() { return _("Deinterlace-CV"); }
+const char* DeInterlaceMain::plugin_title() { return N_("Deinterlace-CV"); }
int DeInterlaceMain::is_realtime() { return 1; }
// if(temp) delete temp;
}
-const char* DeInterlaceMain::plugin_title() { return _("Deinterlace"); }
+const char* DeInterlaceMain::plugin_title() { return N_("Deinterlace"); }
int DeInterlaceMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(DelayAudio, DelayAudioWindow)
-const char* DelayAudio::plugin_title() { return _("Delay audio"); }
+const char* DelayAudio::plugin_title() { return N_("Delay audio"); }
int DelayAudio::is_realtime() { return 1; }
return 1;
}
-const char* DelayVideo::plugin_title() { return _("Delay Video"); }
+const char* DelayVideo::plugin_title() { return N_("Delay Video"); }
LOAD_CONFIGURATION_MACRO(DelayVideo, DelayVideoConfig)
NEW_WINDOW_MACRO(DelayVideo, DelayVideoWindow)
iterations = 1;
}
-const char* DenoiseEffect::plugin_title() { return _("Denoise"); }
+const char* DenoiseEffect::plugin_title() { return N_("Denoise"); }
int DenoiseEffect::is_realtime() { return 1; }
}
int DenoiseFFTEffect::is_realtime() { return 1; }
-const char* DenoiseFFTEffect::plugin_title() { return _("DenoiseFFT"); }
+const char* DenoiseFFTEffect::plugin_title() { return N_("DenoiseFFT"); }
return 0;
}
-const char* DenoiseMJPEG::plugin_title() { return _("Denoise video2"); }
+const char* DenoiseMJPEG::plugin_title() { return N_("Denoise video2"); }
int DenoiseMJPEG::is_realtime() { return 1; }
void DenoiseMJPEG::update_gui()
if(history_valid) delete [] history_valid;
}
-const char* SelTempAvgMain::plugin_title() { return _("Selective Temporal Averaging"); }
+const char* SelTempAvgMain::plugin_title() { return N_("Selective Temporal Averaging"); }
int SelTempAvgMain::is_realtime() { return 1; }
}
-const char* DenoiseVideo::plugin_title() { return _("Denoise video"); }
+const char* DenoiseVideo::plugin_title() { return N_("Denoise video"); }
int DenoiseVideo::is_realtime() { return 1; }
}
-const char* Despike::plugin_title() { return _("Despike"); }
+const char* Despike::plugin_title() { return N_("Despike"); }
int Despike::is_realtime() { return 1; }
NEW_WINDOW_MACRO(Despike, DespikeWindow)
NEW_WINDOW_MACRO(DiffKey, DiffKeyGUI)
LOAD_CONFIGURATION_MACRO(DiffKey, DiffKeyConfig)
-const char* DiffKey::plugin_title() { return _("Difference key"); }
+const char* DiffKey::plugin_title() { return N_("Difference key"); }
int DiffKey::is_realtime() { return 1; }
int DiffKey::is_multichannel() { return 1; }
delete overlayer;
}
-const char* DissolveMain::plugin_title() { return _("Dissolve"); }
+const char* DissolveMain::plugin_title() { return N_("Dissolve"); }
int DissolveMain::is_video() { return 1; }
int DissolveMain::is_transition() { return 1; }
int DissolveMain::uses_gui() { return 0; }
}
}
-const char* DotMain::plugin_title() { return _("DotTV"); }
+const char* DotMain::plugin_title() { return N_("DotTV"); }
int DotMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(DotMain, DotWindow)
if(engine) delete engine;
}
-const char* DownSampleMain::plugin_title() { return _("Downsample"); }
+const char* DownSampleMain::plugin_title() { return N_("Downsample"); }
int DownSampleMain::is_realtime() { return 1; }
bfr_pos = 0;
}
-const char* Echo::plugin_title() { return _("Echo"); }
+const char* Echo::plugin_title() { return N_("Echo"); }
int Echo::is_realtime() { return 1; }
int Echo::is_multichannel() { return 1; }
sample_data -= len;
}
-const char* EchoCancel::plugin_title() { return _("EchoCancel"); }
+const char* EchoCancel::plugin_title() { return N_("EchoCancel"); }
int EchoCancel::is_realtime() { return 1; }
static inline double sqr(double v) { return v*v; }
delete dst;
}
-const char* Edge::plugin_title() { return _("Edge"); }
+const char* Edge::plugin_title() { return N_("Edge"); }
int Edge::is_realtime() { return 1; }
NEW_WINDOW_MACRO(Edge, EdgeWindow);
if(input) delete input;
}
-const char* FieldFrame::plugin_title() { return _("Fields to frames"); }
+const char* FieldFrame::plugin_title() { return N_("Fields to frames"); }
int FieldFrame::is_realtime() { return 1; }
delete overlayer;
}
-const char* FindObjMain::plugin_title() { return _("FindObj"); }
+const char* FindObjMain::plugin_title() { return N_("FindObj"); }
int FindObjMain::is_realtime() { return 1; }
int FindObjMain::is_multichannel() { return 1; }
{
}
-const char* FlashMain::plugin_title() { return _("Flash"); }
+const char* FlashMain::plugin_title() { return N_("Flash"); }
int FlashMain::is_video() { return 1; }
int FlashMain::is_transition() { return 1; }
int FlashMain::uses_gui() { return 0; }
}
-const char* FlipMain::plugin_title() { return _("Flip"); }
+const char* FlipMain::plugin_title() { return N_("Flip"); }
int FlipMain::is_realtime() { return 1; }
-const char* FrameField::plugin_title() { return _("Frames to fields"); }
+const char* FrameField::plugin_title() { return N_("Frames to fields"); }
int FrameField::is_realtime() { return 1; }
NEW_WINDOW_MACRO(FrameField, FrameFieldWindow)
NEW_WINDOW_MACRO(FreeverbEffect, FreeverbWindow)
-const char* FreeverbEffect::plugin_title() { return _("Freeverb"); }
+const char* FreeverbEffect::plugin_title() { return N_("Freeverb"); }
int FreeverbEffect::is_realtime() { return 1; }
int FreeverbEffect::is_multichannel() { return 1; }
if(first_frame) delete first_frame;
}
-const char* FreezeFrameMain::plugin_title() { return _("Freeze Frame"); }
+const char* FreezeFrameMain::plugin_title() { return N_("Freeze Frame"); }
int FreezeFrameMain::is_synthesis() { return 1; }
int FreezeFrameMain::is_realtime() { return 1; }
}
-const char* Gain::plugin_title() { return _("Gain"); }
+const char* Gain::plugin_title() { return N_("Gain"); }
int Gain::is_realtime() { return 1; }
delete engine;
}
-const char* GammaMain::plugin_title() { return _("Gamma"); }
+const char* GammaMain::plugin_title() { return N_("Gamma"); }
int GammaMain::is_realtime() { return 1; }
if(overlayer) delete overlayer;
}
-const char* GradientMain::plugin_title() { return _("Gradient"); }
+const char* GradientMain::plugin_title() { return N_("Gradient"); }
int GradientMain::is_realtime() { return 1; }
int GraphicEQ::is_realtime() { return 1; }
-const char* GraphicEQ::plugin_title() { return _("EQ Graphic"); }
+const char* GraphicEQ::plugin_title() { return N_("EQ Graphic"); }
NEW_WINDOW_MACRO(GraphicEQ, GraphicGUI)
delete [] alpha;
}
-const char* GreyCStorationMain::plugin_title() { return _("GreyCStoration"); }
+const char* GreyCStorationMain::plugin_title() { return N_("GreyCStoration"); }
int GreyCStorationMain::is_realtime() { return 1; }
delete [] wts;
}
-const char* HistEqMain::plugin_title() { return _("HistEq"); }
+const char* HistEqMain::plugin_title() { return N_("HistEq"); }
int HistEqMain::is_realtime() { return 1; }
delete engine;
}
-const char* HistogramMain::plugin_title() { return _("Histogram"); }
+const char* HistogramMain::plugin_title() { return N_("Histogram"); }
int HistogramMain::is_realtime() { return 1; }
delete engine;
}
-const char* HistogramMain::plugin_title() { return _("Histogram Bezier"); }
+const char* HistogramMain::plugin_title() { return N_("Histogram Bezier"); }
int HistogramMain::is_realtime() { return 1; }
delete bgimage;
}
-const char* HoloMain::plugin_title() { return _("HolographicTV"); }
+const char* HoloMain::plugin_title() { return N_("HolographicTV"); }
int HoloMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(HoloMain, HoloWindow)
return 0;
}
-const char* HueEffect::plugin_title() { return _("Hue saturation"); }
+const char* HueEffect::plugin_title() { return N_("Hue saturation"); }
int HueEffect::is_realtime() { return 1; }
NEW_WINDOW_MACRO(HueEffect, HueWindow)
delete engine;
}
-const char* InterpolatePixelsMain::plugin_title() { return _("Interpolate Bayer"); }
+const char* InterpolatePixelsMain::plugin_title() { return N_("Interpolate Bayer"); }
int InterpolatePixelsMain::is_realtime() { return 1; }
InterpolateAllEffect(PluginServer *server);
~InterpolateAllEffect();
- char* plugin_title();
+ const char* plugin_title();
int is_realtime();
int is_multichannel();
int get_parameters();
-char* InterpolateAllEffect::plugin_title() { return _("Interpolate"); }
+char* InterpolateAllEffect::plugin_title() { return N_("Interpolate"); }
int InterpolateAllEffect::is_realtime() { return 0; }
int InterpolateAllEffect::is_multichannel() { return 0; }
-const char* InterpolateAudioEffect::plugin_title() { return _("Interpolate"); }
+const char* InterpolateAudioEffect::plugin_title() { return N_("Interpolate"); }
int InterpolateAudioEffect::is_realtime() { return 1; }
NEW_WINDOW_MACRO(InterpolateVideo, InterpolateVideoWindow)
-const char* InterpolateVideo::plugin_title() { return _("Interpolate Video"); }
+const char* InterpolateVideo::plugin_title() { return N_("Interpolate Video"); }
int InterpolateVideo::is_realtime() { return 1; }
int InterpolateVideo::load_configuration()
: PluginAClient(server) {};
~InvertAudioEffect() {};
- const char* plugin_title() { return _("Invert Audio"); };
+ const char* plugin_title() { return N_("Invert Audio"); };
int is_realtime() { return 1; };
int process_realtime(int64_t size, Samples *input_ptr, Samples *output_ptr) {
double *output_samples = output_ptr->get_data();
}
-const char* InvertVideoEffect::plugin_title() { return _("Invert Video"); }
+const char* InvertVideoEffect::plugin_title() { return N_("Invert Video"); }
int InvertVideoEffect::is_realtime() { return 1; }
NEW_WINDOW_MACRO(InvertVideoEffect, InvertVideoWindow)
}
-const char* IrisSquareMain::plugin_title() { return _("IrisSquare"); }
+const char* IrisSquareMain::plugin_title() { return N_("IrisSquare"); }
int IrisSquareMain::is_video() { return 1; }
int IrisSquareMain::is_transition() { return 1; }
int IrisSquareMain::uses_gui() { return 1; }
}
}
-const char* IVTCMain::plugin_title() { return _("Inverse Telecine"); }
+const char* IVTCMain::plugin_title() { return N_("Inverse Telecine"); }
int IVTCMain::is_realtime() { return 1; }
NEW_WINDOW_MACRO(LensMain, LensGUI)
LOAD_CONFIGURATION_MACRO(LensMain, LensConfig)
int LensMain::is_realtime() { return 1; }
-const char* LensMain::plugin_title() { return _("Lens"); }
+const char* LensMain::plugin_title() { return N_("Lens"); }
void LensMain::update_gui()
{
accum_size = 0;
}
-const char* SoundLevelEffect::plugin_title() { return _("SoundLevel"); }
+const char* SoundLevelEffect::plugin_title() { return N_("SoundLevel"); }
int SoundLevelEffect::is_realtime() { return 1; }
if(temp) delete temp;
}
-const char* LinearBlurMain::plugin_title() { return _("Linear Blur"); }
+const char* LinearBlurMain::plugin_title() { return N_("Linear Blur"); }
int LinearBlurMain::is_realtime() { return 1; }
}
-const char* LiveAudio::plugin_title() { return _("Live Audio"); }
+const char* LiveAudio::plugin_title() { return N_("Live Audio"); }
int LiveAudio::is_realtime() { return 1; }
int LiveAudio::is_multichannel() { return 1; }
int LiveAudio::is_synthesis() { return 1; }
}
-const char* LiveVideo::plugin_title() { return _("Live Video"); }
+const char* LiveVideo::plugin_title() { return N_("Live Video"); }
int LiveVideo::is_realtime() { return 1; }
int LiveVideo::is_multichannel() { return 0; }
int LiveVideo::is_synthesis() { return 1; }
}
-const char* LoopAudio::plugin_title() { return _("Loop audio"); }
+const char* LoopAudio::plugin_title() { return N_("Loop audio"); }
int LoopAudio::is_realtime() { return 1; }
int LoopAudio::is_synthesis() { return 1; }
}
-const char* LoopVideo::plugin_title() { return _("Loop video"); }
+const char* LoopVideo::plugin_title() { return N_("Loop video"); }
int LoopVideo::is_realtime() { return 1; }
int LoopVideo::is_synthesis() { return 1; }
delete rotate_target_dst;
}
-const char *MotionCVMain::plugin_title() { return _("MotionCV"); }
+const char *MotionCVMain::plugin_title() { return N_("MotionCV"); }
int MotionCVMain::is_realtime() { return 1; }
int MotionCVMain::is_multichannel() { return 1; }
delete rotate_target_dst;
}
-const char* MotionHVMain::plugin_title() { return _("MotionHV"); }
+const char* MotionHVMain::plugin_title() { return N_("MotionHV"); }
int MotionHVMain::is_realtime() { return 1; }
int MotionHVMain::is_multichannel() { return 1; }
delete rotate_target_dst;
}
-const char* MotionMain::plugin_title() { return _("Motion"); }
+const char* MotionMain::plugin_title() { return N_("Motion"); }
int MotionMain::is_realtime() { return 1; }
int MotionMain::is_multichannel() { return 1; }
delete global_target_dst;
}
-const char* MotionMain2::plugin_title() { return _("Motion 2 Point"); }
+const char* MotionMain2::plugin_title() { return N_("Motion 2 Point"); }
int MotionMain2::is_realtime() { return 1; }
int MotionMain2::is_multichannel() { return 1; }
delete [] ypts;
}
-const char* Motion51Main::plugin_title() { return _("Motion51"); }
+const char* Motion51Main::plugin_title() { return N_("Motion51"); }
int Motion51Main::is_realtime() { return 1; }
int Motion51Main::is_multichannel() { return 1; }
if(temp) delete temp;
}
-const char* MotionBlurMain::plugin_title() { return _("Motion Blur"); }
+const char* MotionBlurMain::plugin_title() { return N_("Motion Blur"); }
int MotionBlurMain::is_realtime() { return 1; }
{
}
-const char* NormalizeMain::plugin_title() { return _("Normalize"); }
+const char* NormalizeMain::plugin_title() { return N_("Normalize"); }
int NormalizeMain::is_realtime() { return 0; }
int NormalizeMain::is_multichannel() { return 1; }
}
-const char* OilEffect::plugin_title() { return _("Oil painting"); }
+const char* OilEffect::plugin_title() { return N_("Oil painting"); }
int OilEffect::is_realtime() { return 1; }
}
-const char* Overlay::plugin_title() { return _("Overlay"); }
+const char* Overlay::plugin_title() { return N_("Overlay"); }
int Overlay::is_realtime() { return 1; }
int Overlay::is_multichannel() { return 1; }
int Overlay::is_synthesis() { return 1; }
}
-const char* OverlayAudio::plugin_title() { return _("Overlay"); }
+const char* OverlayAudio::plugin_title() { return N_("Overlay"); }
int OverlayAudio::is_realtime() { return 1; }
int OverlayAudio::is_multichannel() { return 1; }
LOAD_CONFIGURATION_MACRO(ParametricEQ, ParametricConfig)
-const char* ParametricEQ::plugin_title() { return _("EQ Parametric"); }
+const char* ParametricEQ::plugin_title() { return N_("EQ Parametric"); }
int ParametricEQ::is_realtime() { return 1; }
void ParametricEQ::read_data(KeyFrame *keyframe)
if(temp) delete temp;
}
-const char* PerspectiveMain::plugin_title() { return _("Perspective"); }
+const char* PerspectiveMain::plugin_title() { return N_("Perspective"); }
int PerspectiveMain::is_realtime() { return 1; }
if(engine) delete engine;
}
-const char* PhotoScaleMain::plugin_title() { return _("Auto Scale"); }
+const char* PhotoScaleMain::plugin_title() { return N_("Auto Scale"); }
int PhotoScaleMain::is_realtime() { return 1; }
}
-char* Piano::plugin_title() { return _("Pianoesizer"); }
+char* Piano::plugin_title() { return N_("Pianoesizer"); }
int Piano::is_realtime() { return 1; }
int Piano::is_synthesis() { return 1; }
int is_realtime();
int is_synthesis();
int load_configuration();
- char* plugin_title();
+ const char* plugin_title();
void read_data(KeyFrame *keyframe);
void save_data(KeyFrame *keyframe);
int show_gui();
if(fft) delete fft;
}
-const char* PitchEffect::plugin_title() { return _("Pitch shift"); }
+const char* PitchEffect::plugin_title() { return N_("Pitch shift"); }
int PitchEffect::is_realtime() { return 1; }
-const char* PolarEffect::plugin_title() { return _("Polar"); }
+const char* PolarEffect::plugin_title() { return N_("Polar"); }
int PolarEffect::is_realtime() { return 1; }
delete rotate;
}
-const char* RadialBlurMain::plugin_title() { return _("Radial Blur"); }
+const char* RadialBlurMain::plugin_title() { return N_("Radial Blur"); }
int RadialBlurMain::is_realtime() { return 1; }
{
}
-const char* ReFrame::plugin_title() { return _("Reframe"); }
+const char* ReFrame::plugin_title() { return N_("Reframe"); }
}
-const char* ReframeRT::plugin_title() { return _("ReframeRT"); }
+const char* ReframeRT::plugin_title() { return N_("ReframeRT"); }
int ReframeRT::is_realtime() { return 1; }
int ReframeRT::is_synthesis() { return 1; }
delete temp;
}
-const char* RemoveGaps::plugin_title() { return _("Remove Gaps"); }
+const char* RemoveGaps::plugin_title() { return N_("Remove Gaps"); }
int RemoveGaps::is_realtime() { return 1; }
NEW_WINDOW_MACRO(RemoveGaps, RemoveGapsWindow)
-const char* Reroute::plugin_title() { return _("Reroute"); }
+const char* Reroute::plugin_title() { return N_("Reroute"); }
int Reroute::is_realtime() { return 1; }
int Reroute::is_multichannel() { return 1; }
{
}
-const char* ResampleEffect::plugin_title() { return _("Resample"); }
+const char* ResampleEffect::plugin_title() { return N_("Resample"); }
void ResampleEffect::reset()
{
delete resample;
}
-const char* ResampleRT::plugin_title() { return _("ResampleRT"); }
+const char* ResampleRT::plugin_title() { return N_("ResampleRT"); }
int ResampleRT::is_realtime() { return 1; }
int ResampleRT::is_synthesis() { return 1; }
}
}
-const char* Reverb::plugin_title() { return _("Reverb"); }
+const char* Reverb::plugin_title() { return N_("Reverb"); }
int Reverb::is_realtime() { return 1; }
int Reverb::is_multichannel() { return 1; }
int Reverb::is_synthesis() { return 1; }
}
-const char* ReverseAudio::plugin_title() { return _("Reverse audio"); }
+const char* ReverseAudio::plugin_title() { return N_("Reverse audio"); }
int ReverseAudio::is_realtime() { return 1; }
}
-const char* ReverseVideo::plugin_title() { return _("Reverse video"); }
+const char* ReverseVideo::plugin_title() { return N_("Reverse video"); }
int ReverseVideo::is_realtime() { return 1; }
delete defaults;
}
-char* RGB601Main::plugin_title() { return _("Inverse Telecine"); }
+char* RGB601Main::plugin_title() { return "Inverse Telecine"; }
int RGB601Main::is_realtime() { return 1; }
int RGB601Main::load_defaults()
}
-const char* RGB601Main::plugin_title() { return _("RGB - 601"); }
+const char* RGB601Main::plugin_title() { return N_("RGB - 601"); }
int RGB601Main::is_realtime() { return 1; }
delete temp_frame;
}
-const char* RGBShiftEffect::plugin_title() { return _("RGBShift"); }
+const char* RGBShiftEffect::plugin_title() { return N_("RGBShift"); }
int RGBShiftEffect::is_realtime() { return 1; }
-const char* RotateEffect::plugin_title() { return _("Rotate"); }
+const char* RotateEffect::plugin_title() { return N_("Rotate"); }
int RotateEffect::is_realtime() { return 1; }
}
-const char* Rumbler::plugin_title() { return _("Rumbler"); }
+const char* Rumbler::plugin_title() { return N_("Rumbler"); }
int Rumbler::is_realtime() { return 1; }
NEW_WINDOW_MACRO(Rumbler, RumblerWindow)
if(overlayer) delete overlayer;
}
-const char* ScaleMain::plugin_title() { return _("Scale"); }
+const char* ScaleMain::plugin_title() { return N_("Scale"); }
int ScaleMain::is_realtime() { return 1; }
overlayer = 0;
}
-const char* ScaleRatioMain::plugin_title() { return _("Scale Ratio"); }
+const char* ScaleRatioMain::plugin_title() { return N_("Scale Ratio"); }
int ScaleRatioMain::is_realtime() { return 1; }
shape_titles.remove_all_objects();
}
-const char* ShapeWipeMain::plugin_title() { return _("Shape Wipe"); }
+const char* ShapeWipeMain::plugin_title() { return N_("Shape Wipe"); }
int ShapeWipeMain::is_transition() { return 1; }
int ShapeWipeMain::uses_gui() { return 1; }
LOAD_CONFIGURATION_MACRO(SharpenMain, SharpenConfig)
-const char* SharpenMain::plugin_title() { return _("Sharpen"); }
+const char* SharpenMain::plugin_title() { return N_("Sharpen"); }
int SharpenMain::is_realtime() { return 1; }
}
-const char* ShiftInterlaceMain::plugin_title() { return _("ShiftInterlace"); }
+const char* ShiftInterlaceMain::plugin_title() { return N_("ShiftInterlace"); }
int ShiftInterlaceMain::is_realtime() { return 1; }
}
-const char* SlideMain::plugin_title() { return _("Slide"); }
+const char* SlideMain::plugin_title() { return N_("Slide"); }
int SlideMain::is_video() { return 1; }
int SlideMain::is_transition() { return 1; }
int SlideMain::uses_gui() { return 1; }
}
-const char* Spectrogram::plugin_title() { return _("Spectrogram"); }
+const char* Spectrogram::plugin_title() { return N_("Spectrogram"); }
int Spectrogram::is_realtime() { return 1; }
int Spectrogram::process_buffer(int64_t size,
NEW_WINDOW_MACRO(Fuse360Main, Fuse360GUI)
LOAD_CONFIGURATION_MACRO(Fuse360Main, Fuse360Config)
int Fuse360Main::is_realtime() { return 1; }
-const char* Fuse360Main::plugin_title() { return N_("360 Fuser"); }
+const char* Fuse360Main::plugin_title() { return "360 Fuser"; }
void Fuse360Main::update_gui()
{
delete overlayer;
}
-const char* SvgMain::plugin_title() { return _("SVG via Inkscape"); }
+const char* SvgMain::plugin_title() { return N_("SVG via Inkscape"); }
int SvgMain::is_realtime() { return 1; }
int SvgMain::is_synthesis() { return 1; }
}
-const char* SwapMain::plugin_title() { return _("Swap channels"); }
+const char* SwapMain::plugin_title() { return N_("Swap channels"); }
int SwapMain::is_synthesis() { return 1; }
int SwapMain::is_realtime() { return 1; }
delete buffer;
}
-const char* SwapFrames::plugin_title() { return _("Swap Frames"); }
+const char* SwapFrames::plugin_title() { return N_("Swap Frames"); }
int SwapFrames::is_realtime() { return 1; }
NEW_WINDOW_MACRO(SwapFrames, SwapFramesWindow)
NEW_WINDOW_MACRO(Synth, SynthWindow);
-const char* Synth::plugin_title() { return _("Synthesizer"); }
+const char* Synth::plugin_title() { return N_("Synthesizer"); }
int Synth::is_realtime() { return 1; }
int Synth::is_synthesis() { return 1; }
{
}
-const char* BlondThemeMain::plugin_title()
-{
- return _("Blond");
-}
+const char* BlondThemeMain::plugin_title() { return N_("Blond"); }
Theme* BlondThemeMain::new_theme()
{
{
}
-const char* BlondCVThemeMain::plugin_title()
-{
- return _("Blond-cv");
-}
+const char* BlondCVThemeMain::plugin_title() { return N_("Blond-cv"); }
Theme* BlondCVThemeMain::new_theme()
{
{
}
-const char* BlondThemeMain::plugin_title()
-{
- return _("Blond-cv");
-}
+const char* BlondThemeMain::plugin_title() { return "Blond-cv"; }
Theme* BlondThemeMain::new_theme()
{
{
}
-const char* BlueDotThemeMain::plugin_title()
-{
- return _("Blue");
-}
+const char* BlueDotThemeMain::plugin_title() { return N_("Blue"); }
Theme* BlueDotThemeMain::new_theme()
{
{
}
-const char* BlueDotThemeMain::plugin_title()
-{
- return _("Blue Dot");
-}
+const char* BlueDotThemeMain::plugin_title() { return N_("Blue Dot"); }
Theme* BlueDotThemeMain::new_theme()
{
{
}
-const char* BrightThemeMain::plugin_title()
-{
- return _("Bright");
-}
+const char* BrightThemeMain::plugin_title() { return N_("Bright"); }
Theme* BrightThemeMain::new_theme()
{
{
}
-const char* HULKTHEMEMain::plugin_title()
-{
- return _("Hulk");
-}
+const char* HULKTHEMEMain::plugin_title() { return N_("Hulk"); }
Theme* HULKTHEMEMain::new_theme()
{
{
}
-const char* PINKLADYMain::plugin_title()
-{
- return _("PinkLady");
-}
+const char* PINKLADYMain::plugin_title() { return N_("PinkLady"); }
Theme* PINKLADYMain::new_theme()
{
SUVMain::~SUVMain()
{
}
-
-const char* SUVMain::plugin_title()
-{
- return _("S.U.V.");
-}
+const char* SUVMain::plugin_title() { return N_("S.U.V."); }
Theme* SUVMain::new_theme()
{
{
}
-const char* UNFLATTHEMEMain::plugin_title()
-{
- return _("UnFlat");
-}
+const char* UNFLATTHEMEMain::plugin_title() { return N_("UnFlat"); }
Theme* UNFLATTHEMEMain::new_theme()
{
delete threshold_engine;
}
-const char* ThresholdMain::plugin_title() { return _("Threshold"); }
+const char* ThresholdMain::plugin_title() { return N_("Threshold"); }
int ThresholdMain::is_realtime() { return 1; }
if(history_valid) delete [] history_valid;
}
-const char* TimeAvgMain::plugin_title() { return _("Time Average"); }
+const char* TimeAvgMain::plugin_title() { return N_("Time Average"); }
int TimeAvgMain::is_realtime() { return 1; }
if(overlayer) delete overlayer;
}
-const char* TimeFrontMain::plugin_title() { return _("TimeFront"); }
+const char* TimeFrontMain::plugin_title() { return N_("TimeFront"); }
int TimeFrontMain::is_realtime() { return 1; }
int TimeFrontMain::is_multichannel() { return 1; }
-const char* TimeStretch::plugin_title() { return _("Time stretch"); }
+const char* TimeStretch::plugin_title() { return N_("Time stretch"); }
int TimeStretch::get_parameters()
{
delete engine;
}
-const char* TimeStretchRT::plugin_title() { return _("Time Stretch RT"); }
+const char* TimeStretchRT::plugin_title() { return N_("Time Stretch RT"); }
int TimeStretchRT::is_realtime() { return 1; }
int TimeStretchRT::is_synthesis() { return 1; }
delete outline_engine;
}
-const char* TitleMain::plugin_title() { return C_("Title"); }
+const char* TitleMain::plugin_title() { return N_("Title"); }
int TitleMain::is_realtime() { return 1; }
int TitleMain::is_synthesis() { return 1; }
overlayer = 0;
}
-const char* TranslateMain::plugin_title() { return _("Translate"); }
+const char* TranslateMain::plugin_title() { return N_("Translate"); }
int TranslateMain::is_realtime() { return 1; }
delete engine;
}
-const char* UnsharpMain::plugin_title() { return _("Unsharp"); }
+const char* UnsharpMain::plugin_title() { return N_("Unsharp"); }
int UnsharpMain::is_realtime() { return 1; }
-const char* VideoScopeEffect::plugin_title() { return _("VideoScope"); }
+const char* VideoScopeEffect::plugin_title() { return N_("VideoScope"); }
int VideoScopeEffect::is_realtime() { return 1; }
int VideoScopeEffect::load_configuration()
LOAD_CONFIGURATION_MACRO(Vocoder, VocoderConfig)
-const char* Vocoder::plugin_title() { return _("Vocoder"); }
+const char* Vocoder::plugin_title() { return N_("Vocoder"); }
int Vocoder::is_realtime() { return 1; }
int Vocoder::is_multichannel() { return 1; }
}
-const char* WaveEffect::plugin_title() { return _("Wave"); }
+const char* WaveEffect::plugin_title() { return N_("Wave"); }
int WaveEffect::is_realtime() { return 1; }
-const char* WhirlEffect::plugin_title() { return _("Whirl"); }
+const char* WhirlEffect::plugin_title() { return N_("Whirl"); }
int WhirlEffect::is_realtime() { return 1; }
int process_realtime(long size, VFrame **input_ptr, VFrame **output_ptr);
int plugin_is_realtime();
int plugin_is_multi_channel();
- char* plugin_title();
+ const char* plugin_title();
int start_realtime();
int stop_realtime();
PluginClientWindow* new_window();
}
-const char* WipeMain::plugin_title() { return _("Wipe"); }
+const char* WipeMain::plugin_title() { return N_("Wipe"); }
int WipeMain::is_video() { return 1; }
int WipeMain::is_transition() { return 1; }
int WipeMain::uses_gui() { return 1; }
}
-const char* YUVEffect::plugin_title() { return _("YUV"); }
+const char* YUVEffect::plugin_title() { return N_("YUV"); }
int YUVEffect::is_realtime() { return 1; }
delete temp_frame;
}
-const char *yuv411Main::plugin_title() { return _("YUV411"); }
+const char *yuv411Main::plugin_title() { return N_("YUV411"); }
int yuv411Main::is_realtime() { return 1; }
#define YUV411_MACRO(type, components) \
delete temp_frame;
}
-const char* YUVShiftEffect::plugin_title() { return _("YUVShift"); }
+const char* YUVShiftEffect::plugin_title() { return N_("YUVShift"); }
int YUVShiftEffect::is_realtime() { return 1; }
delete temp;
}
-const char* ZoomMain::plugin_title() { return _("Zoom"); }
+const char* ZoomMain::plugin_title() { return N_("Zoom"); }
int ZoomMain::is_video() { return 1; }
int ZoomMain::is_transition() { return 1; }
int ZoomMain::uses_gui() { return 1; }
if(temp) delete temp;
}
-const char* ZoomBlurMain::plugin_title() { return _("Zoom Blur"); }
+const char* ZoomBlurMain::plugin_title() { return N_("Zoom Blur"); }
int ZoomBlurMain::is_realtime() { return 1; }
projects / goodguy / history.git / commitdiff