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