cinelerra/commonrender.C

   1 #include "auto.h"
   2 #include "cache.h"
   3 #include "commonrender.h"
   4 #include "condition.h"
   5 #include "edl.h"
   6 #include "edlsession.h"
   7 #include "intautos.h"
   8 #include "localsession.h"
   9 #include "mainsession.h"
  10 #include "module.h"
  11 #include "mwindow.h"
  12 #include "patchbay.h"
  13 #include "patch.h"
  14 #include "playabletracks.h"
  15 #include "preferences.h"
  16 #include "renderengine.h"
  17 #include "track.h"
  18 #include "tracks.h"
  19 #include "transportque.h"
  20 #include "virtualconsole.h"
  21
  22 CommonRender::CommonRender(RenderEngine *renderengine)
  23  : Thread(1, 0, 0)
  24 {
  25         this->renderengine = renderengine;
  26         reset_parameters();
  27         start_lock = new Condition(0, "CommonRender::start_lock");
  28 }
  29
  30 CommonRender::~CommonRender()
  31 {
  32         delete_vconsole();
  33         if(modules)
  34         {
  35                 for(int i = 0; i < total_modules; i++)
  36                         delete modules[i];
  37                 delete [] modules;
  38         }
  39         delete start_lock;
  40 }
  41
  42 void CommonRender::reset_parameters()
  43 {
  44         total_modules = 0;
  45         modules = 0;
  46         vconsole = 0;
  47         done = 0;
  48         interrupt = 0;
  49         last_playback = 0;
  50         asynchronous = 0;
  51         restart_plugins = 0;
  52 }
  53
  54 void CommonRender::arm_command()
  55 {
  56         int64_t temp_length = 1;
  57
  58         current_position = tounits(renderengine->command->playbackstart, 0);
  59
  60         init_output_buffers();
  61
  62         last_playback = 0;
  63         if(test_reconfigure(current_position, temp_length))
  64         {
  65                 restart_playback();
  66         }
  67         else
  68         {
  69                 vconsole->start_playback();
  70         }
  71
  72         done = 0;
  73         interrupt = 0;
  74         last_playback = 0;
  75         restart_plugins = 0;
  76 }
  77
  78
  79
  80 void CommonRender::create_modules()
  81 {
  82 // Create a module for every track, playable or not
  83         Track *current = renderengine->edl->tracks->first;
  84         int module = 0;
  85
  86         if(!modules)
  87         {
  88                 total_modules = get_total_tracks();
  89                 modules = new Module*[total_modules];
  90
  91                 for(module = 0; module < total_modules && current; current = NEXT)
  92                 {
  93                         if(current->data_type == data_type)
  94                         {
  95                                 modules[module] = new_module(current);
  96                                 modules[module]->create_objects();
  97                                 module++;
  98                         }
  99                 }
 100         }
 101         else
 102 // Update changes in plugins for existing modules
 103         {
 104                 for(module = 0; module < total_modules; module++)
 105                 {
 106                         modules[module]->create_objects();
 107                 }
 108         }
 109 }
 110
 111 void CommonRender::start_plugins()
 112 {
 113 // Only start if virtual console was created
 114         if(restart_plugins)
 115         {
 116                 for(int i = 0; i < total_modules; i++)
 117                 {
 118                         modules[i]->render_init();
 119                 }
 120         }
 121 }
 122
 123 int CommonRender::test_reconfigure(int64_t position, int64_t &length)
 124 {
 125         if(!vconsole) return 1;
 126         if(!modules) return 1;
 127
 128         return vconsole->test_reconfigure(position, length, last_playback);
 129 }
 130
 131
 132 void CommonRender::build_virtual_console()
 133 {
 134 // Create new virtual console object
 135         if(!vconsole)
 136         {
 137                 vconsole = new_vconsole_object();
 138         }
 139
 140 // Create nodes
 141         vconsole->create_objects();
 142 }
 143
 144 void CommonRender::start_command()
 145 {
 146         if(renderengine->command->realtime)
 147         {
 148                 Thread::set_realtime(renderengine->edl->session->real_time_playback &&
 149                         data_type == TRACK_AUDIO);
 150                 Thread::start();
 151                 start_lock->lock("CommonRender::start_command");
 152         }
 153 }
 154
 155 int CommonRender::restart_playback()
 156 {
 157         delete_vconsole();
 158         create_modules();
 159         build_virtual_console();
 160         start_plugins();
 161
 162         done = 0;
 163         interrupt = 0;
 164         last_playback = 0;
 165         restart_plugins = 0;
 166         return 0;
 167 }
 168
 169 void CommonRender::delete_vconsole()
 170 {
 171         if(vconsole) delete vconsole;
 172         vconsole = 0;
 173 }
 174
 175 int CommonRender::get_boundaries(int64_t &current_render_length)
 176 {
 177         int64_t loop_end = tounits(renderengine->edl->local_session->loop_end, 1);
 178         int64_t loop_start = tounits(renderengine->edl->local_session->loop_start, 0);
 179         int64_t start_position = tounits(renderengine->command->start_position, 0);
 180         int64_t end_position = tounits(renderengine->command->end_position, 1);
 181
 182
 183 // test absolute boundaries if no loop and not infinite
 184         if(renderengine->command->single_frame() ||
 185                 (!renderengine->edl->local_session->loop_playback &&
 186                 !renderengine->command->infinite))
 187         {
 188                 if(renderengine->command->get_direction() == PLAY_FORWARD)
 189                 {
 190                         if(current_position + current_render_length >= end_position)
 191                         {
 192                                 last_playback = 1;
 193                                 current_render_length = end_position - current_position;
 194                         }
 195                 }
 196 // reverse playback
 197                 else
 198                 {
 199                         if(current_position - current_render_length <= start_position)
 200                         {
 201                                 last_playback = 1;
 202                                 current_render_length = current_position - start_position;
 203                         }
 204                 }
 205         }
 206
 207 // test against loop boundaries
 208         if(!renderengine->command->single_frame() &&
 209                 renderengine->edl->local_session->loop_playback &&
 210                 !renderengine->command->infinite)
 211         {
 212                 if(renderengine->command->get_direction() == PLAY_FORWARD)
 213                 {
 214                         int64_t segment_end = current_position + current_render_length;
 215                         if(segment_end > loop_end)
 216                         {
 217                                 current_render_length = loop_end - current_position;
 218                         }
 219                 }
 220                 else
 221                 {
 222                         int64_t segment_end = current_position - current_render_length;
 223                         if(segment_end < loop_start)
 224                         {
 225                                 current_render_length = current_position - loop_start;
 226                         }
 227                 }
 228         }
 229
 230         if(renderengine->command->single_frame())
 231                 current_render_length = 1;
 232
 233         if(current_render_length < 0) current_render_length = 0;
 234         return 0;
 235 }
 236
 237 void CommonRender::run()
 238 {
 239         start_lock->unlock();
 240 }
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262 CommonRender::CommonRender(MWindow *mwindow, RenderEngine *renderengine)
 263  : Thread()
 264 {
 265         this->mwindow = mwindow;
 266         this->renderengine = renderengine;
 267         current_position = 0;
 268         interrupt = 0;
 269         done = 0;
 270         last_playback = 0;
 271         vconsole = 0;
 272         asynchronous = 1;
 273 }
 274
 275
 276 int CommonRender::wait_for_completion()
 277 {
 278         join();
 279 }
 280
 281
 282
 283
 284
 285 int CommonRender::advance_position(int64_t current_render_length)
 286 {
 287         int64_t loop_end = tounits(renderengine->edl->local_session->loop_end, 1);
 288         int64_t loop_start = tounits(renderengine->edl->local_session->loop_start, 0);
 289
 290 // advance the playback position
 291         if(renderengine->command->get_direction() == PLAY_REVERSE)
 292                 current_position -= current_render_length;
 293         else
 294                 current_position += current_render_length;
 295
 296 // test loop again
 297         if(renderengine->edl->local_session->loop_playback &&
 298                 !renderengine->command->infinite)
 299         {
 300                 if(renderengine->command->get_direction() == PLAY_REVERSE)
 301                 {
 302                         if(current_position <= loop_start)
 303                                 current_position = loop_end;
 304                 }
 305                 else
 306                 {
 307                         if(current_position >= loop_end)
 308                                 current_position = loop_start + (current_position - loop_end);
 309                 }
 310         }
 311         return 0;
 312 }
 313
 314 int64_t CommonRender::tounits(double position, int round)
 315 {
 316         return (int64_t)position;
 317 }
 318
 319 double CommonRender::fromunits(int64_t position)
 320 {
 321         return (double)position;
 322 }