cinelerra/vautomation.C

   1 #include "clip.h"
   2 #include "colors.h"
   3 #include "edl.h"
   4 #include "edlsession.h"
   5 #include "floatauto.h"
   6 #include "floatautos.h"
   7 #include "intauto.h"
   8 #include "intautos.h"
   9 #include "maskautos.h"
  10 #include "overlayframe.inc"
  11 #include "transportque.inc"
  12 #include "vautomation.h"
  13
  14
  15 VAutomation::VAutomation(EDL *edl, Track *track)
  16  : Automation(edl, track)
  17 {
  18 }
  19
  20
  21
  22 VAutomation::~VAutomation()
  23 {
  24 }
  25
  26
  27 int VAutomation::create_objects()
  28 {
  29         Automation::create_objects();
  30
  31         autos[AUTOMATION_FADE] = new FloatAutos(edl, track, 100);
  32         autos[AUTOMATION_FADE]->create_objects();
  33
  34         autos[AUTOMATION_MODE] = new IntAutos(edl, track, TRANSFER_NORMAL);
  35         autos[AUTOMATION_MODE]->create_objects();
  36
  37         autos[AUTOMATION_MASK] = new MaskAutos(edl, track);
  38         autos[AUTOMATION_MASK]->create_objects();
  39
  40         autos[AUTOMATION_CAMERA_X] = new FloatAutos(edl, track, 0.0);
  41         autos[AUTOMATION_CAMERA_X]->create_objects();
  42
  43         autos[AUTOMATION_CAMERA_Y] = new FloatAutos(edl, track, 0.0);
  44         autos[AUTOMATION_CAMERA_Y]->create_objects();
  45
  46         autos[AUTOMATION_PROJECTOR_X] = new FloatAutos(edl, track, 0.0);
  47         autos[AUTOMATION_PROJECTOR_X]->create_objects();
  48
  49         autos[AUTOMATION_PROJECTOR_Y] = new FloatAutos(edl, track, 0.0);
  50         autos[AUTOMATION_PROJECTOR_Y]->create_objects();
  51
  52         autos[AUTOMATION_CAMERA_Z] = new FloatAutos(edl, track, 1.0);
  53         autos[AUTOMATION_CAMERA_Z]->create_objects();
  54
  55         autos[AUTOMATION_PROJECTOR_Z] = new FloatAutos(edl, track, 1.0);
  56         autos[AUTOMATION_PROJECTOR_Z]->create_objects();
  57
  58 //      autos[AUTOMATION_NUDGE] = new FloatAutos(edl, track, 0.0);
  59 //      autos[AUTOMATION_NUDGE]->create_objects();
  60
  61         for(int i = 0; i < AUTOMATION_TOTAL; i++)
  62                 if (autos[i])
  63                 {
  64                         autos[i]->autoidx = i;
  65                         autos[i]->autogrouptype = autogrouptype(i, autos[i]->track);
  66                 }
  67
  68         return 0;
  69 }
  70
  71 int VAutomation::direct_copy_possible(int64_t start, int direction)
  72 {
  73         int64_t end = (direction == PLAY_FORWARD) ? (start + 1) : (start - 1);
  74
  75         if(!Automation::direct_copy_possible(start, direction))
  76                 return 0;
  77
  78 // Automation is constant
  79         double constant;
  80         if(((FloatAutos*)autos[AUTOMATION_FADE])->automation_is_constant(
  81                 start, 1, direction, constant))
  82         {
  83                 if(!EQUIV(constant, 100))
  84                         return 0;
  85         }
  86         else
  87 // Automation varies
  88                 return 0;
  89
  90 // Track must not be muted
  91         if(autos[AUTOMATION_MUTE]->automation_is_constant(start, end))
  92         {
  93                 if(autos[AUTOMATION_MUTE]->get_automation_constant(start, end) > 0)
  94                         return 0;
  95         }
  96         else
  97                 return 0;
  98
  99 // Projector must be centered.
 100         FloatAuto *previous = 0, *next = 0;
 101         float z = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_Z])->get_value(
 102                 start, previous, next);
 103         if(!EQUIV(z, 1)) return 0;
 104
 105         previous = 0;
 106         next = 0;
 107         float x = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_X])->get_value(start,
 108                                 previous,
 109                                 next);
 110         if(!EQUIV(x, 0)) return 0;
 111         previous = 0;
 112         next = 0;
 113         float y = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_Y])->get_value(start,
 114                                 previous,
 115                                 next);
 116         if(!EQUIV(y, 0)) return 0;
 117
 118
 119
 120
 121 // Camera must be centered
 122         previous = 0;
 123         next = 0;
 124         z = ((FloatAutos*)autos[AUTOMATION_CAMERA_Z])->get_value(
 125                 start,
 126                 previous,
 127                 next);
 128         if(!EQUIV(z, 1)) return 0;
 129
 130
 131
 132         previous = 0;
 133         next = 0;
 134         x = ((FloatAutos*)autos[AUTOMATION_CAMERA_X])->get_value(start,
 135                                 previous,
 136                                 next);
 137         if(!EQUIV(x, 0)) return 0;
 138
 139         previous = 0;
 140         next = 0;
 141         y = ((FloatAutos*)autos[AUTOMATION_CAMERA_Y])->get_value(start,
 142                                 previous,
 143                                 next);
 144
 145         if(!EQUIV(y, 0)) return 0;
 146
 147 // No mask must exist
 148         if(((MaskAutos*)autos[AUTOMATION_MASK])->mask_exists(start, direction))
 149                 return 0;
 150
 151         return 1;
 152 }
 153
 154 void VAutomation::get_projector(float *x,
 155         float *y,
 156         float *z,
 157         int64_t position,
 158         int direction)
 159 {
 160         FloatAuto *before, *after;
 161         before = 0;
 162         after = 0;
 163         *x = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_X])->get_value(position,
 164                 before,
 165                 after);
 166         before = 0;
 167         after = 0;
 168         *y = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_Y])->get_value(position,
 169                 before,
 170                 after);
 171         before = 0;
 172         after = 0;
 173         *z = ((FloatAutos*)autos[AUTOMATION_PROJECTOR_Z])->get_value(position,
 174                 before,
 175                 after);
 176 }
 177
 178
 179 void VAutomation::get_camera(float *x,
 180         float *y,
 181         float *z,
 182         int64_t position,
 183         int direction)
 184 {
 185         FloatAuto *before, *after;
 186         before = 0;
 187         after = 0;
 188         *x = ((FloatAutos*)autos[AUTOMATION_CAMERA_X])->get_value(position,
 189                 before,
 190                 after);
 191         before = 0;
 192         after = 0;
 193         *y = ((FloatAutos*)autos[AUTOMATION_CAMERA_Y])->get_value(position,
 194                 before,
 195                 after);
 196         before = 0;
 197         after = 0;
 198         *z = ((FloatAutos*)autos[AUTOMATION_CAMERA_Z])->get_value(position,
 199                 before,
 200                 after);
 201 }
 202