add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / maskengine.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 "bcsignals.h"
23 #include "condition.h"
24 #include "clip.h"
25 #include "maskauto.h"
26 #include "maskautos.h"
27 #include "maskengine.h"
28 #include "mutex.h"
29 #include "transportque.inc"
30 #include "vframe.h"
31
32 #include <math.h>
33 #include <stdint.h>
34 #include <string.h>
35
36 MaskPackage::MaskPackage()
37 {
38 }
39
40 MaskPackage::~MaskPackage()
41 {
42 }
43
44
45
46
47
48
49
50 MaskUnit::MaskUnit(MaskEngine *engine)
51  : LoadClient(engine)
52 {
53         this->engine = engine;
54         this->temp = 0;
55 }
56
57
58 MaskUnit::~MaskUnit()
59 {
60         if(temp) delete temp;
61 }
62
63
64 #define OVERSAMPLE 8
65
66 void MaskUnit::draw_line_clamped(VFrame *frame,
67         int x1, int y1, int x2, int y2, unsigned char k)
68 {
69         int draw_x1, draw_y1;
70         int draw_x2, draw_y2;
71
72         if(y2 < y1) {
73                 draw_x1 = x2;  draw_y1 = y2;
74                 draw_x2 = x1;  draw_y2 = y1;
75         }
76         else {
77                 draw_x1 = x1;  draw_y1 = y1;
78                 draw_x2 = x2;  draw_y2 = y2;
79         }
80
81         unsigned char **rows = (unsigned char**)frame->get_rows();
82
83         if(draw_y2 != draw_y1) {
84                 float slope = ((float)draw_x2 - draw_x1) / ((float)draw_y2 - draw_y1);
85                 int w = frame->get_w() - 1;
86                 int h = frame->get_h();
87
88                 for(float y = draw_y1; y < draw_y2; y++) {
89                         if(y >= 0 && y < h) {
90                                 int x = (int)((y - draw_y1) * slope + draw_x1);
91                                 int y_i = (int)y;
92                                 int x_i = CLIP(x, 0, w);
93
94                                 if(rows[y_i][x_i] == k)
95                                         rows[y_i][x_i] = 0;
96                                 else
97                                         rows[y_i][x_i] = k;
98                         }
99                 }
100         }
101 }
102
103 void MaskUnit::blur_strip(double *val_p,
104         double *val_m,
105         double *dst,
106         double *src,
107         int size,
108         int max)
109 {
110         double *sp_p = src;
111         double *sp_m = src + size - 1;
112         double *vp = val_p;
113         double *vm = val_m + size - 1;
114         double initial_p = sp_p[0];
115         double initial_m = sp_m[0];
116
117 //printf("MaskUnit::blur_strip %d\n", size);
118         for(int k = 0; k < size; k++)
119         {
120                 int terms = (k < 4) ? k : 4;
121                 int l;
122                 for(l = 0; l <= terms; l++)
123                 {
124                         *vp += n_p[l] * sp_p[-l] - d_p[l] * vp[-l];
125                         *vm += n_m[l] * sp_m[l] - d_m[l] * vm[l];
126                 }
127
128                 for( ; l <= 4; l++)
129                 {
130                         *vp += (n_p[l] - bd_p[l]) * initial_p;
131                         *vm += (n_m[l] - bd_m[l]) * initial_m;
132                 }
133                 sp_p++;
134                 sp_m--;
135                 vp++;
136                 vm--;
137         }
138
139         for(int i = 0; i < size; i++)
140         {
141                 double sum = val_p[i] + val_m[i];
142                 CLAMP(sum, 0, max);
143                 dst[i] = sum;
144         }
145 }
146
147 void MaskUnit::do_feather(VFrame *output,
148         VFrame *input,
149         double feather,
150         int start_y,
151         int end_y,
152         int start_x,
153         int end_x)
154 {
155 //printf("MaskUnit::do_feather %f\n", feather);
156 // Get constants
157         double constants[8];
158         double div;
159         double std_dev = sqrt(-(double)(feather * feather) / (2 * log(1.0 / 255.0)));
160         div = sqrt(2 * M_PI) * std_dev;
161         constants[0] = -1.783 / std_dev;
162         constants[1] = -1.723 / std_dev;
163         constants[2] = 0.6318 / std_dev;
164         constants[3] = 1.997  / std_dev;
165         constants[4] = 1.6803 / div;
166         constants[5] = 3.735 / div;
167         constants[6] = -0.6803 / div;
168         constants[7] = -0.2598 / div;
169
170         n_p[0] = constants[4] + constants[6];
171         n_p[1] = exp(constants[1]) *
172                                 (constants[7] * sin(constants[3]) -
173                                 (constants[6] + 2 * constants[4]) * cos(constants[3])) +
174                                 exp(constants[0]) *
175                                 (constants[5] * sin(constants[2]) -
176                                 (2 * constants[6] + constants[4]) * cos(constants[2]));
177
178         n_p[2] = 2 * exp(constants[0] + constants[1]) *
179                                 ((constants[4] + constants[6]) * cos(constants[3]) *
180                                 cos(constants[2]) - constants[5] *
181                                 cos(constants[3]) * sin(constants[2]) -
182                                 constants[7] * cos(constants[2]) * sin(constants[3])) +
183                                 constants[6] * exp(2 * constants[0]) +
184                                 constants[4] * exp(2 * constants[1]);
185
186         n_p[3] = exp(constants[1] + 2 * constants[0]) *
187                                 (constants[7] * sin(constants[3]) -
188                                 constants[6] * cos(constants[3])) +
189                                 exp(constants[0] + 2 * constants[1]) *
190                                 (constants[5] * sin(constants[2]) - constants[4] *
191                                 cos(constants[2]));
192         n_p[4] = 0.0;
193
194         d_p[0] = 0.0;
195         d_p[1] = -2 * exp(constants[1]) * cos(constants[3]) -
196                                 2 * exp(constants[0]) * cos(constants[2]);
197
198         d_p[2] = 4 * cos(constants[3]) * cos(constants[2]) *
199                                 exp(constants[0] + constants[1]) +
200                                 exp(2 * constants[1]) + exp (2 * constants[0]);
201
202         d_p[3] = -2 * cos(constants[2]) * exp(constants[0] + 2 * constants[1]) -
203                                 2 * cos(constants[3]) * exp(constants[1] + 2 * constants[0]);
204
205         d_p[4] = exp(2 * constants[0] + 2 * constants[1]);
206
207         for(int i = 0; i < 5; i++) d_m[i] = d_p[i];
208
209         n_m[0] = 0.0;
210         for(int i = 1; i <= 4; i++)
211                 n_m[i] = n_p[i] - d_p[i] * n_p[0];
212
213         double sum_n_p, sum_n_m, sum_d;
214         double a, b;
215
216         sum_n_p = 0.0;
217         sum_n_m = 0.0;
218         sum_d = 0.0;
219         for(int i = 0; i < 5; i++)
220         {
221                 sum_n_p += n_p[i];
222                 sum_n_m += n_m[i];
223                 sum_d += d_p[i];
224         }
225
226         a = sum_n_p / (1 + sum_d);
227         b = sum_n_m / (1 + sum_d);
228
229         for(int i = 0; i < 5; i++)
230         {
231                 bd_p[i] = d_p[i] * a;
232                 bd_m[i] = d_m[i] * b;
233         }
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256 #define DO_FEATHER(type, max) \
257 { \
258         int frame_w = input->get_w(); \
259         int frame_h = input->get_h(); \
260         int size = MAX(frame_w, frame_h); \
261         double *src = new double[size]; \
262         double *dst = new double[size]; \
263         double *val_p = new double[size]; \
264         double *val_m = new double[size]; \
265         type **in_rows = (type**)input->get_rows(); \
266         type **out_rows = (type**)output->get_rows(); \
267         int j; \
268  \
269 /* printf("DO_FEATHER 1\n"); */ \
270         if(end_x > start_x) \
271         { \
272                 for(j = start_x; j < end_x; j++) \
273                 { \
274         /* printf("DO_FEATHER 1.1 %d\n", j); */ \
275                         bzero(val_p, sizeof(double) * frame_h); \
276                         bzero(val_m, sizeof(double) * frame_h); \
277                         for(int k = 0; k < frame_h; k++) \
278                         { \
279                                 src[k] = (double)in_rows[k][j]; \
280                         } \
281          \
282                         blur_strip(val_p, val_m, dst, src, frame_h, max); \
283          \
284                         for(int k = 0; k < frame_h; k++) \
285                         { \
286                                 out_rows[k][j] = (type)dst[k]; \
287                         } \
288                 } \
289         } \
290  \
291         if(end_y > start_y) \
292         { \
293                 for(j = start_y; j < end_y; j++) \
294                 { \
295         /* printf("DO_FEATHER 2 %d\n", j); */ \
296                         bzero(val_p, sizeof(double) * frame_w); \
297                         bzero(val_m, sizeof(double) * frame_w); \
298                         for(int k = 0; k < frame_w; k++) \
299                         { \
300                                 src[k] = (double)out_rows[j][k]; \
301                         } \
302          \
303                         blur_strip(val_p, val_m, dst, src, frame_w, max); \
304          \
305                         for(int k = 0; k < frame_w; k++) \
306                         { \
307                                 out_rows[j][k] = (type)dst[k]; \
308                         } \
309                 } \
310         } \
311  \
312 /* printf("DO_FEATHER 3\n"); */ \
313  \
314         delete [] src; \
315         delete [] dst; \
316         delete [] val_p; \
317         delete [] val_m; \
318 /* printf("DO_FEATHER 4\n"); */ \
319 }
320
321
322
323
324
325
326
327
328 //printf("do_feather %d\n", frame->get_color_model());
329         switch(input->get_color_model())
330         {
331                 case BC_A8:
332                         DO_FEATHER(unsigned char, 0xff);
333                         break;
334
335                 case BC_A16:
336                         DO_FEATHER(uint16_t, 0xffff);
337                         break;
338
339                 case BC_A_FLOAT:
340                         DO_FEATHER(float, 1);
341                         break;
342         }
343
344
345
346
347 }
348
349 void MaskUnit::process_package(LoadPackage *package)
350 {
351         MaskPackage *ptr = (MaskPackage*)package;
352
353         if(engine->recalculate &&
354                 engine->step == DO_MASK)
355         {
356                 VFrame *mask;
357                 if(engine->feather > 0)
358                         mask = engine->temp_mask;
359                 else
360                         mask = engine->mask;
361
362 SET_TRACE
363 // Generated oversampling frame
364                 int mask_w = mask->get_w();
365                 //int mask_h = mask->get_h();
366                 int oversampled_package_w = mask_w * OVERSAMPLE;
367                 int oversampled_package_h = (ptr->end_y - ptr->start_y) * OVERSAMPLE;
368 //printf("MaskUnit::process_package 1\n");
369
370 SET_TRACE
371                 if(temp &&
372                         (temp->get_w() != oversampled_package_w ||
373                         temp->get_h() != oversampled_package_h))
374                 {
375                         delete temp;
376                         temp = 0;
377                 }
378 //printf("MaskUnit::process_package 1\n");
379
380 SET_TRACE
381                 if(!temp)
382                 {
383                         temp = new VFrame(0,
384                                 -1,
385                                 oversampled_package_w,
386                                 oversampled_package_h,
387                                 BC_A8,
388                                 -1);
389                 }
390
391 SET_TRACE
392                 temp->clear_frame();
393 //printf("MaskUnit::process_package 1 %d\n", engine->point_sets.total);
394
395 SET_TRACE
396
397 // Draw oversampled region of polygons on temp
398                 for(int k = 0; k < engine->point_sets.total; k++)
399                 {
400                         int old_x, old_y;
401                         unsigned char max = k + 1;
402                         ArrayList<MaskPoint*> *points = engine->point_sets.values[k];
403
404                         if(points->total < 3) continue;
405 //printf("MaskUnit::process_package 2 %d %d\n", k, points->total);
406                         for(int i = 0; i < points->total; i++)
407                         {
408                                 MaskPoint *point1 = points->values[i];
409                                 MaskPoint *point2 = (i >= points->total - 1) ?
410                                         points->values[0] :
411                                         points->values[i + 1];
412
413                                 float x, y;
414                                 int segments = (int)(sqrt(SQR(point1->x - point2->x) + SQR(point1->y - point2->y)));
415                                 if(point1->control_x2 == 0 &&
416                                         point1->control_y2 == 0 &&
417                                         point2->control_x1 == 0 &&
418                                         point2->control_y1 == 0)
419                                         segments = 1;
420                                 float x0 = point1->x;
421                                 float y0 = point1->y;
422                                 float x1 = point1->x + point1->control_x2;
423                                 float y1 = point1->y + point1->control_y2;
424                                 float x2 = point2->x + point2->control_x1;
425                                 float y2 = point2->y + point2->control_y1;
426                                 float x3 = point2->x;
427                                 float y3 = point2->y;
428
429                                 for(int j = 0; j <= segments; j++)
430                                 {
431                                         float t = (float)j / segments;
432                                         float tpow2 = t * t;
433                                         float tpow3 = t * t * t;
434                                         float invt = 1 - t;
435                                         float invtpow2 = invt * invt;
436                                         float invtpow3 = invt * invt * invt;
437
438                                         x = (        invtpow3 * x0
439                                                 + 3 * t     * invtpow2 * x1
440                                                 + 3 * tpow2 * invt     * x2
441                                                 +     tpow3            * x3);
442                                         y = (        invtpow3 * y0
443                                                 + 3 * t     * invtpow2 * y1
444                                                 + 3 * tpow2 * invt     * y2
445                                                 +     tpow3            * y3);
446
447                                         y -= ptr->start_y;
448                                         x *= OVERSAMPLE;
449                                         y *= OVERSAMPLE;
450
451                                         if(j > 0)
452                                         {
453                                                 draw_line_clamped(temp, old_x, old_y, (int)x, (int)y, max);
454                                         }
455
456                                         old_x = (int)x;
457                                         old_y = (int)y;
458                                 }
459                         }
460
461 SET_TRACE
462 //printf("MaskUnit::process_package 1\n");
463
464
465
466
467
468 // Fill in the polygon in the horizontal direction
469                         for(int i = 0; i < oversampled_package_h; i++)
470                         {
471                                 unsigned char *row = (unsigned char*)temp->get_rows()[i];
472                                 int value = 0x0;
473                                 int total = 0;
474
475                                 for(int j = 0; j < oversampled_package_w; j++)
476                                         if(row[j] == max) total++;
477
478                                 if(total > 1)
479                                 {
480                                         if(total & 0x1) total--;
481                                         for(int j = 0; j < oversampled_package_w; j++)
482                                         {
483                                                 if(row[j] == max && total > 0)
484                                                 {
485                                                         if(value)
486                                                                 value = 0x0;
487                                                         else
488                                                                 value = max;
489                                                         total--;
490                                                 }
491                                                 else
492                                                 {
493                                                         if(value) row[j] = value;
494                                                 }
495                                         }
496                                 }
497                         }
498                 }
499
500
501 SET_TRACE
502
503
504
505
506
507 #define DOWNSAMPLE(type, temp_type, value) \
508 for(int i = 0; i < ptr->end_y - ptr->start_y; i++) \
509 { \
510         type *output_row = (type*)mask->get_rows()[i + ptr->start_y]; \
511         unsigned char **input_rows = (unsigned char**)temp->get_rows() + i * OVERSAMPLE; \
512  \
513  \
514         for(int j = 0; j < mask_w; j++) \
515         { \
516                 temp_type total = 0; \
517  \
518 /* Accumulate pixel */ \
519                 for(int k = 0; k < OVERSAMPLE; k++) \
520                 { \
521                         unsigned char *input_vector = input_rows[k] + j * OVERSAMPLE; \
522                         for(int l = 0; l < OVERSAMPLE; l++) \
523                         { \
524                                 total += (input_vector[l] ? value : 0); \
525                         } \
526                 } \
527  \
528 /* Divide pixel */ \
529                 total /= OVERSAMPLE * OVERSAMPLE; \
530  \
531                 output_row[j] = total; \
532         } \
533 }
534
535 SET_TRACE
536
537 // Downsample polygon
538                 switch(mask->get_color_model())
539                 {
540                         case BC_A8:
541                         {
542                                 unsigned char value;
543                                 value = (int)((float)engine->value / 100 * 0xff);
544                                 DOWNSAMPLE(unsigned char, int64_t, value);
545                                 break;
546                         }
547
548                         case BC_A16:
549                         {
550                                 uint16_t value;
551                                 value = (int)((float)engine->value / 100 * 0xffff);
552                                 DOWNSAMPLE(uint16_t, int64_t, value);
553                                 break;
554                         }
555
556                         case BC_A_FLOAT:
557                         {
558                                 float value;
559                                 value = (float)engine->value / 100;
560                                 DOWNSAMPLE(float, double, value);
561                                 break;
562                         }
563                 }
564         }
565
566 SET_TRACE
567
568 SET_TRACE
569
570         if(engine->step == DO_X_FEATHER)
571         {
572
573                 if(engine->recalculate)
574                 {
575 // Feather polygon
576                         if(engine->feather > 0) do_feather(engine->mask,
577                                 engine->temp_mask,
578                                 engine->feather,
579                                 ptr->start_y,
580                                 ptr->end_y,
581                                 0,
582                                 0);
583                 }
584 //printf("MaskUnit::process_package 3 %f\n", engine->feather);
585         }
586
587         if(engine->step == DO_Y_FEATHER)
588         {
589                 if(engine->recalculate)
590                 {
591 // Feather polygon
592                         if(engine->feather > 0) do_feather(engine->mask,
593                                 engine->temp_mask,
594                                 engine->feather,
595                                 0,
596                                 0,
597                                 ptr->start_x,
598                                 ptr->end_x);
599                 }
600         }
601
602         if(engine->step == DO_APPLY)
603         {
604 // Apply mask
605                 int mask_w = engine->mask->get_w();
606
607
608 #define APPLY_MASK_SUBTRACT_ALPHA(type, max, components, do_yuv) \
609 { \
610         type *output_row = (type*)engine->output->get_rows()[i]; \
611         type *mask_row = (type*)engine->mask->get_rows()[i]; \
612         int chroma_offset = (int)(max + 1) / 2; \
613  \
614         for(int j  = 0; j < mask_w; j++) \
615         { \
616                 if(components == 4) \
617                 { \
618                         output_row[j * 4 + 3] = output_row[j * 4 + 3] * (max - mask_row[j]) / max; \
619                 } \
620                 else \
621                 { \
622                         output_row[j * 3] = output_row[j * 3] * (max - mask_row[j]) / max; \
623  \
624                         output_row[j * 3 + 1] = output_row[j * 3 + 1] * (max - mask_row[j]) / max; \
625                         output_row[j * 3 + 2] = output_row[j * 3 + 2] * (max - mask_row[j]) / max; \
626  \
627                         if(do_yuv) \
628                         { \
629                                 output_row[j * 3 + 1] += chroma_offset * mask_row[j] / max; \
630                                 output_row[j * 3 + 2] += chroma_offset * mask_row[j] / max; \
631                         } \
632                 } \
633         } \
634 }
635
636 #define APPLY_MASK_MULTIPLY_ALPHA(type, max, components, do_yuv) \
637 { \
638         type *output_row = (type*)engine->output->get_rows()[i]; \
639         type *mask_row = (type*)engine->mask->get_rows()[i]; \
640         int chroma_offset = (int)(max + 1) / 2; \
641  \
642         for(int j  = 0; j < mask_w; j++) \
643         { \
644                 if(components == 4) \
645                 { \
646                         output_row[j * 4 + 3] = output_row[j * 4 + 3] * mask_row[j] / max; \
647                 } \
648                 else \
649                 { \
650                         output_row[j * 3] = output_row[j * 3] * mask_row[j] / max; \
651  \
652                         output_row[j * 3 + 1] = output_row[j * 3 + 1] * mask_row[j] / max; \
653                         output_row[j * 3 + 2] = output_row[j * 3 + 2] * mask_row[j] / max; \
654  \
655                         if(do_yuv) \
656                         { \
657                                 output_row[j * 3 + 1] += chroma_offset * (max - mask_row[j]) / max; \
658                                 output_row[j * 3 + 2] += chroma_offset * (max - mask_row[j]) / max; \
659                         } \
660                 } \
661         } \
662 }
663
664
665
666
667 //printf("MaskUnit::process_package 1 %d\n", engine->mode);
668                 for(int i = ptr->start_y; i < ptr->end_y; i++)
669                 {
670                         switch(engine->mode)
671                         {
672                                 case MASK_MULTIPLY_ALPHA:
673                                         switch(engine->output->get_color_model())
674                                         {
675                                                 case BC_RGB888:
676                                                         APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 3, 0);
677                                                         break;
678                                                 case BC_RGB_FLOAT:
679                                                         APPLY_MASK_MULTIPLY_ALPHA(float, 1.0, 3, 0);
680                                                         break;
681                                                 case BC_YUV888:
682                                                         APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 3, 1);
683                                                         break;
684                                                 case BC_RGBA_FLOAT:
685                                                         APPLY_MASK_MULTIPLY_ALPHA(float, 1.0, 4, 0);
686                                                         break;
687                                                 case BC_YUVA8888:
688                                                         APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 4, 1);
689                                                         break;
690                                                 case BC_RGBA8888:
691                                                         APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 4, 0);
692                                                         break;
693                                                 case BC_RGB161616:
694                                                         APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 3, 0);
695                                                         break;
696                                                 case BC_YUV161616:
697                                                         APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 3, 1);
698                                                         break;
699                                                 case BC_YUVA16161616:
700                                                         APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 4, 1);
701                                                         break;
702                                                 case BC_RGBA16161616:
703                                                         APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 4, 0);
704                                                         break;
705                                         }
706                                         break;
707
708                                 case MASK_SUBTRACT_ALPHA:
709                                         switch(engine->output->get_color_model())
710                                         {
711                                                 case BC_RGB888:
712                                                         APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 3, 0);
713                                                         break;
714                                                 case BC_RGB_FLOAT:
715                                                         APPLY_MASK_SUBTRACT_ALPHA(float, 1.0, 3, 0);
716                                                         break;
717                                                 case BC_RGBA_FLOAT:
718                                                         APPLY_MASK_SUBTRACT_ALPHA(float, 1.0, 4, 0);
719                                                         break;
720                                                 case BC_RGBA8888:
721                                                         APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 4, 0);
722                                                         break;
723                                                 case BC_YUV888:
724                                                         APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 3, 1);
725                                                         break;
726                                                 case BC_YUVA8888:
727                                                         APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 4, 1);
728                                                         break;
729                                                 case BC_RGB161616:
730                                                         APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 3, 0);
731                                                         break;
732                                                 case BC_RGBA16161616:
733                                                         APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 4, 0);
734                                                         break;
735                                                 case BC_YUV161616:
736                                                         APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 3, 1);
737                                                         break;
738                                                 case BC_YUVA16161616:
739                                                         APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 4, 1);
740                                                         break;
741                                         }
742                                         break;
743                         }
744                 }
745         }
746 }
747
748
749
750
751
752 MaskEngine::MaskEngine(int cpus)
753  : LoadServer(cpus, cpus * OVERSAMPLE * 2)
754 // : LoadServer(1, OVERSAMPLE * 2)
755 {
756         mask = 0;
757 }
758
759 MaskEngine::~MaskEngine()
760 {
761         if(mask)
762         {
763                 delete mask;
764                 delete temp_mask;
765         }
766
767         for(int i = 0; i < point_sets.total; i++)
768         {
769                 ArrayList<MaskPoint*> *points = point_sets.values[i];
770                 points->remove_all_objects();
771         }
772         point_sets.remove_all_objects();
773 }
774
775 int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
776         ArrayList<MaskPoint*> *points)
777 {
778 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);
779         if(new_points->total != points->total) return 0;
780
781         for(int i = 0; i < new_points->total; i++)
782         {
783                 if(!(*new_points->values[i] == *points->values[i])) return 0;
784         }
785
786         return 1;
787 }
788
789 void MaskEngine::do_mask(VFrame *output,
790         int64_t start_position_project,
791         MaskAutos *keyframe_set,
792         MaskAuto *keyframe,
793         MaskAuto *default_auto)
794 {
795         int new_color_model = 0;
796         recalculate = 0;
797
798         switch(output->get_color_model())
799         {
800                 case BC_RGB_FLOAT:
801                 case BC_RGBA_FLOAT:
802                         new_color_model = BC_A_FLOAT;
803                         break;
804
805                 case BC_RGB888:
806                 case BC_RGBA8888:
807                 case BC_YUV888:
808                 case BC_YUVA8888:
809                         new_color_model = BC_A8;
810                         break;
811
812                 case BC_RGB161616:
813                 case BC_RGBA16161616:
814                 case BC_YUV161616:
815                 case BC_YUVA16161616:
816                         new_color_model = BC_A16;
817                         break;
818         }
819
820 // Determine if recalculation is needed
821 SET_TRACE
822
823         if(mask &&
824                 (mask->get_w() != output->get_w() ||
825                 mask->get_h() != output->get_h() ||
826                 mask->get_color_model() != new_color_model))
827         {
828                 delete mask;
829                 delete temp_mask;
830                 mask = 0;
831                 recalculate = 1;
832         }
833
834         if(!recalculate)
835         {
836                 if(point_sets.total != keyframe_set->total_submasks(start_position_project,
837                         PLAY_FORWARD))
838                         recalculate = 1;
839         }
840
841         if(!recalculate)
842         {
843                 for(int i = 0;
844                         i < keyframe_set->total_submasks(start_position_project,
845                                 PLAY_FORWARD) && !recalculate;
846                         i++)
847                 {
848                         ArrayList<MaskPoint*> *new_points = new ArrayList<MaskPoint*>;
849                         keyframe_set->get_points(new_points,
850                                 i,
851                                 start_position_project,
852                                 PLAY_FORWARD);
853                         if(!points_equivalent(new_points, point_sets.values[i])) recalculate = 1;
854                         new_points->remove_all_objects();
855                         delete new_points;
856                 }
857         }
858
859         int new_value = keyframe_set->get_value(start_position_project,
860                 PLAY_FORWARD);
861         float new_feather = keyframe_set->get_feather(start_position_project,
862                 PLAY_FORWARD);
863
864         if(recalculate ||
865                 !EQUIV(new_feather, feather) ||
866                 !EQUIV(new_value, value))
867         {
868                 recalculate = 1;
869                 if(!mask)
870                 {
871                         mask = new VFrame(0,
872                                         -1,
873                                         output->get_w(),
874                                         output->get_h(),
875                                         new_color_model,
876                                         -1);
877                         temp_mask = new VFrame(0,
878                                         -1,
879                                         output->get_w(),
880                                         output->get_h(),
881                                         new_color_model,
882                                         -1);
883                 }
884                 if(new_feather > 0)
885                         temp_mask->clear_frame();
886                 else
887                         mask->clear_frame();
888
889                 for(int i = 0; i < point_sets.total; i++)
890                 {
891                         ArrayList<MaskPoint*> *points = point_sets.values[i];
892                         points->remove_all_objects();
893                 }
894                 point_sets.remove_all_objects();
895
896                 for(int i = 0;
897                         i < keyframe_set->total_submasks(start_position_project,
898                                 PLAY_FORWARD);
899                         i++)
900                 {
901                         ArrayList<MaskPoint*> *new_points = new ArrayList<MaskPoint*>;
902                         keyframe_set->get_points(new_points,
903                                 i,
904                                 start_position_project,
905                                 PLAY_FORWARD);
906                         point_sets.append(new_points);
907                 }
908         }
909
910
911
912         this->output = output;
913         this->mode = default_auto->mode;
914         this->feather = new_feather;
915         this->value = new_value;
916
917
918 // Run units
919 SET_TRACE
920         step = DO_MASK;
921         process_packages();
922         step = DO_Y_FEATHER;
923         process_packages();
924         step = DO_X_FEATHER;
925         process_packages();
926         step = DO_APPLY;
927         process_packages();
928 SET_TRACE
929
930
931 }
932
933 void MaskEngine::init_packages()
934 {
935 SET_TRACE
936 //printf("MaskEngine::init_packages 1\n");
937         int division = (int)((float)output->get_h() / (get_total_packages() / 2) + 0.5);
938         if(division < 1) division = 1;
939
940 SET_TRACE
941         for(int i = 0; i < get_total_packages(); i++)
942         {
943                 MaskPackage *ptr = (MaskPackage*)get_package(i);
944
945                 ptr->start_y = output->get_h() * i / get_total_packages();
946                 ptr->end_y = output->get_h() * (i + 1) / get_total_packages();
947
948                 ptr->start_x = output->get_w() * i / get_total_packages();
949                 ptr->end_x = output->get_w() * (i + 1) / get_total_packages();
950         }
951 SET_TRACE
952 //printf("MaskEngine::init_packages 2\n");
953 }
954
955 LoadClient* MaskEngine::new_client()
956 {
957         return new MaskUnit(this);
958 }
959
960 LoadPackage* MaskEngine::new_package()
961 {
962         return new MaskPackage;
963 }
964