4 * Copyright (C) 1997-2011 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include "awindowgui.h"
27 #include "batchrender.h"
28 #include "bcprogressbox.h"
29 #include "bcsignals.h"
32 #include "compresspopup.h"
33 #include "condition.h"
34 #include "confirmsave.h"
35 #include "cwindowgui.h"
40 #include "edlsession.h"
43 #include "filesystem.h"
45 #include "formatcheck.h"
46 #include "formatpopup.h"
47 #include "formattools.h"
48 #include "indexable.h"
52 #include "localsession.h"
53 #include "mainprogress.h"
54 #include "mainsession.h"
58 #include "mwindowgui.h"
60 #include "packagedispatcher.h"
61 #include "packagerenderer.h"
63 #include "playabletracks.h"
64 #include "preferences.h"
65 #include "preferencesthread.h"
66 #include "renderfarm.h"
68 #include "renderprofiles.h"
69 #include "statusbar.h"
73 #include "transportque.h"
76 #include "videoconfig.h"
84 RenderItem::RenderItem(MWindow *mwindow)
85 : BC_MenuItem(_("Render..."), _("Shift-R"), 'R')
87 this->mwindow = mwindow;
91 int RenderItem::handle_event()
93 mwindow->gui->unlock_window();
94 mwindow->render->start_interactive();
95 mwindow->gui->lock_window("RenderItem::handle_event");
108 RenderProgress::RenderProgress(MWindow *mwindow, Render *render)
111 this->mwindow = mwindow;
112 this->render = render;
114 Thread::set_synchronous(1);
117 RenderProgress::~RenderProgress()
124 void RenderProgress::run()
126 Thread::disable_cancel();
129 if(render->total_rendered != last_value)
131 render->progress->update(render->total_rendered);
132 last_value = render->total_rendered;
134 if(mwindow) mwindow->preferences_thread->update_rates();
137 Thread::enable_cancel();
139 Thread::disable_cancel();
145 MainPackageRenderer::MainPackageRenderer(Render *render)
148 this->render = render;
153 MainPackageRenderer::~MainPackageRenderer()
158 int MainPackageRenderer::get_master()
163 int MainPackageRenderer::get_result()
165 return render->result;
168 void MainPackageRenderer::set_result(int value)
171 render->result = value;
177 void MainPackageRenderer::set_progress(int64_t value)
179 render->counter_lock->lock("MainPackageRenderer::set_progress");
180 // Increase total rendered for all nodes
181 render->total_rendered += value;
183 // Update frames per second for master node
184 render->preferences->set_rate(frames_per_second, -1);
186 //printf("MainPackageRenderer::set_progress %d %ld %f\n", __LINE__, (long)value, frames_per_second);
188 // If non interactive, print progress out
189 if(!render->progress)
190 render->show_progress();
192 render->counter_lock->unlock();
195 mwindow->preferences->copy_rates_from(preferences);
198 int MainPackageRenderer::progress_cancelled()
200 return (render->progress && render->progress->is_cancelled()) ||
201 render->batch_cancelled;
205 Render::Render(MWindow *mwindow)
208 this->mwindow = mwindow;
212 package_lock = new Mutex("Render::package_lock");
213 counter_lock = new Mutex("Render::counter_lock");
214 completion = new Condition(0, "Render::completion");
215 progress_timer = new Timer;
216 range_type = RANGE_BACKCOMPAT;
217 preferences = new Preferences();
218 thread = new RenderThread(mwindow, this);
232 delete progress_timer;
233 if( asset ) asset->Garbage::remove_user();
237 void Render::start_interactive()
239 if( !thread->running() ) {
240 mode = Render::INTERACTIVE;
241 BC_DialogThread::start();
243 else if( in_progress ) {
245 mwindow->gui->get_abs_cursor(cx, cy, 1);
246 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
247 error_box.create_objects(_("Already rendering"));
248 error_box.raise_window();
249 error_box.run_window();
251 else if( render_window ) {
252 render_window->raise_window();
257 void Render::start_batches(ArrayList<BatchRenderJob*> *jobs)
259 if(!thread->running())
261 mode = Render::BATCH;
267 else if( in_progress ) {
269 mwindow->gui->get_abs_cursor(cx, cy, 1);
270 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
271 error_box.create_objects("Already rendering");
272 error_box.raise_window();
273 error_box.run_window();
275 // raise the window if rendering hasn't started yet
276 else if( render_window ) {
277 render_window->raise_window();
281 void Render::start_batches(ArrayList<BatchRenderJob*> *jobs,
282 BC_Hash *boot_defaults, Preferences *batch_prefs)
284 mode = Render::BATCH;
286 preferences->copy_from(batch_prefs);
294 BC_Window* Render::new_gui()
300 if(mode == Render::INTERACTIVE) {
301 // Fix the asset for rendering
302 if(!asset) asset = new Asset;
303 load_defaults(asset);
304 check_asset(mwindow->edl, *asset);
305 int px = mwindow->gui->get_pop_cursor_x(1);
306 int py = mwindow->gui->get_pop_cursor_y(1);
307 // Get format from user
308 render_window = new RenderWindow(mwindow, this, asset, px, py);
309 render_window->create_objects();
312 return render_window;
315 void Render::handle_done_event(int result)
318 mwindow->edl->session->render_beep = beep;
319 // add to recentlist only on OK
320 render_window->render_format->path_recent->
321 add_item(File::formattostr(asset->format), asset->path);
322 setenv("CIN_RENDER", asset->path, 1);
327 void Render::handle_close_event(int result)
330 double render_range = get_render_range();
331 const char *err_msg = 0;
333 if( !result && !render_range ) {
334 err_msg = _("zero render range");
337 if( !result && asset->video_data ) {
338 double frame_rate = mwindow->edl->session->frame_rate;
339 if( frame_rate > 0 && render_range+1e-3 < 1./frame_rate ) {
340 err_msg = _("Video data and range less than 1 frame");
344 if( !result && asset->audio_data ) {
345 double sample_rate = mwindow->edl->session->sample_rate;
346 if( sample_rate > 0 && render_range+1e-6 < 1./sample_rate ) {
347 err_msg = _("Audio data and range less than 1 sample");
351 if( !result && File::is_image_render(asset->format) ) {
352 if( asset->video_data ) {
353 double frames = render_range * mwindow->edl->session->frame_rate;
354 if( !EQUIV(frames, 1.) ) {
355 err_msg = _("Image format and not 1 frame");
360 err_msg = _("Image format and no video data");
366 mwindow->gui->get_abs_cursor(cx, cy, 1);
367 ErrorBox error_box(_(PROGRAM_NAME ": Error"),cx, cy);
368 error_box.create_objects(err_msg);
369 error_box.raise_window();
370 error_box.run_window();
374 // Check the asset format for errors.
375 FormatCheck format_check(asset);
376 if( format_check.check_format() )
382 save_defaults(asset);
384 mwindow->save_defaults();
388 if(debug) printf("Render::handle_close_event %d\n", __LINE__);
389 if(!result) start_render();
390 if(debug) printf("Render::handle_close_event %d\n", __LINE__);
397 void Render::stop_operation()
399 if(thread->Thread::running())
402 // Wait for completion
403 completion->lock("Render::stop_operation");
408 int Render::check_asset(EDL *edl, Asset &asset)
410 if(asset.video_data &&
411 edl->tracks->playable_video_tracks() &&
412 File::renders_video(&asset))
414 asset.video_data = 1;
416 asset.width = edl->session->output_w;
417 asset.height = edl->session->output_h;
418 asset.interlace_mode = edl->session->interlace_mode;
422 asset.video_data = 0;
426 if(asset.audio_data &&
427 edl->tracks->playable_audio_tracks() &&
428 File::renders_audio(&asset))
430 asset.audio_data = 1;
431 asset.channels = edl->session->audio_channels;
435 asset.audio_data = 0;
439 if(!asset.audio_data &&
447 int Render::get_strategy(int use_renderfarm, int use_labels)
449 return use_renderfarm ?
450 (use_labels ? FILE_PER_LABEL_FARM : SINGLE_PASS_FARM) :
451 (use_labels ? FILE_PER_LABEL : SINGLE_PASS ) ;
453 int Render::get_strategy()
455 return get_strategy(preferences->use_renderfarm, use_labels);
458 void Render::start_progress()
460 char filename[BCTEXTLEN];
461 char string[BCTEXTLEN];
464 progress_max = packages->get_progress_max();
466 progress_timer->update();
470 // Generate the progress box
471 fs.extract_name(filename, default_asset->path);
472 sprintf(string, _("Rendering %s..."), filename);
474 // Don't bother with the filename since renderfarm defeats the meaning
475 progress = mwindow->mainprogress->start_progress(_("Rendering..."),
477 render_progress = new RenderProgress(mwindow, this);
478 render_progress->start();
482 void Render::stop_progress()
486 char string[BCTEXTLEN], string2[BCTEXTLEN];
487 delete render_progress;
488 progress->get_time(string);
489 elapsed_time = progress->get_time();
490 progress->stop_progress();
493 sprintf(string2, _("Rendering took %s"), string);
494 mwindow->gui->lock_window("");
495 mwindow->gui->show_message(string2);
496 mwindow->gui->update_default_message();
497 mwindow->gui->stop_hourglass();
498 mwindow->gui->unlock_window();
503 void Render::show_progress()
505 int64_t current_eta = progress_timer->get_scaled_difference(1000);
506 if (current_eta - last_eta < 1000 ) return;
507 double eta = !total_rendered ? 0 :
508 current_eta / 1000. * (progress_max / (double)total_rendered - 1.);
509 char string[BCTEXTLEN]; Units::totext(string, eta, TIME_HMS2);
510 printf("\r%d%% %s: %s ",
511 (int)(100 * (float)total_rendered / progress_max), _("ETA"), string);
513 last_eta = current_eta;
518 void Render::start_render()
528 void Render::create_filename(char *path,
535 int len = strlen(default_path);
536 char printf_string[BCTEXTLEN];
538 for(i = 0, j = 0; i < number_start; i++, j++)
540 printf_string[j] = default_path[i];
544 sprintf(&printf_string[j], "%%0%dd", total_digits);
545 j = strlen(printf_string);
548 // Copy remainder of string
549 for( ; i < len; i++, j++)
551 printf_string[j] = default_path[i];
553 printf_string[j] = 0;
554 // Print the printf argument to the path
555 sprintf(path, printf_string, current_number);
558 void Render::get_starting_number(char *path,
564 int len = strlen(path);
565 char number_text[BCTEXTLEN];
573 ptr2 = strrchr(path, '/');
575 // Search for first 0 after last /.
577 ptr = strchr(ptr2, '0');
579 if(ptr && isdigit(*ptr))
581 number_start = ptr - path;
583 // Store the first number
584 char *ptr2 = number_text;
588 current_number = atol(number_text);
589 total_digits = strlen(number_text);
593 // No number found or number not long enough
594 if(total_digits < min_digits)
598 total_digits = min_digits;
603 int Render::load_defaults(Asset *asset)
605 use_labels = mwindow->defaults->get("RENDER_FILE_PER_LABEL", 0);
606 load_mode = mwindow->defaults->get("RENDER_LOADMODE", LOADMODE_NEW_TRACKS);
607 range_type = mwindow->defaults->get("RENDER_RANGE_TYPE", RANGE_PROJECT);
609 // some defaults which work
610 asset->video_data = 1;
611 asset->audio_data = 1;
612 asset->format = FILE_FFMPEG;
613 strcpy(asset->acodec, "mp4.qt");
614 strcpy(asset->vcodec, "mp4.qt");
616 asset->load_defaults(mwindow->defaults,
617 "RENDER_", 1, 1, 1, 1, 1);
621 int Render::load_profile(int profile_slot, Asset *asset)
623 char string_name[100];
624 sprintf(string_name, "RENDER_%i_FILE_PER_LABEL", profile_slot);
625 use_labels = mwindow->defaults->get(string_name, 0);
626 // Load mode is not part of the profile
627 // printf(string_name, "RENDER_%i_LOADMODE", profile_slot);
628 // load_mode = mwindow->defaults->get(string_name, LOADMODE_NEW_TRACKS);
629 sprintf(string_name, "RENDER_%i_RANGE_TYPE", profile_slot);
630 range_type = mwindow->defaults->get(string_name, RANGE_PROJECT);
632 sprintf(string_name, "RENDER_%i_", profile_slot);
633 asset->load_defaults(mwindow->defaults,
634 string_name, 1, 1, 1, 1, 1);
639 int Render::save_defaults(Asset *asset)
641 mwindow->defaults->update("RENDER_FILE_PER_LABEL", use_labels);
642 mwindow->defaults->update("RENDER_LOADMODE", load_mode);
643 mwindow->defaults->update("RENDER_RANGE_TYPE", range_type);
645 asset->save_defaults(mwindow->defaults,
646 "RENDER_", 1, 1, 1, 1, 1);
651 static void run_script(const char *script, const char *arg)
653 char *const argv[] = { (char*)script, (char*)arg, 0 };
654 execvp(script ,&argv[0]);
655 perror("execvp script failed");
659 RenderThread::RenderThread(MWindow *mwindow, Render *render)
662 this->mwindow = mwindow;
663 this->render = render;
666 RenderThread::~RenderThread()
671 void RenderThread::render_single(int test_overwrite, Asset *asset, EDL *edl,
672 int strategy, int range_type)
674 // Total length in seconds
676 RenderFarmServer *farm_server = 0;
680 render->in_progress = 1;
683 render->default_asset = asset;
684 render->progress = 0;
687 // Create rendering command
688 TransportCommand *command = new TransportCommand;
689 command->command = NORMAL_FWD;
690 command->get_edl()->copy_all(edl);
691 command->change_type = CHANGE_ALL;
693 switch( range_type ) {
694 case RANGE_BACKCOMPAT:
695 // Get highlighted playback range
696 command->set_playback_range();
697 // Adjust playback range with in/out points
698 command->playback_range_adjust_inout();
701 command->playback_range_project();
703 case RANGE_SELECTION:
704 command->set_playback_range();
707 command->playback_range_inout();
710 command->playback_range_1frame();
714 render->packages = new PackageDispatcher;
717 CICache *audio_cache = new CICache(render->preferences);
718 CICache *video_cache = new CICache(render->preferences);
720 render->default_asset->frame_rate = command->get_edl()->session->frame_rate;
721 render->default_asset->sample_rate = command->get_edl()->session->sample_rate;
723 // Conform asset to EDL. Find out if any tracks are playable.
724 render->result = render->check_asset(command->get_edl(),
725 *render->default_asset);
729 // Get total range to render
730 render->total_start = command->start_position;
731 render->total_end = command->end_position;
732 total_length = render->total_end - render->total_start;
735 if(EQUIV(total_length, 0))
744 // Stop background rendering
745 if(mwindow) mwindow->stop_brender();
747 fs.complete_path(render->default_asset->path);
749 render->result = render->packages->create_packages(mwindow,
753 render->default_asset,
759 render->total_rendered = 0;
763 // Start dispatching external jobs
766 mwindow->gui->lock_window("Render::render 1");
767 mwindow->gui->show_message(_("Starting render farm"));
768 mwindow->gui->start_hourglass();
769 mwindow->gui->unlock_window();
773 printf("Render::render: starting render farm\n");
776 if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
778 farm_server = new RenderFarmServer(mwindow,
783 &render->total_rendered,
784 render->counter_lock,
785 render->default_asset,
788 render->result = farm_server->start_clients();
794 mwindow->gui->lock_window("Render::render 2");
795 mwindow->gui->show_message(_("Failed to start render farm"),
796 mwindow->theme->message_error);
797 mwindow->gui->stop_hourglass();
798 mwindow->gui->unlock_window();
802 printf("Render::render: Failed to start render farm\n");
808 // Perform local rendering
813 render->start_progress();
818 MainPackageRenderer package_renderer(render);
819 render->result = package_renderer.initialize(mwindow,
820 command->get_edl(), // Copy of master EDL
822 render->default_asset);
830 while(!render->result)
832 // Get unfinished job
833 RenderPackage *package;
835 if(strategy == SINGLE_PASS_FARM)
837 package = render->packages->get_package(
838 package_renderer.frames_per_second,
844 package = render->packages->get_package(0, -1, 1);
853 if(package_renderer.render_package(package))
861 printf("Render::render_single: Session finished.\n");
867 if( strategy == SINGLE_PASS_FARM ||
868 strategy == FILE_PER_LABEL_FARM ) {
869 if( !render->progress ) {
870 while( farm_server->active_clients() > 0 ) {
872 render->show_progress();
875 farm_server->wait_clients();
876 render->result |= render->packages->packages_are_done();
879 if(debug) printf("Render::render %d\n", __LINE__);
883 (!render->progress || !render->progress->is_cancelled()) &&
884 !render->batch_cancelled)
886 if(debug) printf("Render::render %d\n", __LINE__);
889 if(debug) printf("Render::render %d\n", __LINE__);
891 mwindow->gui->get_abs_cursor(cx, cy, 1);
892 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
893 error_box.create_objects(_("Error rendering data."));
894 error_box.raise_window();
895 error_box.run_window();
896 if(debug) printf("Render::render %d\n", __LINE__);
900 printf("Render::render: Error rendering data\n");
903 if(debug) printf("Render::render %d\n", __LINE__);
905 // Delete the progress box
906 render->stop_progress();
908 if(debug) printf("Render::render %d\n", __LINE__);
912 // Paste all packages into timeline if desired
914 if(!render->result &&
915 render->load_mode != LOADMODE_NOTHING &&
917 render->mode != Render::BATCH)
919 if(debug) printf("Render::render %d\n", __LINE__);
920 mwindow->gui->lock_window("Render::render 3");
921 if(debug) printf("Render::render %d\n", __LINE__);
923 mwindow->undo->update_undo_before();
925 if(debug) printf("Render::render %d\n", __LINE__);
928 ArrayList<Indexable*> *assets = render->packages->get_asset_list();
929 if(debug) printf("Render::render %d\n", __LINE__);
930 if(render->load_mode == LOADMODE_PASTE)
932 if(debug) printf("Render::render %d\n", __LINE__);
933 mwindow->load_assets(assets, -1, render->load_mode, 0, 0,
934 mwindow->edl->session->labels_follow_edits,
935 mwindow->edl->session->plugins_follow_edits,
936 mwindow->edl->session->autos_follow_edits,
938 if(debug) printf("Render::render %d\n", __LINE__);
939 for(int i = 0; i < assets->size(); i++)
940 assets->get(i)->Garbage::remove_user();
942 if(debug) printf("Render::render %d\n", __LINE__);
945 mwindow->save_backup();
946 if(debug) printf("Render::render %d\n", __LINE__);
947 mwindow->undo->update_undo_after(_("render"), LOAD_ALL);
948 if(debug) printf("Render::render %d\n", __LINE__);
949 mwindow->update_plugin_guis();
950 if(debug) printf("Render::render %d\n", __LINE__);
951 mwindow->gui->update(1, FORCE_REDRAW, 1, 1, 1, 1, 0);
952 if(debug) printf("Render::render %d\n", __LINE__);
953 mwindow->sync_parameters(CHANGE_ALL);
954 if(debug) printf("Render::render %d\n", __LINE__);
955 mwindow->gui->unlock_window();
958 mwindow->awindow->gui->async_update_assets();
960 if(debug) printf("Render::render %d\n", __LINE__);
963 if(debug) printf("Render::render %d\n", __LINE__);
968 mwindow->gui->lock_window("Render::render 3");
969 mwindow->gui->stop_hourglass();
970 mwindow->gui->unlock_window();
973 //printf("Render::render 110\n");
974 // Need to restart because brender always stops before render.
976 mwindow->restart_brender();
977 if(farm_server) delete farm_server;
981 // Must delete packages after server
982 delete render->packages;
984 render->packages = 0;
985 render->in_progress = 0;
986 if(debug) printf("Render::render %d\n", __LINE__);
989 void RenderThread::run()
992 render->preferences->copy_from(mwindow->preferences);
994 if(render->mode == Render::INTERACTIVE)
996 render_single(1, render->asset, mwindow->edl,
997 render->get_strategy(), render->range_type);
1000 if(render->mode == Render::BATCH)
1003 // printf("RenderThread::run %d %d %d\n",
1005 // render->jobs->total,
1007 for(int i = 0; i < render->jobs->total && !render->result; i++)
1010 BatchRenderJob *job = render->jobs->values[i];
1014 if( *job->edl_path == '@' )
1016 run_script(job->edl_path+1, job->asset->path);
1021 mwindow->batch_render->update_active(i);
1025 printf("Render::run: %s\n", job->edl_path);
1030 FileXML *file = new FileXML;
1032 edl->create_objects();
1033 file->read_from_file(job->edl_path);
1034 edl->load_xml(file, LOAD_ALL);
1036 render_single(0, job->asset, edl, job->get_strategy(), RANGE_BACKCOMPAT);
1039 edl->Garbage::remove_user();
1044 mwindow->batch_render->update_done(i, 1, render->elapsed_time);
1047 char string[BCTEXTLEN];
1048 render->elapsed_time =
1049 (double)render->progress_timer->get_scaled_difference(1);
1050 Units::totext(string,
1051 render->elapsed_time,
1053 printf("Render::run: done in %s\n", string);
1059 mwindow->batch_render->update_active(-1);
1061 printf("Render::run: failed\n");
1069 mwindow->batch_render->update_active(-1);
1070 mwindow->batch_render->update_done(-1, 0, 0);
1073 render->completion->unlock();
1075 if( render->mode == Render::INTERACTIVE && render->beep )
1076 mwindow->beep(3000., 1.5, 0.5);
1084 RenderWindow::RenderWindow(MWindow *mwindow,
1089 : BC_Window(_(PROGRAM_NAME ": Render"), x, y,
1090 WIDTH, HEIGHT, WIDTH, HEIGHT, 0, 0, 1)
1092 this->mwindow = mwindow;
1093 this->render = render;
1094 this->asset = asset;
1104 RenderWindow::~RenderWindow()
1106 lock_window("RenderWindow::~RenderWindow");
1107 delete render_format;
1109 delete renderprofile;
1114 void RenderWindow::load_profile(int profile_slot)
1116 render->load_profile(profile_slot, asset);
1117 update_range_type(render->range_type);
1118 render_format->update(asset, &render->use_labels);
1122 void RenderWindow::create_objects()
1125 lock_window("RenderWindow::create_objects");
1126 add_subwindow(new BC_Title(x, y,
1127 (char*)(render->use_labels ?
1128 _("Select the first file to render to:") :
1129 _("Select a file to render to:"))));
1132 render_format = new RenderFormat(mwindow, this, asset);
1133 render_format->create_objects(x, y,
1134 1, 1, 1, 1, 0, 1, 0, 0, &render->use_labels, 0);
1137 add_subwindow(title = new BC_Title(x, y, _("Render range:")));
1139 int is_image = File::is_image_render(asset->format);
1141 render->range_type = RANGE_1FRAME;
1143 int x1 = x + title->get_w() + 20, y1 = y;
1144 add_subwindow(rangeproject = new RenderRangeProject(this,
1145 render->range_type == RANGE_PROJECT, x1, y));
1146 int x2 = x1 + rangeproject->get_w();
1148 add_subwindow(rangeselection = new RenderRangeSelection(this,
1149 render->range_type == RANGE_SELECTION, x1, y));
1150 int x3 = x1 + rangeselection->get_w();
1151 if( x2 < x3 ) x2 = x3;
1153 add_subwindow(rangeinout = new RenderRangeInOut(this,
1154 render->range_type == RANGE_INOUT, x1, y));
1155 x3 = x1 + rangeinout->get_w();
1156 if( x2 < x3 ) x2 = x3;
1158 add_subwindow(range1frame = new RenderRange1Frame(this,
1159 render->range_type == RANGE_1FRAME, x1, y));
1160 x3 = x1 + range1frame->get_w();
1161 if( x2 < x3 ) x2 = x3;
1164 enable_render_range(0);
1167 render->beep = mwindow->edl->session->render_beep;
1168 add_subwindow(beep_on_done = new RenderBeepOnDone(this, x1, y1));
1170 renderprofile = new RenderProfile(mwindow, this, x, y, 1);
1171 renderprofile->create_objects();
1174 loadmode = new LoadMode(mwindow, this, x, y, &render->load_mode, 1);
1175 loadmode->create_objects();
1177 add_subwindow(new BC_OKButton(this));
1178 add_subwindow(new BC_CancelButton(this));
1184 void RenderWindow::update_range_type(int range_type)
1186 if( render->range_type == range_type ) return;
1187 render->range_type = range_type;
1188 rangeproject->update(range_type == RANGE_PROJECT);
1189 rangeselection->update(range_type == RANGE_SELECTION);
1190 rangeinout->update(range_type == RANGE_INOUT);
1191 range1frame->update(range_type == RANGE_1FRAME);
1194 void RenderWindow::enable_render_range(int v)
1197 rangeproject->enable();
1198 rangeselection->enable();
1199 rangeinout->enable();
1200 range1frame->enable();
1203 rangeproject->disable();
1204 rangeselection->disable();
1205 rangeinout->disable();
1206 range1frame->disable();
1211 RenderRangeProject::RenderRangeProject(RenderWindow *rwindow, int value, int x, int y)
1212 : BC_Radial(x, y, value, _("Project"))
1214 this->rwindow = rwindow;
1216 int RenderRangeProject::handle_event()
1218 rwindow->update_range_type(RANGE_PROJECT);
1222 RenderRangeSelection::RenderRangeSelection(RenderWindow *rwindow, int value, int x, int y)
1223 : BC_Radial(x, y, value, _("Selection"))
1225 this->rwindow = rwindow;
1227 int RenderRangeSelection::handle_event()
1229 rwindow->update_range_type(RANGE_SELECTION);
1234 RenderRangeInOut::RenderRangeInOut(RenderWindow *rwindow, int value, int x, int y)
1235 : BC_Radial(x, y, value, _("In/Out Points"))
1237 this->rwindow = rwindow;
1239 int RenderRangeInOut::handle_event()
1241 rwindow->update_range_type(RANGE_INOUT);
1245 RenderRange1Frame::RenderRange1Frame(RenderWindow *rwindow, int value, int x, int y)
1246 : BC_Radial(x, y, value, _("One Frame"))
1248 this->rwindow = rwindow;
1250 int RenderRange1Frame::handle_event()
1252 rwindow->update_range_type(RANGE_1FRAME);
1256 double Render::get_render_range()
1258 EDL *edl = mwindow->edl;
1259 double last = edl->tracks->total_playable_length();
1260 double framerate = edl->session->frame_rate;
1261 if( framerate <= 0 ) framerate = 1;
1262 double start = 0, end = last;
1263 switch( range_type ) {
1265 case RANGE_BACKCOMPAT:
1266 start = edl->local_session->get_selectionstart(1);
1267 end = edl->local_session->get_selectionend(1);
1268 if( EQUIV(start, end) ) end = last;
1272 case RANGE_SELECTION:
1273 start = edl->local_session->get_selectionstart(1);
1274 end = edl->local_session->get_selectionend(1);
1277 start = edl->local_session->inpoint_valid() ?
1278 edl->local_session->get_inpoint() : 0;
1279 end = edl->local_session->outpoint_valid() ?
1280 edl->local_session->get_outpoint() : last;
1283 start = end = edl->local_session->get_selectionstart(1);
1284 if( edl->session->frame_rate > 0 ) end += 1./edl->session->frame_rate;
1287 if( start < 0 ) start = 0;
1288 if( end > last ) end = last;
1292 RenderFormat::RenderFormat(MWindow *mwindow, BC_WindowBase *window, Asset *asset)
1293 : FormatTools(mwindow, window, asset)
1296 RenderFormat::~RenderFormat()
1300 void RenderFormat::update_format()
1302 FormatTools::update_format();
1303 RenderWindow *render_window = (RenderWindow *)window;
1304 if( render_window->is_hidden() ) return;
1306 int is_image = File::is_image_render(asset->format);
1308 render_window->update_range_type(RANGE_1FRAME);
1309 render_window->enable_render_range(0);
1312 render_window->enable_render_range(1);
1315 RenderBeepOnDone::RenderBeepOnDone(RenderWindow *rwindow, int x, int y)
1316 : BC_CheckBox(x, y, rwindow->render->beep, _("Beep on done"))
1318 this->rwindow = rwindow;
1321 int RenderBeepOnDone::handle_event()
1323 rwindow->render->beep = get_value();