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 "track.h"
  30 #include "transportque.inc"
  31 #include "vframe.h"
  32
  33 #include <math.h>
  34 #include <stdint.h>
  35 #include <string.h>
  36
  37 void write_mask(VFrame *vfrm, const char *fmt, ...)
  38 {
  39   va_list ap;    va_start(ap, fmt);
  40   char fn[256];  vsnprintf(fn, sizeof(fn), fmt, ap);
  41   va_end(ap);
  42   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
  43   if( fp ) {
  44     int w = vfrm->get_w(), h = vfrm->get_h();
  45     int m = vfrm->get_color_model();
  46     fprintf(fp,"P5\n%d %d\n%d\n",w,h,m==BC_A8? 0xff : 0xffff);
  47     int bpp = m==BC_A8? 1 : 2;
  48     fwrite(vfrm->get_data(),bpp*w,h,fp);  fflush(fp);
  49     if( fp != stdout ) fclose(fp);
  50   }
  51 }
  52
  53 MaskPackage::MaskPackage()
  54 {
  55 }
  56
  57 MaskPackage::~MaskPackage()
  58 {
  59 }
  60
  61 MaskUnit::MaskUnit(MaskEngine *engine)
  62  : LoadClient(engine)
  63 {
  64         this->engine = engine;
  65         spot = 0;
  66         r = 0;
  67 }
  68
  69 MaskUnit::~MaskUnit()
  70 {
  71 }
  72
  73 void MaskUnit::draw_line(int v, int ix1, int iy1, int ix2, int iy2)
  74 {
  75         if( iy1 == iy2 ) return;
  76         int x1 = iy1 < iy2 ? ix1 : ix2;
  77         int y1 = iy1 < iy2 ? iy1 : iy2;
  78         int x2 = iy1 < iy2 ? ix2 : ix1;
  79         int y2 = iy1 < iy2 ? iy2 : iy1;
  80         float slope = (float)(x2-x1) / (y2-y1);
  81         int dy = y1 - start_y;
  82         int i = dy < 0 ? (y1=start_y, -dy) : 0;
  83         if( y2 > end_y ) y2 = end_y;
  84         if( y2 < start_y || y1 >= end_y ) return;
  85
  86         VFrame *temp = engine->temp;
  87         int w1 = temp->get_w()-1;
  88         temp_t **rows = (temp_t **)temp->get_rows();
  89         for( int y=y1; y<y2; ++i,++y ) {
  90                 int x = (int)(i*slope + x1);
  91                 bclamp(x, 0, w1);
  92                 rows[y][x] = rows[y][x] == v ? 0 : v;
  93         }
  94 }
  95
  96 void MaskUnit::draw_fill(int v)
  97 {
  98         VFrame *temp = engine->temp;
  99         int temp_w = temp->get_w();
 100         temp_t **rows = (temp_t**)temp->get_rows();
 101
 102         for( int y=start_y; y<end_y; ++y ) {
 103                 temp_t *row = rows[y];
 104                 int value = 0, total = 0;
 105                 for( int x=0; x<temp_w; ++x )
 106                         if( row[x] == v ) ++total;
 107                 if( total < 2 ) continue;
 108                 if( total & 0x1 ) --total;
 109                 for( int x=0; x<temp_w; ++x ) {
 110                         if( row[x]==v && total>0 ) {
 111                                 --total;
 112                                 value = value ? 0 : v;
 113                         }
 114                         else if( value )
 115                                 row[x] = value;
 116                 }
 117         }
 118 }
 119
 120 void MaskUnit::draw_feather(int ix1,int iy1, int ix2,int iy2)
 121 {
 122         int x1 = iy1 < iy2 ? ix1 : ix2;
 123         int y1 = iy1 < iy2 ? iy1 : iy2;
 124         int x2 = iy1 < iy2 ? ix2 : ix1;
 125         int y2 = iy1 < iy2 ? iy2 : iy1;
 126         VFrame *temp = engine->temp;
 127         int h = temp->get_h();
 128         if( y2 < 0 || y1 >= h ) return;
 129
 130         int x = x1, y = y1;
 131         int dx = x2-x1, dy = y2-y1;
 132         int dx2 = 2*dx, dy2 = 2*dy;
 133         if( dx < 0 ) dx = -dx;
 134         int m = dx > dy ? dx : dy, n = m;
 135         if( dy >= dx ) {
 136                 if( dx2 >= 0 ) do {     /* +Y, +X */
 137                         draw_spot(x, y++);
 138                         if( (m -= dx2) < 0 ) { m += dy2;  ++x; }
 139                 } while( --n >= 0 );
 140                 else do {              /* +Y, -X */
 141                         draw_spot(x, y++);
 142                         if( (m += dx2) < 0 ) { m += dy2;  --x; }
 143                 } while( --n >= 0 );
 144         }
 145         else {
 146                 if( dx2 >= 0 ) do {     /* +X, +Y */
 147                         draw_spot(x++, y);
 148                         if( (m -= dy2) < 0 ) { m += dx2;  ++y; }
 149                 } while( --n >= 0 );
 150                 else do {              /* -X, +Y */
 151                         draw_spot(x--, y);
 152                         if( (m -= dy2) < 0 ) { m -= dx2;  ++y; }
 153                 } while( --n >= 0 );
 154         }
 155 }
 156
 157 void MaskUnit::draw_spot(int ix, int iy)
 158 {
 159         int rr = r * r, n = abs(r), rv = r * v;
 160         if( iy < start_y-n || iy >= end_y+n ) return;
 161         VFrame *temp = engine->temp;
 162         int w1 = temp->get_w()-1, h1 = temp->get_h()-1;
 163         int xs = ix - n;  bclamp(xs, 0, w1);
 164         int xn = ix + n;  bclamp(xn, 0, w1);
 165         int ys = iy - n;  bclamp(ys, 0, h1);
 166         int yn = iy + n;  bclamp(yn, 0, h1);
 167
 168         temp_t **rows = (temp_t**)temp->get_rows();
 169         for( int y=ys ; y<=yn; ++y ) {
 170                 temp_t *row = rows[y];
 171                 for( int x=xs; x<=xn; ++x ) {
 172                         int dx = x-ix, dy = y-iy;
 173                         int dd = dx*dx + dy*dy;
 174                         if( dd >= rr ) continue;
 175                         temp_t *rp = &row[x], a = spot[dd];
 176                         if( rv*(*rp-a) < 0 ) *rp = a;
 177                 }
 178         }
 179 }
 180
 181 void MaskUnit::process_package(LoadPackage *package)
 182 {
 183         MaskPackage *ptr = (MaskPackage*)package;
 184         start_y = ptr->start_y;
 185         end_y = ptr->end_y;
 186         if( start_y >= end_y ) return;
 187         mask_model = engine->mask->get_color_model();
 188         VFrame *temp = engine->temp;
 189         if( engine->recalculate && engine->step == DO_MASK ) {
 190 // Draw masked region of polygons on temp
 191                 for( int k=0; k<engine->edges.size(); ++k ) {
 192                         if( !engine->edges[k] ) continue;
 193                         MaskEdge &edge = *engine->edges[k];
 194                         if( edge.size() < 3 ) continue;
 195                         int v = k + 1;
 196                         for( int i=0; i<edge.size(); ++i ) {
 197                                 MaskCoord a = edge[i];
 198                                 MaskCoord b = i<edge.size()-1 ? edge[i+1] : edge[0];
 199                                 draw_line(v, a.x,a.y, b.x,b.y);
 200                         }
 201                         draw_fill(v);
 202                 }
 203 // map temp to fader alpha
 204                 int temp_w = temp->get_w();
 205                 temp_t **rows = (temp_t**)temp->get_rows();
 206                 temp_t *fade = engine->fade;
 207                 for( int y=start_y; y<end_y; ++y ) {
 208                         temp_t *tp = rows[y];
 209                         for( int i=temp_w; --i>=0; ++tp ) *tp = fade[*tp];
 210                 }
 211         }
 212         if( engine->recalculate && engine->step == DO_FEATHER ) {
 213 // draw feather
 214                 for( int k=0; k<engine->edges.size(); ++k ) {
 215                         if( !(v = engine->faders[k]) ) continue;
 216                         if( !(r = engine->feathers[k]) ) continue;
 217                         MaskEdge &edge = *engine->edges[k];
 218                         if( !edge.size() ) continue;
 219                         float rv = r * v, vv = fabs(v);
 220                         int fg = 0xffff * (rv >= 0 ? vv : 0);
 221                         int bg = 0xffff * (rv >= 0 ? 0 : vv);
 222                         int rr = r*r;  double dr = 1./rr;
 223                         temp_t psf[rr+1];  spot = psf;
 224                         for( int i=0; i<=rr; ++i ) {
 225                                 double d = i*dr;
 226                                 psf[i] = (1-d)*fg + d*bg;
 227                         }
 228                         int n = edge.size();
 229                         for( int i=0; i<n; ++i ) {
 230                                 MaskCoord &a = edge[i];
 231                                 MaskCoord &b = i<edge.size()-1 ? edge[i+1] : edge[0];
 232                                 draw_feather(a.x,a.y, b.x,b.y);
 233                         }
 234                 }
 235
 236 #define REMAP(cmodel, type, expr) case cmodel: { \
 237 type **msk_rows = (type**)engine->mask->get_rows(); \
 238 for( int y=start_y; y<end_y; ++y ) { \
 239         temp_t *rp = rows[y]; \
 240         type *mp = msk_rows[y]; \
 241         for( int i=temp_w; --i>=0; ++rp,++mp ) *mp = expr; \
 242 } } break
 243 // map alpha to mask
 244                 const float to_flt = 1/65535.;
 245                 int temp_w = temp->get_w();
 246                 temp_t **rows = (temp_t**)temp->get_rows();
 247                 switch( mask_model ) {
 248                 REMAP(BC_A8, uint8_t, *rp >> 8);
 249                 REMAP(BC_A16, uint16_t, *rp);
 250                 REMAP(BC_A_FLOAT, float, *rp * to_flt);
 251                 }
 252         }
 253
 254 // Apply mask
 255         if( engine->step == DO_APPLY ) {
 256                 int mask_w = engine->mask->get_w();
 257                 uint8_t **out_rows = engine->output->get_rows();
 258                 uint8_t **msk_rows = engine->mask->get_rows();
 259 #define APPLY_MASK_ALPHA(cmodel, type, max, components, do_yuv) \
 260 case cmodel: \
 261 for( int y=ptr->start_y; y<ptr->end_y; ++y ) { \
 262         type *out_row = (type*)out_rows[y]; \
 263         type *msk_row = (type*)msk_rows[y]; \
 264         type chroma_offset = (int)(max + 1) / 2; \
 265         for( int x=0; x<mask_w; ++x ) { \
 266                 type a = msk_row[x], b = max-a; \
 267                 if( components == 4 ) { \
 268                         out_row[x*4 + 3] = out_row[x*4 + 3]*b / max; \
 269                 } \
 270                 else { \
 271                         out_row[x*3 + 0] = out_row[x*3 + 0]*b / max; \
 272                         out_row[x*3 + 1] = out_row[x*3 + 1]*b / max; \
 273                         out_row[x*3 + 2] = out_row[x*3 + 2]*b / max; \
 274                         if( do_yuv ) { \
 275                                 out_row[x*3 + 1] += chroma_offset*a / max; \
 276                                 out_row[x*3 + 2] += chroma_offset*a / max; \
 277                         } \
 278                 } \
 279         } \
 280 } break
 281
 282                 switch( engine->output->get_color_model() ) { \
 283                 APPLY_MASK_ALPHA(BC_RGB888, uint8_t, 0xff, 3, 0); \
 284                 APPLY_MASK_ALPHA(BC_RGB_FLOAT, float, 1.0, 3, 0); \
 285                 APPLY_MASK_ALPHA(BC_YUV888, uint8_t, 0xff, 3, 1); \
 286                 APPLY_MASK_ALPHA(BC_RGBA_FLOAT, float, 1.0, 4, 0); \
 287                 APPLY_MASK_ALPHA(BC_YUVA8888, uint8_t, 0xff, 4, 1); \
 288                 APPLY_MASK_ALPHA(BC_RGBA8888, uint8_t, 0xff, 4, 0); \
 289                 APPLY_MASK_ALPHA(BC_RGB161616, uint16_t, 0xffff, 3, 0); \
 290                 APPLY_MASK_ALPHA(BC_YUV161616, uint16_t, 0xffff, 3, 1); \
 291                 APPLY_MASK_ALPHA(BC_YUVA16161616, uint16_t, 0xffff, 4, 1); \
 292                 APPLY_MASK_ALPHA(BC_RGBA16161616, uint16_t, 0xffff, 4, 0); \
 293                 }
 294         }
 295 }
 296
 297
 298 MaskEngine::MaskEngine(int cpus)
 299  : LoadServer(cpus, 2*cpus)
 300 // : LoadServer(1, 1)
 301 {
 302         mask = 0;
 303         temp = 0;
 304 }
 305
 306 MaskEngine::~MaskEngine()
 307 {
 308         delete mask;
 309         delete temp;
 310         for( int i = 0; i < point_sets.total; i++ )
 311                 point_sets[i]->remove_all_objects();
 312         point_sets.remove_all_objects();
 313 }
 314
 315 int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
 316         ArrayList<MaskPoint*> *points)
 317 {
 318 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);
 319         if( new_points->total != points->total ) return 0;
 320
 321         for( int i = 0; i < new_points->total; i++ ) {
 322                 if( !(*new_points->get(i) == *points->get(i)) ) return 0;
 323         }
 324
 325         return 1;
 326 }
 327
 328 void MaskEngine::draw_edge(MaskEdge &edge, MaskPointSet &points)
 329 {
 330         if( points.size() < 2 ) return;
 331         edge.remove_all();
 332         for( int i=0; i<points.size(); ++i ) {
 333                 MaskPoint *ap = points[i];
 334                 MaskPoint *bp = (i>=points.size()-1) ?
 335                                 points[0] : points[i+1];
 336                 int segments = 0;
 337                 if( ap->control_x2 == 0 && ap->control_y2 == 0 &&
 338                     bp->control_x1 == 0 && bp->control_y1 == 0 )
 339                         segments = 1;
 340                 float x0 = ap->x, y0 = ap->y;
 341                 float x1 = ap->x + ap->control_x2;
 342                 float y1 = ap->y + ap->control_y2;
 343                 float x2 = bp->x + bp->control_x1;
 344                 float y2 = bp->y + bp->control_y1;
 345                 float x3 = bp->x, y3 = bp->y;
 346
 347 // from Playback3D::do_mask_sync
 348                 float cx3 = -  x0 + 3*x1 - 3*x2 + x3;
 349                 float cx2 =  3*x0 - 6*x1 + 3*x2;
 350                 float cx1 = -3*x0 + 3*x1;
 351                 float cx0 =    x0;
 352
 353                 float cy3 = -  y0 + 3*y1 - 3*y2 + y3;
 354                 float cy2 =  3*y0 - 6*y1 + 3*y2;
 355                 float cy1 = -3*y0 + 3*y1;
 356                 float cy0 =    y0;
 357
 358                 if( segments == 0 ) {
 359                         float maxaccel1 = fabs(2*cy2) + fabs(6*cy3);
 360                         float maxaccel2 = fabs(2*cx2) + fabs(6*cx3);
 361                         float maxaccel = maxaccel1 > maxaccel2 ? maxaccel1 : maxaccel2;
 362                         float h = 1.0;
 363                         if( maxaccel > 8.0 ) h = sqrt((8.0) / maxaccel);
 364                         segments = int(1/h);
 365                 }
 366
 367                 for( int j = 0; j <= segments; ++j ) {
 368                         float t = (float)j / segments;
 369                         float x = cx0 + t*(cx1 + t*(cx2 + t*cx3));
 370                         float y = cy0 + t*(cy1 + t*(cy2 + t*cy3));
 371                         edge.append(x, y);
 372                 }
 373         }
 374 }
 375
 376 void MaskEngine::do_mask(VFrame *output,
 377         int64_t start_position_project,
 378         MaskAutos *keyframe_set,
 379         MaskAuto *keyframe,
 380         MaskAuto *default_auto)
 381 {
 382         this->output = output;
 383         recalculate = 0;
 384         int mask_model = 0;
 385
 386         switch( output->get_color_model() ) {
 387         case BC_RGB_FLOAT:
 388         case BC_RGBA_FLOAT:
 389                 mask_model = BC_A_FLOAT;
 390                 break;
 391
 392         case BC_RGB888:
 393         case BC_RGBA8888:
 394         case BC_YUV888:
 395         case BC_YUVA8888:
 396                 mask_model = BC_A8;
 397                 break;
 398
 399         case BC_RGB161616:
 400         case BC_RGBA16161616:
 401         case BC_YUV161616:
 402         case BC_YUVA16161616:
 403                 mask_model = BC_A16;
 404                 break;
 405         }
 406
 407 // Determine if recalculation is needed
 408 SET_TRACE
 409
 410         int mask_w = output->get_w(), mask_h = output->get_h();
 411         if( mask && ( mask->get_color_model() != mask_model ||
 412             mask->get_w() != mask_w || mask->get_h() != mask_h ) ) {
 413                 delete mask;  mask = 0;
 414                 recalculate = 1;
 415         }
 416         if( temp && ( temp->get_w() != mask_w || temp->get_h() != mask_h ) ) {
 417                 delete temp;  temp = 0;
 418         }
 419
 420         total_submasks = keyframe_set->total_submasks(start_position_project, PLAY_FORWARD);
 421         if( total_submasks != point_sets.size() )
 422                 recalculate = 1;
 423
 424         for( int i=0; i<total_submasks && !recalculate; ++i ) {
 425                 float new_fader = keyframe_set->get_fader(start_position_project, i, PLAY_FORWARD);
 426                 if( new_fader != faders[i] ) { recalculate = 1;  break; }
 427                 float new_feather = keyframe_set->get_feather(start_position_project, i, PLAY_FORWARD);
 428                 if( new_feather != feathers[i] ) { recalculate = 1;  break; }
 429                 ArrayList<MaskPoint*> new_points;
 430                 keyframe_set->get_points(&new_points, i,
 431                                 start_position_project, PLAY_FORWARD);
 432                 if( !points_equivalent(&new_points, point_sets[i]) )
 433                         recalculate = 1;
 434                 new_points.remove_all_objects();
 435         }
 436
 437         if( recalculate ) {
 438                 for( int i = 0; i < point_sets.total; i++ ) {
 439                         ArrayList<MaskPoint*> *points = point_sets[i];
 440                         points->remove_all_objects();
 441                 }
 442                 point_sets.remove_all_objects();
 443                 edges.remove_all_objects();
 444                 faders.remove_all();
 445                 feathers.remove_all();
 446                 fade[0] = 0;
 447
 448                 int show_mask = keyframe_set->track->masks;
 449                 for( int i=0; i<total_submasks; ++i ) {
 450                         float fader = keyframe_set->get_fader(start_position_project, i, PLAY_FORWARD);
 451                         float v = fader / 100;
 452                         faders.append(v);
 453                         temp_t t = fabs(v) * 0xffff;
 454                         if( fader < 0 ) {
 455                                 if( fade[0] < t ) fade[0] = t;
 456                                 t = 0;
 457                         }
 458                         fade[i+1] = t;
 459                         float feather = keyframe_set->get_feather(start_position_project, i, PLAY_FORWARD);
 460                         feathers.append(feather);
 461                         MaskPointSet *new_points = new MaskPointSet();
 462                         keyframe_set->get_points(new_points, i, start_position_project, PLAY_FORWARD);
 463                         point_sets.append(new_points);
 464                         MaskEdge *edge = edges.append(new MaskEdge());
 465                         if( !((show_mask>>i) & 1) ) continue;
 466                         draw_edge(*edge, *new_points);
 467                 }
 468 // draw mask
 469                 if( !mask ) mask = new VFrame(mask_w, mask_h, mask_model, 0);
 470                 if( !temp ) temp = new VFrame(mask_w, mask_h, BC_A16, 0);
 471                 mask->clear_frame();
 472                 temp->clear_frame();
 473                 step = DO_MASK;
 474                 process_packages();
 475                 step = DO_FEATHER;
 476                 process_packages();
 477         }
 478 // Run units
 479 SET_TRACE
 480         step = DO_APPLY;
 481         process_packages();
 482 SET_TRACE
 483 }
 484
 485 void MaskEngine::init_packages()
 486 {
 487 SET_TRACE
 488 //printf("MaskEngine::init_packages 1\n");
 489         int x0 = 0, y0 = 0, i = 0, n = get_total_packages();
 490         int out_w = output->get_w(), out_h = output->get_h();
 491 SET_TRACE
 492         while( i < n ) {
 493                 MaskPackage *ptr = (MaskPackage*)get_package(i++);
 494                 int x1 = (out_w * i) / n, y1 = (out_h * i) / n;
 495                 ptr->start_x = x0;  ptr->end_x = x1;
 496                 ptr->start_y = y0;  ptr->end_y = y1;
 497                 x0 = x1;  y0 = y1;
 498         }
 499 SET_TRACE
 500 //printf("MaskEngine::init_packages 2\n");
 501 }
 502
 503 LoadClient* MaskEngine::new_client()
 504 {
 505         return new MaskUnit(this);
 506 }
 507
 508 LoadPackage* MaskEngine::new_package()
 509 {
 510         return new MaskPackage;
 511 }
 512