cinelerra-5.1/cinelerra/maskautos.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "automation.inc"
  23 #include "clip.h"
  24 #include "edl.h"
  25 #include "edlsession.h"
  26 #include "localsession.h"
  27 #include "maskauto.h"
  28 #include "maskautos.h"
  29 #include "track.h"
  30 #include "transportque.inc"
  31
  32 MaskAutos::MaskAutos(EDL *edl,
  33         Track *track)
  34  : Autos(edl, track)
  35 {
  36         type = AUTOMATION_TYPE_MASK;
  37 }
  38
  39 MaskAutos::~MaskAutos()
  40 {
  41 }
  42
  43
  44
  45
  46 void MaskAutos::update_parameter(MaskAuto *src)
  47 {
  48         double selection_start = edl->local_session->get_selectionstart(0);
  49         double selection_end = edl->local_session->get_selectionend(0);
  50
  51 // Selection is always aligned to frame for masks
  52
  53 // Create new keyframe if auto keyframes or replace entire keyframe.
  54         if( !edl->session->span_keyframes ||
  55             EQUIV(selection_start, selection_end) )
  56         {
  57 // Search for keyframe to write to
  58                 MaskAuto *dst = (MaskAuto*)get_auto_for_editing();
  59
  60                 dst->copy_data(src);
  61         }
  62         else
  63 // Replace changed parameter in all selected keyframes.
  64         {
  65 // Search all keyframes in selection but don't create a new one.
  66                 int64_t start = track->to_units(selection_start, 0);
  67                 int64_t end = track->to_units(selection_end, 0);
  68                 Auto *current_auto = 0;
  69                 MaskAuto *current = 0;
  70                 current = (MaskAuto*)get_prev_auto(start,
  71                         PLAY_FORWARD,
  72                         current_auto,
  73                         1);
  74
  75 // The first one determines the changed parameters since it is the one displayed
  76 // in the GUI.
  77                 MaskAuto *first = current;
  78
  79 // Update the first one last, so it is available for comparisons to the changed one.
  80                 for(current = (MaskAuto*)NEXT;
  81                         current && current->position < end;
  82                         current = (MaskAuto*)NEXT)
  83                 {
  84                         current->update_parameter(first,
  85                                 src);
  86                 }
  87                 first->copy_data(src);
  88         }
  89 }
  90
  91
  92
  93 void MaskAutos::get_points(MaskPoints *points,
  94         int submask,
  95         int64_t position,
  96         int direction)
  97 {
  98         MaskAuto *begin = 0, *end = 0;
  99         position = (direction == PLAY_FORWARD) ? position : (position - 1);
 100
 101 // Get auto before and after position
 102         for(MaskAuto* current = (MaskAuto*)last;
 103                 current;
 104                 current = (MaskAuto*)PREVIOUS)
 105         {
 106                 if(current->position <= position)
 107                 {
 108                         begin = current;
 109                         end = NEXT ? (MaskAuto*)NEXT : current;
 110                         break;
 111                 }
 112         }
 113
 114 // Nothing before position found
 115         if(!begin)
 116         {
 117                 begin = end = (MaskAuto*)first;
 118         }
 119
 120 // Nothing after position found
 121         if(!begin)
 122         {
 123                 begin = end = (MaskAuto*)default_auto;
 124         }
 125
 126
 127         SubMask *mask1 = begin->get_submask(submask);
 128         SubMask *mask2 = end->get_submask(submask);
 129
 130         points->remove_all_objects();
 131         int total_points = MAX(mask1->points.size(), mask2->points.size());
 132         for(int i = 0; i < total_points; i++)
 133         {
 134                 MaskPoint *point = new MaskPoint;
 135                 MaskPoint point1;
 136                 int need_point1 = 1;
 137                 MaskPoint point2;
 138                 int need_point2 = 1;
 139
 140                 if(i < mask1->points.size())
 141                 {
 142                         point1.copy_from(*mask1->points.get(i));
 143                         need_point1 = 0;
 144                 }
 145
 146                 if(i < mask2->points.size())
 147                 {
 148                         point2.copy_from(*mask2->points.get(i));
 149                         need_point2 = 0;
 150                 }
 151
 152                 if(need_point1) point1.copy_from(point2);
 153                 if(need_point2) point2.copy_from(point1);
 154
 155                 avg_points(point,
 156                         &point1,
 157                         &point2,
 158                         position,
 159                         begin->position,
 160                         end->position);
 161                 points->append(point);
 162         }
 163 }
 164
 165
 166 double MaskAutos::get_feather(int64_t position, int i, int direction)
 167 {
 168         Auto *begin = 0, *end = 0;
 169         position = (direction == PLAY_FORWARD) ? position : (position - 1);
 170         MaskAuto*prev = (MaskAuto*)get_prev_auto(position, PLAY_FORWARD, begin, 1);
 171         MaskAuto*next = (MaskAuto*)get_next_auto(position, PLAY_FORWARD, end, 1);
 172         SubMask *prev_mask = prev->get_submask(i), *next_mask = next->get_submask(i);
 173
 174         double weight = end->position == begin->position ? 0.0 :
 175                 (double)(position - begin->position) / (end->position - begin->position);
 176
 177         double result = prev_mask->feather * (1-weight) + next_mask->feather*weight;
 178         return result;
 179 }
 180
 181 double MaskAutos::get_fader(int64_t position, int i, int direction)
 182 {
 183         Auto *begin = 0, *end = 0;
 184         position = (direction == PLAY_FORWARD) ? position : (position - 1);
 185         MaskAuto*prev = (MaskAuto*)get_prev_auto(position, PLAY_FORWARD, begin, 1);
 186         MaskAuto*next = (MaskAuto*)get_next_auto(position, PLAY_FORWARD, end, 1);
 187         SubMask *prev_mask = prev->get_submask(i), *next_mask = next->get_submask(i);
 188
 189         double weight = end->position == begin->position ? 0.0 :
 190                 (double)(position - begin->position) / (end->position - begin->position);
 191
 192         double result = prev_mask->fader * (1-weight) + next_mask->fader*weight;
 193 // printf("MaskAutos::get_fader %d %d %d %f %d %f %d\n", __LINE__, i,
 194 // ((MaskAuto*)begin)->fader, 1.0 - weight, ((MaskAuto*)end)->fader, weight, result);
 195         return result;
 196 }
 197
 198
 199 void MaskAutos::avg_points(MaskPoint *output, MaskPoint *input1, MaskPoint *input2,
 200                 int64_t output_position, int64_t position1, int64_t position2)
 201 {
 202         if(position2 == position1) {
 203                 *output = *input1;
 204         }
 205         else {
 206                 float fraction2 = (float)(output_position - position1) / (position2 - position1);
 207                 float fraction1 = 1 - fraction2;
 208                 output->x = input1->x * fraction1 + input2->x * fraction2;
 209                 output->y = input1->y * fraction1 + input2->y * fraction2;
 210                 output->control_x1 = input1->control_x1 * fraction1 + input2->control_x1 * fraction2;
 211                 output->control_y1 = input1->control_y1 * fraction1 + input2->control_y1 * fraction2;
 212                 output->control_x2 = input1->control_x2 * fraction1 + input2->control_x2 * fraction2;
 213                 output->control_y2 = input1->control_y2 * fraction1 + input2->control_y2 * fraction2;
 214         }
 215
 216 }
 217
 218
 219 Auto* MaskAutos::new_auto()
 220 {
 221         return new MaskAuto(edl, this);
 222 }
 223
 224 void MaskAutos::dump(FILE *fp)
 225 {
 226         fprintf(fp, "   MaskAutos::dump %p\n", this);
 227         fprintf(fp, "   Default: position %jd submasks %d\n",
 228                 default_auto->position,
 229                 ((MaskAuto*)default_auto)->masks.total);
 230         ((MaskAuto*)default_auto)->dump(fp);
 231         for( Auto* current = first; current; current=NEXT ) {
 232                 fprintf(fp, "   position %jd masks %d\n",
 233                         current->position,
 234                         ((MaskAuto*)current)->masks.total);
 235                 ((MaskAuto*)current)->dump(fp);
 236         }
 237 }
 238
 239 int MaskAutos::mask_exists(int64_t position, int direction)
 240 {
 241         Auto *current = 0;
 242         position = (direction == PLAY_FORWARD) ? position : (position - 1);
 243
 244         MaskAuto* keyframe = (MaskAuto*)get_prev_auto(position, direction, current);
 245
 246         for( int i = 0; i < keyframe->masks.total; i++ ) {
 247                 SubMask *mask = keyframe->get_submask(i);
 248                 if(mask->points.total > 1)
 249                         return 1;
 250         }
 251         return 0;
 252 }
 253
 254 int MaskAutos::total_submasks(int64_t position, int direction)
 255 {
 256         position = (direction == PLAY_FORWARD) ? position : (position - 1);
 257         for( MaskAuto* current=(MaskAuto*)last; current; current=(MaskAuto*)PREVIOUS ) {
 258                 if( current->position <= position ) {
 259                         return current->masks.total;
 260                 }
 261         }
 262
 263         return ((MaskAuto*)default_auto)->masks.total;
 264 }
 265
 266
 267 void MaskAutos::translate_masks(float translate_x, float translate_y)
 268 {
 269         ((MaskAuto *)default_auto)->translate_submasks(translate_x, translate_y);
 270         for( MaskAuto* current=(MaskAuto*)first; current; current=(MaskAuto*)NEXT ) {
 271                 current->translate_submasks(translate_x, translate_y);
 272         }
 273 }
 274
 275 void MaskAutos::set_proxy(int orig_scale, int new_scale)
 276 {
 277         ((MaskAuto *)default_auto)->scale_submasks(orig_scale, new_scale);
 278         for( MaskAuto* current=(MaskAuto*)first; current; current=(MaskAuto*)NEXT ) {
 279                 current->scale_submasks(orig_scale, new_scale);
 280         }
 281 }
 282