initial commit
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / maskauto.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 "clip.h"
23 #include "filexml.h"
24 #include "maskauto.h"
25 #include "maskautos.h"
26
27 #include <stdlib.h>
28 #include <string.h>
29
30
31 MaskPoint::MaskPoint()
32 {
33         x = 0;
34         y = 0;
35         control_x1 = 0;
36         control_y1 = 0;
37         control_x2 = 0;
38         control_y2 = 0;
39 }
40
41 void MaskPoint::copy_from(MaskPoint &ptr)
42 {
43         this->x = ptr.x;
44         this->y = ptr.y;
45         this->control_x1 = ptr.control_x1;
46         this->control_y1 = ptr.control_y1;
47         this->control_x2 = ptr.control_x2;
48         this->control_y2 = ptr.control_y2;
49 }
50
51 MaskPoint& MaskPoint::operator=(MaskPoint& ptr)
52 {
53         copy_from(ptr);
54         return *this;
55 }
56
57 int MaskPoint::operator==(MaskPoint& ptr)
58 {
59         return EQUIV(x, ptr.x) &&
60                 EQUIV(y, ptr.y) &&
61                 EQUIV(control_x1, ptr.control_x1) &&
62                 EQUIV(control_y1, ptr.control_y1) &&
63                 EQUIV(control_x2, ptr.control_x2) &&
64                 EQUIV(control_y2, ptr.control_y2);
65 }
66
67 SubMask::SubMask(MaskAuto *keyframe)
68 {
69         this->keyframe = keyframe;
70 }
71
72 SubMask::~SubMask()
73 {
74         points.remove_all_objects();
75 }
76
77 int SubMask::equivalent(SubMask& ptr)
78 {
79         if(points.size() != ptr.points.size()) return 0;
80
81         for(int i = 0; i < points.size(); i++)
82         {
83                 if(!(*points.get(i) == *ptr.points.get(i)))
84                         return 0;
85         }
86
87         return 1;
88 }
89
90
91 int SubMask::operator==(SubMask& ptr)
92 {
93         return equivalent(ptr);
94 }
95
96 void SubMask::copy_from(SubMask& ptr)
97 {
98         points.remove_all_objects();
99 //printf("SubMask::copy_from 1 %p %d\n", this, ptr.points.total);
100         for(int i = 0; i < ptr.points.total; i++)
101         {
102                 MaskPoint *point = new MaskPoint;
103                 *point = *ptr.points.values[i];
104                 points.append(point);
105         }
106 }
107
108 void SubMask::load(FileXML *file)
109 {
110         points.remove_all_objects();
111
112         int result = 0;
113         while(!result)
114         {
115                 result = file->read_tag();
116
117                 if(!result)
118                 {
119                         if(file->tag.title_is("/MASK"))
120                         {
121                                 result = 1;
122                         }
123                         else
124                         if(file->tag.title_is("POINT"))
125                         {
126                                 XMLBuffer data;
127                                 file->read_text_until("/POINT", &data);
128
129                                 MaskPoint *point = new MaskPoint;
130                                 char *ptr = data.cstr();
131 //printf("MaskAuto::load 1 %s\n", ptr);
132
133                                 point->x = atof(ptr);
134                                 ptr = strchr(ptr, ',');
135 //printf("MaskAuto::load 2 %s\n", ptr + 1);
136                                 if(ptr)
137                                 {
138                                         point->y = atof(ptr + 1);
139                                         ptr = strchr(ptr + 1, ',');
140
141                                         if(ptr)
142                                         {
143 //printf("MaskAuto::load 3 %s\n", ptr + 1);
144                                                 point->control_x1 = atof(ptr + 1);
145                                                 ptr = strchr(ptr + 1, ',');
146                                                 if(ptr)
147                                                 {
148 //printf("MaskAuto::load 4 %s\n", ptr + 1);
149                                                         point->control_y1 = atof(ptr + 1);
150                                                         ptr = strchr(ptr + 1, ',');
151                                                         if(ptr)
152                                                         {
153 //printf("MaskAuto::load 5 %s\n", ptr + 1);
154                                                                 point->control_x2 = atof(ptr + 1);
155                                                                 ptr = strchr(ptr + 1, ',');
156                                                                 if(ptr) point->control_y2 = atof(ptr + 1);
157                                                         }
158                                                 }
159                                         }
160
161                                 }
162                                 points.append(point);
163                         }
164                 }
165         }
166 }
167
168 void SubMask::copy(FileXML *file)
169 {
170         if(points.total)
171         {
172                 file->tag.set_title("MASK");
173                 file->tag.set_property("NUMBER", keyframe->masks.number_of(this));
174                 file->append_tag();
175                 file->append_newline();
176
177                 for(int i = 0; i < points.total; i++)
178                 {
179                         file->append_newline();
180                         file->tag.set_title("POINT");
181                         file->append_tag();
182                         char string[BCTEXTLEN];
183 //printf("SubMask::copy 1 %p %d %p\n", this, i, points.values[i]);
184                         sprintf(string, "%.7g, %.7g, %.7g, %.7g, %.7g, %.7g",
185                                 points.values[i]->x,
186                                 points.values[i]->y,
187                                 points.values[i]->control_x1,
188                                 points.values[i]->control_y1,
189                                 points.values[i]->control_x2,
190                                 points.values[i]->control_y2);
191 //printf("SubMask::copy 2\n");
192                         file->append_text(string);
193                         file->tag.set_title("/POINT");
194                         file->append_tag();
195                 }
196                 file->append_newline();
197
198                 file->tag.set_title("/MASK");
199                 file->append_tag();
200                 file->append_newline();
201         }
202 }
203
204 void SubMask::dump()
205 {
206         for(int i = 0; i < points.total; i++)
207         {
208                 printf("          point=%d x=%.2f y=%.2f in_x=%.2f in_y=%.2f out_x=%.2f out_y=%.2f\n",
209                         i,
210                         points.values[i]->x,
211                         points.values[i]->y,
212                         points.values[i]->control_x1,
213                         points.values[i]->control_y1,
214                         points.values[i]->control_x2,
215                         points.values[i]->control_y2);
216         }
217 }
218
219
220 MaskAuto::MaskAuto(EDL *edl, MaskAutos *autos)
221  : Auto(edl, autos)
222 {
223         mode = MASK_SUBTRACT_ALPHA;
224         feather = 0;
225         value = 100;
226         apply_before_plugins = 0;
227         disable_opengl_masking = 0;
228
229 // We define a fixed number of submasks so that interpolation for each
230 // submask matches.
231
232         for(int i = 0; i < SUBMASKS; i++)
233                 masks.append(new SubMask(this));
234 }
235
236 MaskAuto::~MaskAuto()
237 {
238         masks.remove_all_objects();
239 }
240
241 int MaskAuto::operator==(Auto &that)
242 {
243         return identical((MaskAuto*)&that);
244 }
245
246
247
248 int MaskAuto::operator==(MaskAuto &that)
249 {
250         return identical((MaskAuto*)&that);
251 }
252
253
254 int MaskAuto::identical(MaskAuto *src)
255 {
256         if(value != src->value ||
257                 mode != src->mode ||
258                 feather != src->feather ||
259                 masks.size() != src->masks.size() ||
260                 apply_before_plugins != src->apply_before_plugins ||
261                 disable_opengl_masking != src->disable_opengl_masking) return 0;
262
263         for(int i = 0; i < masks.size(); i++)
264                 if(!(*masks.values[i] == *src->masks.values[i])) return 0;
265
266         return 1;
267 }
268
269 void MaskAuto::update_parameter(MaskAuto *ref, MaskAuto *src)
270 {
271         if(src->value != ref->value)
272         {
273                 this->value = src->value;
274         }
275
276         if(src->mode != ref->mode)
277         {
278                 this->mode = src->mode;
279         }
280
281         if(!EQUIV(src->feather, ref->feather))
282         {
283                 this->feather = src->feather;
284         }
285
286         for(int i = 0; i < masks.size(); i++)
287         {
288                 if(!src->get_submask(i)->equivalent(*ref->get_submask(i)))
289                         this->get_submask(i)->copy_from(*src->get_submask(i));
290         }
291 }
292
293 void MaskAuto::copy_from(Auto *src)
294 {
295         copy_from((MaskAuto*)src);
296 }
297
298 void MaskAuto::copy_from(MaskAuto *src)
299 {
300         Auto::copy_from(src);
301         copy_data(src);
302 }
303
304 void MaskAuto::copy_data(MaskAuto *src)
305 {
306         mode = src->mode;
307         feather = src->feather;
308         value = src->value;
309         apply_before_plugins = src->apply_before_plugins;
310         disable_opengl_masking = src->disable_opengl_masking;
311
312         masks.remove_all_objects();
313         for(int i = 0; i < src->masks.size(); i++)
314         {
315                 masks.append(new SubMask(this));
316                 masks.values[i]->copy_from(*src->masks.values[i]);
317         }
318 }
319
320 int MaskAuto::interpolate_from(Auto *a1, Auto *a2, int64_t position, Auto *templ) {
321         if(!a1) a1 = previous;
322         if(!a2) a2 = next;
323         MaskAuto  *mask_auto1 = (MaskAuto *)a1;
324         MaskAuto  *mask_auto2 = (MaskAuto *)a2;
325
326         if (!mask_auto2 || !mask_auto1 || mask_auto2->masks.total == 0)
327         // can't interpolate, fall back to copying (using template if possible)
328         {
329                 return Auto::interpolate_from(a1, a2, position, templ);
330         }
331         this->mode = mask_auto1->mode;
332         this->feather = mask_auto1->feather;
333         this->value = mask_auto1->value;
334         this->apply_before_plugins = mask_auto1->apply_before_plugins;
335         this->disable_opengl_masking = mask_auto1->disable_opengl_masking;
336         this->position = position;
337         masks.remove_all_objects();
338
339         for(int i = 0;
340                 i < mask_auto1->masks.total;
341                 i++)
342         {
343                 SubMask *new_submask = new SubMask(this);
344                 masks.append(new_submask);
345                 SubMask *mask1 = mask_auto1->masks.values[i];
346                 SubMask *mask2 = mask_auto2->masks.values[i];
347
348                 // just in case, should never happen
349                 int total_points = MIN(mask1->points.total, mask2->points.total);
350                 for(int j = 0; j < total_points; j++)
351                 {
352                         MaskPoint *point = new MaskPoint;
353                         MaskAutos::avg_points(point,
354                                 mask1->points.values[j],
355                                 mask2->points.values[j],
356                                 position,
357                                 mask_auto1->position,
358                                 mask_auto2->position);
359                         new_submask->points.append(point);
360                 }
361         }
362         return 1;
363
364
365 }
366
367
368 SubMask* MaskAuto::get_submask(int number)
369 {
370         CLAMP(number, 0, masks.size() - 1);
371         return masks.values[number];
372 }
373
374 void MaskAuto::get_points(ArrayList<MaskPoint*> *points,
375         int submask)
376 {
377         points->remove_all_objects();
378         SubMask *submask_ptr = get_submask(submask);
379         for(int i = 0; i < submask_ptr->points.size(); i++)
380         {
381                 MaskPoint *point = new MaskPoint;
382                 point->copy_from(*submask_ptr->points.get(i));
383                 points->append(point);
384         }
385 }
386
387 void MaskAuto::set_points(ArrayList<MaskPoint*> *points,
388         int submask)
389 {
390         SubMask *submask_ptr = get_submask(submask);
391         submask_ptr->points.remove_all_objects();
392         for(int i = 0; i < points->size(); i++)
393         {
394                 MaskPoint *point = new MaskPoint;
395                 point->copy_from(*points->get(i));
396                 submask_ptr->points.append(point);
397         }
398 }
399
400
401 void MaskAuto::load(FileXML *file)
402 {
403         mode = file->tag.get_property("MODE", mode);
404         feather = file->tag.get_property("FEATHER", feather);
405         value = file->tag.get_property("VALUE", value);
406         apply_before_plugins = file->tag.get_property("APPLY_BEFORE_PLUGINS", apply_before_plugins);
407         disable_opengl_masking = file->tag.get_property("DISABLE_OPENGL_MASKING", disable_opengl_masking);
408         for(int i = 0; i < masks.size(); i++)
409         {
410                 delete masks.values[i];
411                 masks.values[i] = new SubMask(this);
412         }
413
414         int result = 0;
415         while(!result)
416         {
417                 result = file->read_tag();
418
419                 if(!result)
420                 {
421                         if(file->tag.title_is("/AUTO"))
422                                 result = 1;
423                         else
424                         if(file->tag.title_is("MASK"))
425                         {
426                                 SubMask *mask = masks.values[file->tag.get_property("NUMBER", 0)];
427                                 mask->load(file);
428                         }
429                 }
430         }
431 //      dump();
432 }
433
434 void MaskAuto::copy(int64_t start, int64_t end, FileXML *file, int default_auto)
435 {
436         file->tag.set_title("AUTO");
437         file->tag.set_property("MODE", mode);
438         file->tag.set_property("VALUE", value);
439         file->tag.set_property("FEATHER", feather);
440         file->tag.set_property("APPLY_BEFORE_PLUGINS", apply_before_plugins);
441         file->tag.set_property("DISABLE_OPENGL_MASKING", disable_opengl_masking);
442
443         if(default_auto)
444                 file->tag.set_property("POSITION", 0);
445         else
446                 file->tag.set_property("POSITION", position - start);
447         file->append_tag();
448         file->append_newline();
449
450         for(int i = 0; i < masks.size(); i++)
451         {
452 //printf("MaskAuto::copy 1 %p %d %p\n", this, i, masks.values[i]);
453                 masks.values[i]->copy(file);
454 //printf("MaskAuto::copy 10\n");
455         }
456
457         file->append_newline();
458         file->tag.set_title("/AUTO");
459         file->append_tag();
460         file->append_newline();
461 }
462
463 void MaskAuto::dump()
464 {
465         printf("         mode=%d value=%d\n", mode, value);
466         for(int i = 0; i < masks.size(); i++)
467         {
468                 printf("         submask %d\n", i);
469                 masks.values[i]->dump();
470         }
471 }
472
473 void MaskAuto::translate_submasks(float translate_x, float translate_y)
474 {
475         for(int i = 0; i < masks.size(); i++)
476         {
477                 SubMask *mask = get_submask(i);
478                 for (int j = 0; j < mask->points.total; j++)
479                 {
480                         mask->points.values[j]->x += translate_x;
481                         mask->points.values[j]->y += translate_y;
482                 }
483         }
484 }
485
486 void MaskAuto::scale_submasks(int orig_scale, int new_scale)
487 {
488         for(int i = 0; i < masks.size(); i++)
489         {
490                 SubMask *mask = get_submask(i);
491                 for (int j = 0; j < mask->points.total; j++)
492                 {
493                         float orig_x = mask->points.values[j]->x * orig_scale;
494                         float orig_y = mask->points.values[j]->y * orig_scale;
495                         mask->points.values[j]->x = orig_x / new_scale;
496                         mask->points.values[j]->y = orig_y / new_scale;
497
498                         orig_x = mask->points.values[j]->control_x1 * orig_scale;
499                         orig_y = mask->points.values[j]->control_y1 * orig_scale;
500                         mask->points.values[j]->control_x1 = orig_x / new_scale;
501                         mask->points.values[j]->control_y1 = orig_y / new_scale;
502
503                         orig_x = mask->points.values[j]->control_x2 * orig_scale;
504                         orig_y = mask->points.values[j]->control_y2 * orig_scale;
505                         mask->points.values[j]->control_x2 = orig_x / new_scale;
506                         mask->points.values[j]->control_y2 = orig_y / new_scale;
507                 }
508         }
509 }
510
511