cinelerra/renderengine.C

   1 #include "amodule.h"
   2 #include "arender.h"
   3 #include "asset.h"
   4 #include "audiodevice.h"
   5 #include "bcsignals.h"
   6 #include "channeldb.h"
   7 #include "condition.h"
   8 #include "edl.h"
   9 #include "edlsession.h"
  10 #include "mutex.h"
  11 #include "mwindow.h"
  12 #include "playbackengine.h"
  13 #include "preferences.h"
  14 #include "preferencesthread.h"
  15 #include "renderengine.h"
  16 #include "mainsession.h"
  17 #include "tracks.h"
  18 #include "transportque.h"
  19 #include "videodevice.h"
  20 #include "vrender.h"
  21 #include "workarounds.h"
  22
  23
  24
  25 RenderEngine::RenderEngine(PlaybackEngine *playback_engine,
  26         Preferences *preferences,
  27         TransportCommand *command,
  28         Canvas *output,
  29         ArrayList<PluginServer*> *plugindb,
  30         ChannelDB *channeldb)
  31  : Thread(1, 0, 0)
  32 {
  33         this->playback_engine = playback_engine;
  34         this->output = output;
  35         this->plugindb = plugindb;
  36         this->channeldb = channeldb;
  37         audio = 0;
  38         video = 0;
  39         config = new PlaybackConfig;
  40         arender = 0;
  41         vrender = 0;
  42         do_audio = 0;
  43         do_video = 0;
  44         interrupted = 0;
  45         actual_frame_rate = 0;
  46         this->preferences = new Preferences;
  47         this->command = new TransportCommand;
  48         this->preferences->copy_from(preferences);
  49         this->command->copy_from(command);
  50         edl = new EDL;
  51         edl->create_objects();
  52 // EDL only changed in construction.
  53 // The EDL contained in later commands is ignored.
  54         edl->copy_all(command->get_edl());
  55         audio_cache = 0;
  56         video_cache = 0;
  57         if(playback_engine && playback_engine->mwindow)
  58                 mwindow = playback_engine->mwindow;
  59         else
  60                 mwindow = 0;
  61         show_tc = 0;
  62
  63
  64         input_lock = new Condition(1, "RenderEngine::input_lock");
  65         start_lock = new Condition(1, "RenderEngine::start_lock");
  66         output_lock = new Condition(1, "RenderEngine::output_lock");
  67         interrupt_lock = new Mutex("RenderEngine::interrupt_lock");
  68         first_frame_lock = new Condition(1, "RenderEngine::first_frame_lock");
  69         reset_parameters();
  70 }
  71
  72 RenderEngine::~RenderEngine()
  73 {
  74         close_output();
  75         delete command;
  76         delete preferences;
  77         if(arender) delete arender;
  78         if(vrender) delete vrender;
  79         delete edl;
  80         delete input_lock;
  81         delete start_lock;
  82         delete output_lock;
  83         delete interrupt_lock;
  84         delete first_frame_lock;
  85         delete config;
  86 }
  87
  88 int RenderEngine::arm_command(TransportCommand *command,
  89         int &current_vchannel,
  90         int &current_achannel)
  91 {
  92 // Prevent this renderengine from accepting another command until finished.
  93 // Since the renderengine is often deleted after the input_lock command it must
  94 // be locked here as well as in the calling routine.
  95
  96
  97         input_lock->lock("RenderEngine::arm_command");
  98
  99
 100         this->command->copy_from(command);
 101
 102 // Fix background rendering asset to use current dimensions and ignore
 103 // headers.
 104         preferences->brender_asset->frame_rate = command->get_edl()->session->frame_rate;
 105         preferences->brender_asset->width = command->get_edl()->session->output_w;
 106         preferences->brender_asset->height = command->get_edl()->session->output_h;
 107         preferences->brender_asset->use_header = 0;
 108         preferences->brender_asset->layers = 1;
 109         preferences->brender_asset->video_data = 1;
 110
 111         done = 0;
 112         interrupted = 0;
 113
 114 // Retool configuration for this node
 115         this->config->copy_from(command->get_edl()->session->playback_config);
 116         VideoOutConfig *vconfig = this->config->vconfig;
 117         AudioOutConfig *aconfig = this->config->aconfig;
 118         if(command->realtime)
 119         {
 120                 int device_channels = 0;
 121                 int edl_channels = 0;
 122                 if(command->single_frame())
 123                 {
 124                         vconfig->driver = PLAYBACK_X11;
 125                         device_channels = 1;
 126                         edl_channels = command->get_edl()->session->video_channels;
 127                 }
 128                 else
 129                 {
 130                         device_channels = 1;
 131                         edl_channels = command->get_edl()->session->video_channels;
 132                 }
 133
 134                 for(int i = 0; i < MAX_CHANNELS; i++)
 135                 {
 136                         vconfig->do_channel[i] =
 137                                 ((i == current_vchannel) &&
 138                                         device_channels &&
 139                                         edl_channels);
 140
 141 // GCC 3.2 optimization error causes do_channel[0] to always be 0 unless
 142 // we do this.
 143 Workarounds::clamp(vconfig->do_channel[i], 0, 1);
 144
 145                         if(vconfig->do_channel[i])
 146                         {
 147                                 current_vchannel++;
 148                                 device_channels--;
 149                                 edl_channels--;
 150                         }
 151                 }
 152         }
 153         else
 154         {
 155                 vconfig->driver = PLAYBACK_X11;
 156                 for(int i = 0; i < MAX_CHANNELS; i++)
 157                 {
 158                         vconfig->do_channel[i] = (i < command->get_edl()->session->video_channels);
 159                         vconfig->do_channel[i] = (i < command->get_edl()->session->video_channels);
 160                 }
 161         }
 162
 163
 164
 165         get_duty();
 166
 167         if(do_audio)
 168         {
 169                 fragment_len = aconfig->fragment_size;
 170 // Larger of audio_module_fragment and fragment length adjusted for speed
 171 // Extra memory must be allocated for rendering slow motion.
 172                 adjusted_fragment_len = (int64_t)((float)aconfig->fragment_size /
 173                         command->get_speed() + 0.5);
 174                 if(adjusted_fragment_len < aconfig->fragment_size)
 175                         adjusted_fragment_len = aconfig->fragment_size;
 176         }
 177
 178 // Set lock so audio doesn't start until video has started.
 179         if(do_video)
 180         {
 181                 while(first_frame_lock->get_value() > 0)
 182                         first_frame_lock->lock("RenderEngine::arm_command");
 183         }
 184         else
 185 // Set lock so audio doesn't wait for video which is never to come.
 186         {
 187                 while(first_frame_lock->get_value() <= 0)
 188                         first_frame_lock->unlock();
 189         }
 190
 191         open_output();
 192         create_render_threads();
 193         arm_render_threads();
 194
 195         return 0;
 196 }
 197
 198 void RenderEngine::get_duty()
 199 {
 200         do_audio = 0;
 201         do_video = 0;
 202
 203 //edl->dump();
 204         if(!command->single_frame() &&
 205                 edl->tracks->playable_audio_tracks() &&
 206                 edl->session->audio_channels)
 207         {
 208                 do_audio = 1;
 209         }
 210
 211         if(edl->tracks->playable_video_tracks() &&
 212                 config->vconfig->total_playable_channels())
 213         {
 214                 do_video = 1;
 215         }
 216 }
 217
 218 void RenderEngine::create_render_threads()
 219 {
 220         if(do_video && !vrender)
 221         {
 222                 vrender = new VRender(this);
 223         }
 224
 225         if(do_audio && !arender)
 226         {
 227                 arender = new ARender(this);
 228         }
 229 }
 230
 231
 232 int RenderEngine::get_output_w()
 233 {
 234         return edl->session->output_w;
 235 }
 236
 237 int RenderEngine::get_output_h()
 238 {
 239         return edl->session->output_h;
 240 }
 241
 242 int RenderEngine::brender_available(int position, int direction)
 243 {
 244         if(playback_engine)
 245         {
 246                 int64_t corrected_position = position;
 247                 if(direction == PLAY_REVERSE)
 248                         corrected_position--;
 249                 return playback_engine->brender_available(corrected_position);
 250         }
 251         else
 252                 return 0;
 253 }
 254
 255 Channel* RenderEngine::get_current_channel()
 256 {
 257         if(channeldb)
 258         {
 259                 switch(config->vconfig->driver)
 260                 {
 261                         case PLAYBACK_BUZ:
 262                                 if(config->vconfig->buz_out_channel >= 0 &&
 263                                         config->vconfig->buz_out_channel < channeldb->size())
 264                                 {
 265                                         return channeldb->get(config->vconfig->buz_out_channel);
 266                                 }
 267                                 break;
 268                         case VIDEO4LINUX2JPEG:
 269
 270                                 break;
 271                 }
 272         }
 273         return 0;
 274 }
 275
 276 CICache* RenderEngine::get_acache()
 277 {
 278         if(playback_engine)
 279                 return playback_engine->audio_cache;
 280         else
 281                 return audio_cache;
 282 }
 283
 284 CICache* RenderEngine::get_vcache()
 285 {
 286         if(playback_engine)
 287                 return playback_engine->video_cache;
 288         else
 289                 return video_cache;
 290 }
 291
 292 void RenderEngine::set_acache(CICache *cache)
 293 {
 294         this->audio_cache = cache;
 295 }
 296
 297 void RenderEngine::set_vcache(CICache *cache)
 298 {
 299         this->video_cache = cache;
 300 }
 301
 302
 303 double RenderEngine::get_tracking_position()
 304 {
 305         if(playback_engine)
 306                 return playback_engine->get_tracking_position();
 307         else
 308                 return 0;
 309 }
 310
 311 int RenderEngine::open_output()
 312 {
 313         if(command->realtime)
 314         {
 315 // Allocate devices
 316                 if(do_audio)
 317                 {
 318                         audio = new AudioDevice;
 319                         if (audio->open_output(config->aconfig,
 320                                 edl->session->sample_rate,
 321                                 adjusted_fragment_len,
 322                                 edl->session->audio_channels,
 323                                 edl->session->real_time_playback))
 324                         {
 325                                 do_audio = 0;
 326                                 delete audio;
 327                                 audio = 0;
 328                         }
 329                 }
 330
 331                 if(do_video)
 332                 {
 333                         video = new VideoDevice;
 334                 }
 335
 336 // Initialize sharing
 337
 338
 339 // Start playback
 340                 if(do_audio && do_video)
 341                 {
 342                         video->set_adevice(audio);
 343                         audio->set_vdevice(video);
 344                 }
 345
 346
 347
 348 // Retool playback configuration
 349                 if(do_audio)
 350                 {
 351                         audio->set_software_positioning(edl->session->playback_software_position);
 352                         audio->start_playback();
 353                 }
 354
 355                 if(do_video)
 356                 {
 357                         video->open_output(config->vconfig,
 358                                 edl->session->frame_rate,
 359                                 get_output_w(),
 360                                 get_output_h(),
 361                                 output,
 362                                 command->single_frame());
 363                         Channel *channel = get_current_channel();
 364                         if(channel) video->set_channel(channel);
 365                         video->set_quality(80);
 366                         video->set_cpus(preferences->processors);
 367                 }
 368         }
 369
 370         return 0;
 371 }
 372
 373 int64_t RenderEngine::session_position()
 374 {
 375         if(do_audio)
 376         {
 377                 return audio->current_position();
 378         }
 379
 380         if(do_video)
 381         {
 382                 return (int64_t)((double)vrender->session_frame /
 383                                 edl->session->frame_rate *
 384                                 edl->session->sample_rate /
 385                                 command->get_speed() + 0.5);
 386         }
 387 }
 388
 389 void RenderEngine::reset_sync_position()
 390 {
 391         timer.update();
 392 }
 393
 394 int64_t RenderEngine::sync_position()
 395 {
 396 // Use audio device
 397 // No danger of race conditions because the output devices are closed after all
 398 // threads join.
 399         if(do_audio)
 400         {
 401                 return audio->current_position();
 402         }
 403
 404         if(do_video)
 405         {
 406                 int64_t result = timer.get_scaled_difference(
 407                         edl->session->sample_rate);
 408                 return result;
 409         }
 410 }
 411
 412 PluginServer* RenderEngine::scan_plugindb(char *title,
 413         int data_type)
 414 {
 415         for(int i = 0; i < plugindb->total; i++)
 416         {
 417                 PluginServer *server = plugindb->values[i];
 418                 if(!strcasecmp(server->title, title) &&
 419                         ((data_type == TRACK_AUDIO && server->audio) ||
 420                         (data_type == TRACK_VIDEO && server->video)))
 421                         return plugindb->values[i];
 422         }
 423         return 0;
 424 }
 425
 426 int RenderEngine::start_command()
 427 {
 428         if(command->realtime)
 429         {
 430                 interrupt_lock->lock("RenderEngine::start_command");
 431                 start_lock->lock("RenderEngine::start_command 1");
 432                 Thread::start();
 433                 start_lock->lock("RenderEngine::start_command 2");
 434                 start_lock->unlock();
 435         }
 436         return 0;
 437 }
 438
 439 void RenderEngine::arm_render_threads()
 440 {
 441         if(do_audio)
 442         {
 443                 arender->arm_command();
 444         }
 445
 446         if(do_video)
 447         {
 448                 vrender->arm_command();
 449         }
 450 }
 451
 452
 453 void RenderEngine::start_render_threads()
 454 {
 455 // Synchronization timer.  Gets reset once again after the first video frame.
 456         timer.update();
 457
 458         if(do_audio)
 459         {
 460                 arender->start_command();
 461         }
 462
 463         if(do_video)
 464         {
 465                 vrender->start_command();
 466         }
 467 }
 468
 469 void RenderEngine::update_framerate(float framerate)
 470 {
 471         playback_engine->mwindow->edl->session->actual_frame_rate = framerate;
 472         playback_engine->mwindow->preferences_thread->update_framerate();
 473 }
 474
 475 void RenderEngine::wait_render_threads()
 476 {
 477         if(do_audio)
 478         {
 479                 arender->Thread::join();
 480         }
 481
 482         if(do_video)
 483         {
 484                 vrender->Thread::join();
 485         }
 486 }
 487
 488 void RenderEngine::interrupt_playback()
 489 {
 490         interrupt_lock->lock("RenderEngine::interrupt_playback");
 491         interrupted = 1;
 492         if(audio)
 493         {
 494                 audio->interrupt_playback();
 495         }
 496         if(video)
 497         {
 498 //printf("RenderEngine::interrupt_playback 3 %p\n", this);
 499                 video->interrupt_playback();
 500 //printf("RenderEngine::interrupt_playback 4 %p\n", this);
 501         }
 502         interrupt_lock->unlock();
 503 }
 504
 505 int RenderEngine::close_output()
 506 {
 507         if(audio)
 508         {
 509                 audio->close_all();
 510                 delete audio;
 511                 audio = 0;
 512         }
 513
 514
 515
 516         if(video)
 517         {
 518                 video->close_all();
 519                 delete video;
 520                 video = 0;
 521         }
 522         return 0;
 523 }
 524
 525 void RenderEngine::get_output_levels(double *levels, int64_t position)
 526 {
 527         if(do_audio)
 528         {
 529                 int history_entry = arender->get_history_number(arender->level_samples,
 530                         position);
 531                 for(int i = 0; i < MAXCHANNELS; i++)
 532                 {
 533                         if(arender->audio_out[i])
 534                                 levels[i] = arender->level_history[i][history_entry];
 535                 }
 536         }
 537 }
 538
 539 void RenderEngine::get_module_levels(ArrayList<double> *module_levels, int64_t position)
 540 {
 541         if(do_audio)
 542         {
 543                 for(int i = 0; i < arender->total_modules; i++)
 544                 {
 545 //printf("RenderEngine::get_module_levels %p %p\n", ((AModule*)arender->modules[i]), ((AModule*)arender->modules[i])->level_samples);
 546                         int history_entry = arender->get_history_number(((AModule*)arender->modules[i])->level_samples, position);
 547
 548                         module_levels->append(((AModule*)arender->modules[i])->level_history[history_entry]);
 549                 }
 550         }
 551 }
 552
 553
 554
 555
 556
 557 void RenderEngine::run()
 558 {
 559         start_render_threads();
 560         start_lock->unlock();
 561         interrupt_lock->unlock();
 562
 563         wait_render_threads();
 564
 565         interrupt_lock->lock("RenderEngine::run");
 566
 567
 568         if(interrupted)
 569         {
 570                 playback_engine->tracking_position = playback_engine->get_tracking_position();
 571         }
 572
 573         close_output();
 574
 575 // Fix the tracking position
 576         if(playback_engine)
 577         {
 578                 if(command->command == CURRENT_FRAME)
 579                 {
 580 //printf("RenderEngine::run 4.1 %d\n", playback_engine->tracking_position);
 581                         playback_engine->tracking_position = command->playbackstart;
 582                 }
 583                 else
 584                 {
 585 // Make sure transport doesn't issue a pause command next
 586 //printf("RenderEngine::run 4.1 %d\n", playback_engine->tracking_position);
 587                         if(!interrupted)
 588                         {
 589                                 if(do_audio)
 590                                         playback_engine->tracking_position =
 591                                                 (double)arender->current_position /
 592                                                         command->get_edl()->session->sample_rate;
 593                                 else
 594                                 if(do_video)
 595                                 {
 596                                         playback_engine->tracking_position =
 597                                                 (double)vrender->current_position /
 598                                                         command->get_edl()->session->frame_rate;
 599                                 }
 600                         }
 601
 602                         if(!interrupted) playback_engine->command->command = STOP;
 603                         playback_engine->stop_tracking();
 604
 605                 }
 606                 playback_engine->is_playing_back = 0;
 607         }
 608
 609         input_lock->unlock();
 610         interrupt_lock->unlock();
 611 }
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637 int RenderEngine::reset_parameters()
 638 {
 639         start_position = 0;
 640         follow_loop = 0;
 641         end_position = 0;
 642         infinite = 0;
 643         start_position = 0;
 644         do_audio = 0;
 645         do_video = 0;
 646         done = 0;
 647 }
 648
 649 int RenderEngine::arm_playback_audio(int64_t input_length,
 650                         int64_t amodule_render_fragment,
 651                         int64_t playback_buffer,
 652                         int64_t output_length)
 653 {
 654
 655         do_audio = 1;
 656
 657         arender = new ARender(this);
 658         arender->arm_playback(current_sample,
 659                                                         input_length,
 660                                                         amodule_render_fragment,
 661                                                         playback_buffer,
 662                                                         output_length);
 663 }
 664
 665 int RenderEngine::arm_playback_video(int every_frame,
 666                         int64_t read_length,
 667                         int64_t output_length,
 668                         int track_w,
 669                         int track_h,
 670                         int output_w,
 671                         int output_h)
 672 {
 673         do_video = 1;
 674         this->every_frame = every_frame;
 675
 676         vrender = new VRender(this);
 677 //      vrender->arm_playback(current_sample,
 678 //                                                      read_length,
 679 //                                                      output_length,
 680 //                                                      output_length,
 681 //                                                      track_w,
 682 //                                                      track_h,
 683 //                                                      output_w,
 684 //                                                      output_h);
 685 }
 686
 687 int RenderEngine::start_video()
 688 {
 689 // start video for realtime
 690         if(video) video->start_playback();
 691         vrender->start_playback();
 692 }
 693
 694
 695 int64_t RenderEngine::get_correction_factor(int reset)
 696 {
 697         if(!every_frame)
 698         {
 699                 int64_t x;
 700 //              x = playbackengine->correction_factor;
 701 //              if(reset) playbackengine->correction_factor = 0;
 702                 return x;
 703         }
 704         else
 705                 return 0;
 706 }
 707