cinelerra-5.1/cinelerra/render.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 1997-2011 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "arender.h"
  22 #include "asset.h"
  23 #include "auto.h"
  24 #include "awindow.h"
  25 #include "awindowgui.h"
  26 #include "batchrender.h"
  27 #include "bcprogressbox.h"
  28 #include "bcsignals.h"
  29 #include "cache.h"
  30 #include "clip.h"
  31 #include "compresspopup.h"
  32 #include "condition.h"
  33 #include "confirmsave.h"
  34 #include "cwindowgui.h"
  35 #include "cwindow.h"
  36 #include "bchash.h"
  37 #include "edits.h"
  38 #include "edl.h"
  39 #include "edlsession.h"
  40 #include "errorbox.h"
  41 #include "file.h"
  42 #include "filesystem.h"
  43 #include "filexml.h"
  44 #include "formatcheck.h"
  45 #include "formatpopup.h"
  46 #include "formattools.h"
  47 #include "indexable.h"
  48 #include "labels.h"
  49 #include "language.h"
  50 #include "loadmode.h"
  51 #include "localsession.h"
  52 #include "mainprogress.h"
  53 #include "mainsession.h"
  54 #include "mainundo.h"
  55 #include "module.h"
  56 #include "mutex.h"
  57 #include "mwindowgui.h"
  58 #include "mwindow.h"
  59 #include "packagedispatcher.h"
  60 #include "packagerenderer.h"
  61 #include "patchbay.h"
  62 #include "playabletracks.h"
  63 #include "preferences.h"
  64 #include "preferencesthread.h"
  65 #include "renderfarm.h"
  66 #include "render.h"
  67 #include "renderprofiles.h"
  68 #include "statusbar.h"
  69 #include "theme.h"
  70 #include "timebar.h"
  71 #include "tracks.h"
  72 #include "transportque.h"
  73 #include "vedit.h"
  74 #include "vframe.h"
  75 #include "videoconfig.h"
  76 #include "vrender.h"
  77
  78 #include <ctype.h>
  79 #include <string.h>
  80
  81
  82
  83 RenderItem::RenderItem(MWindow *mwindow)
  84  : BC_MenuItem(_("Render..."), _("Shift-R"), 'R')
  85 {
  86         this->mwindow = mwindow;
  87         set_shift(1);
  88 }
  89
  90 int RenderItem::handle_event()
  91 {
  92         mwindow->gui->unlock_window();
  93         mwindow->render->start_interactive();
  94         mwindow->gui->lock_window("RenderItem::handle_event");
  95         return 1;
  96 }
  97
  98 RenderProgress::RenderProgress(MWindow *mwindow, Render *render)
  99  : Thread(1, 0, 0)
 100 {
 101         this->mwindow = mwindow;
 102         this->render = render;
 103         last_value = 0;
 104         Thread::set_synchronous(1);
 105 }
 106
 107 RenderProgress::~RenderProgress()
 108 {
 109         Thread::cancel();
 110         Thread::join();
 111 }
 112
 113
 114 void RenderProgress::run()
 115 {
 116         Thread::disable_cancel();
 117         for( ;; ) {
 118                 if( render->total_rendered != last_value ) {
 119                         render->progress->update(render->total_rendered);
 120                         last_value = render->total_rendered;
 121
 122                         if( mwindow ) mwindow->preferences_thread->update_rates();
 123                 }
 124
 125                 Thread::enable_cancel();
 126                 sleep(1);
 127                 Thread::disable_cancel();
 128         }
 129 }
 130
 131
 132
 133 MainPackageRenderer::MainPackageRenderer(Render *render)
 134  : PackageRenderer()
 135 {
 136         this->render = render;
 137 }
 138
 139
 140
 141 MainPackageRenderer::~MainPackageRenderer()
 142 {
 143 }
 144
 145
 146 int MainPackageRenderer::get_master()
 147 {
 148         return 1;
 149 }
 150
 151 int MainPackageRenderer::get_result()
 152 {
 153         return render->result;
 154 }
 155
 156 void MainPackageRenderer::set_result(int value)
 157 {
 158         if( value )
 159                 render->result = value;
 160 }
 161
 162 void MainPackageRenderer::set_progress(int64_t value)
 163 {
 164         render->counter_lock->lock("MainPackageRenderer::set_progress");
 165 // Increase total rendered for all nodes
 166         render->total_rendered += value;
 167
 168 // Update frames per second for master node
 169         render->preferences->set_rate(frames_per_second, -1);
 170
 171 //printf("MainPackageRenderer::set_progress %d %ld %f\n", __LINE__, (long)value, frames_per_second);
 172
 173 // If non interactive, print progress out
 174         if( !render->progress )
 175                 render->show_progress();
 176
 177         render->counter_lock->unlock();
 178
 179         if( mwindow )
 180                 mwindow->preferences->copy_rates_from(preferences);
 181 }
 182
 183 int MainPackageRenderer::progress_cancelled()
 184 {
 185         return (render->progress && render->progress->is_cancelled()) ||
 186                 render->batch_cancelled;
 187 }
 188
 189 void RenderAssets::clear()
 190 {
 191         for( int i=size(); --i>=0; get(i)->remove_user() );
 192         remove_all();
 193 }
 194 RenderAssets::RenderAssets()
 195 {
 196 }
 197 RenderAssets::~RenderAssets()
 198 {
 199          clear();
 200 }
 201
 202 Render::Render(MWindow *mwindow)
 203  : BC_DialogThread()
 204 {
 205         this->mwindow = mwindow;
 206         in_progress = 0;
 207         progress = 0;
 208         elapsed_time = 0.0;
 209         package_lock = new Mutex("Render::package_lock");
 210         counter_lock = new Mutex("Render::counter_lock");
 211         completion = new Condition(0, "Render::completion");
 212         progress_timer = new Timer;
 213         range_type = RANGE_BACKCOMPAT;
 214         preferences = new Preferences();
 215         thread = new RenderThread(mwindow, this);
 216         render_window = 0;
 217         asset = 0;
 218         result = 0;
 219         beep = 0;
 220 }
 221
 222 Render::~Render()
 223 {
 224         close_window();
 225         delete package_lock;
 226         delete counter_lock;
 227         delete completion;
 228         delete preferences;
 229         delete progress_timer;
 230         if( asset ) asset->Garbage::remove_user();
 231         delete thread;
 232 }
 233
 234 void Render::start_interactive()
 235 {
 236         if( !thread->running() ) {
 237                 mode = Render::INTERACTIVE;
 238                 BC_DialogThread::start();
 239         }
 240         else if( in_progress ) {
 241                 int cx, cy;
 242                 mwindow->gui->get_abs_cursor(cx, cy, 1);
 243                 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
 244                 error_box.create_objects(_("Already rendering"));
 245                 error_box.raise_window();
 246                 error_box.run_window();
 247         }
 248         else if( render_window ) {
 249                 render_window->raise_window();
 250         }
 251 }
 252
 253
 254 void Render::start_batches(ArrayList<BatchRenderJob*> *jobs)
 255 {
 256         if( !thread->running() ) {
 257                 mode = Render::BATCH;
 258                 batch_cancelled = 0;
 259                 this->jobs = jobs;
 260                 completion->reset();
 261                 start_render();
 262         }
 263         else if( in_progress ) {
 264                 int cx, cy;
 265                 mwindow->gui->get_abs_cursor(cx, cy, 1);
 266                 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
 267                 error_box.create_objects("Already rendering");
 268                 error_box.raise_window();
 269                 error_box.run_window();
 270         }
 271         // raise the window if rendering hasn't started yet
 272         else if( render_window ) {
 273                 render_window->raise_window();
 274         }
 275 }
 276
 277 void Render::start_batches(ArrayList<BatchRenderJob*> *jobs,
 278         BC_Hash *boot_defaults, Preferences *batch_prefs)
 279 {
 280         mode = Render::BATCH;
 281         batch_cancelled = 0;
 282         preferences->copy_from(batch_prefs);
 283         this->jobs = jobs;
 284
 285         completion->reset();
 286         thread->run();
 287 }
 288
 289
 290 BC_Window* Render::new_gui()
 291 {
 292         this->jobs = 0;
 293         batch_cancelled = 0;
 294         result = 0;
 295
 296         if( mode == Render::INTERACTIVE ) {
 297 // Fix the asset for rendering
 298                 if( !asset ) asset = new Asset;
 299                 load_defaults(asset);
 300                 check_asset(mwindow->edl, *asset);
 301                 int px = mwindow->gui->get_pop_cursor_x(1);
 302                 int py = mwindow->gui->get_pop_cursor_y(1);
 303 // Get format from user
 304                 render_window = new RenderWindow(mwindow, this, asset, px, py);
 305                 render_window->create_objects();
 306         }
 307
 308         return render_window;
 309 }
 310
 311 void Render::handle_done_event(int result)
 312 {
 313         if( !result ) {
 314                 mwindow->edl->session->render_beep = beep;
 315                 // add to recentlist only on OK
 316                 render_window->render_format->path_recent->
 317                         add_item(File::formattostr(asset->format), asset->path);
 318                 setenv("CIN_RENDER", asset->path, 1);
 319         }
 320         render_window = 0;
 321 }
 322
 323 void Render::handle_close_event(int result)
 324 {
 325         const int debug = 0;
 326         double render_range = get_render_range();
 327         const char *err_msg = 0;
 328
 329         if( !result && !render_range ) {
 330                 err_msg = _("zero render range");
 331                 result = 1;
 332         }
 333         if( !result && asset->video_data ) {
 334                 double frame_rate = mwindow->edl->session->frame_rate;
 335                 if( frame_rate > 0 && render_range+1e-3 < 1./frame_rate ) {
 336                         err_msg = _("Video data and range less than 1 frame");
 337                         result = 1;
 338                 }
 339         }
 340         if( !result && asset->audio_data ) {
 341                 double sample_rate = mwindow->edl->session->sample_rate;
 342                 if( sample_rate > 0 && render_range+1e-6 < 1./sample_rate ) {
 343                         err_msg = _("Audio data and range less than 1 sample");
 344                         result = 1;
 345                 }
 346         }
 347         if( !result && File::is_image_render(asset->format) ) {
 348                 if( asset->video_data ) {
 349                         double frames = render_range * mwindow->edl->session->frame_rate;
 350                         if( !EQUIV(frames, 1.) ) {
 351                                 err_msg = _("Image format and not 1 frame");
 352                                 result = 1;
 353                         }
 354                 }
 355                 else {
 356                         err_msg = _("Image format and no video data");
 357                         result = 1;
 358                 }
 359         }
 360         if( err_msg ) {
 361                 int cx, cy;
 362                 mwindow->gui->get_abs_cursor(cx, cy, 1);
 363                 ErrorBox error_box(_(PROGRAM_NAME ": Error"),cx, cy);
 364                 error_box.create_objects(err_msg);
 365                 error_box.raise_window();
 366                 error_box.run_window();
 367         }
 368
 369         if( !result ) {
 370 // Check the asset format for errors.
 371                 FormatCheck format_check(asset);
 372                 if( format_check.check_format() )
 373                         result = 1;
 374         }
 375
 376 //PRINT_TRACE
 377
 378         save_defaults(asset);
 379 //PRINT_TRACE
 380         mwindow->save_defaults();
 381 //PRINT_TRACE
 382
 383         if( !result ) {
 384                 if( debug ) printf("Render::handle_close_event %d\n", __LINE__);
 385                 if( !result ) start_render();
 386                 if( debug ) printf("Render::handle_close_event %d\n", __LINE__);
 387         }
 388 //PRINT_TRACE
 389 }
 390
 391
 392
 393 void Render::stop_operation()
 394 {
 395         if( thread->Thread::running() ) {
 396                 batch_cancelled = 1;
 397 // Wait for completion
 398                 completion->lock("Render::stop_operation");
 399                 completion->reset();
 400         }
 401 }
 402
 403 int Render::check_asset(EDL *edl, Asset &asset)
 404 {
 405         if( asset.video_data &&
 406                 edl->tracks->playable_video_tracks() &&
 407                 File::renders_video(&asset) ) {
 408                 asset.video_data = 1;
 409                 asset.layers = 1;
 410                 asset.width = edl->session->output_w;
 411                 asset.height = edl->session->output_h;
 412                 asset.interlace_mode = edl->session->interlace_mode;
 413         }
 414         else {
 415                 asset.video_data = 0;
 416                 asset.layers = 0;
 417         }
 418
 419         if( asset.audio_data &&
 420                 edl->tracks->playable_audio_tracks() &&
 421                 File::renders_audio(&asset) ) {
 422                 asset.audio_data = 1;
 423                 asset.channels = edl->session->audio_channels;
 424         }
 425         else {
 426                 asset.audio_data = 0;
 427                 asset.channels = 0;
 428         }
 429
 430         if( !asset.audio_data &&
 431                 !asset.video_data ) {
 432                 return 1;
 433         }
 434         return 0;
 435 }
 436
 437 int Render::get_strategy(int use_renderfarm, int use_labels)
 438 {
 439         return use_renderfarm ?
 440                 (use_labels ? FILE_PER_LABEL_FARM : SINGLE_PASS_FARM) :
 441                 (use_labels ? FILE_PER_LABEL      : SINGLE_PASS     ) ;
 442 }
 443 int Render::get_strategy()
 444 {
 445         return get_strategy(preferences->use_renderfarm, use_labels);
 446 }
 447
 448 void Render::start_progress()
 449 {
 450         char filename[BCTEXTLEN];
 451         char string[BCTEXTLEN];
 452         progress_max = packages->get_progress_max();
 453
 454         progress_timer->update();
 455         last_eta = 0;
 456         if( mwindow ) {
 457 // Generate the progress box
 458                 FileSystem fs;
 459                 fs.extract_name(filename, default_asset->path);
 460                 sprintf(string, _("Rendering %s..."), filename);
 461
 462 // Don't bother with the filename since renderfarm defeats the meaning
 463                 progress = mwindow->mainprogress->start_progress(_("Rendering..."),
 464                         progress_max);
 465                 render_progress = new RenderProgress(mwindow, this);
 466                 render_progress->start();
 467         }
 468 }
 469
 470 void Render::stop_progress()
 471 {
 472         if( progress ) {
 473                 char string[BCTEXTLEN], string2[BCTEXTLEN];
 474                 delete render_progress;
 475                 progress->get_time(string);
 476                 elapsed_time = progress->get_time();
 477                 progress->stop_progress();
 478                 delete progress;
 479
 480                 sprintf(string2, _("Rendering took %s"), string);
 481                 mwindow->gui->lock_window("");
 482                 mwindow->gui->show_message(string2);
 483                 mwindow->gui->update_default_message();
 484                 mwindow->gui->stop_hourglass();
 485                 mwindow->gui->unlock_window();
 486         }
 487         progress = 0;
 488 }
 489
 490 void Render::show_progress()
 491 {
 492         int64_t current_eta = progress_timer->get_scaled_difference(1000);
 493         if( current_eta - last_eta < 1000  ) return;
 494         double eta = !total_rendered ? 0 :
 495                 current_eta / 1000. * (progress_max / (double)total_rendered - 1.);
 496         char string[BCTEXTLEN];  Units::totext(string, eta, TIME_HMS2);
 497         printf("\r%d%% %s: %s      ",
 498                 (int)(100 * (float)total_rendered / progress_max), _("ETA"), string);
 499         fflush(stdout);
 500         last_eta = current_eta;
 501 }
 502
 503
 504
 505 void Render::start_render()
 506 {
 507         in_progress = 0;
 508         elapsed_time = 0.0;
 509         result = 0;
 510         completion->reset();
 511         thread->start();
 512 }
 513
 514
 515 void Render::create_filename(char *path,
 516         char *default_path,
 517         int current_number,
 518         int total_digits,
 519         int number_start)
 520 {
 521         int i, j;
 522         int len = strlen(default_path);
 523         char printf_string[BCTEXTLEN];
 524
 525         for( i=0, j=0; i<number_start; ++i, ++j ) {
 526                 printf_string[j] = default_path[i];
 527         }
 528
 529 // Found the number
 530         sprintf(&printf_string[j], "%%0%dd", total_digits);
 531         j = strlen(printf_string);
 532         i += total_digits;
 533
 534 // Copy remainder of string
 535         for( ; i<len; ++i, ++j ) {
 536                 printf_string[j] = default_path[i];
 537         }
 538         printf_string[j] = 0;
 539 // Print the printf argument to the path
 540         sprintf(path, printf_string, current_number);
 541 }
 542
 543 void Render::get_starting_number(char *path,
 544         int &current_number,
 545         int &number_start,
 546         int &total_digits,
 547         int min_digits)
 548 {
 549         int len = strlen(path);
 550         char number_text[BCTEXTLEN];
 551         char *ptr = 0;
 552         char *ptr2 = 0;
 553
 554         total_digits = 0;
 555         number_start = 0;
 556
 557 // Search for last /
 558         ptr2 = strrchr(path, '/');
 559
 560 // Search for first 0 after last /.
 561         if( ptr2 )
 562                 ptr = strchr(ptr2, '0');
 563
 564         if( ptr && isdigit(*ptr) ) {
 565                 number_start = ptr - path;
 566
 567 // Store the first number
 568                 char *ptr2 = number_text;
 569                 while( isdigit(*ptr) ) *ptr2++ = *ptr++;
 570                 *ptr2++ = 0;
 571                 current_number = atol(number_text);
 572                 total_digits = strlen(number_text);
 573         }
 574
 575
 576 // No number found or number not long enough
 577         if( total_digits < min_digits ) {
 578                 current_number = 1;
 579                 number_start = len;
 580                 total_digits = min_digits;
 581         }
 582 }
 583
 584
 585 int Render::load_defaults(Asset *asset)
 586 {
 587         use_labels = mwindow->defaults->get("RENDER_FILE_PER_LABEL", 0);
 588         load_mode = mwindow->defaults->get("RENDER_LOADMODE", LOADMODE_NEW_TRACKS);
 589         range_type = mwindow->defaults->get("RENDER_RANGE_TYPE", RANGE_PROJECT);
 590
 591 // some defaults which work
 592         asset->video_data = 1;
 593         asset->audio_data = 1;
 594         asset->format = FILE_FFMPEG;
 595         strcpy(asset->acodec, "mp4.qt");
 596         strcpy(asset->vcodec, "mp4.qt");
 597
 598         asset->load_defaults(mwindow->defaults,
 599                 "RENDER_", 1, 1, 1, 1, 1);
 600         return 0;
 601 }
 602
 603 int Render::load_profile(int profile_slot, Asset *asset)
 604 {
 605         char string_name[100];
 606         sprintf(string_name, "RENDER_%i_FILE_PER_LABEL", profile_slot);
 607         use_labels = mwindow->defaults->get(string_name, 0);
 608 // Load mode is not part of the profile
 609 //      printf(string_name, "RENDER_%i_LOADMODE", profile_slot);
 610 //      load_mode = mwindow->defaults->get(string_name, LOADMODE_NEW_TRACKS);
 611         sprintf(string_name, "RENDER_%i_RANGE_TYPE", profile_slot);
 612         range_type = mwindow->defaults->get(string_name, RANGE_PROJECT);
 613
 614         sprintf(string_name, "RENDER_%i_", profile_slot);
 615         asset->load_defaults(mwindow->defaults,
 616                 string_name, 1, 1, 1, 1, 1);
 617         return 0;
 618 }
 619
 620
 621 int Render::save_defaults(Asset *asset)
 622 {
 623         mwindow->defaults->update("RENDER_FILE_PER_LABEL", use_labels);
 624         mwindow->defaults->update("RENDER_LOADMODE", load_mode);
 625         mwindow->defaults->update("RENDER_RANGE_TYPE", range_type);
 626
 627         asset->save_defaults(mwindow->defaults,
 628                 "RENDER_", 1, 1, 1, 1, 1);
 629         return 0;
 630 }
 631
 632 void Render::update_assets()
 633 {
 634         if( packages )
 635                 packages->get_asset_list(assets);
 636 }
 637
 638 static void run_script(const char *script, const char *arg)
 639 {
 640         char *const argv[] = { (char*)script, (char*)arg, 0 };
 641         execvp(script ,&argv[0]);
 642         perror("execvp script failed");
 643         exit(1);
 644 }
 645
 646 RenderThread::RenderThread(MWindow *mwindow, Render *render)
 647  : Thread(0, 0, 0)
 648 {
 649         this->mwindow = mwindow;
 650         this->render = render;
 651         render_frames = 0;
 652 }
 653
 654 RenderThread::~RenderThread()
 655 {
 656 }
 657
 658
 659 void RenderThread::render_single(int test_overwrite, Asset *asset, EDL *edl,
 660         int strategy, int range_type)
 661 {
 662 // Total length in seconds
 663         double total_length = 0;
 664         RenderFarmServer *farm_server = 0;
 665
 666         render->in_progress = 1;
 667         render->default_asset = asset;
 668         render->progress = 0;
 669         render->result = 0;
 670
 671 // Create rendering command
 672         TransportCommand *command = new TransportCommand;
 673         command->command = NORMAL_FWD;
 674         command->get_edl()->copy_all(edl);
 675         command->change_type = CHANGE_ALL;
 676
 677         switch( range_type ) {
 678         case RANGE_BACKCOMPAT:
 679 // Get highlighted playback range
 680                 command->set_playback_range();
 681 // Adjust playback range with in/out points
 682                 command->playback_range_adjust_inout();
 683                 break;
 684         case RANGE_PROJECT:
 685                 command->playback_range_project();
 686                 break;
 687         case RANGE_SELECTION:
 688                 command->set_playback_range();
 689                 break;
 690         case RANGE_INOUT:
 691                 command->playback_range_inout();
 692                 break;
 693         case RANGE_1FRAME:
 694                 command->playback_range_1frame();
 695                 break;
 696         }
 697
 698         render->packages = new PackageDispatcher;
 699
 700 // Create caches
 701         CICache *audio_cache = new CICache(render->preferences);
 702         CICache *video_cache = new CICache(render->preferences);
 703
 704         render->default_asset->frame_rate = command->get_edl()->session->frame_rate;
 705         render->default_asset->sample_rate = command->get_edl()->session->sample_rate;
 706
 707 // Conform asset to EDL.  Find out if any tracks are playable.
 708         render->result = render->check_asset(command->get_edl(),
 709                 *render->default_asset);
 710
 711         if( !render->result ) {
 712 // Get total range to render
 713                 render->total_start = command->start_position;
 714                 render->total_end = command->end_position;
 715                 total_length = render->total_end - render->total_start;
 716
 717 // Nothing to render
 718                 if( EQUIV(total_length, 0) ) {
 719                         render->result = 1;
 720                 }
 721         }
 722         render_frames = render->default_asset->frame_rate * total_length;
 723
 724 // Generate packages
 725         if( !render->result ) {
 726 // Stop background rendering
 727                 if( mwindow ) mwindow->stop_brender();
 728
 729                 FileSystem fs;
 730                 fs.complete_path(render->default_asset->path);
 731
 732                 render->result = render->packages->create_packages(mwindow, command->get_edl(),
 733                         render->preferences, strategy, render->default_asset,
 734                         render->total_start, render->total_end, test_overwrite);
 735         }
 736
 737         render->total_rendered = 0;
 738
 739         if( !render->result ) {
 740 // Start dispatching external jobs
 741                 if( mwindow ) {
 742                         mwindow->gui->lock_window("Render::render 1");
 743                         mwindow->gui->show_message(_("Starting render farm"));
 744                         mwindow->gui->start_hourglass();
 745                         mwindow->gui->unlock_window();
 746                 }
 747                 else {
 748                         printf("Render::render: starting render farm\n");
 749                 }
 750
 751                 if( strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM ) {
 752                         farm_server = new RenderFarmServer(mwindow, render->packages,
 753                                 render->preferences, 1, &render->result,
 754                                 &render->total_rendered, render->counter_lock,
 755                                 render->default_asset, command->get_edl(), 0);
 756                         render->result = farm_server->start_clients();
 757
 758                         if( render->result ) {
 759                                 if( mwindow ) {
 760                                         mwindow->gui->lock_window("Render::render 2");
 761                                         mwindow->gui->show_message(_("Failed to start render farm"),
 762                                                 mwindow->theme->message_error);
 763                                         mwindow->gui->stop_hourglass();
 764                                         mwindow->gui->unlock_window();
 765                                 }
 766                                 else {
 767                                         printf("Render::render: Failed to start render farm\n");
 768                                 }
 769                         }
 770                 }
 771         }
 772
 773 // Perform local rendering
 774
 775         render->assets.clear();
 776         if( !render->result ) {
 777                 render->start_progress();
 778
 779                 MainPackageRenderer package_renderer(render);
 780                 render->result = package_renderer.initialize(mwindow,
 781                                 command->get_edl(),   // Copy of master EDL
 782                                 render->preferences,
 783                                 render->default_asset);
 784
 785                 while( !render->result ) {
 786                         int fps = strategy == SINGLE_PASS_FARM ?
 787                                 package_renderer.frames_per_second : 0;
 788 // Get unfinished job
 789                         RenderPackage *package = render->packages->get_package(fps, -1, 1);
 790 // Exit point
 791                         if( !package ) break;
 792
 793                         if( package_renderer.render_package(package) )
 794                                 render->result = 1;
 795                 } // file_number
 796
 797 printf("Render::render_single: Session finished.\n");
 798
 799                 if( strategy == SINGLE_PASS_FARM ||
 800                     strategy == FILE_PER_LABEL_FARM ) {
 801                         if( !render->progress ) {
 802                                 while( farm_server->active_clients() > 0 ) {
 803                                         sleep(1);
 804                                         render->show_progress();
 805                                 }
 806                         }
 807                         farm_server->wait_clients();
 808                         render->result |= render->packages->packages_are_done();
 809                 }
 810
 811 // Notify of error
 812                 if( render->result && !render->batch_cancelled &&
 813                     (!render->progress || !render->progress->is_cancelled()) ) {
 814                         if( mwindow ) {
 815                                 int cx, cy;
 816                                 mwindow->gui->get_abs_cursor(cx, cy, 1);
 817                                 ErrorBox error_box(_(PROGRAM_NAME ": Error"), cx, cy);
 818                                 error_box.create_objects(_("Error rendering data."));
 819                                 error_box.raise_window();
 820                                 error_box.run_window();
 821                         }
 822                         else {
 823                                 printf("Render::render: Error rendering data\n");
 824                         }
 825                 }
 826
 827 // Delete the progress box
 828                 render->stop_progress();
 829                 render->update_assets();
 830         }
 831
 832 // Paste all packages into timeline if desired
 833
 834         if( !render->result && mwindow &&
 835             render->load_mode != LOADMODE_NOTHING &&
 836             render->mode != Render::BATCH ) {
 837                 mwindow->gui->lock_window("Render::render 3");
 838
 839                 mwindow->undo->update_undo_before();
 840                 if( render->load_mode == LOADMODE_PASTE )
 841                         mwindow->clear(0);
 842                 mwindow->load_assets(&render->assets,
 843                         -1, render->load_mode, 0, 0,
 844                         mwindow->edl->session->labels_follow_edits,
 845                         mwindow->edl->session->plugins_follow_edits,
 846                         mwindow->edl->session->autos_follow_edits,
 847                         0); // overwrite
 848                 mwindow->save_backup();
 849                 mwindow->undo->update_undo_after(_("render"), LOAD_ALL);
 850                 mwindow->update_plugin_guis();
 851                 mwindow->gui->update(1, FORCE_REDRAW, 1, 1, 1, 1, 0);
 852                 mwindow->sync_parameters(CHANGE_ALL);
 853                 mwindow->gui->unlock_window();
 854
 855                 mwindow->awindow->gui->async_update_assets();
 856         }
 857
 858 // Disable hourglass
 859         if( mwindow ) {
 860                 mwindow->gui->lock_window("Render::render 3");
 861                 mwindow->gui->stop_hourglass();
 862                 mwindow->gui->unlock_window();
 863         }
 864
 865 //printf("Render::render 110\n");
 866 // Need to restart because brender always stops before render.
 867         if( mwindow )
 868                 mwindow->restart_brender();
 869         if( farm_server ) delete farm_server;
 870         delete command;
 871         delete audio_cache;
 872         delete video_cache;
 873 // Must delete packages after server
 874         delete render->packages;
 875
 876         render->packages = 0;
 877         render->in_progress = 0;
 878 }
 879
 880 void RenderThread::run()
 881 {
 882         char *script = 0;
 883         Timer render_timer;
 884
 885         if( mwindow )
 886                 render->preferences->copy_from(mwindow->preferences);
 887
 888         if( render->mode == Render::INTERACTIVE ) {
 889                 render_single(1, render->asset, mwindow->edl,
 890                         render->get_strategy(), render->range_type);
 891         }
 892         else
 893         if( render->mode == Render::BATCH ) {
 894                 for( int i=0; i<render->jobs->total && !render->result; ++i ) {
 895                         BatchRenderJob *job = render->jobs->values[i];
 896                         if( !job->enabled ) continue;
 897                         if( mwindow )
 898                                 mwindow->batch_render->update_active(i);
 899                         else
 900                                 printf("Render::run: %s\n", job->edl_path);
 901
 902                         FileXML *file = new FileXML;
 903                         EDL *edl = new EDL;
 904                         edl->create_objects();
 905                         file->read_from_file(job->edl_path);
 906                         edl->load_xml(file, LOAD_ALL);
 907                         delete file;
 908
 909                         render_single(0, job->asset, edl, job->get_strategy(), RANGE_BACKCOMPAT);
 910                         if( !render->result ) {
 911                                 if( !i )
 912                                         script = job->create_script(edl, &render->assets);
 913                                 if( mwindow )
 914                                         mwindow->batch_render->update_done(i, 1, render->elapsed_time);
 915                                 else {
 916                                         char string[BCTEXTLEN];
 917                                         render->elapsed_time =
 918                                                 (double)render->progress_timer->get_scaled_difference(1);
 919                                         Units::totext(string, render->elapsed_time, TIME_HMS2);
 920                                         printf("Render::run: done in %s\n", string);
 921                                 }
 922                         }
 923                         else {
 924                                 if( mwindow )
 925                                         mwindow->batch_render->update_active(-1);
 926                                 else
 927                                         printf("Render::run: failed\n");
 928                         }
 929                 }
 930                 if( mwindow ) {
 931                         mwindow->batch_render->update_active(-1);
 932                         mwindow->batch_render->update_done(-1, 0, 0);
 933                 }
 934         }
 935         render->completion->unlock();
 936
 937         if( !render->result ) {
 938                 double render_time = render_timer.get_difference() / 1000.0;
 939                 double render_rate = render_time > 0 ? render_frames / render_time : 0;
 940                 printf("** rendered %jd frames in %0.3f secs, %0.3f fps\n",
 941                         render_frames, render_time, render_rate);
 942         }
 943
 944         if( render->mode == Render::INTERACTIVE && render->beep )
 945                 mwindow->beep(3000., 1.5, 0.5);
 946
 947         if( script ) {
 948                 if( !render->result )
 949                         run_script(script, 0);
 950                 delete [] script;
 951         }
 952 }
 953
 954
 955 #define WIDTH 480
 956 #define HEIGHT 480
 957
 958
 959 RenderWindow::RenderWindow(MWindow *mwindow,
 960         Render *render,
 961         Asset *asset,
 962         int x,
 963         int y)
 964  : BC_Window(_(PROGRAM_NAME ": Render"), x, y,
 965         WIDTH, HEIGHT, WIDTH, HEIGHT, 0, 0, 1)
 966 {
 967         this->mwindow = mwindow;
 968         this->render = render;
 969         this->asset = asset;
 970         render_format = 0;
 971         loadmode = 0;
 972         renderprofile = 0;
 973         rangeproject = 0;
 974         rangeselection = 0;
 975         rangeinout = 0;
 976         range1frame = 0;
 977 }
 978
 979 RenderWindow::~RenderWindow()
 980 {
 981         lock_window("RenderWindow::~RenderWindow");
 982         delete render_format;
 983         delete loadmode;
 984         delete renderprofile;
 985         unlock_window();
 986 }
 987
 988
 989 void RenderWindow::load_profile(int profile_slot)
 990 {
 991         render->load_profile(profile_slot, asset);
 992         update_range_type(render->range_type);
 993         render_format->update(asset, &render->use_labels);
 994 }
 995
 996
 997 void RenderWindow::create_objects()
 998 {
 999         int x = 10, y = 10;
1000         lock_window("RenderWindow::create_objects");
1001         add_subwindow(new BC_Title(x, y,
1002                 (char*)(render->use_labels ?
1003                         _("Select the first file to render to:") :
1004                         _("Select a file to render to:"))));
1005         y += 25;
1006
1007         render_format = new RenderFormat(mwindow, this, asset);
1008         render_format->create_objects(x, y,
1009                 1, 1, 1, 1, 0, 1, 0, 0, &render->use_labels, 0);
1010
1011         BC_Title *title;
1012         add_subwindow(title = new BC_Title(x, y, _("Render range:")));
1013
1014         int is_image = File::is_image_render(asset->format);
1015         if( is_image )
1016                 render->range_type = RANGE_1FRAME;
1017
1018         int x1 = x + title->get_w() + 20, y1 = y;
1019         add_subwindow(rangeproject = new RenderRangeProject(this,
1020                 render->range_type == RANGE_PROJECT, x1, y));
1021         int x2 = x1 + rangeproject->get_w();
1022         y += 20;
1023         add_subwindow(rangeselection = new RenderRangeSelection(this,
1024                 render->range_type == RANGE_SELECTION, x1, y));
1025         int x3 = x1 + rangeselection->get_w();
1026         if( x2 < x3 ) x2 = x3;
1027         y += 20;
1028         add_subwindow(rangeinout = new RenderRangeInOut(this,
1029                 render->range_type == RANGE_INOUT, x1, y));
1030         x3 = x1 + rangeinout->get_w();
1031         if( x2 < x3 ) x2 = x3;
1032         y += 20;
1033         add_subwindow(range1frame = new RenderRange1Frame(this,
1034                 render->range_type == RANGE_1FRAME, x1, y));
1035         x3 = x1 + range1frame->get_w();
1036         if( x2 < x3 ) x2 = x3;
1037         y += 30;
1038         if( is_image )
1039                 enable_render_range(0);
1040
1041         x1 = x2 + 20;
1042         render->beep = mwindow->edl->session->render_beep;
1043         add_subwindow(beep_on_done = new RenderBeepOnDone(this, x1, y1));
1044
1045         renderprofile = new RenderProfile(mwindow, this, x, y, 1);
1046         renderprofile->create_objects();
1047         y += 70;
1048
1049         loadmode = new LoadMode(mwindow, this, x, y, &render->load_mode, 1);
1050         loadmode->create_objects();
1051
1052         add_subwindow(new BC_OKButton(this));
1053         add_subwindow(new BC_CancelButton(this));
1054
1055         show_window();
1056         unlock_window();
1057 }
1058
1059 void RenderWindow::update_range_type(int range_type)
1060 {
1061         if( render->range_type == range_type ) return;
1062         render->range_type = range_type;
1063         rangeproject->update(range_type == RANGE_PROJECT);
1064         rangeselection->update(range_type == RANGE_SELECTION);
1065         rangeinout->update(range_type == RANGE_INOUT);
1066         range1frame->update(range_type == RANGE_1FRAME);
1067 }
1068
1069 void RenderWindow::enable_render_range(int v)
1070 {
1071         if( v ) {
1072                 rangeproject->enable();
1073                 rangeselection->enable();
1074                 rangeinout->enable();
1075                 range1frame->enable();
1076         }
1077         else {
1078                 rangeproject->disable();
1079                 rangeselection->disable();
1080                 rangeinout->disable();
1081                 range1frame->disable();
1082         }
1083 }
1084
1085
1086 RenderRangeProject::RenderRangeProject(RenderWindow *rwindow, int value, int x, int y)
1087  : BC_Radial(x, y, value, _("Project"))
1088 {
1089         this->rwindow = rwindow;
1090 }
1091 int RenderRangeProject::handle_event()
1092 {
1093         rwindow->update_range_type(RANGE_PROJECT);
1094         return 1;
1095 }
1096
1097 RenderRangeSelection::RenderRangeSelection(RenderWindow *rwindow, int value, int x, int y)
1098  : BC_Radial(x, y, value, _("Selection"))
1099 {
1100         this->rwindow = rwindow;
1101 }
1102 int RenderRangeSelection::handle_event()
1103 {
1104         rwindow->update_range_type(RANGE_SELECTION);
1105         return 1;
1106 }
1107
1108
1109 RenderRangeInOut::RenderRangeInOut(RenderWindow *rwindow, int value, int x, int y)
1110  : BC_Radial(x, y, value, _("In/Out Points"))
1111 {
1112         this->rwindow = rwindow;
1113 }
1114 int RenderRangeInOut::handle_event()
1115 {
1116         rwindow->update_range_type(RANGE_INOUT);
1117         return 1;
1118 }
1119
1120 RenderRange1Frame::RenderRange1Frame(RenderWindow *rwindow, int value, int x, int y)
1121  : BC_Radial(x, y, value, _("One Frame"))
1122 {
1123         this->rwindow = rwindow;
1124 }
1125 int RenderRange1Frame::handle_event()
1126 {
1127         rwindow->update_range_type(RANGE_1FRAME);
1128         return 1;
1129 }
1130
1131 double Render::get_render_range()
1132 {
1133         EDL *edl = mwindow->edl;
1134         double last = edl->tracks->total_playable_length();
1135         double framerate = edl->session->frame_rate;
1136         if( framerate <= 0 ) framerate = 1;
1137         double start = 0, end = last;
1138         switch( range_type ) {
1139         default:
1140         case RANGE_BACKCOMPAT:
1141                 start = edl->local_session->get_selectionstart(1);
1142                 end   = edl->local_session->get_selectionend(1);
1143                 if( EQUIV(start, end) ) end = last;
1144                 break;
1145         case RANGE_PROJECT:
1146                 break;
1147         case RANGE_SELECTION:
1148                 start = edl->local_session->get_selectionstart(1);
1149                 end   = edl->local_session->get_selectionend(1);
1150                 break;
1151         case RANGE_INOUT:
1152                 start = edl->local_session->inpoint_valid() ?
1153                         edl->local_session->get_inpoint() : 0;
1154                 end   = edl->local_session->outpoint_valid() ?
1155                         edl->local_session->get_outpoint() : last;
1156                 break;
1157         case RANGE_1FRAME:
1158                 start = end = edl->local_session->get_selectionstart(1);
1159                 if( edl->session->frame_rate > 0 ) end += 1./edl->session->frame_rate;
1160                 break;
1161         }
1162         if( start < 0 ) start = 0;
1163         if( end > last ) end = last;
1164         return end - start;
1165 }
1166
1167 RenderFormat::RenderFormat(MWindow *mwindow, BC_WindowBase *window, Asset *asset)
1168  : FormatTools(mwindow, window, asset)
1169 {
1170 }
1171 RenderFormat::~RenderFormat()
1172 {
1173 }
1174
1175 void RenderFormat::update_format()
1176 {
1177         FormatTools::update_format();
1178         RenderWindow *render_window = (RenderWindow *)window;
1179         if( render_window->is_hidden() ) return;
1180
1181         int is_image = File::is_image_render(asset->format);
1182         if( is_image ) {
1183                 render_window->update_range_type(RANGE_1FRAME);
1184                 render_window->enable_render_range(0);
1185         }
1186         else
1187                 render_window->enable_render_range(1);
1188 }
1189
1190 RenderBeepOnDone::RenderBeepOnDone(RenderWindow *rwindow, int x, int y)
1191  : BC_CheckBox(x, y, rwindow->render->beep, _("Beep on done"))
1192 {
1193         this->rwindow = rwindow;
1194 }
1195
1196 int RenderBeepOnDone::handle_event()
1197 {
1198         rwindow->render->beep = get_value();
1199         return 1;
1200 }
1201
1202