cinelerra/transportque.C

   1 #include "bcsignals.h"
   2 #include "clip.h"
   3 #include "condition.h"
   4 #include "edl.h"
   5 #include "edlsession.h"
   6 #include "localsession.h"
   7 #include "tracks.h"
   8 #include "transportque.h"
   9
  10 TransportCommand::TransportCommand()
  11 {
  12 // In rendering we want a master EDL so settings don't get clobbered
  13 // in the middle of a job.
  14         edl = new EDL;
  15         edl->create_objects();
  16         command = 0;
  17         change_type = 0;
  18         reset();
  19 }
  20
  21 TransportCommand::~TransportCommand()
  22 {
  23         delete edl;
  24 }
  25
  26 void TransportCommand::reset()
  27 {
  28         playbackstart = 0;
  29         start_position = 0;
  30         end_position = 0;
  31         infinite = 0;
  32         realtime = 0;
  33         resume = 0;
  34 // Don't reset the change type for commands which don't perform the change
  35         if(command != STOP) change_type = 0;
  36         command = COMMAND_NONE;
  37 }
  38
  39 EDL* TransportCommand::get_edl()
  40 {
  41         return edl;
  42 }
  43
  44 void TransportCommand::delete_edl()
  45 {
  46         delete edl;
  47         edl = 0;
  48 }
  49
  50 void TransportCommand::new_edl()
  51 {
  52         edl = new EDL;
  53         edl->create_objects();
  54 }
  55
  56
  57 void TransportCommand::copy_from(TransportCommand *command)
  58 {
  59         this->command = command->command;
  60         this->change_type = command->change_type;
  61         this->edl->copy_all(command->edl);
  62         this->start_position = command->start_position;
  63         this->end_position = command->end_position;
  64         this->playbackstart = command->playbackstart;
  65         this->realtime = command->realtime;
  66         this->resume = command->resume;
  67 }
  68
  69 TransportCommand& TransportCommand::operator=(TransportCommand &command)
  70 {
  71         copy_from(&command);
  72         return *this;
  73 }
  74
  75 int TransportCommand::single_frame()
  76 {
  77         return (command == SINGLE_FRAME_FWD ||
  78                 command == SINGLE_FRAME_REWIND ||
  79                 command == CURRENT_FRAME);
  80 }
  81
  82
  83 int TransportCommand::get_direction()
  84 {
  85         switch(command)
  86         {
  87                 case SINGLE_FRAME_FWD:
  88                 case NORMAL_FWD:
  89                 case FAST_FWD:
  90                 case SLOW_FWD:
  91                 case CURRENT_FRAME:
  92                         return PLAY_FORWARD;
  93                         break;
  94
  95                 case SINGLE_FRAME_REWIND:
  96                 case NORMAL_REWIND:
  97                 case FAST_REWIND:
  98                 case SLOW_REWIND:
  99                         return PLAY_REVERSE;
 100                         break;
 101
 102                 default:
 103                         return PLAY_FORWARD;
 104                         break;
 105         }
 106 }
 107
 108 float TransportCommand::get_speed()
 109 {
 110         switch(command)
 111         {
 112                 case SLOW_FWD:
 113                 case SLOW_REWIND:
 114                         return 0.5;
 115                         break;
 116
 117                 case NORMAL_FWD:
 118                 case NORMAL_REWIND:
 119                 case SINGLE_FRAME_FWD:
 120                 case SINGLE_FRAME_REWIND:
 121                 case CURRENT_FRAME:
 122                         return 1;
 123                         break;
 124
 125                 case FAST_FWD:
 126                 case FAST_REWIND:
 127                         return 2;
 128                         break;
 129         }
 130 }
 131
 132 // Assume starting without pause
 133 void TransportCommand::set_playback_range(EDL *edl, int use_inout)
 134 {
 135         if(!edl) edl = this->edl;
 136
 137
 138
 139
 140         switch(command)
 141         {
 142                 case SLOW_FWD:
 143                 case FAST_FWD:
 144                 case NORMAL_FWD:
 145                         start_position = edl->local_session->get_selectionstart(1);
 146                         if(EQUIV(edl->local_session->get_selectionend(1), edl->local_session->get_selectionstart(1)))
 147                                 end_position = edl->tracks->total_playable_length();
 148                         else
 149                                 end_position = edl->local_session->get_selectionend(1);
 150 // this prevents a crash if start position is after the loop when playing forwards
 151                     if (edl->local_session->loop_playback && start_position > edl->local_session->loop_end)
 152                         {
 153                                     start_position = edl->local_session->loop_start;
 154                         }
 155                         break;
 156
 157                 case SLOW_REWIND:
 158                 case FAST_REWIND:
 159                 case NORMAL_REWIND:
 160                         end_position = edl->local_session->get_selectionend(1);
 161                         if(EQUIV(edl->local_session->get_selectionend(1), edl->local_session->get_selectionstart(1)))
 162                                 start_position = 0;
 163                         else
 164                                 start_position = edl->local_session->get_selectionstart(1);
 165 // this prevents a crash if start position is before the loop when playing backwards
 166                         if (edl->local_session->loop_playback && start_position <= edl->local_session->loop_start)
 167                         {
 168                                         start_position = edl->local_session->loop_end;
 169                                         end_position = edl->local_session->loop_end;
 170                         }
 171                         break;
 172
 173                 case CURRENT_FRAME:
 174                 case SINGLE_FRAME_FWD:
 175                         start_position = edl->local_session->get_selectionstart(1);
 176                         end_position = start_position +
 177                                 1.0 /
 178                                 edl->session->frame_rate;
 179                         break;
 180
 181                 case SINGLE_FRAME_REWIND:
 182                         start_position = edl->local_session->get_selectionend(1);
 183                         end_position = start_position -
 184                                 1.0 /
 185                                 edl->session->frame_rate;
 186                         break;
 187         }
 188
 189
 190         if(use_inout)
 191         {
 192                 if(edl->local_session->inpoint_valid())
 193                         start_position = edl->local_session->get_inpoint();
 194                 if(edl->local_session->outpoint_valid())
 195                         end_position = edl->local_session->get_outpoint();
 196         }
 197
 198         switch(get_direction())
 199         {
 200                 case PLAY_FORWARD:
 201                         playbackstart = start_position;
 202                         break;
 203
 204                 case PLAY_REVERSE:
 205                         playbackstart = end_position;
 206                         break;
 207         }
 208
 209 }
 210
 211 void TransportCommand::adjust_playback_range()
 212 {
 213
 214
 215         if(edl->local_session->inpoint_valid() ||
 216                 edl->local_session->outpoint_valid())
 217         {
 218                 if(edl->local_session->inpoint_valid())
 219                         start_position = edl->local_session->get_inpoint();
 220                 else
 221                         start_position = 0;
 222
 223                 if(edl->local_session->outpoint_valid())
 224                         end_position = edl->local_session->get_outpoint();
 225                 else
 226                         end_position = edl->tracks->total_playable_length();
 227         }
 228 }
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247 TransportQue::TransportQue()
 248 {
 249         input_lock = new Condition(1, "TransportQue::input_lock");
 250         output_lock = new Condition(0, "TransportQue::output_lock");
 251 }
 252
 253 TransportQue::~TransportQue()
 254 {
 255         delete input_lock;
 256         delete output_lock;
 257 }
 258
 259 int TransportQue::send_command(int command,
 260                 int change_type,
 261                 EDL *new_edl,
 262                 int realtime,
 263                 int resume,
 264                 int use_inout)
 265 {
 266         input_lock->lock("TransportQue::send_command 1");
 267         this->command.command = command;
 268 // Mutually exclusive operation
 269         this->command.change_type |= change_type;
 270         this->command.realtime = realtime;
 271         this->command.resume = resume;
 272
 273         if(new_edl)
 274         {
 275 // Just change the EDL if the change requires it because renderengine
 276 // structures won't point to the new EDL otherwise and because copying the
 277 // EDL for every cursor movement is slow.
 278                 if(change_type == CHANGE_EDL ||
 279                         change_type == CHANGE_ALL)
 280                 {
 281 // Copy EDL
 282                         this->command.get_edl()->copy_all(new_edl);
 283                 }
 284                 else
 285                 if(change_type == CHANGE_PARAMS)
 286                 {
 287                         this->command.get_edl()->synchronize_params(new_edl);
 288                 }
 289
 290 // Set playback range
 291                 this->command.set_playback_range(new_edl, use_inout);
 292         }
 293
 294         input_lock->unlock();
 295
 296         output_lock->unlock();
 297         return 0;
 298 }
 299
 300 void TransportQue::update_change_type(int change_type)
 301 {
 302         input_lock->lock("TransportQue::update_change_type");
 303         this->command.change_type |= change_type;
 304         input_lock->unlock();
 305 }