#include "file.h"
#include "filesystem.h"
#include "filexml.h"
+#include "indexable.h"
#include "keyframe.h"
#include "keys.h"
#include "labels.h"
#include "transportque.h"
#include "vframe.h"
-// Farmed is not present if not preferences->use_renderfarm
+#include "dvdcreate.h"
+#include "bdcreate.h"
+
int BatchRenderThread::column_widths[] = { 42, 42, 42, 222, 222, 150 };
const char *BatchRenderThread::column_titles[] = {
N_("Enabled"), N_("Labeled"), N_("Farmed"), N_("Output"), N_("EDL"), N_("Elapsed")
int BatchRenderMenuItem::handle_event()
{
- mwindow->batch_render->start();
+ mwindow->batch_render->start(1, 1);
return 1;
}
-
-BatchRenderJob::BatchRenderJob(Preferences *preferences, int labeled, int farmed)
+BatchRenderJob::BatchRenderJob(const char *tag,
+ Preferences *preferences, int labeled, int farmed)
{
+ this->tag = tag;
this->preferences = preferences;
this->labeled = labeled;
this->farmed = farmed >= 0 ? farmed : preferences->use_renderfarm;
elapsed = 0;
}
+BatchRenderJob::BatchRenderJob(Preferences *preferences, int labeled, int farmed)
+ : BatchRenderJob("JOB", preferences, labeled, farmed)
+{
+}
+
BatchRenderJob::~BatchRenderJob()
{
asset->Garbage::remove_user();
elapsed = 0;
}
+BatchRenderJob *BatchRenderJob::copy()
+{
+ BatchRenderJob *t = new BatchRenderJob(tag, preferences, labeled, farmed);
+ t->copy_from(this);
+ return t;
+}
+
void BatchRenderJob::load(FileXML *file)
{
int result = 0;
enabled = file->tag.get_property("ENABLED", enabled);
farmed = file->tag.get_property("FARMED", farmed);
- labeled = file->tag.get_property("STRATEGY", labeled);
+ labeled = file->tag.get_property("LABELED", labeled);
edl_path[0] = 0;
file->tag.get_property("EDL_PATH", edl_path);
elapsed = file->tag.get_property("ELAPSED", elapsed);
void BatchRenderJob::save(FileXML *file)
{
+ char end_tag[BCSTRLEN]; end_tag[0] = '/';
+ strcpy(&end_tag[1], file->tag.get_title());
file->tag.set_property("ENABLED", enabled);
file->tag.set_property("FARMED", farmed);
file->tag.set_property("LABELED", labeled);
defaults.save_string(string);
file->append_text(string);
free(string);
- file->tag.set_title("/JOB");
+ file->tag.set_title(end_tag);
file->append_tag();
file->append_newline();
}
+char *BatchRenderJob::create_script(EDL *edl, ArrayList<Indexable *> *idxbls)
+{
+ return 0;
+}
+
int BatchRenderJob::get_strategy()
{
-// if set, overrides farmed, labeled
- int use_renderfarm = farmed && preferences->use_renderfarm ? 1 : 0;
- return Render::get_strategy(use_renderfarm, labeled);
+ return Render::get_strategy(farmed, labeled);
}
warn = 1;
render = 0;
batch_path[0] = 0;
-}
-
-BatchRenderThread::BatchRenderThread()
- : BC_DialogThread()
-{
- mwindow = 0;
- current_job = 0;
- rendering_job = -1;
- is_rendering = 0;
- default_job = 0;
- boot_defaults = 0;
- preferences = 0;
- warn = 1;
- render = 0;
- batch_path[0] = 0;
+ do_farmed = 0;
+ do_labeled = 0;
}
BatchRenderThread::~BatchRenderThread()
close_window();
delete boot_defaults;
delete preferences;
+ delete default_job;
delete render;
}
jobs.remove_all_objects();
}
+void BatchRenderThread::start(int do_farmed, int do_labeled)
+{
+ this->do_farmed = do_farmed;
+ this->do_labeled = do_labeled;
+ BC_DialogThread::start();
+}
+
void BatchRenderThread::handle_close_event(int result)
{
// Save settings
{
current_start = 0.0;
current_end = 0.0;
- default_job = new BatchRenderJob(mwindow->preferences);
+ default_job = new BatchRenderJob(mwindow->preferences, 0, -1);
load_jobs(batch_path, mwindow->preferences);
load_defaults(mwindow->defaults);
this->gui = new BatchRenderGUI(mwindow, this,
warn = file.tag.get_property("WARN", 1);
}
else if( file.tag.title_is("JOB") ) {
- BatchRenderJob *job = new BatchRenderJob(preferences);
+ BatchRenderJob *job = new BatchRenderJob(preferences, 0,0);
+ jobs.append(job);
+ job->load(&file);
+ }
+ else if( file.tag.title_is("DVD_JOB") ) {
+ DVD_BatchRenderJob *job = new DVD_BatchRenderJob(preferences, 0,0,0,0);
+ jobs.append(job);
+ job->load(&file);
+ }
+ else if( file.tag.title_is("BD_JOB") ) {
+ BD_BatchRenderJob *job = new BD_BatchRenderJob(preferences, 0,0);
jobs.append(job);
job->load(&file);
}
file.append_newline();
for( int i = 0; i < jobs.total; i++ ) {
- file.tag.set_title("JOB");
- jobs.values[i]->save(&file);
+ file.tag.set_title(jobs[i]->tag);
+ jobs[i]->save(&file);
}
file.tag.set_title("/JOBS");
file.append_tag();
void BatchRenderThread::new_job()
{
- BatchRenderJob *result = new BatchRenderJob(mwindow->preferences);
- result->copy_from(get_current_job());
+ BatchRenderJob *result = get_current_job()->copy();
jobs.append(result);
current_job = jobs.total - 1;
gui->create_list(1);
command->playback_range_adjust_inout();
// Create test packages
- packages->create_packages(mwindow,
- command->get_edl(),
- preferences,
- job->get_strategy(),
- job->asset,
- command->start_position,
- command->end_position,
- 0);
+ packages->create_packages(mwindow, command->get_edl(),
+ preferences, job->get_strategy(), job->asset,
+ command->start_position, command->end_position, 0);
// Append output paths allocated to total
packages->get_package_paths(paths);
int x = mwindow->theme->batchrender_x1;
int y = 5;
- int x1 = x, x2 = get_w()/2 + 10; // mwindow->theme->batchrender_x2;
+ int x1 = x, x2 = get_w()/2 + 30; // mwindow->theme->batchrender_x2;
int y1 = 5, y2 = 5;
// output file
y1 += output_path_title->get_h() + mwindow->theme->widget_border;
format_tools = new BatchFormat(mwindow, this, thread->get_current_asset());
- format_tools->set_w(get_w() / 2);
+ format_tools->set_w(x2 - 40);
BatchRenderJob *current_job = thread->get_current_job();
format_tools->create_objects(x1, y1, 1, 1, 1, 1, 0, 1, 0, 0,
- ¤t_job->labeled, 0);
- if( mwindow->preferences->use_renderfarm ) {
+ thread->do_labeled ? ¤t_job->labeled : 0, 0);
+ if( thread->do_labeled < 0 )
+ format_tools->labeled_files->disable();
+ if( thread->do_farmed ) {
use_renderfarm = new BatchRenderUseFarm(thread, x1, y1,
¤t_job->farmed);
add_subwindow(use_renderfarm);
y1 += use_renderfarm->get_h() + 10;
+ if( thread->do_farmed < 0 )
+ use_renderfarm->disable();
}
+
// input EDL
add_subwindow(edl_path_title = new BC_Title(x2, y2, _("EDL Path:")));
y2 += edl_path_title->get_h() + mwindow->theme->widget_border;
output_path_title->reposition_window(x1, y1);
y1 += output_path_title->get_h() + mwindow->theme->widget_border;
format_tools->reposition_window(x1, y1);
- if( use_renderfarm )
+ if( thread->do_farmed )
use_renderfarm->reposition_window(x1, y1);
// input EDL
x = x2, y = y2;
list_columns = 0;
list_titles[list_columns] = _(column_titles[ENABLED_COL]);
list_width[list_columns++] = thread->list_width[ENABLED_COL];
- list_titles[list_columns] = _(column_titles[LABELED_COL]);
- list_width[list_columns++] = thread->list_width[LABELED_COL];
- if( mwindow->preferences->use_renderfarm ) {
+ if( thread->do_labeled > 0 ) {
+ list_titles[list_columns] = _(column_titles[LABELED_COL]);
+ list_width[list_columns++] = thread->list_width[LABELED_COL];
+ }
+ if( thread->do_farmed > 0 ) {
list_titles[list_columns] = _(column_titles[FARMED_COL]);
list_width[list_columns++] = thread->list_width[FARMED_COL];
}
BatchRenderJob *job = thread->jobs.values[i];
char string[BCTEXTLEN];
BC_ListBoxItem *enabled = new BC_ListBoxItem(job->enabled ? "X" : " ");
- BC_ListBoxItem *labeled = new BC_ListBoxItem(job->labeled ? "X" : " ");
- BC_ListBoxItem *farmed = !mwindow->preferences->use_renderfarm ? 0 :
- new BC_ListBoxItem(job->farmed ? "X" : " ");
+ BC_ListBoxItem *labeled = thread->do_labeled > 0 ?
+ new BC_ListBoxItem(job->labeled ? "X" : " ") : 0;
+ BC_ListBoxItem *farmed = thread->do_farmed > 0 ?
+ new BC_ListBoxItem(job->farmed ? "X" : " ") : 0;
BC_ListBoxItem *out_path = new BC_ListBoxItem(job->asset->path);
BC_ListBoxItem *edl_path = new BC_ListBoxItem(job->edl_path);
BC_ListBoxItem *elapsed = new BC_ListBoxItem(!job->elapsed ? _("Unknown") :
Units::totext(string, job->elapsed, TIME_HMS2));
int col = 0;
list_items[col++].append(enabled);
- list_items[col++].append(labeled);
+ if( labeled ) list_items[col++].append(labeled);
if( farmed ) list_items[col++].append(farmed);
list_items[col++].append(out_path);
list_items[col++].append(edl_path);
list_items[col].append(elapsed);
if( i == thread->current_job ) {
enabled->set_selected(1);
- labeled->set_selected(1);
+ if( labeled ) labeled->set_selected(1);
if( farmed ) farmed->set_selected(1);
out_path->set_selected(1);
edl_path->set_selected(1);
}
if( i == thread->rendering_job ) {
enabled->set_color(RED);
- labeled->set_color(RED);
+ if( labeled ) labeled->set_color(RED);
if( farmed ) farmed->set_color(RED);
out_path->set_color(RED);
edl_path->set_color(RED);
void BatchRenderGUI::change_job()
{
BatchRenderJob *job = thread->get_current_job();
- format_tools->update(job->asset, &job->labeled);
- if( use_renderfarm ) use_renderfarm->update(&job->farmed);
+ format_tools->update(job->asset, thread->do_labeled ? &job->labeled : 0);
+ if( thread->do_farmed ) use_renderfarm->update(&job->farmed);
edl_path_text->update(job->edl_path);
}
int col_x = 0, changed = 1;
if( cursor_x < (col_x += thread->list_width[ENABLED_COL]) )
job->enabled = !job->enabled;
- else if( cursor_x < (col_x += thread->list_width[LABELED_COL]) )
+ else if( thread->do_labeled > 0 &&
+ cursor_x < (col_x += thread->list_width[LABELED_COL]) )
job->labeled = job->edl_path[0] != '@' ? !job->labeled : 0;
- else if( thread->gui->use_renderfarm &&
+ else if( thread->do_farmed > 0 &&
cursor_x < (col_x += thread->list_width[FARMED_COL]) )
job->farmed = job->edl_path[0] != '@' ? !job->farmed : 0;
else
{
int col = 0;
thread->list_width[ENABLED_COL] = get_column_width(col++);
- thread->list_width[LABELED_COL] = get_column_width(col++);
- if( thread->gui->use_renderfarm )
+ if( thread->do_labeled > 0 )
+ thread->list_width[LABELED_COL] = get_column_width(col++);
+ if( thread->do_farmed > 0 )
thread->list_width[FARMED_COL] = get_column_width(col++);
thread->list_width[OUTPUT_COL] = get_column_width(col++);
thread->list_width[EDL_COL] = get_column_width(col++);
#include "browsebutton.inc"
#include "filexml.inc"
#include "formattools.h"
+#include "indexable.inc"
#include "keyframe.inc"
#include "mwindow.inc"
#include "preferences.inc"
class BatchRenderJob
{
public:
- BatchRenderJob(Preferences *preferences, int labeled=0, int farmed=-1);
- ~BatchRenderJob();
-
+ BatchRenderJob(const char *tag,
+ Preferences *preferences, int labeled, int farmed);
+ BatchRenderJob(Preferences *preferences, int labeled, int farmed);
+ BatchRenderJob(const char *tag);
+ virtual ~BatchRenderJob();
+ virtual BatchRenderJob *copy();
+ virtual void load(FileXML *file);
+ virtual void save(FileXML *file);
+ virtual int get_strategy();
+ virtual char *create_script(EDL *edl, ArrayList<Indexable *> *idxbls);
void copy_from(BatchRenderJob *src);
- void load(FileXML *file);
- void save(FileXML *file);
- int get_strategy();
+ const char *tag;
// Source EDL to render
char edl_path[BCTEXTLEN];
// Destination file for output
class BatchRenderThread : public BC_DialogThread
{
public:
- BatchRenderThread(MWindow *mwindow);
- BatchRenderThread();
+ BatchRenderThread(MWindow *mwindow=0);
~BatchRenderThread();
void handle_close_event(int result);
BC_Window* new_gui();
void update_active(int number);
void update_done(int number, int create_list, double elapsed_time);
void move_batch(int src, int dst);
+ void start(int do_farmed, int do_labeled);
static void trap_hook(FILE *fp, void *vp);
MWindow *mwindow;
static const char *column_titles[BATCHRENDER_COLUMNS];
static int column_widths[BATCHRENDER_COLUMNS];
int list_width[BATCHRENDER_COLUMNS];
+ int do_farmed;
+ int do_labeled;
// job being edited
int current_job;
// job being rendered
#include "filexml.h"
#include "interlacemodes.h"
#include "keyframe.h"
-#include "labels.h"
#include "mainerror.h"
#include "mainundo.h"
#include "mwindow.h"
return 1;
}
-
-CreateBD_Thread::CreateBD_Thread(MWindow *mwindow)
- : BC_DialogThread()
+BD_BatchRenderJob::BD_BatchRenderJob(Preferences *preferences, int labeled, int farmed)
+ : BatchRenderJob("BD_JOB", preferences, labeled, farmed)
{
- this->mwindow = mwindow;
- this->gui = 0;
- this->use_deinterlace = 0;
- this->use_scale = Rescale::none;
- this->use_histogram = 0;
- this->use_inverse_telecine = 0;
- this->use_wide_audio = 0;
- this->use_resize_tracks = 0;
- this->use_label_chapters = 0;
-
- this->bd_size = BD_SIZE;
- this->bd_width = BD_WIDTH;
- this->bd_height = BD_HEIGHT;
- this->bd_aspect_width = BD_WIDE_ASPECT_WIDTH;
- this->bd_aspect_height = BD_WIDE_ASPECT_HEIGHT;
- this->bd_framerate = BD_FRAMERATE;
- this->bd_samplerate = BD_SAMPLERATE;
- this->bd_max_bitrate = BD_MAX_BITRATE;
- this->bd_kaudio_rate = BD_KAUDIO_RATE;
- this->max_w = this->max_h = 0;
}
-CreateBD_Thread::~CreateBD_Thread()
-{
- close_window();
-}
-
-int CreateBD_Thread::get_udfs_mount(char *udfs, char *mopts, char *mntpt)
+int BD_BatchRenderJob::get_udfs_mount(char *udfs, char *mopts, char *mntpt)
{
int ret = 0;
-// default: mount -t udf -o loop $1/bd.udfs $1/udfs
- strcpy(udfs,"$1/bd.udfs");
- strcpy(mopts,"-t udf -o loop $1/bd.udfs ");
- strcpy(mntpt,"$1/udfs");
+// default: mount -t udf -o loop $dir/bd.udfs $dir/udfs
+ strcpy(udfs,"$dir/bd.udfs");
+ strcpy(mopts,"-t udf -o loop $dir/bd.udfs ");
+ strcpy(mntpt,"$dir/udfs");
const char *home = getenv("HOME");
if( !home ) return ret;
FILE *fp = fopen("/etc/fstab","r");
return ret;
}
+char *BD_BatchRenderJob::create_script(EDL *edl, ArrayList<Indexable *> *idxbls)
+{
+ char script[BCTEXTLEN];
+ strcpy(script, edl_path);
+ FILE *fp = 0;
+ char *bp = strrchr(script,'/');
+ int fd = -1;
+ if( bp ) {
+ strcpy(bp, "/bd.sh");
+ fd = open(script, O_WRONLY+O_CREAT+O_TRUNC, 0755);
+ }
+ if( fd >= 0 )
+ fp = fdopen(fd, "w");
+ if( !fp ) {
+ char err[BCTEXTLEN], msg[BCTEXTLEN];
+ strerror_r(errno, err, sizeof(err));
+ sprintf(msg, _("Unable to save: %s\n-- %s"), script, err);
+ MainError::show_error(msg);
+ return 0;
+ }
+ char udfs[BCTEXTLEN], mopts[BCTEXTLEN], mntpt[BCTEXTLEN];
+ int is_usr_mnt = get_udfs_mount(udfs, mopts, mntpt);
+ const char *exec_path = File::get_cinlib_path();
+ fprintf(fp,"#!/bin/bash -ex\n");
+ fprintf(fp,"dir=`dirname $0`\n");
+ fprintf(fp,"PATH=$PATH:%s\n",exec_path);
+ fprintf(fp,"mkdir -p $dir/udfs\n");
+ fprintf(fp,"sz=`du -cb $dir/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 -b 2048 %s $blks\n", udfs);
+ fprintf(fp,"mount %s%s\n", mopts, mntpt);
+ fprintf(fp,"bdwrite %s $dir/bd.m2ts*\n",mntpt);
+ fprintf(fp,"umount %s\n",mntpt);
+ if( is_usr_mnt )
+ fprintf(fp,"mv -f %s $dir/bd.udfs\n", udfs);
+ fprintf(fp,"echo To burn bluray, load writable media and run:\n");
+ fprintf(fp,"echo for WORM: growisofs -dvd-compat -Z /dev/bd=$dir/bd.udfs\n");
+ fprintf(fp,"echo for RW: dd if=$dir/bd.udfs of=/dev/bd bs=2048000\n");
+ fprintf(fp,"kill $$\n");
+ fprintf(fp,"\n");
+ fclose(fp);
+ return cstrdup(script);
+}
+
+
+CreateBD_Thread::CreateBD_Thread(MWindow *mwindow)
+ : BC_DialogThread()
+{
+ this->mwindow = mwindow;
+ this->gui = 0;
+ this->use_deinterlace = 0;
+ this->use_scale = Rescale::none;
+ this->use_histogram = 0;
+ this->use_inverse_telecine = 0;
+ this->use_wide_audio = 0;
+ this->use_resize_tracks = 0;
+ this->use_labeled = 0;
+ this->use_farmed = 0;
+
+ this->bd_size = BD_SIZE;
+ this->bd_width = BD_WIDTH;
+ this->bd_height = BD_HEIGHT;
+ this->bd_aspect_width = BD_WIDE_ASPECT_WIDTH;
+ this->bd_aspect_height = BD_WIDE_ASPECT_HEIGHT;
+ this->bd_framerate = BD_FRAMERATE;
+ this->bd_samplerate = BD_SAMPLERATE;
+ this->bd_max_bitrate = BD_MAX_BITRATE;
+ this->bd_kaudio_rate = BD_KAUDIO_RATE;
+ this->max_w = this->max_h = 0;
+}
+
+CreateBD_Thread::~CreateBD_Thread()
+{
+ close_window();
+}
+
int CreateBD_Thread::create_bd_jobs(ArrayList<BatchRenderJob*> *jobs, const char *asset_dir)
{
EDL *edl = mwindow->edl;
use_wide_audio ? BD_WIDE_CHANNELS : BD_CHANNELS;
session->interlace_mode = bd_interlace_mode;
- char script_filename[BCTEXTLEN];
- sprintf(script_filename, "%s/bd.sh", asset_dir);
- int fd = open(script_filename, O_WRONLY+O_CREAT+O_TRUNC, 0755);
- FILE *fp = fdopen(fd, "w");
- if( !fp ) {
- char err[BCTEXTLEN], msg[BCTEXTLEN];
- strerror_r(errno, err, sizeof(err));
- sprintf(msg, _("Unable to save: %s\n-- %s"), script_filename, err);
- MainError::show_error(msg);
- return 1;
- }
- char udfs[BCTEXTLEN], mopts[BCTEXTLEN], mntpt[BCTEXTLEN];
- int is_usr_mnt = get_udfs_mount(udfs, mopts, mntpt);
- const char *exec_path = File::get_cinlib_path();
- 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 -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 -b 2048 %s $blks\n", udfs);
- fprintf(fp,"mount %s%s\n", mopts, 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);
- fprintf(fp,"echo To burn bluray, load writable media and run:\n");
- fprintf(fp,"echo for WORM: growisofs -dvd-compat -Z /dev/bd=$1/bd.udfs\n");
- fprintf(fp,"echo for RW: dd if=$1/bd.udfs of=/dev/bd bs=2048000\n");
- fprintf(fp,"kill $$\n");
- fprintf(fp,"\n");
- fclose(fp);
-
session->audio_channels = session->audio_tracks =
!use_wide_audio ? BD_CHANNELS : BD_WIDE_CHANNELS;
for( int i=0; i<MAX_CHANNELS; ++i )
return 1;
}
- BatchRenderJob *job = new BatchRenderJob(mwindow->preferences, use_label_chapters);
+ BatchRenderJob *job = new BD_BatchRenderJob(mwindow->preferences,
+ use_labeled, use_farmed);
jobs->append(job);
strcpy(&job->edl_path[0], xml_filename);
Asset *asset = job->asset;
}
asset->ff_video_bitrate = vid_bitrate;
asset->ff_video_quality = -1;
-
- job = new BatchRenderJob(mwindow->preferences, 0, 0);
- jobs->append(job);
- job->edl_path[0] = '@';
- strcpy(&job->edl_path[1], script_filename);
- strcpy(&job->asset->path[0], asset_dir);
-
return 0;
}
mwindow->resync_guis();
if( ret ) return;
mwindow->batch_render->save_jobs();
- mwindow->batch_render->start();
+ mwindow->batch_render->start(-use_farmed, -use_labeled);
}
BC_Window* CreateBD_Thread::new_gui()
use_inverse_telecine = 0;
use_wide_audio = 0;
use_resize_tracks = 0;
- use_label_chapters = 0;
+ use_labeled = 0;
+ use_farmed = 0;
use_standard = !strcmp(mwindow->default_std(),"NTSC") ?
BD_1920x1080_2997i : BD_1920x1080_25i;
bd_size = BD_SIZE;
int scr_x = mwindow->gui->get_screen_x(0, -1);
int scr_w = mwindow->gui->get_screen_w(0, -1);
int scr_h = mwindow->gui->get_screen_h(0, -1);
- int w = 500, h = 280;
+ int w = 500, h = 290;
int x = scr_x + scr_w/2 - w/2, y = scr_h/2 - h/2;
gui = new CreateBD_GUI(this, x, y, w, h);
}
CreateBD_LabelChapters::CreateBD_LabelChapters(CreateBD_GUI *gui, int x, int y)
- : BC_CheckBox(x, y, &gui->thread->use_label_chapters, _("Chapters at Labels"))
+ : BC_CheckBox(x, y, &gui->thread->use_labeled, _("Chapters at Labels"))
{
this->gui = gui;
}
{
}
+CreateBD_UseRenderFarm::CreateBD_UseRenderFarm(CreateBD_GUI *gui, int x, int y)
+ : BC_CheckBox(x, y, &gui->thread->use_farmed, _("Use render farm"))
+{
+ this->gui = gui;
+}
+
+CreateBD_UseRenderFarm::~CreateBD_UseRenderFarm()
+{
+}
+
+
CreateBD_WideAudio::CreateBD_WideAudio(CreateBD_GUI *gui, int x, int y)
: BC_CheckBox(x, y, &gui->thread->use_wide_audio, _("Audio 5.1"))
{
need_histogram = 0;
non_standard = 0;
need_wide_audio = 0;
- need_label_chapters = 0;
+ need_labeled = 0;
+ need_farmed = 0;
ok = 0;
cancel = 0;
}
add_subwindow(scale);
scale->create_objects();
y += standard->get_h() + pady/2;
- need_deinterlace = new CreateBD_Deinterlace(this, x, y);
+ x1 = x; int y1 = y;
+ need_deinterlace = new CreateBD_Deinterlace(this, x1, y);
add_subwindow(need_deinterlace);
- x1 = x + 170; //, x2 = x1 + 150;
- need_inverse_telecine = new CreateBD_InverseTelecine(this, x1, y);
- add_subwindow(need_inverse_telecine);
y += need_deinterlace->get_h() + pady/2;
- need_histogram = new CreateBD_Histogram(this, x, y);
+ need_histogram = new CreateBD_Histogram(this, x1, y);
add_subwindow(need_histogram);
- need_wide_audio = new CreateBD_WideAudio(this, x1, y);
- add_subwindow(need_wide_audio);
y += need_histogram->get_h() + pady/2;
- non_standard = new BC_Title(x, y+5, "", MEDIUMFONT, RED);
+ non_standard = new BC_Title(x1, y+5, "", MEDIUMFONT, RED);
add_subwindow(non_standard);
+ x1 += 160; y = y1;
+ need_inverse_telecine = new CreateBD_InverseTelecine(this, x1, y);
+ add_subwindow(need_inverse_telecine);
+ y += need_inverse_telecine->get_h() + pady/2;
+ need_wide_audio = new CreateBD_WideAudio(this, x1, y);
+ add_subwindow(need_wide_audio);
+ y += need_wide_audio->get_h() + pady/2;
need_resize_tracks = new CreateBD_ResizeTracks(this, x1, y);
add_subwindow(need_resize_tracks);
-// need_label_chapters = new CreateBD_LabelChapters(this, x2, y);
-// add_subwindow(need_label_chapters);
+ x1 += 160; y = y1;
+ need_labeled = new CreateBD_LabelChapters(this, x1, y);
+ add_subwindow(need_labeled);
+ y += need_labeled->get_h() + pady/2;
+ need_farmed = new CreateBD_UseRenderFarm(this, x1, y);
+ add_subwindow(need_farmed);
ok_w = BC_OKButton::calculate_w();
ok_h = BC_OKButton::calculate_h();
ok_x = 10;
need_resize_tracks->set_value(thread->use_resize_tracks);
need_histogram->set_value(thread->use_histogram);
need_wide_audio->set_value(thread->use_wide_audio);
-// need_label_chapters->set_value(thread->use_label_chapters);
+ need_labeled->set_value(thread->use_labeled);
+ need_farmed->set_value(thread->use_farmed);
}
int CreateBD_Thread::
use_scale = Rescale::none;
use_resize_tracks = 0;
use_wide_audio = 0;
- use_label_chapters = 0;
+ use_labeled = 0;
+ use_farmed = 0;
if( !mwindow->edl ) return 1;
}
}
if( !has_deinterlace && max_h > 2*bd_height ) use_deinterlace = 1;
- // Labels *labels = mwindow->edl->labels;
- // use_label_chapters = labels && labels->first ? 1 : 0;
if( tracks->recordable_audio_tracks() == BD_WIDE_CHANNELS )
use_wide_audio = 1;
MWindow *mwindow;
};
+class BD_BatchRenderJob : public BatchRenderJob
+{
+public:
+ static int get_udfs_mount(char *udfs, char *mopts, char *mntpt);
+ BD_BatchRenderJob(Preferences *preferences, int labeled, int farmed);
+ char *create_script(EDL *edl, ArrayList<Indexable *> *idxbls);
+};
+
class CreateBD_Thread : public BC_DialogThread
{
static const int BD_MAX_BITRATE, BD_CHANNELS, BD_WIDE_CHANNELS;
static const double BD_FRAMERATE, BD_SAMPLERATE, BD_KAUDIO_RATE;
static const int BD_INTERLACE_MODE;
- static int get_udfs_mount(char *udfs, char *mopts, char *mntpt);
public:
CreateBD_Thread(MWindow *mwindow);
~CreateBD_Thread();
void handle_close_event(int result);
BC_Window* new_gui();
int option_presets();
+ int create_bd_script(const char *path, EDL *edl);
int create_bd_jobs(ArrayList<BatchRenderJob*> *jobs, const char *asset_dir);
int insert_video_plugin(const char *title, KeyFrame *default_keyframe);
int resize_tracks();
char tmp_path[BCTEXTLEN];
int use_deinterlace, use_inverse_telecine;
int use_scale, use_resize_tracks;
- int use_wide_audio;
- int use_histogram, use_label_chapters;
+ int use_wide_audio, use_farmed;
+ int use_histogram, use_labeled;
int use_standard;
int64_t bd_size;
CreateBD_GUI *gui;
};
+class CreateBD_UseRenderFarm : public BC_CheckBox
+{
+public:
+ CreateBD_UseRenderFarm(CreateBD_GUI *gui, int x, int y);
+ ~CreateBD_UseRenderFarm();
+
+ CreateBD_GUI *gui;
+};
+
+
class CreateBD_WideAudio : public BC_CheckBox
{
public:
CreateBD_Histogram *need_histogram;
BC_Title *non_standard;
CreateBD_WideAudio *need_wide_audio;
- CreateBD_LabelChapters *need_label_chapters;
+ CreateBD_LabelChapters *need_labeled;
+ CreateBD_UseRenderFarm *need_farmed;
int ok_x, ok_y, ok_w, ok_h;
CreateBD_OK *ok;
int cancel_x, cancel_y, cancel_w, cancel_h;
}
+DVD_BatchRenderJob::DVD_BatchRenderJob(Preferences *preferences,
+ int labeled, int farmed, int standard, int muxed)
+ : BatchRenderJob("DVD_JOB", preferences, labeled, farmed)
+{
+ this->standard = standard;
+ this->muxed = muxed;
+
+ chapter = -1;
+ edl = 0;
+ fp =0;
+}
+
+void DVD_BatchRenderJob::copy_from(DVD_BatchRenderJob *src)
+{
+ standard = src->standard;
+ muxed = src->muxed;
+ BatchRenderJob::copy_from(src);
+}
+
+DVD_BatchRenderJob *DVD_BatchRenderJob::copy()
+{
+ DVD_BatchRenderJob *t = new DVD_BatchRenderJob(preferences,
+ labeled, farmed, standard, muxed);
+ t->copy_from(this);
+ return t;
+}
+
+void DVD_BatchRenderJob::load(FileXML *file)
+{
+ standard = file->tag.get_property("STANDARD", standard);
+ muxed = file->tag.get_property("MUXED", muxed);
+ BatchRenderJob::load(file);
+}
+
+void DVD_BatchRenderJob::save(FileXML *file)
+{
+ file->tag.set_property("STANDARD", standard);
+ file->tag.set_property("MUXED", muxed);
+ BatchRenderJob::save(file);
+}
+
+void DVD_BatchRenderJob::create_chapter(double pos)
+{
+ fprintf(fp,"%s", !chapter++? "\" chapters=\"" : ",");
+ int secs = pos, mins = secs/60;
+ int frms = (pos-secs) * edl->session->frame_rate;
+ fprintf(fp,"%d:%02d:%02d.%d", mins/60, mins%60, secs%60, frms);
+}
+
+char *DVD_BatchRenderJob::create_script(EDL *edl, ArrayList<Indexable *> *idxbls)
+{
+ char script[BCTEXTLEN];
+ strcpy(script, edl_path);
+ this->edl = edl;
+ this->fp = 0;
+ char *bp = strrchr(script,'/');
+ int fd = -1;
+ if( bp ) {
+ strcpy(bp, "/dvd.sh");
+ fd = open(script, O_WRONLY+O_CREAT+O_TRUNC, 0755);
+ }
+ if( fd >= 0 )
+ fp = fdopen(fd, "w");
+ if( !fp ) {
+ char err[BCTEXTLEN], msg[BCTEXTLEN];
+ strerror_r(errno, err, sizeof(err));
+ sprintf(msg, _("Unable to save: %s\n-- %s"), script, err);
+ MainError::show_error(msg);
+ return 0;
+ }
+
+ fprintf(fp,"#!/bin/bash\n");
+ fprintf(fp,"dir=`dirname $0`\n");
+ fprintf(fp,"echo \"running %s\"\n", script);
+ fprintf(fp,"\n");
+ const char *exec_path = File::get_cinlib_path();
+ fprintf(fp,"PATH=$PATH:%s\n",exec_path);
+ int file_seq = farmed || labeled ? 1 : 0;
+ if( !muxed ) {
+ if( file_seq ) {
+ fprintf(fp, "cat > $dir/dvd.m2v $dir/dvd.m2v0*\n");
+ fprintf(fp, "mplex -M -f 8 -o $dir/dvd.mpg $dir/dvd.m2v $dir/dvd.ac3\n");
+ file_seq = 0;
+ }
+ else
+ fprintf(fp, "mplex -f 8 -o $dir/dvd.mpg $dir/dvd.m2v $dir/dvd.ac3\n");
+ }
+ fprintf(fp,"rm -rf $dir/iso\n");
+ fprintf(fp,"mkdir -p $dir/iso\n");
+ fprintf(fp,"\n");
+// dvdauthor ver 0.7.0 requires this to work
+ int norm = dvd_formats[standard].norm;
+ const char *name = dvd_norms[norm].name;
+ fprintf(fp,"export VIDEO_FORMAT=%s\n", name);
+ fprintf(fp,"dvdauthor -x - <<eof\n");
+ fprintf(fp,"<dvdauthor dest=\"$dir/iso\">\n");
+ fprintf(fp," <vmgm>\n");
+ fprintf(fp," <fpc> jump title 1; </fpc>\n");
+ fprintf(fp," </vmgm>\n");
+ fprintf(fp," <titleset>\n");
+ fprintf(fp," <titles>\n");
+ char std[BCSTRLEN], *cp = std;
+ for( const char *np=name; *np!=0; ++cp,++np) *cp = *np + 'a'-'A';
+ *cp = 0;
+ EDLSession *session = edl->session;
+ fprintf(fp," <video format=\"%s\" aspect=\"%d:%d\" resolution=\"%dx%d\"/>\n",
+ std, (int)session->aspect_w, (int)session->aspect_h,
+ session->output_w, session->output_h);
+ fprintf(fp," <audio format=\"ac3\" lang=\"en\"/>\n");
+ fprintf(fp," <pgc>\n");
+ int total_idxbls = !file_seq ? 1 : idxbls->size();
+ int secs = 0;
+ double vob_pos = 0;
+ double total_length = edl->tracks->total_length();
+ Label *label = edl->labels->first;
+ for( int i=0; i<total_idxbls; ++i ) {
+ Indexable *idxbl = idxbls->get(i);
+ double video_length = idxbl->have_video() && idxbl->get_frame_rate() > 0 ?
+ (double)idxbl->get_video_frames() / idxbl->get_frame_rate() : 0 ;
+ double audio_length = idxbl->have_audio() && idxbl->get_sample_rate() > 0 ?
+ (double)idxbl->get_audio_samples() / idxbl->get_sample_rate() : 0 ;
+ double length = idxbl->have_video() && idxbl->have_audio() ?
+ bmin(video_length, audio_length) :
+ idxbl->have_video() ? video_length :
+ idxbl->have_audio() ? audio_length : 0;
+ fprintf(fp," <vob file=\"%s", !file_seq ? "dvd.mpg" : idxbl->path);
+ chapter = 0;
+ double vob_end = i+1>=total_idxbls ? total_length : vob_pos + length;
+ if( labeled ) {
+ while( label && label->position < vob_end ) {
+ create_chapter(label->position - vob_pos);
+ label = label->next;
+ }
+ }
+ else {
+ while( secs < vob_end ) {
+ create_chapter(secs - vob_pos);
+ secs += 10*60; // ch every 10 minutes
+ }
+ }
+ fprintf(fp,"\"/>\n");
+ vob_pos = vob_end;
+ }
+ fprintf(fp," </pgc>\n");
+ fprintf(fp," </titles>\n");
+ fprintf(fp," </titleset>\n");
+ fprintf(fp,"</dvdauthor>\n");
+ fprintf(fp,"eof\n");
+ fprintf(fp,"\n");
+ fprintf(fp,"echo To burn dvd, load blank media and run:\n");
+ fprintf(fp,"echo growisofs -dvd-compat -Z /dev/dvd -dvd-video $dir/iso\n");
+ fprintf(fp,"kill $$\n");
+ fprintf(fp,"\n");
+ fclose(fp);
+ return cstrdup(script);
+}
+
+
CreateDVD_Thread::CreateDVD_Thread(MWindow *mwindow)
: BC_DialogThread()
{
this->use_wide_audio = 0;
this->use_ffmpeg = 0;
this->use_resize_tracks = 0;
- this->use_label_chapters = 0;
+ this->use_labeled = 0;
+ this->use_farmed = 0;
this->dvd_size = DVD_SIZE;
this->dvd_width = DVD_WIDTH;
return 1;
}
EDLSession *session = edl->session;
-
double total_length = edl->tracks->total_length();
if( total_length <= 0 ) {
char msg[BCTEXTLEN];
session->audio_channels = session->audio_tracks =
use_wide_audio ? DVD_WIDE_CHANNELS : DVD_CHANNELS;
- char script_filename[BCTEXTLEN];
- sprintf(script_filename, "%s/dvd.sh", asset_dir);
- int fd = open(script_filename, O_WRONLY+O_CREAT+O_TRUNC, 0755);
- FILE *fp = fdopen(fd, "w");
- if( !fp ) {
- char err[BCTEXTLEN], msg[BCTEXTLEN];
- strerror_r(errno, err, sizeof(err));
- sprintf(msg, _("Unable to save: %s\n-- %s"), script_filename, err);
- MainError::show_error(msg);
- return 1;
- }
- fprintf(fp,"#!/bin/bash\n");
- fprintf(fp,"echo \"running %s\" $# $*\n", script_filename);
- fprintf(fp,"\n");
- const char *exec_path = File::get_cinlib_path();
- fprintf(fp,"PATH=$PATH:%s\n",exec_path);
- if( mwindow->preferences->use_renderfarm ||
- (use_label_chapters && edl->labels ) ) {
- if( !use_ffmpeg ) {
- fprintf(fp, "cat > $1/dvd.m2v $1/dvd.m2v0*\n");
- fprintf(fp, "mplex -M -f 8 -o $1/dvd.mpg $1/dvd.m2v $1/dvd.ac3\n");
- }
- else
- fprintf(fp, "ffmpeg -f concat -safe 0 -i <(for f in \"$1/dvd.mpg0\"*; do "
- "echo \"file '$f'\"; done) -c copy -y $1/dvd.mpg\n");
- }
- else
- fprintf(fp, "mplex -f 8 -o $1/dvd.mpg $1/dvd.m2v $1/dvd.ac3\n");
- fprintf(fp,"rm -rf $1/iso\n");
- fprintf(fp,"mkdir -p $1/iso\n");
- fprintf(fp,"\n");
-// dvdauthor ver 0.7.0 requires this to work
- int norm = dvd_formats[use_standard].norm;
- const char *name = dvd_norms[norm].name;
- fprintf(fp,"export VIDEO_FORMAT=%s\n", name);
- fprintf(fp,"dvdauthor -x - <<eof\n");
- fprintf(fp,"<dvdauthor dest=\"$1/iso\">\n");
- fprintf(fp," <vmgm>\n");
- fprintf(fp," <fpc> jump title 1; </fpc>\n");
- fprintf(fp," </vmgm>\n");
- fprintf(fp," <titleset>\n");
- fprintf(fp," <titles>\n");
- char std[BCSTRLEN], *cp = std;
- for( const char *np=name; *np!=0; ++cp,++np) *cp = *np + 'a'-'A';
- *cp = 0;
- fprintf(fp," <video format=\"%s\" aspect=\"%d:%d\" resolution=\"%dx%d\"/>\n",
- std, (int)session->aspect_w, (int)session->aspect_h,
- session->output_w, session->output_h);
- fprintf(fp," <audio format=\"ac3\" lang=\"en\"/>\n");
- fprintf(fp," <pgc>\n");
- fprintf(fp," <vob file=\"$1/dvd.mpg\" chapters=\"");
- if( use_label_chapters && edl->labels ) {
- Label *label = edl->labels->first;
- while( label ) {
- int secs = label->position;
- int mins = secs / 60;
- int frms = (label->position-secs) * session->frame_rate;
- fprintf(fp,"%d:%02d:%02d.%d", mins/60, mins%60, secs%60, frms);
- if( (label=label->next) != 0 ) fprintf(fp, ",");
- }
- }
- else {
- int mins = 0;
- for( int secs=0 ; secs<total_length; secs+=10*60 ) {
- mins = secs / 60;
- fprintf(fp,"%d:%02d:00,", mins/60, mins%60);
- }
- fprintf(fp,"%d:%02d:00", mins/60, mins%60);
- }
- fprintf(fp,"\"/>\n");
- fprintf(fp," </pgc>\n");
- fprintf(fp," </titles>\n");
- fprintf(fp," </titleset>\n");
- fprintf(fp,"</dvdauthor>\n");
- fprintf(fp,"eof\n");
- fprintf(fp,"\n");
- fprintf(fp,"echo To burn dvd, load blank media and run:\n");
- fprintf(fp,"echo growisofs -dvd-compat -Z /dev/dvd -dvd-video $1/iso\n");
- fprintf(fp,"kill $$\n");
- fprintf(fp,"\n");
- fclose(fp);
-
session->audio_channels = session->audio_tracks =
!use_wide_audio ? DVD_CHANNELS : DVD_WIDE_CHANNELS;
for( int i=0; i<MAX_CHANNELS; ++i )
return 1;
}
- BatchRenderJob *job = new BatchRenderJob(mwindow->preferences, use_label_chapters);
+ BatchRenderJob *job = new DVD_BatchRenderJob(mwindow->preferences,
+ use_labeled, use_farmed, use_standard, use_ffmpeg);
jobs->append(job);
strcpy(&job->edl_path[0], xml_filename);
Asset *asset = job->asset;
strcpy(asset->fformat, "dvd");
asset->audio_data = 1;
+ asset->channels = session->audio_channels;
+ asset->sample_rate = session->sample_rate;
strcpy(asset->acodec, "dvd.dvd");
FFMPEG::set_option_path(option_path, "audio/%s", asset->acodec);
FFMPEG::load_options(option_path, asset->ff_audio_options,
sizeof(asset->ff_video_options));
asset->ff_video_bitrate = vid_bitrate;
asset->ff_video_quality = -1;
+ use_farmed = job->farmed;
}
else {
sprintf(&asset->path[0],"%s/dvd.m2v", asset_dir);
asset->vmpeg_preset = 8;
asset->vmpeg_field_order = 0;
asset->vmpeg_pframe_distance = 0;
+ use_farmed = job->farmed;
job = new BatchRenderJob(mwindow->preferences, 0, 0);
jobs->append(job);
strcpy(&job->edl_path[0], xml_filename);
asset->ac3_bitrate = dvd_kaudio_rate;
}
- job = new BatchRenderJob(mwindow->preferences, 0, 0);
- jobs->append(job);
- job->edl_path[0] = '@';
- strcpy(&job->edl_path[1], script_filename);
- strcpy(&job->asset->path[0], asset_dir);
-
return 0;
}
mwindow->resync_guis();
if( ret ) return;
mwindow->batch_render->save_jobs();
- mwindow->batch_render->start();
+ mwindow->batch_render->start(-use_farmed, -use_labeled);
}
BC_Window* CreateDVD_Thread::new_gui()
use_wide_audio = 0;
use_ffmpeg = 0;
use_resize_tracks = 0;
- use_label_chapters = 0;
+ use_labeled = 0;
+ use_farmed = 0;
use_standard = DVD_NTSC_4x3;
dvd_size = DVD_SIZE;
}
CreateDVD_LabelChapters::CreateDVD_LabelChapters(CreateDVD_GUI *gui, int x, int y)
- : BC_CheckBox(x, y, &gui->thread->use_label_chapters, _("Chapters at Labels"))
+ : BC_CheckBox(x, y, &gui->thread->use_labeled, _("Chapters at Labels"))
{
this->gui = gui;
}
{
}
+CreateDVD_UseRenderFarm::CreateDVD_UseRenderFarm(CreateDVD_GUI *gui, int x, int y)
+ : BC_CheckBox(x, y, &gui->thread->use_farmed, _("Use render farm"))
+{
+ this->gui = gui;
+}
+
+CreateDVD_UseRenderFarm::~CreateDVD_UseRenderFarm()
+{
+}
+
CreateDVD_WideAudio::CreateDVD_WideAudio(CreateDVD_GUI *gui, int x, int y)
: BC_CheckBox(x, y, &gui->thread->use_wide_audio, _("Audio 5.1"))
{
need_resize_tracks = 0;
need_histogram = 0;
need_wide_audio = 0;
- need_label_chapters = 0;
+ need_labeled = 0;
+ need_farmed = 0;
ok = 0;
cancel = 0;
}
add_subwindow(scale);
scale->create_objects();
y += standard->get_h() + pady/2;
- need_deinterlace = new CreateDVD_Deinterlace(this, x, y);
+ x1 = x; int y1 = y;
+ need_deinterlace = new CreateDVD_Deinterlace(this, x1, y);
add_subwindow(need_deinterlace);
- x1 = x + 170;
- int x2 = x1 + 170;
- need_inverse_telecine = new CreateDVD_InverseTelecine(this, x1, y);
- add_subwindow(need_inverse_telecine);
- need_use_ffmpeg = new CreateDVD_UseFFMpeg(this, x2, y);
- add_subwindow(need_use_ffmpeg);
y += need_deinterlace->get_h() + pady/2;
need_histogram = new CreateDVD_Histogram(this, x, y);
add_subwindow(need_histogram);
+ y = y1; x1 += 170;
+ need_inverse_telecine = new CreateDVD_InverseTelecine(this, x1, y);
+ add_subwindow(need_inverse_telecine);
+ y += need_inverse_telecine->get_h() + pady/2;
need_wide_audio = new CreateDVD_WideAudio(this, x1, y);
add_subwindow(need_wide_audio);
- need_resize_tracks = new CreateDVD_ResizeTracks(this, x2, y);
+ y += need_wide_audio->get_h() + pady/2;
+ need_use_ffmpeg = new CreateDVD_UseFFMpeg(this, x1, y);
+ add_subwindow(need_use_ffmpeg);
+ y += need_use_ffmpeg->get_h() + pady/2;
+ need_resize_tracks = new CreateDVD_ResizeTracks(this, x1, y);
add_subwindow(need_resize_tracks);
- y += need_histogram->get_h() + pady/2;
- need_label_chapters = new CreateDVD_LabelChapters(this, x1, y);
- add_subwindow(need_label_chapters);
+ y = y1; x1 += 170;
+ need_labeled = new CreateDVD_LabelChapters(this, x1, y);
+ add_subwindow(need_labeled);
+ y += need_labeled->get_h() + pady/2;
+ need_farmed = new CreateDVD_UseRenderFarm(this, x1, y);
+ add_subwindow(need_farmed);
ok_w = BC_OKButton::calculate_w();
ok_h = BC_OKButton::calculate_h();
ok_x = 10;
need_resize_tracks->set_value(thread->use_resize_tracks);
need_histogram->set_value(thread->use_histogram);
need_wide_audio->set_value(thread->use_wide_audio);
- need_label_chapters->set_value(thread->use_label_chapters);
+ need_labeled->set_value(thread->use_labeled);
+ need_farmed->set_value(thread->use_farmed);
}
int CreateDVD_Thread::
use_scale = Rescale::none;
use_resize_tracks = 0;
use_wide_audio = 0;
- use_label_chapters = 0;
+ use_labeled = 0;
+ use_farmed = 0;
if( !mwindow->edl ) return 1;
}
if( !has_deinterlace && max_h > 2*dvd_height ) use_deinterlace = 1;
Labels *labels = mwindow->edl->labels;
- use_label_chapters = labels && labels->first ? 1 : 0;
+ use_labeled = labels && labels->first ? 1 : 0;
if( tracks->recordable_audio_tracks() == DVD_WIDE_CHANNELS )
use_wide_audio = 1;
+ use_farmed = mwindow->preferences->use_renderfarm;
return 0;
}
MWindow *mwindow;
};
+class DVD_BatchRenderJob : public BatchRenderJob
+{
+ int chapter;
+ FILE *fp;
+ EDL *edl;
+public:
+ DVD_BatchRenderJob(Preferences *preferences,
+ int labeled, int farmed, int standard, int muxed);
+ void copy_from(DVD_BatchRenderJob *src);
+ DVD_BatchRenderJob *copy();
+ void load(FileXML *file);
+ void save(FileXML *file);
+ char *create_script(EDL *edl, ArrayList<Indexable *> *idxbls);
+ void create_chapter(double pos);
+
+ int standard;
+ int muxed;
+};
class CreateDVD_Thread : public BC_DialogThread
{
void handle_close_event(int result);
BC_Window* new_gui();
int option_presets();
+ void create_chapter(FILE *fp, double pos);
+ static int create_dvd_script(BatchRenderJob *job);
int create_dvd_jobs(ArrayList<BatchRenderJob*> *jobs, const char *asset_path);
int insert_video_plugin(const char *title, KeyFrame *default_keyframe);
int resize_tracks();
char tmp_path[BCTEXTLEN];
int use_deinterlace, use_inverse_telecine;
int use_scale, use_resize_tracks;
- int use_wide_audio;
- int use_histogram, use_label_chapters;
+ int use_wide_audio, use_farmed;
+ int use_histogram, use_labeled;
int use_ffmpeg, use_standard;
int64_t dvd_size;
CreateDVD_GUI *gui;
};
+class CreateDVD_UseRenderFarm : public BC_CheckBox
+{
+public:
+ CreateDVD_UseRenderFarm(CreateDVD_GUI *gui, int x, int y);
+ ~CreateDVD_UseRenderFarm();
+
+ CreateDVD_GUI *gui;
+};
+
class CreateDVD_WideAudio : public BC_CheckBox
{
public:
CreateDVD_ResizeTracks *need_resize_tracks;
CreateDVD_Histogram *need_histogram;
CreateDVD_WideAudio *need_wide_audio;
- CreateDVD_LabelChapters *need_label_chapters;
+ CreateDVD_LabelChapters *need_labeled;
+ CreateDVD_UseRenderFarm *need_farmed;
int ok_x, ok_y, ok_w, ok_h;
CreateDVD_OK *ok;
int cancel_x, cancel_y, cancel_w, cancel_h;
class CreateDVD_ResizeTracks;
class CreateDVD_Histogram;
class CreateDVD_LabelChapters;
+class CreateDVD_UseRenderFarm;
class CreateDVD_WideAudio;
class CreateDVD_WideAspect;
class CreateDVD_UseFFMpeg;
int File::close_file(int ignore_thread)
{
- const int debug = 0;
-
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
-
if( !ignore_thread ) {
stop_audio_thread();
stop_video_thread();
}
-
-
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
if( file ) {
// The file's asset is a copy of the argument passed to open_file so the
// user must copy lengths from the file's asset.
file->close_file();
delete file;
}
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
delete_temp_samples_buffer();
delete_temp_frame_buffer();
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
-
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
-
reset_parameters();
- if( debug ) printf("File::close_file file=%p %d\n", file, __LINE__);
return 0;
}
-
-
int File::get_index(IndexFile *index_file, MainProgressBar *progress_bar)
{
return !file ? -1 : file->get_index(index_file, progress_bar);
}
-
-
int File::start_audio_thread(int buffer_size, int ring_buffers)
{
this->audio_ring_buffers = ring_buffers;
return 0;
}
-int File::start_video_thread(int buffer_size,
- int color_model,
- int ring_buffers,
- int compressed)
+int File::start_video_thread(int buffer_size, int color_model,
+ int ring_buffers, int compressed)
{
this->video_ring_buffers = ring_buffers;
this->video_buffer_size = buffer_size;
if( !video_thread ) {
video_thread = new FileThread(this, 0, 1);
- video_thread->start_writing(buffer_size,
- color_model,
- ring_buffers,
- compressed);
+ video_thread->start_writing(buffer_size, color_model,
+ ring_buffers, compressed);
}
return 0;
}
break; }
case DO_BATCHRENDER: {
- BatchRenderThread *thread = new BatchRenderThread;
+ BatchRenderThread *thread = new BatchRenderThread(0);
thread->start_rendering(config_path,
batch_path);
break; }
delete package_lock;
}
-int PackageDispatcher::create_packages(MWindow *mwindow,
- EDL *edl,
- Preferences *preferences,
- int strategy,
- Asset *default_asset,
- double total_start,
- double total_end,
- int test_overwrite)
+int PackageDispatcher::create_packages(MWindow *mwindow, EDL *edl,
+ Preferences *preferences, int strategy, Asset *default_asset,
+ double total_start, double total_end, int test_overwrite)
{
+ Label *label;
int result = 0;
this->mwindow = mwindow;
// total_end,
// default_asset->frame_rate);
-
-
- if(strategy == SINGLE_PASS)
- {
+ switch( strategy ) {
+ case SINGLE_PASS:
total_len = this->total_end - this->total_start;
package_len = total_len;
min_package_len = total_len;
packages[0]->audio_do = default_asset->audio_data;
packages[0]->video_do = default_asset->video_data;
strcpy(packages[0]->path, default_asset->path);
- }
- else
- if(strategy == SINGLE_PASS_FARM)
- {
+ break;
+ case SINGLE_PASS_FARM:
packaging_engine = File::new_packaging_engine(default_asset);
- packaging_engine->create_packages_single_farm(
- edl,
- preferences,
- default_asset,
- total_start,
- total_end);
- }
- else
- if(strategy == FILE_PER_LABEL || strategy == FILE_PER_LABEL_FARM)
- {
- Label *label = edl->labels->first;
+ packaging_engine->create_packages_single_farm(edl, preferences,
+ default_asset, total_start, total_end);
+ break;
+ case FILE_PER_LABEL:
+ case FILE_PER_LABEL_FARM:
+ label = edl->labels->first;
total_packages = 0;
packages = new RenderPackage*[edl->labels->total() + 2];
Render::get_starting_number(default_asset->path,
- current_number,
- number_start,
- total_digits,
- 2);
-
- while(audio_position < audio_end)
- {
- RenderPackage *package =
- packages[total_packages] =
- new RenderPackage;
+ current_number, number_start, total_digits, 3);
+
+ while( audio_position < audio_end ) {
+ RenderPackage *package = new RenderPackage;
+ packages[total_packages++] = package;
package->audio_start = audio_position;
package->video_start = video_position;
package->audio_do = default_asset->audio_data;
package->video_do = default_asset->video_data;
-
- while(label &&
+ while( label &&
(label->position < (double)audio_position / default_asset->sample_rate ||
- EQUIV(label->position, (double)audio_position / default_asset->sample_rate)))
- {
+ EQUIV(label->position, (double)audio_position / default_asset->sample_rate)) ) {
label = label->next;
}
- if(!label)
- {
+ if( !label ) {
package->audio_end = Units::to_int64(total_end * default_asset->sample_rate);
package->video_end = Units::to_int64(total_end * default_asset->frame_rate);
}
- else
- {
+ else {
package->audio_end = Units::to_int64(label->position * default_asset->sample_rate);
package->video_end = Units::to_int64(label->position * default_asset->frame_rate);
}
- if(package->audio_end > audio_end)
- {
+ if( package->audio_end > audio_end ) {
package->audio_end = audio_end;
}
- if(package->video_end > video_end)
- {
+ if( package->video_end > video_end ) {
package->video_end = video_end;
}
audio_position = package->audio_end;
video_position = package->video_end;
+
// Create file number differently if image file sequence
- Render::create_filename(package->path,
- default_asset->path,
- current_number,
- total_digits,
- number_start);
- current_number++;
-
- total_packages++;
+ Render::create_filename(package->path, default_asset->path,
+ current_number++, total_digits, number_start);
}
total_allocated = total_packages;
- }
- else
- if(strategy == BRENDER_FARM)
- {
+ break;
+ case BRENDER_FARM:
total_len = this->total_end - this->total_start;
// Create packages as they're requested.
packages = 0;
Render::get_starting_number(default_asset->path,
- current_number,
- number_start,
- total_digits,
- 6);
+ current_number, number_start, total_digits, 6);
// Master node only
- if(preferences->renderfarm_nodes.total == 1)
- {
+ if( preferences->renderfarm_nodes.total == 1 ) {
package_len = total_len;
min_package_len = total_len;
}
- else
- {
+ else {
package_len = preferences->brender_fragment /
edl->session->frame_rate;
min_package_len = 1.0 / edl->session->frame_rate;
}
+ break;
}
// Test existence of every output file.
// Only if this isn't a background render or non interactive.
- if(strategy != BRENDER_FARM &&
- test_overwrite &&
- mwindow)
- {
+ if( strategy != BRENDER_FARM && test_overwrite && mwindow ) {
ArrayList<char*> paths;
get_package_paths(&paths);
result = ConfirmSave::test_files(mwindow, &paths);
{
if (strategy == SINGLE_PASS_FARM)
packaging_engine->get_package_paths(path_list);
- else
- {
- for(int i = 0; i < total_allocated; i++)
+ else {
+ for( int i=0; i<total_allocated; ++i )
path_list->append(strdup(packages[i]->path));
path_list->set_free();
}
}
RenderPackage* PackageDispatcher::get_package(double frames_per_second,
- int client_number,
- int use_local_rate)
+ int client_number, int use_local_rate)
{
- const int debug = 0;
package_lock->lock("PackageDispatcher::get_package");
- if(debug) printf("PackageDispatcher::get_package %d %f %d %d\n",
- __LINE__,
- frames_per_second,
- client_number,
- use_local_rate);
-
// Store new frames per second for the node
- if(!EQUIV(frames_per_second, 0))
- {
+ if( !EQUIV(frames_per_second, 0) ) {
preferences->set_rate(frames_per_second, client_number);
if(mwindow) mwindow->preferences->copy_rates_from(preferences);
}
- else
+ else {
// Use previous frames per second
- {
frames_per_second = preferences->get_rate(client_number);
}
- if(debug) printf("PackageDispatcher::get_package %d %f %d %d\n",
- __LINE__,
- frames_per_second,
- client_number,
- use_local_rate);
-
float avg_frames_per_second = preferences->get_avg_rate(use_local_rate);
RenderPackage *result = 0;
+ switch( strategy ) {
//printf("PackageDispatcher::get_package 1 %d\n", strategy);
- if(strategy == SINGLE_PASS ||
- strategy == FILE_PER_LABEL ||
- strategy == FILE_PER_LABEL_FARM)
- {
- if(current_package < total_packages)
- {
- result = packages[current_package];
- current_package++;
- }
- }
- else
- if(strategy == SINGLE_PASS_FARM)
- {
+ case SINGLE_PASS:
+ case FILE_PER_LABEL:
+ case FILE_PER_LABEL_FARM:
+ if( current_package < total_packages )
+ result = packages[current_package++];
+ break;
+ case SINGLE_PASS_FARM:
result = packaging_engine->get_package_single_farm(frames_per_second,
- client_number,
- use_local_rate);
- }
- else
- if(strategy == BRENDER_FARM)
- {
+ client_number, use_local_rate);
+ break;
+ case BRENDER_FARM:
//printf("Dispatcher::get_package 1 %d %d\n", video_position, video_end);
- if(video_position < video_end)
- {
+ if( video_position < video_end ) {
// Allocate new packages
- if(total_packages == 0)
- {
+ if( total_packages == 0 ) {
total_allocated = 256;
packages = new RenderPackage*[total_allocated];
}
- else
- if(total_packages >= total_allocated)
- {
+ else if( total_packages >= total_allocated ) {
RenderPackage **old_packages = packages;
total_allocated *= 2;
packages = new RenderPackage*[total_allocated];
double scaled_len;
// No load balancing data exists
- if(EQUIV(frames_per_second, 0) ||
- EQUIV(avg_frames_per_second, 0))
- {
+ if( EQUIV(frames_per_second, 0) ||
+ EQUIV(avg_frames_per_second, 0)) {
scaled_len = package_len;
}
- else
+ else {
// Load balancing data exists
- {
scaled_len = package_len *
- frames_per_second /
- avg_frames_per_second;
+ frames_per_second / avg_frames_per_second;
}
scaled_len = MAX(scaled_len, min_package_len);
// The frame numbers are read from the vframe objects themselves.
- Render::create_filename(result->path,
- default_asset->path,
- 0,
- total_digits,
- number_start);
+ Render::create_filename(result->path, default_asset->path,
+ 0, total_digits, number_start);
//printf("PackageDispatcher::get_package 2 %s\n", result->path);
-
- current_number++;
- total_packages++;
- current_package++;
+ ++current_number;
+ ++total_packages;
+ ++current_package;
}
+ break;
}
package_lock->unlock();
-
- if(debug && result) printf("PackageDispatcher::get_package %d %ld\n", __LINE__, (long)(result->video_end - result->video_start));
return result;
}
-ArrayList<Indexable*>* PackageDispatcher::get_asset_list()
+int PackageDispatcher::get_asset_list(ArrayList<Indexable*> &idxbls)
{
- ArrayList<Indexable*> *assets = new ArrayList<Indexable*>;
-
-const int debug = 0;
-if(debug) printf("PackageDispatcher::get_asset_list %d\n", __LINE__);
-if(debug) default_asset->dump();
- for(int i = 0; i < current_package; i++)
- {
+ if( strategy == SINGLE_PASS_FARM )
+ return packaging_engine->get_asset_list(idxbls);
+ for( int i=0; i<current_package; ++i ) {
Asset *asset = new Asset;
asset->copy_from(default_asset, 1);
strcpy(asset->path, packages[i]->path);
asset->video_length = packages[i]->video_end - packages[i]->video_start;
asset->audio_length = packages[i]->audio_end - packages[i]->audio_start;
- assets->append(asset);
-if(debug) printf("PackageDispatcher::get_asset_list %d\n", __LINE__);
-if(debug) asset->dump();
+ idxbls.append(asset);
}
-
- return assets;
+ return current_package;
}
int64_t PackageDispatcher::get_progress_max()
{
- if (strategy == SINGLE_PASS_FARM)
- return packaging_engine->get_progress_max();
- else
- return Units::to_int64(default_asset->sample_rate *
- (total_end - total_start)) +
+ return strategy == SINGLE_PASS_FARM ?
+ packaging_engine->get_progress_max() :
+ Units::to_int64(default_asset->sample_rate * (total_end - total_start)) +
Units::to_int64(preferences->render_preroll *
- total_allocated *
- default_asset->sample_rate);
+ total_allocated * default_asset->sample_rate);
}
int PackageDispatcher::get_total_packages()
int PackageDispatcher::packages_are_done()
{
- if (packaging_engine)
- return packaging_engine->packages_are_done();
- return 0;
+ return packaging_engine ? packaging_engine->packages_are_done() : 0;
}
+
RenderPackage* get_package(double frames_per_second,
int client_number,
int use_local_rate);
-// Return a new asset list of what was rendered. You must delete the return
-// value with Garbage::remove_user for each member of the list & delete for
-// the list.
- ArrayList<Indexable*>* get_asset_list();
+// Return a new path list of what was rendered.
void get_package_paths(ArrayList<char*> *path_list);
+// Return a new asset list of what was rendered.
+ int get_asset_list(ArrayList<Indexable*> &idxbls);
RenderPackage* get_package(int number);
int get_total_packages();
FileSystem fs;
asset = new Asset(*default_asset);
- if(!get_master() && preferences->renderfarm_vfs && preferences->use_renderfarm)
+ if( !get_master() && preferences->renderfarm_vfs && preferences->use_renderfarm )
snprintf(asset->path, sizeof(asset->path),
RENDERFARM_FS_PREFIX "%s", package->path);
else
file->set_processors(preferences->processors);
result = file->open_file(preferences, asset, 0, 1);
- if(result && mwindow)
- {
+ if( result && mwindow ) {
// open failed
char string[BCTEXTLEN];
snprintf(string, sizeof(string), _("Couldn't open %s"), asset->path);
error.run_window();
}
else
- if(mwindow)
- {
+ if( mwindow ) {
mwindow->sighandler->push_file(file);
IndexFile::delete_index(preferences, asset);
}
render_engine->set_vcache(video_cache);
render_engine->arm_command(command);
- if(package->use_brender)
- {
+ if( package->use_brender ) {
audio_preroll = Units::to_int64((double)preferences->brender_preroll /
default_asset->frame_rate *
default_asset->sample_rate);
video_preroll = preferences->brender_preroll;
}
- else
- {
+ else {
audio_preroll = Units::to_int64(preferences->render_preroll *
default_asset->sample_rate);
video_preroll = Units::to_int64(preferences->render_preroll *
default_asset->frame_rate);
}
audio_position = package->audio_start - audio_preroll;
- if( audio_position < 0 )
- {
+ if( audio_position < 0 ) {
audio_preroll += audio_position;
audio_position = 0;
}
video_position = package->video_start - video_preroll;
- if( video_position < 0 )
- {
+ if( video_position < 0 ) {
video_preroll += video_position;
video_position = 0;
}
// PRINT_TRACE
// Create output buffers
- if(asset->audio_data)
- {
+ if( asset->audio_data ) {
file->start_audio_thread(audio_read_length,
preferences->processors > 1 ? 2 : 1);
}
// PRINT_TRACE
- if(asset->video_data)
- {
+ if( asset->video_data ) {
compressed_output = new VFrame;
// The write length needs to correlate with the processor count because
// it is passed to the file handler which usually processes frames simultaneously.
//printf("PackageRenderer::create_engine %d video_write_length=%d\n", __LINE__, video_write_length);
// starting frames are corrupted if video_write_length > 2. Work around it, for now.
- if(video_write_length > 2)
- {
+ if( video_write_length > 2 ) {
video_write_length = 2;
}
file->start_video_thread(video_write_length,
//printf("PackageRenderer::create_engine %d\n", __LINE__);
- if(mwindow)
- {
+ if( mwindow ) {
video_device = new VideoDevice;
video_device->open_output(vconfig,
command->get_edl()->session->frame_rate,
{
//printf("PackageRenderer::do_audio %d\n", __LINE__);
// Do audio data
- if(asset->audio_data)
- {
+ if( asset->audio_data ) {
audio_output = file->get_audio_buffer();
// Zero unused channels in output vector
- for(int i = 0; i < MAX_CHANNELS; i++)
- {
+ for( int i = 0; i < MAX_CHANNELS; i++ ) {
audio_output_ptr[i] = (i < asset->channels) ?
audio_output[i] :
0;
// Fix buffers for preroll
int64_t output_length = audio_read_length;
- if(audio_preroll > 0)
- {
- if(audio_preroll >= output_length)
+ if( audio_preroll > 0 ) {
+ if( audio_preroll >= output_length )
output_length = 0;
- else
- {
+ else {
output_length -= audio_preroll;
- for(int i = 0; i < MAX_CHANNELS; i++)
- {
- if(audio_output_ptr[i])
- {
+ for( int i = 0; i < MAX_CHANNELS; i++ ) {
+ if( audio_output_ptr[i] ) {
double *data = audio_output_ptr[i]->get_data();
- for(int j = 0; j < output_length; j++)
- {
+ for( int j = 0; j < output_length; j++ ) {
data[j] = data[j + audio_read_length - output_length];
}
}
void PackageRenderer::do_video()
{
- const int debug = 0;
// Do video data
- if(asset->video_data)
- {
+ if( asset->video_data ) {
// get the absolute video position from the audio position
int64_t video_end = video_position + video_read_length;
- if(video_end > package->video_end)
+ if( video_end > package->video_end )
video_end = package->video_end;
- while(video_position < video_end && !result)
- {
+ while( !result && video_position < video_end ) {
// Try to copy the compressed frame directly from the input to output files
-//printf("PackageRenderer::do_video 2 video_position=%ld\n", video_position);
- if(direct_frame_copy(command->get_edl(),
- video_position,
- file,
- result))
- {
+ if( direct_frame_copy(command->get_edl(),
+ video_position, file, result) ) {
// Direct frame copy failed.
// Switch back to background compression
- if(direct_frame_copying)
- {
+ if( direct_frame_copying ) {
file->start_video_thread(video_write_length,
command->get_edl()->session->color_model,
// Try to use the rendering engine to write the frame.
// Get a buffer for background writing.
- if(video_write_position == 0)
+ if( video_write_position == 0 )
video_output = file->get_video_buffer();
-
- if(debug) printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output);
- if(debug) printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output[0]);
-
-
-
-
// Construct layered output buffer
video_output_ptr = video_output[0][video_write_position];
- if(debug)
- {
- printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output_ptr);
- printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
- video_output_ptr->dump();
- }
- if(!result)
+ if( !result )
result = render_engine->vrender->process_buffer(
- video_output_ptr,
- video_position,
- 0);
-
-
- if(debug) printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
-
- if(!result &&
+ video_output_ptr, video_position, 0);
+ if( !result &&
mwindow &&
- video_device->output_visible())
- {
+ video_device->output_visible() ) {
// Vector for video device
VFrame *preview_output;
video_device->write_buffer(preview_output,
command->get_edl());
}
-
- if(debug) printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
-
-
// Don't write to file
- if(video_preroll && !result)
- {
+ if( video_preroll && !result ) {
video_preroll--;
// Keep the write position at 0 until ready to write real frames
result = file->write_video_buffer(0);
video_write_position = 0;
}
else
- if(!result)
- {
+ if( !result ) {
// Set background rendering parameters
// Allow us to skip sections of the output file by setting the frame number.
// Used by background render and render farm.
-//printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
video_output_ptr->set_number(video_position);
video_write_position++;
- if(video_write_position >= video_write_length)
- {
+ if( video_write_position >= video_write_length ) {
result = file->write_video_buffer(video_write_position);
-//printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
// Update the brender map after writing the files.
- if(package->use_brender)
- {
-//printf("PackageRenderer::do_video 10\n");
- for(int i = 0; i < video_write_position && !result; i++)
- {
+ if( package->use_brender ) {
+ for( int i = 0; i < video_write_position && !result; i++ ) {
result = set_video_map(video_position + 1 - video_write_position + i,
BRender::RENDERED);
}
-//printf("PackageRenderer::do_video 11 %d\n", result);
}
video_write_position = 0;
}
}
-//printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
-
-
}
video_position++;
- if(!result && get_result()) result = 1;
- if(!result && progress_cancelled()) result = 1;
+ if( !result && get_result() ) result = 1;
+ if( !result && progress_cancelled() ) result = 1;
}
}
- else
- {
+ else {
video_position += video_read_length;
}
}
void PackageRenderer::stop_output()
{
int error = 0;
- if(asset->audio_data)
- {
+ if( asset->audio_data ) {
// stop file I/O
file->stop_audio_thread();
}
- if(asset->video_data)
- {
+ if( asset->video_data ) {
delete compressed_output;
- if(video_write_position)
+ if( video_write_position )
file->write_video_buffer(video_write_position);
- if(package->use_brender)
- {
- for(int i = 0; i < video_write_position && !error; i++)
- {
+ if( package->use_brender ) {
+ for( int i = 0; i < video_write_position && !error; i++ ) {
error = set_video_map(video_position - video_write_position + i,
BRender::RENDERED);
}
}
video_write_position = 0;
- if(!error) file->stop_video_thread();
- if(mwindow)
- {
+ if( !error ) file->stop_video_thread();
+ if( mwindow ) {
// video_device->stop_playback();
video_device->close_all();
delete video_device;
void PackageRenderer::close_output()
{
- if(mwindow)
+ if( mwindow )
mwindow->sighandler->pull_file(file);
file->close_file();
delete file;
// package->video_start,
// package->video_end - package->video_start);
- if(debug) PRINT_TRACE
+ if( debug ) PRINT_TRACE
if( package->video_do ) default_asset->video_data = 1;
if( package->audio_do ) default_asset->audio_data = 1;
Render::check_asset(edl, *default_asset);
create_output();
- if(debug) PRINT_TRACE
- if(!asset->video_data) video_done = 1;
- if(!asset->audio_data) audio_done = 1;
+ if( !asset->video_data ) video_done = 1;
+ if( !asset->audio_data ) audio_done = 1;
// Create render engine
- if(!result)
- {
-if(debug) PRINT_TRACE
+ if( !result ) {
create_engine();
-if(debug) PRINT_TRACE
-
-
// Main loop
timer->update();
total_samples_rendered = 0;
- while((!audio_done || !video_done) && !result)
- {
+ while( !result && (!audio_done || !video_done) ) {
int need_audio = 0, need_video = 0;
-
-
-
-
// Calculate lengths to process. Audio fragment is constant.
- if(!audio_done)
- {
- if(audio_position + audio_read_length >= package->audio_end)
- {
+ if( !audio_done ) {
+ if( audio_position + audio_read_length >= package->audio_end ) {
audio_done = 1;
audio_read_length = package->audio_end - audio_position;
}
//printf("PackageRenderer::render_package 6 %d\n", samples_rendered);
- if(!video_done)
- {
- if(audio_done)
- {
+ if( !video_done ) {
+ if( audio_done ) {
// video_read_length = package->video_end - video_position;
// // Packetize video length so progress gets updated
// video_read_length = (int)MIN(asset->frame_rate, video_read_length);
// video_read_length = MAX(video_read_length, 30);
video_read_length = 1;
}
- else
+ else {
// Guide video with audio
- {
video_read_length = Units::to_int64(
(double)(audio_position + audio_read_length) /
asset->sample_rate *
}
// Clamp length
- if(video_position + video_read_length >= package->video_end)
- {
+ if( video_position + video_read_length >= package->video_end ) {
video_done = 1;
video_read_length = package->video_end - video_position;
}
// Calculate samples rendered for progress bar.
- if(audio_done)
+ if( audio_done )
samples_rendered = Units::round((double)video_read_length /
asset->frame_rate *
asset->sample_rate);
need_video = 1;
}
- if(debug) PRINT_TRACE
-
- if(debug) printf("PackageRenderer::render_package 1 %d %jd %jd\n",
- result, audio_read_length, video_read_length);
- if(need_video && !result) do_video();
- if(debug) printf("PackageRenderer::render_package %d %d %d\n",
- __LINE__, result, samples_rendered);
- if(need_audio && !result) do_audio();
+ if( need_video && !result ) do_video();
+ if( need_audio && !result ) do_audio();
-
- if(debug) PRINT_TRACE
- if(!result)
- {
+ if( debug ) PRINT_TRACE
+ if( !result ) {
// Calculate frames per second for the renderfarm table.
total_samples_rendered += samples_rendered;
- if(!video_done && timer->get_difference() > 30000)
- {
+ if( !video_done && timer->get_difference() > 30000 ) {
frames_per_second = (double)total_samples_rendered *
asset->frame_rate /
asset->sample_rate /
}
set_progress(samples_rendered);
}
- if(debug) PRINT_TRACE
-
+ if( !result && progress_cancelled() ) result = 1;
-
-
- if(!result && progress_cancelled()) result = 1;
- if(debug) PRINT_TRACE
-
-// printf("PackageRenderer::render_package 10 %d %d %d %d\n",
// audio_read_length, video_read_length, samples_rendered, result);
- if(result)
+ if( result )
set_result(result);
else
result = get_result();
Edit *playable_edit = 0;
//printf("Render::direct_frame_copy 1\n");
- if(direct_copy_possible(edl,
+ if( direct_copy_possible(edl,
video_position,
playable_track,
playable_edit,
- file))
- {
+ file) ) {
// Switch to direct copying
- if(!direct_frame_copying)
- {
- if(video_write_position)
- {
+ if( !direct_frame_copying ) {
+ if( video_write_position ) {
error |= file->write_video_buffer(video_write_position);
video_write_position = 0;
}
}
//printf("Render::direct_frame_copy 2\n");
- if(!package->use_brender)
- {
+ if( !package->use_brender ) {
error |= ((VEdit*)playable_edit)->read_frame(compressed_output,
video_position,
PLAY_FORWARD,
}
- if(!error && video_preroll > 0)
- {
+ if( !error && video_preroll > 0 ) {
video_preroll--;
}
else
- if(!error)
- {
- if(package->use_brender)
- {
+ if( !error ) {
+ if( package->use_brender ) {
//printf("PackageRenderer::direct_frame_copy 1\n");
error = set_video_map(video_position, BRender::SCANNED);
//printf("PackageRenderer::direct_frame_copy 10 %d\n", error);
}
- else
- {
+ else {
VFrame ***temp_output = new VFrame**[1];
temp_output[0] = new VFrame*[1];
temp_output[0][0] = compressed_output;
Track* current_track;
// Number of playable tracks must equal 1
- for(current_track = edl->tracks->first;
+ for( current_track = edl->tracks->first;
current_track && result;
- current_track = current_track->next)
- {
- if(current_track->data_type == TRACK_VIDEO)
- {
- if(playable_tracks->is_playable(current_track,
+ current_track = current_track->next ) {
+ if( current_track->data_type == TRACK_VIDEO ) {
+ if( playable_tracks->is_playable(current_track,
current_position,
PLAY_FORWARD,
- 1))
- {
+ 1) ) {
playable_track = current_track;
total_playable_tracks++;
}
}
//printf("Render::direct_copy_possible 1 %d\n", result);
- if(total_playable_tracks != 1) result = 0;
+ if( total_playable_tracks != 1 ) result = 0;
//printf("Render::direct_copy_possible 2 %d\n", result);
// Edit must have a source file
// TODO: descend into nested EDL's
- if(result)
- {
+ if( result ) {
//printf("Render::direct_copy_possible 3 %d\n", result);
playable_edit = playable_track->edits->get_playable_edit(current_position, 1);
//printf("Render::direct_copy_possible 4 %d %p\n", result, playable_edit);
- if(!playable_edit)
+ if( !playable_edit )
result = 0;
}
// Source file must be able to copy to destination file.
// Source file must be same size as project output.
- if(result)
- {
- if(!file->can_copy_from(playable_edit->asset,
+ if( result ) {
+ if( !file->can_copy_from(playable_edit->asset,
current_position + playable_track->nudge,
edl->session->output_w,
- edl->session->output_h))
+ edl->session->output_h) )
result = 0;
}
//printf("Render::direct_copy_possible 6 %d\n", result);
// Test conditions mutual between vrender.C and this.
- if(result &&
- !playable_track->direct_copy_possible(current_position, PLAY_FORWARD, 1))
+ if( result &&
+ !playable_track->direct_copy_possible(current_position, PLAY_FORWARD, 1) )
result = 0;
//printf("Render::direct_copy_possible 7 %d\n", result);
}
-int PackagingEngineDefault::create_packages_single_farm(
- EDL *edl,
- Preferences *preferences,
- Asset *default_asset,
- double total_start,
- double total_end)
+int PackagingEngineDefault::create_packages_single_farm(EDL *edl,
+ Preferences *preferences, Asset *default_asset,
+ double total_start, double total_end)
{
this->total_start = total_start;
this->total_end = total_end;
audio_end = Units::to_int64(total_end * default_asset->sample_rate);
video_end = Units::to_int64(total_end * default_asset->frame_rate);
current_package = 0;
+ current_position = 0;
double total_len = total_end - total_start;
total_packages = preferences->renderfarm_job_count;
package_len = total_len / total_packages;
min_package_len = 2.0 / edl->session->frame_rate;
-
-//printf("PackageDispatcher::create_packages: %f / %d = %f\n", total_len, total_packages, package_len);
int current_number; // The number being injected into the filename.
int number_start; // Character in the filename path at which the number begins
int total_digits; // Total number of digits including padding the user specified.
Render::get_starting_number(default_asset->path,
- current_number,
- number_start,
- total_digits,
- 3);
+ current_number, number_start, total_digits, 3);
- for(int i = 0; i < total_allocated; i++)
- {
+ for( int i=0; i<total_allocated; ++i ) {
RenderPackage *package = packages[i] = new RenderPackage;
// Create file number differently if image file sequence
- Render::create_filename(package->path,
- default_asset->path,
- current_number,
- total_digits,
- number_start);
+ Render::create_filename(package->path, default_asset->path,
+ current_number, total_digits, number_start);
current_number++;
}
return 0;
}
RenderPackage* PackagingEngineDefault::get_package_single_farm(double frames_per_second,
- int client_number,
- int use_local_rate)
+ int client_number, int use_local_rate)
{
-
-//printf("PackageDispatcher::get_package %ld %ld %ld %ld\n", audio_position, video_position, audio_end, video_end);
-
- RenderPackage *result = 0;
- float avg_frames_per_second = preferences->get_avg_rate(use_local_rate);
-
- if(audio_position < audio_end ||
- video_position < video_end)
- {
+ RenderPackage *result = 0;
+ float avg_frames_per_second = preferences->get_avg_rate(use_local_rate);
+ double length = package_len;
+ int scaled_length = 0;
+
+ if( (default_asset->audio_data &&
+ (audio_position < audio_end && !EQUIV(audio_position, audio_end))) ||
+ (default_asset->video_data &&
+ (video_position < video_end && !EQUIV(video_position, video_end))) ) {
// Last package
- double scaled_len;
- result = packages[current_package];
- result->audio_start = audio_position;
- result->video_start = video_position;
- result->video_do = default_asset->video_data;
- result->audio_do = default_asset->audio_data;
-
- if(current_package >= total_allocated - 1)
- {
- result->audio_end = audio_end;
- result->video_end = video_end;
- audio_position = result->audio_end;
- video_position = result->video_end;
+ result = packages[current_package];
+ result->audio_start = audio_position;
+ result->video_start = video_position;
+ result->video_do = default_asset->video_data;
+ result->audio_do = default_asset->audio_data;
+
+ if( current_package >= total_allocated-1 ) {
+ result->audio_end = audio_end;
+ result->video_end = video_end;
+ audio_position = result->audio_end;
+ video_position = result->video_end;
+ }
+ else {
+ if( frames_per_second > 0 &&
+ !EQUIV(frames_per_second, 0) && !EQUIV(avg_frames_per_second, 0) ) {
+// package size to fit the requestor.
+ length *= frames_per_second / avg_frames_per_second;
+ scaled_length = 1;
}
- else
-// No useful speed data. May get infinity for real fast jobs.
- if(frames_per_second > 0x7fffff || frames_per_second < 0 ||
- EQUIV(frames_per_second, 0) ||
- EQUIV(avg_frames_per_second, 0))
- {
- scaled_len = MAX(package_len, min_package_len);
-
- result->audio_end = audio_position +
- Units::round(scaled_len * default_asset->sample_rate);
- result->video_end = video_position +
- Units::round(scaled_len * default_asset->frame_rate);
-
-// If we get here without any useful speed data render the whole thing.
- if(current_package >= total_packages - 1)
- {
- result->audio_end = audio_end;
- result->video_end = video_end;
- }
- else
- {
- result->audio_end = MIN(audio_end, result->audio_end);
- result->video_end = MIN(video_end, result->video_end);
- }
-
- audio_position = result->audio_end;
- video_position = result->video_end;
+ if( length < min_package_len )
+ length = min_package_len;
+ double end_position = current_position + length;
+
+ if( result->video_do ) {
+ int64_t video_end = end_position * default_asset->frame_rate;
+ result->video_end = MIN(this->video_end, video_end);
+ end_position = video_end / default_asset->frame_rate;
}
- else
-// Useful speed data and future packages exist. Scale the
-// package size to fit the requestor.
- {
- scaled_len = package_len *
- frames_per_second /
- avg_frames_per_second;
- scaled_len = MAX(scaled_len, min_package_len);
-
- result->audio_end = result->audio_start +
- Units::to_int64(scaled_len * default_asset->sample_rate);
- result->video_end = result->video_start +
- Units::to_int64(scaled_len * default_asset->frame_rate);
-
- result->audio_end = MIN(audio_end, result->audio_end);
- result->video_end = MIN(video_end, result->video_end);
-
- audio_position = result->audio_end;
- video_position = result->video_end;
+ if( result->audio_do ) {
+ int64_t audio_end = end_position * default_asset->sample_rate;
+ result->audio_end = MIN(this->audio_end, audio_end);
+ }
+ audio_position = result->audio_end;
+ video_position = result->video_end;
+ current_position = end_position;
// Package size is no longer touched between total_packages and total_allocated
- if(current_package < total_packages - 1)
- {
- package_len = (double)(audio_end - audio_position) /
- (double)default_asset->sample_rate /
- (double)(total_packages - current_package);
+ if( scaled_length && current_package < total_packages-1 ) {
+ double remaining =
+ result->audio_do ? (double)(audio_end - audio_position) /
+ default_asset->sample_rate :
+ result->video_do ? (double)(video_end - video_position) /
+ default_asset->frame_rate : 0;
+ if( remaining > 0 ) {
+ int jobs = total_packages - current_package;
+ package_len = remaining / jobs;
}
-
}
-
- current_package++;
-//printf("Dispatcher::get_package 50 %lld %lld %lld %lld\n",
-//result->audio_start,
-//result->video_start,
-//result->audio_end,
-//result->video_end);
}
- return result;
+ current_package++;
+//printf("Dispatcher::get_package 50 %lld %lld %lld %lld\n",
+// result->audio_start, result->video_start, result->audio_end, result->video_end);
+ }
+ return result;
}
void PackagingEngineDefault::get_package_paths(ArrayList<char*> *path_list)
{
- for(int i = 0; i < total_allocated; i++)
- {
+ for( int i=0; i<total_allocated; ++i ) {
path_list->append(strdup(packages[i]->path));
}
path_list->set_free();
}
+int PackagingEngineDefault::get_asset_list(ArrayList<Indexable *> &idxbls)
+{
+ for( int i=0; i<current_package; ++i ) {
+ Asset *asset = new Asset;
+ asset->copy_from(default_asset, 1);
+ strcpy(asset->path, packages[i]->path);
+ asset->video_length = packages[i]->video_end - packages[i]->video_start;
+ asset->audio_length = packages[i]->audio_end - packages[i]->audio_start;
+ idxbls.append(asset);
+ }
+ return current_package;
+}
+
int64_t PackagingEngineDefault::get_progress_max()
{
- return Units::to_int64(default_asset->sample_rate *
- (total_end - total_start)) +
- Units::to_int64(preferences->render_preroll *
- 2 *
- default_asset->sample_rate);
+ return Units::to_int64(default_asset->sample_rate * (total_end - total_start)) +
+ Units::to_int64(preferences->render_preroll * 2 * default_asset->sample_rate);
}
int PackagingEngineDefault::packages_are_done()
return 0;
}
-
-
-
int use_local_rate) = 0;
virtual int64_t get_progress_max() = 0;
virtual void get_package_paths(ArrayList<char*> *path_list) = 0;
+ virtual int get_asset_list(ArrayList<Indexable *> &idxbls) = 0;
virtual int packages_are_done() = 0;
};
int use_local_rate);
int64_t get_progress_max();
void get_package_paths(ArrayList<char*> *path_list);
+ int get_asset_list(ArrayList<Indexable *> &idxbls);
int packages_are_done();
private:
RenderPackage **packages;
int64_t video_position;
int64_t audio_end;
int64_t video_end;
+ double current_position;
int current_package;
Asset *default_asset;
Preferences *preferences;
if( !handler ) handler = !mwindow_gui->record->running() ?
(RemoteHandler *)mwindow_gui->cwindow_remote_handler :
(RemoteHandler *)mwindow_gui->record_remote_handler ;
+ gui->lock_window("RemoteControl::activate");
gui->set_active(handler);
gui->set_color(handler->color);
gui->fill_color(handler->color);
+ gui->unlock_window();
result = 1;
}
active_lock->unlock();
-
/*
* CINELERRA
* Copyright (C) 1997-2011 Adam Williams <broadcast at earthling dot net>
return 1;
}
-
-
-
-
-
-
-
-
-
RenderProgress::RenderProgress(MWindow *mwindow, Render *render)
: Thread(1, 0, 0)
{
void RenderProgress::run()
{
Thread::disable_cancel();
- while(1)
- {
- if(render->total_rendered != last_value)
- {
+ for( ;; ) {
+ if( render->total_rendered != last_value ) {
render->progress->update(render->total_rendered);
last_value = render->total_rendered;
- if(mwindow) mwindow->preferences_thread->update_rates();
+ if( mwindow ) mwindow->preferences_thread->update_rates();
}
Thread::enable_cancel();
void MainPackageRenderer::set_result(int value)
{
- if(value)
+ if( value )
render->result = value;
-
-
-
}
void MainPackageRenderer::set_progress(int64_t value)
//printf("MainPackageRenderer::set_progress %d %ld %f\n", __LINE__, (long)value, frames_per_second);
// If non interactive, print progress out
- if(!render->progress)
+ if( !render->progress )
render->show_progress();
render->counter_lock->unlock();
render->batch_cancelled;
}
+void RenderAssets::clear()
+{
+ for( int i=size(); --i>=0; get(i)->remove_user() );
+ remove_all();
+}
+RenderAssets::RenderAssets()
+{
+}
+RenderAssets::~RenderAssets()
+{
+ clear();
+}
Render::Render(MWindow *mwindow)
: BC_DialogThread()
void Render::start_batches(ArrayList<BatchRenderJob*> *jobs)
{
- if(!thread->running())
- {
+ if( !thread->running() ) {
mode = Render::BATCH;
batch_cancelled = 0;
this->jobs = jobs;
batch_cancelled = 0;
result = 0;
- if(mode == Render::INTERACTIVE) {
+ if( mode == Render::INTERACTIVE ) {
// Fix the asset for rendering
- if(!asset) asset = new Asset;
+ if( !asset ) asset = new Asset;
load_defaults(asset);
check_asset(mwindow->edl, *asset);
int px = mwindow->gui->get_pop_cursor_x(1);
void Render::handle_done_event(int result)
{
- if(!result) {
+ if( !result ) {
mwindow->edl->session->render_beep = beep;
// add to recentlist only on OK
render_window->render_format->path_recent->
error_box.run_window();
}
- if(!result) {
+ if( !result ) {
// Check the asset format for errors.
FormatCheck format_check(asset);
if( format_check.check_format() )
//PRINT_TRACE
if( !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__);
+ 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
}
void Render::stop_operation()
{
- if(thread->Thread::running())
- {
+ if( thread->Thread::running() ) {
batch_cancelled = 1;
// Wait for completion
completion->lock("Render::stop_operation");
int Render::check_asset(EDL *edl, Asset &asset)
{
- if(asset.video_data &&
+ if( asset.video_data &&
edl->tracks->playable_video_tracks() &&
- File::renders_video(&asset))
- {
+ File::renders_video(&asset) ) {
asset.video_data = 1;
asset.layers = 1;
asset.width = edl->session->output_w;
asset.height = edl->session->output_h;
asset.interlace_mode = edl->session->interlace_mode;
}
- else
- {
+ else {
asset.video_data = 0;
asset.layers = 0;
}
- if(asset.audio_data &&
+ if( asset.audio_data &&
edl->tracks->playable_audio_tracks() &&
- File::renders_audio(&asset))
- {
+ File::renders_audio(&asset) ) {
asset.audio_data = 1;
asset.channels = edl->session->audio_channels;
}
- else
- {
+ else {
asset.audio_data = 0;
asset.channels = 0;
}
- if(!asset.audio_data &&
- !asset.video_data)
- {
+ if( !asset.audio_data &&
+ !asset.video_data ) {
return 1;
}
return 0;
{
char filename[BCTEXTLEN];
char string[BCTEXTLEN];
- FileSystem fs;
-
progress_max = packages->get_progress_max();
progress_timer->update();
last_eta = 0;
- if(mwindow)
- {
+ if( mwindow ) {
// Generate the progress box
+ FileSystem fs;
fs.extract_name(filename, default_asset->path);
sprintf(string, _("Rendering %s..."), filename);
void Render::stop_progress()
{
- if(progress)
- {
+ if( progress ) {
char string[BCTEXTLEN], string2[BCTEXTLEN];
delete render_progress;
progress->get_time(string);
void Render::show_progress()
{
int64_t current_eta = progress_timer->get_scaled_difference(1000);
- if (current_eta - last_eta < 1000 ) return;
+ if( current_eta - last_eta < 1000 ) return;
double eta = !total_rendered ? 0 :
current_eta / 1000. * (progress_max / (double)total_rendered - 1.);
char string[BCTEXTLEN]; Units::totext(string, eta, TIME_HMS2);
int len = strlen(default_path);
char printf_string[BCTEXTLEN];
- for(i = 0, j = 0; i < number_start; i++, j++)
- {
+ for( i=0, j=0; i<number_start; ++i, ++j ) {
printf_string[j] = default_path[i];
}
i += total_digits;
// Copy remainder of string
- for( ; i < len; i++, j++)
- {
+ for( ; i<len; ++i, ++j ) {
printf_string[j] = default_path[i];
}
printf_string[j] = 0;
ptr2 = strrchr(path, '/');
// Search for first 0 after last /.
- if(ptr2)
+ if( ptr2 )
ptr = strchr(ptr2, '0');
- if(ptr && isdigit(*ptr))
- {
+ if( ptr && isdigit(*ptr) ) {
number_start = ptr - path;
// Store the first number
char *ptr2 = number_text;
- while(isdigit(*ptr))
- *ptr2++ = *ptr++;
+ while( isdigit(*ptr) ) *ptr2++ = *ptr++;
*ptr2++ = 0;
current_number = atol(number_text);
total_digits = strlen(number_text);
// No number found or number not long enough
- if(total_digits < min_digits)
- {
+ if( total_digits < min_digits ) {
current_number = 1;
number_start = len;
total_digits = min_digits;
return 0;
}
+void Render::update_assets()
+{
+ if( packages )
+ packages->get_asset_list(assets);
+}
static void run_script(const char *script, const char *arg)
{
// Total length in seconds
double total_length = 0;
RenderFarmServer *farm_server = 0;
- FileSystem fs;
- const int debug = 0;
render->in_progress = 1;
-
-
render->default_asset = asset;
render->progress = 0;
render->result = 0;
render->result = render->check_asset(command->get_edl(),
*render->default_asset);
- if(!render->result)
- {
+ if( !render->result ) {
// Get total range to render
render->total_start = command->start_position;
render->total_end = command->end_position;
total_length = render->total_end - render->total_start;
// Nothing to render
- if(EQUIV(total_length, 0))
- {
+ if( EQUIV(total_length, 0) ) {
render->result = 1;
}
}
render_frames = render->default_asset->frame_rate * total_length;
// Generate packages
- if(!render->result)
- {
+ if( !render->result ) {
// Stop background rendering
- if(mwindow) mwindow->stop_brender();
+ if( mwindow ) mwindow->stop_brender();
+ FileSystem fs;
fs.complete_path(render->default_asset->path);
- render->result = render->packages->create_packages(mwindow,
- command->get_edl(),
- render->preferences,
- strategy,
- render->default_asset,
- render->total_start,
- render->total_end,
- test_overwrite);
+ render->result = render->packages->create_packages(mwindow, command->get_edl(),
+ render->preferences, strategy, render->default_asset,
+ render->total_start, render->total_end, test_overwrite);
}
render->total_rendered = 0;
- if(!render->result)
- {
+ if( !render->result ) {
// Start dispatching external jobs
- if(mwindow)
- {
+ if( mwindow ) {
mwindow->gui->lock_window("Render::render 1");
mwindow->gui->show_message(_("Starting render farm"));
mwindow->gui->start_hourglass();
mwindow->gui->unlock_window();
}
- else
- {
+ else {
printf("Render::render: starting render farm\n");
}
- if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
- {
- farm_server = new RenderFarmServer(mwindow,
- render->packages,
- render->preferences,
- 1,
- &render->result,
- &render->total_rendered,
- render->counter_lock,
- render->default_asset,
- command->get_edl(),
- 0);
+ if( strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM ) {
+ farm_server = new RenderFarmServer(mwindow, render->packages,
+ render->preferences, 1, &render->result,
+ &render->total_rendered, render->counter_lock,
+ render->default_asset, command->get_edl(), 0);
render->result = farm_server->start_clients();
- if(render->result)
- {
- if(mwindow)
- {
+ if( render->result ) {
+ if( mwindow ) {
mwindow->gui->lock_window("Render::render 2");
mwindow->gui->show_message(_("Failed to start render farm"),
mwindow->theme->message_error);
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
}
- else
- {
+ else {
printf("Render::render: Failed to start render farm\n");
}
}
// Perform local rendering
- if(!render->result)
- {
+ render->assets.clear();
+ if( !render->result ) {
render->start_progress();
MainPackageRenderer package_renderer(render);
render->preferences,
render->default_asset);
- while(!render->result)
- {
+ while( !render->result ) {
+ int fps = strategy == SINGLE_PASS_FARM ?
+ package_renderer.frames_per_second : 0;
// Get unfinished job
- RenderPackage *package;
-
- if(strategy == SINGLE_PASS_FARM)
- {
- package = render->packages->get_package(
- package_renderer.frames_per_second,
- -1,
- 1);
- }
- else
- {
- package = render->packages->get_package(0, -1, 1);
- }
-
+ RenderPackage *package = render->packages->get_package(fps, -1, 1);
// Exit point
- if(!package)
- {
- break;
- }
+ if( !package ) break;
- if(package_renderer.render_package(package))
+ if( package_renderer.render_package(package) )
render->result = 1;
-
-
} // file_number
printf("Render::render_single: Session finished.\n");
render->result |= render->packages->packages_are_done();
}
-if(debug) printf("Render::render %d\n", __LINE__);
-
// Notify of error
- if(render->result &&
- (!render->progress || !render->progress->is_cancelled()) &&
- !render->batch_cancelled)
- {
-if(debug) printf("Render::render %d\n", __LINE__);
- if(mwindow)
- {
-if(debug) printf("Render::render %d\n", __LINE__);
+ if( render->result && !render->batch_cancelled &&
+ (!render->progress || !render->progress->is_cancelled()) ) {
+ if( mwindow ) {
int cx, cy;
mwindow->gui->get_abs_cursor(cx, cy, 1);
ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
error_box.create_objects(_("Error rendering data."));
error_box.raise_window();
error_box.run_window();
-if(debug) printf("Render::render %d\n", __LINE__);
}
- else
- {
+ else {
printf("Render::render: Error rendering data\n");
}
}
-if(debug) printf("Render::render %d\n", __LINE__);
// Delete the progress box
render->stop_progress();
-if(debug) printf("Render::render %d\n", __LINE__);
+ render->update_assets();
}
// Paste all packages into timeline if desired
- if(!render->result &&
- render->load_mode != LOADMODE_NOTHING &&
- mwindow &&
- render->mode != Render::BATCH)
- {
-if(debug) printf("Render::render %d\n", __LINE__);
+ if( !render->result && mwindow &&
+ render->load_mode != LOADMODE_NOTHING &&
+ render->mode != Render::BATCH ) {
mwindow->gui->lock_window("Render::render 3");
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->undo->update_undo_before();
-
-if(debug) printf("Render::render %d\n", __LINE__);
-
-
- ArrayList<Indexable*> *assets = render->packages->get_asset_list();
-if(debug) printf("Render::render %d\n", __LINE__);
- if(render->load_mode == LOADMODE_PASTE)
+ if( render->load_mode == LOADMODE_PASTE )
mwindow->clear(0);
-if(debug) printf("Render::render %d\n", __LINE__);
- mwindow->load_assets(assets, -1, render->load_mode, 0, 0,
+ mwindow->load_assets(&render->assets,
+ -1, render->load_mode, 0, 0,
mwindow->edl->session->labels_follow_edits,
mwindow->edl->session->plugins_follow_edits,
mwindow->edl->session->autos_follow_edits,
0); // overwrite
-if(debug) printf("Render::render %d\n", __LINE__);
- for(int i = 0; i < assets->size(); i++)
- assets->get(i)->Garbage::remove_user();
- delete assets;
-if(debug) printf("Render::render %d\n", __LINE__);
-
-
mwindow->save_backup();
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->undo->update_undo_after(_("render"), LOAD_ALL);
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->update_plugin_guis();
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->gui->update(1, FORCE_REDRAW, 1, 1, 1, 1, 0);
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->sync_parameters(CHANGE_ALL);
-if(debug) printf("Render::render %d\n", __LINE__);
mwindow->gui->unlock_window();
-
mwindow->awindow->gui->async_update_assets();
-
-if(debug) printf("Render::render %d\n", __LINE__);
}
-if(debug) printf("Render::render %d\n", __LINE__);
-
// Disable hourglass
- if(mwindow)
- {
+ if( mwindow ) {
mwindow->gui->lock_window("Render::render 3");
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
//printf("Render::render 110\n");
// Need to restart because brender always stops before render.
- if(mwindow)
+ if( mwindow )
mwindow->restart_brender();
- if(farm_server) delete farm_server;
+ if( farm_server ) delete farm_server;
delete command;
delete audio_cache;
delete video_cache;
render->packages = 0;
render->in_progress = 0;
-if(debug) printf("Render::render %d\n", __LINE__);
}
void RenderThread::run()
{
+ char *script = 0;
Timer render_timer;
if( mwindow )
render->preferences->copy_from(mwindow->preferences);
- if(render->mode == Render::INTERACTIVE)
- {
+ if( render->mode == Render::INTERACTIVE ) {
render_single(1, render->asset, mwindow->edl,
render->get_strategy(), render->range_type);
}
else
- if(render->mode == Render::BATCH)
- {
-// PRINT_TRACE
-// printf("RenderThread::run %d %d %d\n",
-// __LINE__,
-// render->jobs->total,
-// render->result);
- for(int i = 0; i < render->jobs->total && !render->result; i++)
- {
-//PRINT_TRACE
+ if( render->mode == Render::BATCH ) {
+ for( int i=0; i<render->jobs->total && !render->result; ++i ) {
BatchRenderJob *job = render->jobs->values[i];
-//PRINT_TRACE
- if(job->enabled)
- {
- if( *job->edl_path == '@' )
- {
- run_script(job->edl_path+1, job->asset->path);
- }
-
- if(mwindow)
- {
- mwindow->batch_render->update_active(i);
- }
- else
- {
- printf("Render::run: %s\n", job->edl_path);
- }
-
-//PRINT_TRACE
-
- FileXML *file = new FileXML;
- EDL *edl = new EDL;
- 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->get_strategy(), RANGE_BACKCOMPAT);
-
-//PRINT_TRACE
- edl->Garbage::remove_user();
- delete file;
- if(!render->result)
- {
- if(mwindow)
- mwindow->batch_render->update_done(i, 1, render->elapsed_time);
- else
- {
- char string[BCTEXTLEN];
- render->elapsed_time =
- (double)render->progress_timer->get_scaled_difference(1);
- Units::totext(string,
- render->elapsed_time,
- TIME_HMS2);
- printf("Render::run: done in %s\n", string);
- }
+ if( !job->enabled ) continue;
+ 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);
+ edl->load_xml(file, LOAD_ALL);
+ delete file;
+
+ render_single(0, job->asset, edl, job->get_strategy(), RANGE_BACKCOMPAT);
+ if( !render->result ) {
+ if( !i )
+ script = job->create_script(edl, &render->assets);
+ if( mwindow )
+ mwindow->batch_render->update_done(i, 1, render->elapsed_time);
+ else {
+ char string[BCTEXTLEN];
+ render->elapsed_time =
+ (double)render->progress_timer->get_scaled_difference(1);
+ Units::totext(string, render->elapsed_time, TIME_HMS2);
+ printf("Render::run: done in %s\n", string);
}
+ }
+ else {
+ if( mwindow )
+ mwindow->batch_render->update_active(-1);
else
- {
- if(mwindow)
- mwindow->batch_render->update_active(-1);
- else
- printf("Render::run: failed\n");
- }
+ printf("Render::run: failed\n");
}
-//PRINT_TRACE
}
-
- if(mwindow)
- {
+ if( mwindow ) {
mwindow->batch_render->update_active(-1);
mwindow->batch_render->update_done(-1, 0, 0);
}
}
render->completion->unlock();
- double render_time = render_timer.get_difference() / 1000.0;
- double render_rate = render_time > 0 ? render_frames / render_time : 0;
- printf("** rendered %jd frames in %0.3f secs, %0.3f fps\n",
- render_frames, render_time, render_rate);
+
+ if( !render->result ) {
+ double render_time = render_timer.get_difference() / 1000.0;
+ double render_rate = render_time > 0 ? render_frames / render_time : 0;
+ printf("** rendered %jd frames in %0.3f secs, %0.3f fps\n",
+ render_frames, render_time, render_rate);
+ }
if( render->mode == Render::INTERACTIVE && render->beep )
mwindow->beep(3000., 1.5, 0.5);
+
+ if( script ) {
+ if( !render->result )
+ run_script(script, 0);
+ delete [] script;
+ }
}
class RenderWindow;
+class RenderAssets : public ArrayList<Indexable *>
+{
+public:
+ RenderAssets();
+ ~RenderAssets();
+
+ void clear();
+};
class Render : public BC_DialogThread
{
void start_progress();
void stop_progress();
void show_progress();
+ void update_assets();
// Procedure the run function should use.
int mode;
MainProgressBar *progress;
RenderProgress *render_progress;
RenderThread *thread;
+ RenderAssets assets;
MWindow *mwindow;
PlayableTracks *playable_tracks;
PackageDispatcher *packages;
{
copy_settings(track);
edits->copy_from(track->edits);
- for(int i = 0; i < this->plugin_set.total; i++)
- delete this->plugin_set.values[i];
this->plugin_set.remove_all_objects();
- for(int i = 0; i < track->plugin_set.total; i++)
- {
+ for( int i=0; i<track->plugin_set.total; ++i ) {
PluginSet *new_plugin_set = plugin_set.append(new PluginSet(edl, this));
new_plugin_set->copy_from(track->plugin_set.values[i]);
}
projects / goodguy / cinelerra.git / commitdiff