record batch dir path fix, handle yuv in gl masking, sync up maskengine/playback3d...

[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / maskengine.C

diff --git a/cinelerra-5.1/cinelerra/maskengine.C b/cinelerra-5.1/cinelerra/maskengine.C
index ed7cbaaebdbddfafcf72709f205eb891f5542e42..589b7938a875b9dc27a1aba95ee193d91dfa5456 100644 (file)
--- a/cinelerra-5.1/cinelerra/maskengine.C
+++ b/cinelerra-5.1/cinelerra/maskengine.C
@@ -33,6 +33,22 @@
 #include <stdint.h>
 #include <string.h>
 
 #include <stdint.h>
 #include <string.h>
 

+void write_mask(VFrame *vfrm, const char *fmt, ...)
+{
+  va_list ap;    va_start(ap, fmt);
+  char fn[256];  vsnprintf(fn, sizeof(fn), fmt, ap);
+  va_end(ap);
+  FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
+  if( fp ) {
+    int w = vfrm->get_w(), h = vfrm->get_h();
+    int m = vfrm->get_color_model();
+    fprintf(fp,"P5\n%d %d\n%d\n",w,h,m==BC_A8? 0xff : 0xffff);
+    int bpp = m==BC_A8? 1 : 2;
+    fwrite(vfrm->get_data(),bpp*w,h,fp);  fflush(fp);
+    if( fp != stdout ) fclose(fp);
+  }
+}
+

 MaskPackage::MaskPackage()
 {
 }
 MaskPackage::MaskPackage()
 {
 }


@@ -41,726 +57,257 @@ MaskPackage::~MaskPackage()
 {
 }
 
 {
 }
 

-
-
-
-
-
-

 MaskUnit::MaskUnit(MaskEngine *engine)
  : LoadClient(engine)
 {
        this->engine = engine;
 MaskUnit::MaskUnit(MaskEngine *engine)
  : LoadClient(engine)
 {
        this->engine = engine;

-       this->temp = 0;
+       spot = 0;
+       r = 0;

 }
 
 }
 

-

 MaskUnit::~MaskUnit()
 {
 MaskUnit::~MaskUnit()
 {

-       if(temp) delete temp;

 }
 
 }
 

-
-#define OVERSAMPLE 8
-
-void MaskUnit::draw_line_clamped(VFrame *frame,
-       int x1, int y1, int x2, int y2, unsigned char k)
+void MaskUnit::draw_line(int v, int ix1, int iy1, int ix2, int iy2)

 {
 {

-       int draw_x1, draw_y1;
-       int draw_x2, draw_y2;
-
-       if(y2 < y1) {
-               draw_x1 = x2;  draw_y1 = y2;
-               draw_x2 = x1;  draw_y2 = y1;
-       }
-       else {
-               draw_x1 = x1;  draw_y1 = y1;
-               draw_x2 = x2;  draw_y2 = y2;
-       }
-
-       unsigned char **rows = (unsigned char**)frame->get_rows();
-
-       if(draw_y2 != draw_y1) {
-               float slope = ((float)draw_x2 - draw_x1) / ((float)draw_y2 - draw_y1);
-               int w = frame->get_w() - 1;
-               int h = frame->get_h();
-
-               for(float y = draw_y1; y < draw_y2; y++) {
-                       if(y >= 0 && y < h) {
-                               int x = (int)((y - draw_y1) * slope + draw_x1);
-                               int y_i = (int)y;
-                               int x_i = CLIP(x, 0, w);
-
-                               if(rows[y_i][x_i] == k)
-                                       rows[y_i][x_i] = 0;
-                               else
-                                       rows[y_i][x_i] = k;
-                       }
-               }
+       if( iy1 == iy2 ) return;
+       int x1 = iy1 < iy2 ? ix1 : ix2;
+       int y1 = iy1 < iy2 ? iy1 : iy2;
+       int x2 = iy1 < iy2 ? ix2 : ix1;
+       int y2 = iy1 < iy2 ? iy2 : iy1;
+       float slope = (float)(x2-x1) / (y2-y1);
+       int dy = y1 - start_y;
+       int i = dy < 0 ? (y1=start_y, -dy) : 0;
+       if( y2 > end_y ) y2 = end_y;
+       if( y2 < start_y || y1 >= end_y ) return;
+
+       VFrame *temp = engine->temp;
+       int w1 = temp->get_w()-1;
+       temp_t **rows = (temp_t **)temp->get_rows();
+       for( int y=y1; y<y2; ++i,++y ) {
+               int x = (int)(i*slope + x1);
+               bclamp(x, 0, w1);
+               rows[y][x] = rows[y][x] == v ? 0 : v;

        }
 }
 
        }
 }
 

-void MaskUnit::blur_strip(double *val_p,
-       double *val_m,
-       double *dst,
-       double *src,
-       int size,
-       int max)
+void MaskUnit::draw_fill(int v)

 {
 {

-       double *sp_p = src;
-       double *sp_m = src + size - 1;
-       double *vp = val_p;
-       double *vm = val_m + size - 1;
-       double initial_p = sp_p[0];
-       double initial_m = sp_m[0];
-
-//printf("MaskUnit::blur_strip %d\n", size);
-       for(int k = 0; k < size; k++)
-       {
-               int terms = (k < 4) ? k : 4;
-               int l;
-               for(l = 0; l <= terms; l++)
-               {
-                       *vp += n_p[l] * sp_p[-l] - d_p[l] * vp[-l];
-                       *vm += n_m[l] * sp_m[l] - d_m[l] * vm[l];
-               }
-
-               for( ; l <= 4; l++)
-               {
-                       *vp += (n_p[l] - bd_p[l]) * initial_p;
-                       *vm += (n_m[l] - bd_m[l]) * initial_m;
+       VFrame *temp = engine->temp;
+       int temp_w = temp->get_w();
+       temp_t **rows = (temp_t**)temp->get_rows();
+
+       for( int y=start_y; y<end_y; ++y ) {
+               temp_t *row = rows[y];
+               int value = 0, total = 0;
+               for( int x=0; x<temp_w; ++x )
+                       if( row[x] == v ) ++total;
+               if( total < 2 ) continue;
+               if( total & 0x1 ) --total;
+               for( int x=0; x<temp_w; ++x ) {
+                       if( row[x]==v && total>0 ) {
+                               --total;
+                               value = value ? 0 : v;
+                       }
+                       else if( value )
+                               row[x] = value;

                }
                }

-               sp_p++;
-               sp_m--;
-               vp++;
-               vm--;
-       }
-
-       for(int i = 0; i < size; i++)
-       {
-               double sum = val_p[i] + val_m[i];
-               CLAMP(sum, 0, max);
-               dst[i] = sum;

        }
 }
 
        }
 }
 

-void MaskUnit::do_feather(VFrame *output,
-       VFrame *input,
-       double feather,
-       int start_y,
-       int end_y,
-       int start_x,
-       int end_x)
+void MaskUnit::draw_feather(int ix1,int iy1, int ix2,int iy2)

 {
 {

-//printf("MaskUnit::do_feather %f\n", feather);
-// Get constants
-       double constants[8];
-       double div;
-       double std_dev = sqrt(-(double)(feather * feather) / (2 * log(1.0 / 255.0)));
-       div = sqrt(2 * M_PI) * std_dev;
-       constants[0] = -1.783 / std_dev;
-       constants[1] = -1.723 / std_dev;
-       constants[2] = 0.6318 / std_dev;
-       constants[3] = 1.997  / std_dev;
-       constants[4] = 1.6803 / div;
-       constants[5] = 3.735 / div;
-       constants[6] = -0.6803 / div;
-       constants[7] = -0.2598 / div;
-
-       n_p[0] = constants[4] + constants[6];
-       n_p[1] = exp(constants[1]) *
-                               (constants[7] * sin(constants[3]) -
-                               (constants[6] + 2 * constants[4]) * cos(constants[3])) +
-                               exp(constants[0]) *
-                               (constants[5] * sin(constants[2]) -
-                               (2 * constants[6] + constants[4]) * cos(constants[2]));
-
-       n_p[2] = 2 * exp(constants[0] + constants[1]) *
-                               ((constants[4] + constants[6]) * cos(constants[3]) *
-                               cos(constants[2]) - constants[5] *
-                               cos(constants[3]) * sin(constants[2]) -
-                               constants[7] * cos(constants[2]) * sin(constants[3])) +
-                               constants[6] * exp(2 * constants[0]) +
-                               constants[4] * exp(2 * constants[1]);
-
-       n_p[3] = exp(constants[1] + 2 * constants[0]) *
-                               (constants[7] * sin(constants[3]) -
-                               constants[6] * cos(constants[3])) +
-                               exp(constants[0] + 2 * constants[1]) *
-                               (constants[5] * sin(constants[2]) - constants[4] *
-                               cos(constants[2]));
-       n_p[4] = 0.0;
-
-       d_p[0] = 0.0;
-       d_p[1] = -2 * exp(constants[1]) * cos(constants[3]) -
-                               2 * exp(constants[0]) * cos(constants[2]);
-
-       d_p[2] = 4 * cos(constants[3]) * cos(constants[2]) *
-                               exp(constants[0] + constants[1]) +
-                               exp(2 * constants[1]) + exp (2 * constants[0]);
-
-       d_p[3] = -2 * cos(constants[2]) * exp(constants[0] + 2 * constants[1]) -
-                               2 * cos(constants[3]) * exp(constants[1] + 2 * constants[0]);
-
-       d_p[4] = exp(2 * constants[0] + 2 * constants[1]);
-
-       for(int i = 0; i < 5; i++) d_m[i] = d_p[i];
-
-       n_m[0] = 0.0;
-       for(int i = 1; i <= 4; i++)
-               n_m[i] = n_p[i] - d_p[i] * n_p[0];
-
-       double sum_n_p, sum_n_m, sum_d;
-       double a, b;
-
-       sum_n_p = 0.0;
-       sum_n_m = 0.0;
-       sum_d = 0.0;
-       for(int i = 0; i < 5; i++)
-       {
-               sum_n_p += n_p[i];
-               sum_n_m += n_m[i];
-               sum_d += d_p[i];
+       int x1 = iy1 < iy2 ? ix1 : ix2;
+       int y1 = iy1 < iy2 ? iy1 : iy2;
+       int x2 = iy1 < iy2 ? ix2 : ix1;
+       int y2 = iy1 < iy2 ? iy2 : iy1;
+       VFrame *temp = engine->temp;
+       int h = temp->get_h();
+       if( y2 < 0 || y1 >= h ) return;
+
+       int x = x1, y = y1;
+       int dx = x2-x1, dy = y2-y1;
+       int dx2 = 2*dx, dy2 = 2*dy;
+       if( dx < 0 ) dx = -dx;
+       int m = dx > dy ? dx : dy, n = m;
+       if( dy >= dx ) {
+               if( dx2 >= 0 ) do {     /* +Y, +X */
+                       draw_spot(x, y++);
+                       if( (m -= dx2) < 0 ) { m += dy2;  ++x; }
+               } while( --n >= 0 );
+               else do {              /* +Y, -X */
+                       draw_spot(x, y++);
+                       if( (m += dx2) < 0 ) { m += dy2;  --x; }
+               } while( --n >= 0 );

        }
        }

-
-       a = sum_n_p / (1 + sum_d);
-       b = sum_n_m / (1 + sum_d);
-
-       for(int i = 0; i < 5; i++)
-       {
-               bd_p[i] = d_p[i] * a;
-               bd_m[i] = d_m[i] * b;
+       else {
+               if( dx2 >= 0 ) do {     /* +X, +Y */
+                       draw_spot(x++, y);
+                       if( (m -= dy2) < 0 ) { m += dx2;  ++y; }
+               } while( --n >= 0 );
+               else do {              /* -X, +Y */
+                       draw_spot(x--, y);
+                       if( (m -= dy2) < 0 ) { m -= dx2;  ++y; }
+               } while( --n >= 0 );

        }
        }

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#define DO_FEATHER(type, max) \
-{ \
-       int frame_w = input->get_w(); \
-       int frame_h = input->get_h(); \
-       int size = MAX(frame_w, frame_h); \
-       double *src = new double[size]; \
-       double *dst = new double[size]; \
-       double *val_p = new double[size]; \
-       double *val_m = new double[size]; \
-       type **in_rows = (type**)input->get_rows(); \
-       type **out_rows = (type**)output->get_rows(); \
-       int j; \
- \
-/* printf("DO_FEATHER 1\n"); */ \
-       if(end_x > start_x) \
-       { \
-               for(j = start_x; j < end_x; j++) \
-               { \
-       /* printf("DO_FEATHER 1.1 %d\n", j); */ \
-                       bzero(val_p, sizeof(double) * frame_h); \
-                       bzero(val_m, sizeof(double) * frame_h); \
-                       for(int k = 0; k < frame_h; k++) \
-                       { \
-                               src[k] = (double)in_rows[k][j]; \
-                       } \
-        \
-                       blur_strip(val_p, val_m, dst, src, frame_h, max); \
-        \
-                       for(int k = 0; k < frame_h; k++) \
-                       { \
-                               out_rows[k][j] = (type)dst[k]; \
-                       } \
-               } \
-       } \
- \
-       if(end_y > start_y) \
-       { \
-               for(j = start_y; j < end_y; j++) \
-               { \
-       /* printf("DO_FEATHER 2 %d\n", j); */ \
-                       bzero(val_p, sizeof(double) * frame_w); \
-                       bzero(val_m, sizeof(double) * frame_w); \
-                       for(int k = 0; k < frame_w; k++) \
-                       { \
-                               src[k] = (double)out_rows[j][k]; \
-                       } \
-        \
-                       blur_strip(val_p, val_m, dst, src, frame_w, max); \
-        \
-                       for(int k = 0; k < frame_w; k++) \
-                       { \
-                               out_rows[j][k] = (type)dst[k]; \
-                       } \
-               } \
-       } \
- \
-/* printf("DO_FEATHER 3\n"); */ \
- \
-       delete [] src; \
-       delete [] dst; \
-       delete [] val_p; \
-       delete [] val_m; \
-/* printf("DO_FEATHER 4\n"); */ \

 }
 
 }
 

-
-
-
-
-
-
-
-//printf("do_feather %d\n", frame->get_color_model());
-       switch(input->get_color_model())
-       {
-               case BC_A8:
-                       DO_FEATHER(unsigned char, 0xff);
-                       break;
-
-               case BC_A16:
-                       DO_FEATHER(uint16_t, 0xffff);
-                       break;
-
-               case BC_A_FLOAT:
-                       DO_FEATHER(float, 1);
-                       break;
+void MaskUnit::draw_spot(int ix, int iy)
+{
+       int rr = r * r, n = abs(r), rv = r * v;
+       if( iy < start_y-n || iy >= end_y+n ) return;
+       VFrame *temp = engine->temp;
+       int w1 = temp->get_w()-1, h1 = temp->get_h()-1;
+       int xs = ix - n;  bclamp(xs, 0, w1);
+       int xn = ix + n;  bclamp(xn, 0, w1);
+       int ys = iy - n;  bclamp(ys, 0, h1);
+       int yn = iy + n;  bclamp(yn, 0, h1);
+
+       temp_t **rows = (temp_t**)temp->get_rows();
+       for( int y=ys ; y<=yn; ++y ) {
+               temp_t *row = rows[y];
+               for( int x=xs; x<=xn; ++x ) {
+                       int dx = x-ix, dy = y-iy;
+                       int dd = dx*dx + dy*dy;
+                       if( dd >= rr ) continue;
+                       temp_t *rp = &row[x], a = spot[dd];
+                       if( rv*(*rp-a) < 0 ) *rp = a;
+               }

        }
        }

-
-
-
-

 }
 
 void MaskUnit::process_package(LoadPackage *package)
 {
        MaskPackage *ptr = (MaskPackage*)package;
 }
 
 void MaskUnit::process_package(LoadPackage *package)
 {
        MaskPackage *ptr = (MaskPackage*)package;

-
-       if(engine->recalculate &&
-               engine->step == DO_MASK)
-       {
-               VFrame *mask;
-               if(engine->feather > 0)
-                       mask = engine->temp_mask;
-               else
-                       mask = engine->mask;
-
-SET_TRACE
-// Generated oversampling frame
-               int mask_w = mask->get_w();
-               //int mask_h = mask->get_h();
-               int oversampled_package_w = mask_w * OVERSAMPLE;
-               int oversampled_package_h = (ptr->end_y - ptr->start_y) * OVERSAMPLE;
-//printf("MaskUnit::process_package 1\n");
-
-SET_TRACE
-               if(temp &&
-                       (temp->get_w() != oversampled_package_w ||
-                       temp->get_h() != oversampled_package_h)) {
-                       delete temp;  temp = 0;
-               }
-//printf("MaskUnit::process_package 1\n");
-
-SET_TRACE
-               if(!temp) {
-                       temp = new VFrame(oversampled_package_w, oversampled_package_h, BC_A8, 0);
-               }
-
-SET_TRACE
-               temp->clear_frame();
-//printf("MaskUnit::process_package 1 %d\n", engine->point_sets.total);
-
-SET_TRACE
-
-// Draw oversampled region of polygons on temp
-               for(int k = 0; k < engine->point_sets.total; k++)
-               {
-                       int old_x, old_y;
-                       unsigned char max = k + 1;
-                       ArrayList<MaskPoint*> *points = engine->point_sets.values[k];
-
-                       if(points->total < 3) continue;
-//printf("MaskUnit::process_package 2 %d %d\n", k, points->total);
-                       for(int i = 0; i < points->total; i++)
-                       {
-                               MaskPoint *point1 = points->values[i];
-                               MaskPoint *point2 = (i >= points->total - 1) ?
-                                       points->values[0] :
-                                       points->values[i + 1];
-
-                               float x, y;
-                               int segments = (int)(sqrt(SQR(point1->x - point2->x) + SQR(point1->y - point2->y)));
-                               if(point1->control_x2 == 0 &&
-                                       point1->control_y2 == 0 &&
-                                       point2->control_x1 == 0 &&
-                                       point2->control_y1 == 0)
-                                       segments = 1;
-                               float x0 = point1->x;
-                               float y0 = point1->y;
-                               float x1 = point1->x + point1->control_x2;
-                               float y1 = point1->y + point1->control_y2;
-                               float x2 = point2->x + point2->control_x1;
-                               float y2 = point2->y + point2->control_y1;
-                               float x3 = point2->x;
-                               float y3 = point2->y;
-
-                               for(int j = 0; j <= segments; j++)
-                               {
-                                       float t = (float)j / segments;
-                                       float tpow2 = t * t;
-                                       float tpow3 = t * t * t;
-                                       float invt = 1 - t;
-                                       float invtpow2 = invt * invt;
-                                       float invtpow3 = invt * invt * invt;
-
-                                       x = (        invtpow3 * x0
-                                               + 3 * t     * invtpow2 * x1
-                                               + 3 * tpow2 * invt     * x2
-                                               +     tpow3            * x3);
-                                       y = (        invtpow3 * y0
-                                               + 3 * t     * invtpow2 * y1
-                                               + 3 * tpow2 * invt     * y2
-                                               +     tpow3            * y3);
-
-                                       y -= ptr->start_y;
-                                       x *= OVERSAMPLE;
-                                       y *= OVERSAMPLE;
-
-                                       if(j > 0)
-                                       {
-                                               draw_line_clamped(temp, old_x, old_y, (int)x, (int)y, max);
-                                       }
-
-                                       old_x = (int)x;
-                                       old_y = (int)y;
-                               }
-                       }
-
-SET_TRACE
-//printf("MaskUnit::process_package 1\n");
-
-
-
-
-
-// Fill in the polygon in the horizontal direction
-                       for(int i = 0; i < oversampled_package_h; i++)
-                       {
-                               unsigned char *row = (unsigned char*)temp->get_rows()[i];
-                               int value = 0x0;
-                               int total = 0;
-
-                               for(int j = 0; j < oversampled_package_w; j++)
-                                       if(row[j] == max) total++;
-
-                               if(total > 1)
-                               {
-                                       if(total & 0x1) total--;
-                                       for(int j = 0; j < oversampled_package_w; j++)
-                                       {
-                                               if(row[j] == max && total > 0)
-                                               {
-                                                       if(value)
-                                                               value = 0x0;
-                                                       else
-                                                               value = max;
-                                                       total--;
-                                               }
-                                               else
-                                               {
-                                                       if(value) row[j] = value;
-                                               }
-                                       }
-                               }
+       start_y = ptr->start_y;
+       end_y = ptr->end_y;
+       if( start_y >= end_y ) return;
+       mask_model = engine->mask->get_color_model();
+       VFrame *temp = engine->temp;
+       if( engine->recalculate && engine->step == DO_MASK ) {
+// Draw masked region of polygons on temp
+               for( int k=0; k<engine->edges.size(); ++k ) {
+                       if( !engine->edges[k] ) continue;
+                       MaskEdge &edge = *engine->edges[k];
+                       if( edge.size() < 3 ) continue;
+                       int v = k + 1;
+                       for( int i=0; i<edge.size(); ++i ) {
+                               MaskCoord a = edge[i];
+                               MaskCoord b = i<edge.size()-1 ? edge[i+1] : edge[0];
+                               draw_line(v, a.x,a.y, b.x,b.y);

                        }
                        }

+                       draw_fill(v);

                }
                }

-
-
-SET_TRACE
-
-
-
-
-
-#define DOWNSAMPLE(type, temp_type, value) \
-for(int i = 0; i < ptr->end_y - ptr->start_y; i++) \
-{ \
-       type *output_row = (type*)mask->get_rows()[i + ptr->start_y]; \
-       unsigned char **input_rows = (unsigned char**)temp->get_rows() + i * OVERSAMPLE; \
- \
- \
-       for(int j = 0; j < mask_w; j++) \
-       { \
-               temp_type total = 0; \
- \
-/* Accumulate pixel */ \
-               for(int k = 0; k < OVERSAMPLE; k++) \
-               { \
-                       unsigned char *input_vector = input_rows[k] + j * OVERSAMPLE; \
-                       for(int l = 0; l < OVERSAMPLE; l++) \
-                       { \
-                               total += (input_vector[l] ? value : 0); \
-                       } \
-               } \
- \
-/* Divide pixel */ \
-               total /= OVERSAMPLE * OVERSAMPLE; \
- \
-               output_row[j] = total; \
-       } \
-}
-
-SET_TRACE
-
-// Downsample polygon
-               switch(mask->get_color_model())
-               {
-                       case BC_A8:
-                       {
-                               unsigned char value;
-                               value = (int)((float)engine->value / 100 * 0xff);
-                               DOWNSAMPLE(unsigned char, int64_t, value);
-                               break;
-                       }
-
-                       case BC_A16:
-                       {
-                               uint16_t value;
-                               value = (int)((float)engine->value / 100 * 0xffff);
-                               DOWNSAMPLE(uint16_t, int64_t, value);
-                               break;
+// map temp to fader alpha
+               int temp_w = temp->get_w();
+               temp_t **rows = (temp_t**)temp->get_rows();
+               temp_t *fade = engine->fade;
+               for( int y=start_y; y<end_y; ++y ) {
+                       temp_t *tp = rows[y];
+                       for( int i=temp_w; --i>=0; ++tp ) *tp = fade[*tp];
+               }
+       }
+       if( engine->recalculate && engine->step == DO_FEATHER ) {
+// draw feather
+               for( int k=0; k<engine->edges.size(); ++k ) {
+                       if( !(v = engine->faders[k]) ) continue;
+                       if( !(r = engine->feathers[k]) ) continue;
+                       MaskEdge &edge = *engine->edges[k];
+                       if( !edge.size() ) continue;
+                       float rv = r * v, vv = fabs(v);
+                       int fg = 0xffff * (rv >= 0 ? vv : 0);
+                       int bg = 0xffff * (rv >= 0 ? 0 : vv);
+                       int rr = r*r;  double dr = 1./rr;
+                       temp_t psf[rr+1];  spot = psf;
+                       for( int i=0; i<=rr; ++i ) {
+                               double d = i*dr;
+                               psf[i] = (1-d)*fg + d*bg;

                        }
                        }

-
-                       case BC_A_FLOAT:
-                       {
-                               float value;
-                               value = (float)engine->value / 100;
-                               DOWNSAMPLE(float, double, value);
-                               break;
+                       int n = edge.size();
+                       for( int i=0; i<n; ++i ) {
+                               MaskCoord &a = edge[i];
+                               MaskCoord &b = i<edge.size()-1 ? edge[i+1] : edge[0];
+                               draw_feather(a.x,a.y, b.x,b.y);

                        }
                }
                        }
                }

-       }

 
 

-SET_TRACE
-
-SET_TRACE
-
-       if(engine->step == DO_X_FEATHER)
-       {
-
-               if(engine->recalculate)
-               {
-// Feather polygon
-                       if(engine->feather > 0) do_feather(engine->mask,
-                               engine->temp_mask,
-                               engine->feather,
-                               ptr->start_y,
-                               ptr->end_y,
-                               0,
-                               0);
+#define REMAP(cmodel, type, expr) case cmodel: { \
+type **msk_rows = (type**)engine->mask->get_rows(); \
+for( int y=start_y; y<end_y; ++y ) { \
+       temp_t *rp = rows[y]; \
+       type *mp = msk_rows[y]; \
+       for( int i=temp_w; --i>=0; ++rp,++mp ) *mp = expr; \
+} } break
+// map alpha to mask
+               const float to_flt = 1/65535.;
+               int temp_w = temp->get_w();
+               temp_t **rows = (temp_t**)temp->get_rows();
+               switch( mask_model ) {
+               REMAP(BC_A8, uint8_t, *rp >> 8);
+               REMAP(BC_A16, uint16_t, *rp);
+               REMAP(BC_A_FLOAT, float, *rp * to_flt);

                }
                }

-//printf("MaskUnit::process_package 3 %f\n", engine->feather);

        }
 
        }
 

-       if(engine->step == DO_Y_FEATHER)
-       {
-               if(engine->recalculate)
-               {
-// Feather polygon
-                       if(engine->feather > 0) do_feather(engine->mask,
-                               engine->temp_mask,
-                               engine->feather,
-                               0,
-                               0,
-                               ptr->start_x,
-                               ptr->end_x);
-               }
-       }
-
-       if(engine->step == DO_APPLY)
-       {

 // Apply mask
 // Apply mask

+       if( engine->step == DO_APPLY ) {

                int mask_w = engine->mask->get_w();
                int mask_w = engine->mask->get_w();

-
-
-#define APPLY_MASK_SUBTRACT_ALPHA(type, max, components, do_yuv) \
-{ \
-       type *output_row = (type*)engine->output->get_rows()[i]; \
-       type *mask_row = (type*)engine->mask->get_rows()[i]; \
-       int chroma_offset = (int)(max + 1) / 2; \
- \
-       for(int j  = 0; j < mask_w; j++) \
-       { \
-               if(components == 4) \
-               { \
-                       output_row[j * 4 + 3] = output_row[j * 4 + 3] * (max - mask_row[j]) / max; \
-               } \
-               else \
-               { \
-                       output_row[j * 3] = output_row[j * 3] * (max - mask_row[j]) / max; \
- \
-                       output_row[j * 3 + 1] = output_row[j * 3 + 1] * (max - mask_row[j]) / max; \
-                       output_row[j * 3 + 2] = output_row[j * 3 + 2] * (max - mask_row[j]) / max; \
- \
-                       if(do_yuv) \
-                       { \
-                               output_row[j * 3 + 1] += chroma_offset * mask_row[j] / max; \
-                               output_row[j * 3 + 2] += chroma_offset * mask_row[j] / max; \
-                       } \
+               uint8_t **out_rows = engine->output->get_rows();
+               uint8_t **msk_rows = engine->mask->get_rows();
+#define APPLY_MASK_ALPHA(cmodel, type, max, components, do_yuv) \
+case cmodel: \
+for( int y=ptr->start_y; y<ptr->end_y; ++y ) { \
+       type *out_row = (type*)out_rows[y]; \
+       type *msk_row = (type*)msk_rows[y]; \
+       type chroma_offset = (int)(max + 1) / 2; \
+       for( int x=0; x<mask_w; ++x ) { \
+               type a = msk_row[x], b = max-a; \
+               if( components == 4 ) { \
+                       out_row[x*4 + 3] = out_row[x*4 + 3]*b / max; \

                } \
                } \

-       } \
-}
-
-#define APPLY_MASK_MULTIPLY_ALPHA(type, max, components, do_yuv) \
-{ \
-       type *output_row = (type*)engine->output->get_rows()[i]; \
-       type *mask_row = (type*)engine->mask->get_rows()[i]; \
-       int chroma_offset = (int)(max + 1) / 2; \
- \
-       for(int j  = 0; j < mask_w; j++) \
-       { \
-               if(components == 4) \
-               { \
-                       output_row[j * 4 + 3] = output_row[j * 4 + 3] * mask_row[j] / max; \
-               } \
-               else \
-               { \
-                       output_row[j * 3] = output_row[j * 3] * mask_row[j] / max; \
- \
-                       output_row[j * 3 + 1] = output_row[j * 3 + 1] * mask_row[j] / max; \
-                       output_row[j * 3 + 2] = output_row[j * 3 + 2] * mask_row[j] / max; \
- \
-                       if(do_yuv) \
-                       { \
-                               output_row[j * 3 + 1] += chroma_offset * (max - mask_row[j]) / max; \
-                               output_row[j * 3 + 2] += chroma_offset * (max - mask_row[j]) / max; \
+               else { \
+                       out_row[x*3 + 0] = out_row[x*3 + 0]*b / max; \
+                       out_row[x*3 + 1] = out_row[x*3 + 1]*b / max; \
+                       out_row[x*3 + 2] = out_row[x*3 + 2]*b / max; \
+                       if( do_yuv ) { \
+                               out_row[x*3 + 1] += chroma_offset*a / max; \
+                               out_row[x*3 + 2] += chroma_offset*a / max; \

                        } \
                } \
        } \
                        } \
                } \
        } \

-}
-
-
-
-
-//printf("MaskUnit::process_package 1 %d\n", engine->mode);
-               for(int i = ptr->start_y; i < ptr->end_y; i++)
-               {
-                       switch(engine->mode)
-                       {
-                               case MASK_MULTIPLY_ALPHA:
-                                       switch(engine->output->get_color_model())
-                                       {
-                                               case BC_RGB888:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 3, 0);
-                                                       break;
-                                               case BC_RGB_FLOAT:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(float, 1.0, 3, 0);
-                                                       break;
-                                               case BC_YUV888:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 3, 1);
-                                                       break;
-                                               case BC_RGBA_FLOAT:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(float, 1.0, 4, 0);
-                                                       break;
-                                               case BC_YUVA8888:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 4, 1);
-                                                       break;
-                                               case BC_RGBA8888:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(unsigned char, 0xff, 4, 0);
-                                                       break;
-                                               case BC_RGB161616:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 3, 0);
-                                                       break;
-                                               case BC_YUV161616:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 3, 1);
-                                                       break;
-                                               case BC_YUVA16161616:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 4, 1);
-                                                       break;
-                                               case BC_RGBA16161616:
-                                                       APPLY_MASK_MULTIPLY_ALPHA(uint16_t, 0xffff, 4, 0);
-                                                       break;
-                                       }
-                                       break;
-
-                               case MASK_SUBTRACT_ALPHA:
-                                       switch(engine->output->get_color_model())
-                                       {
-                                               case BC_RGB888:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 3, 0);
-                                                       break;
-                                               case BC_RGB_FLOAT:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(float, 1.0, 3, 0);
-                                                       break;
-                                               case BC_RGBA_FLOAT:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(float, 1.0, 4, 0);
-                                                       break;
-                                               case BC_RGBA8888:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 4, 0);
-                                                       break;
-                                               case BC_YUV888:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 3, 1);
-                                                       break;
-                                               case BC_YUVA8888:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(unsigned char, 0xff, 4, 1);
-                                                       break;
-                                               case BC_RGB161616:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 3, 0);
-                                                       break;
-                                               case BC_RGBA16161616:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 4, 0);
-                                                       break;
-                                               case BC_YUV161616:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 3, 1);
-                                                       break;
-                                               case BC_YUVA16161616:
-                                                       APPLY_MASK_SUBTRACT_ALPHA(uint16_t, 0xffff, 4, 1);
-                                                       break;
-                                       }
-                                       break;
-                       }
+} break
+
+               switch( engine->output->get_color_model() ) { \
+               APPLY_MASK_ALPHA(BC_RGB888, uint8_t, 0xff, 3, 0); \
+               APPLY_MASK_ALPHA(BC_RGB_FLOAT, float, 1.0, 3, 0); \
+               APPLY_MASK_ALPHA(BC_YUV888, uint8_t, 0xff, 3, 1); \
+               APPLY_MASK_ALPHA(BC_RGBA_FLOAT, float, 1.0, 4, 0); \
+               APPLY_MASK_ALPHA(BC_YUVA8888, uint8_t, 0xff, 4, 1); \
+               APPLY_MASK_ALPHA(BC_RGBA8888, uint8_t, 0xff, 4, 0); \
+               APPLY_MASK_ALPHA(BC_RGB161616, uint16_t, 0xffff, 3, 0); \
+               APPLY_MASK_ALPHA(BC_YUV161616, uint16_t, 0xffff, 3, 1); \
+               APPLY_MASK_ALPHA(BC_YUVA16161616, uint16_t, 0xffff, 4, 1); \
+               APPLY_MASK_ALPHA(BC_RGBA16161616, uint16_t, 0xffff, 4, 0); \

                }
        }
 }
 
 
                }
        }
 }
 
 

-
-
-

 MaskEngine::MaskEngine(int cpus)
 MaskEngine::MaskEngine(int cpus)

- : LoadServer(cpus, cpus * OVERSAMPLE * 2)
-// : LoadServer(1, OVERSAMPLE * 2)
+ : LoadServer(cpus, 2*cpus)
+// : LoadServer(1, 1)

 {
        mask = 0;
 {
        mask = 0;

+       temp = 0;

 }
 
 MaskEngine::~MaskEngine()
 {
 }
 
 MaskEngine::~MaskEngine()
 {

-       if(mask)
-       {
-               delete mask;
-               delete temp_mask;
-       }
-
-       for(int i = 0; i < point_sets.total; i++)
-       {
-               ArrayList<MaskPoint*> *points = point_sets.values[i];
-               points->remove_all_objects();
-       }
+       delete mask;
+       delete temp;
+       for( int i = 0; i < point_sets.total; i++ )
+               point_sets[i]->remove_all_objects();

        point_sets.remove_all_objects();
 }
 
        point_sets.remove_all_objects();
 }
 


@@ -768,150 +315,167 @@ int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
        ArrayList<MaskPoint*> *points)
 {
 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);
        ArrayList<MaskPoint*> *points)
 {
 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);

-       if(new_points->total != points->total) return 0;
+       if( new_points->total != points->total ) return 0;

 
 

-       for(int i = 0; i < new_points->total; i++)
-       {
-               if(!(*new_points->values[i] == *points->values[i])) return 0;
+       for( int i = 0; i < new_points->total; i++ ) {
+               if( !(*new_points->get(i) == *points->get(i)) ) return 0;

        }
 
        return 1;
 }
 
        }
 
        return 1;
 }
 

+void MaskEngine::draw_edge(MaskEdge &edge, MaskPointSet &points)
+{
+       if( points.size() < 2 ) return;
+       edge.remove_all();
+       for( int i=0; i<points.size(); ++i ) {
+               MaskPoint *ap = points[i];
+               MaskPoint *bp = (i>=points.size()-1) ?
+                               points[0] : points[i+1];
+               int segments = 0;
+               if( ap->control_x2 == 0 && ap->control_y2 == 0 &&
+                   bp->control_x1 == 0 && bp->control_y1 == 0 )
+                       segments = 1;
+               float x0 = ap->x, y0 = ap->y;
+               float x1 = ap->x + ap->control_x2;
+               float y1 = ap->y + ap->control_y2;
+               float x2 = bp->x + bp->control_x1;
+               float y2 = bp->y + bp->control_y1;
+               float x3 = bp->x, y3 = bp->y;
+
+// from Playback3D::do_mask_sync
+               float cx3 = -  x0 + 3*x1 - 3*x2 + x3;
+               float cx2 =  3*x0 - 6*x1 + 3*x2;
+               float cx1 = -3*x0 + 3*x1;
+               float cx0 =    x0;
+
+               float cy3 = -  y0 + 3*y1 - 3*y2 + y3;
+               float cy2 =  3*y0 - 6*y1 + 3*y2;
+               float cy1 = -3*y0 + 3*y1;
+               float cy0 =    y0;
+
+               if( segments == 0 ) {
+                       float maxaccel1 = fabs(2*cy2) + fabs(6*cy3);
+                       float maxaccel2 = fabs(2*cx2) + fabs(6*cx3);
+                       float maxaccel = maxaccel1 > maxaccel2 ? maxaccel1 : maxaccel2;
+                       float h = 1.0;
+                       if( maxaccel > 8.0 ) h = sqrt((8.0) / maxaccel);
+                       segments = int(1/h);
+               }
+
+               for( int j = 0; j <= segments; ++j ) {
+                       float t = (float)j / segments;
+                       float x = cx0 + t*(cx1 + t*(cx2 + t*cx3));
+                       float y = cy0 + t*(cy1 + t*(cy2 + t*cy3));
+                       edge.append(x, y);
+               }
+       }
+}
+

 void MaskEngine::do_mask(VFrame *output,
        int64_t start_position_project,
        MaskAutos *keyframe_set,
        MaskAuto *keyframe,
        MaskAuto *default_auto)
 {
 void MaskEngine::do_mask(VFrame *output,
        int64_t start_position_project,
        MaskAutos *keyframe_set,
        MaskAuto *keyframe,
        MaskAuto *default_auto)
 {

-       int new_color_model = 0;
+       this->output = output;

        recalculate = 0;
        recalculate = 0;

-
-       switch(output->get_color_model())
-       {
-               case BC_RGB_FLOAT:
-               case BC_RGBA_FLOAT:
-                       new_color_model = BC_A_FLOAT;
-                       break;
-
-               case BC_RGB888:
-               case BC_RGBA8888:
-               case BC_YUV888:
-               case BC_YUVA8888:
-                       new_color_model = BC_A8;
-                       break;
-
-               case BC_RGB161616:
-               case BC_RGBA16161616:
-               case BC_YUV161616:
-               case BC_YUVA16161616:
-                       new_color_model = BC_A16;
-                       break;
+       int mask_model = 0;
+
+       switch( output->get_color_model() ) {
+       case BC_RGB_FLOAT:
+       case BC_RGBA_FLOAT:
+               mask_model = BC_A_FLOAT;
+               break;
+
+       case BC_RGB888:
+       case BC_RGBA8888:
+       case BC_YUV888:
+       case BC_YUVA8888:
+               mask_model = BC_A8;
+               break;
+
+       case BC_RGB161616:
+       case BC_RGBA16161616:
+       case BC_YUV161616:
+       case BC_YUVA16161616:
+               mask_model = BC_A16;
+               break;

        }
 
 // Determine if recalculation is needed
 SET_TRACE
 
        }
 
 // Determine if recalculation is needed
 SET_TRACE
 

-       if(mask &&
-               (mask->get_w() != output->get_w() ||
-               mask->get_h() != output->get_h() ||
-               mask->get_color_model() != new_color_model))
-       {
-               delete mask;
-               delete temp_mask;
-               mask = 0;
+       int mask_w = output->get_w(), mask_h = output->get_h();
+       if( mask && ( mask->get_color_model() != mask_model ||
+           mask->get_w() != mask_w || mask->get_h() != mask_h ) ) {
+               delete mask;  mask = 0;

                recalculate = 1;
        }
                recalculate = 1;
        }

-
-       if(!recalculate)
-       {
-               if(point_sets.total != keyframe_set->total_submasks(start_position_project,
-                       PLAY_FORWARD))
-                       recalculate = 1;
+       if( temp && ( temp->get_w() != mask_w || temp->get_h() != mask_h ) ) {
+               delete temp;  temp = 0;

        }
 
        }
 

-       if(!recalculate)
-       {
-               for(int i = 0;
-                       i < keyframe_set->total_submasks(start_position_project,
-                               PLAY_FORWARD) && !recalculate;
-                       i++)
-               {
-                       ArrayList<MaskPoint*> *new_points = new ArrayList<MaskPoint*>;
-                       keyframe_set->get_points(new_points,
-                               i,
-                               start_position_project,
-                               PLAY_FORWARD);
-                       if(!points_equivalent(new_points, point_sets.values[i])) recalculate = 1;
-                       new_points->remove_all_objects();
-                       delete new_points;
-               }
-       }
+       total_submasks = keyframe_set->total_submasks(start_position_project, PLAY_FORWARD);
+       if( total_submasks != point_sets.size() )
+               recalculate = 1;

 
 

-       int new_value = keyframe_set->get_value(start_position_project,
-               PLAY_FORWARD);
-       float new_feather = keyframe_set->get_feather(start_position_project,
-               PLAY_FORWARD);
+       for( int i=0; i<total_submasks && !recalculate; ++i ) {
+               float new_fader = keyframe_set->get_fader(start_position_project, i, PLAY_FORWARD);
+               if( new_fader != faders[i] ) { recalculate = 1;  break; }
+               float new_feather = keyframe_set->get_feather(start_position_project, i, PLAY_FORWARD);
+               if( new_feather != feathers[i] ) { recalculate = 1;  break; }
+               ArrayList<MaskPoint*> new_points;
+               keyframe_set->get_points(&new_points, i,
+                               start_position_project, PLAY_FORWARD);
+               if( !points_equivalent(&new_points, point_sets[i]) )
+                       recalculate = 1;
+               new_points.remove_all_objects();
+       }

 
 

-       if(recalculate ||
-               !EQUIV(new_feather, feather) ||
-               !EQUIV(new_value, value))
-       {
-               recalculate = 1;
-               if(!mask)
-               {
-                       mask = new VFrame(output->get_w(), output->get_h(),
-                                       new_color_model, 0);
-                       temp_mask = new VFrame(output->get_w(), output->get_h(),
-                                       new_color_model, 0);
-               }
-               if(new_feather > 0)
-                       temp_mask->clear_frame();
-               else
-                       mask->clear_frame();
-
-               for(int i = 0; i < point_sets.total; i++)
-               {
-                       ArrayList<MaskPoint*> *points = point_sets.values[i];
+       if( recalculate ) {
+               for( int i = 0; i < point_sets.total; i++ ) {
+                       ArrayList<MaskPoint*> *points = point_sets[i];

                        points->remove_all_objects();
                }
                point_sets.remove_all_objects();
                        points->remove_all_objects();
                }
                point_sets.remove_all_objects();

-
-               for(int i = 0;
-                       i < keyframe_set->total_submasks(start_position_project,
-                               PLAY_FORWARD);
-                       i++)
-               {
-                       ArrayList<MaskPoint*> *new_points = new ArrayList<MaskPoint*>;
-                       keyframe_set->get_points(new_points,
-                               i,
-                               start_position_project,
-                               PLAY_FORWARD);
+               edges.remove_all_objects();
+               faders.remove_all();
+               feathers.remove_all();
+               fade[0] = 0;
+
+               for( int i=0; i<total_submasks; ++i ) {
+                       float fader = keyframe_set->get_fader(start_position_project, i, PLAY_FORWARD);
+                       float v = fader / 100;
+                       faders.append(v);
+                       temp_t t = fabs(v) * 0xffff;
+                       if( fader < 0 ) {
+                               if( fade[0] < t ) fade[0] = t;
+                               t = 0;
+                       }
+                       fade[i+1] = t;
+                       float feather = keyframe_set->get_feather(start_position_project, i, PLAY_FORWARD);
+                       feathers.append(feather);
+                       MaskPointSet *new_points = new MaskPointSet();
+                       keyframe_set->get_points(new_points, i, start_position_project, PLAY_FORWARD);

                        point_sets.append(new_points);
                        point_sets.append(new_points);

+                       draw_edge(*edges.append(new MaskEdge()), *new_points);

                }
                }

+// draw mask
+               if( !mask ) mask = new VFrame(mask_w, mask_h, mask_model, 0);
+               if( !temp ) temp = new VFrame(mask_w, mask_h, BC_A16, 0);
+               mask->clear_frame();
+               temp->clear_frame();
+               step = DO_MASK;
+               process_packages();
+               step = DO_FEATHER;
+               process_packages();

        }
        }

-
-
-
-       this->output = output;
-       this->mode = default_auto->mode;
-       this->feather = new_feather;
-       this->value = new_value;
-
-

 // Run units
 SET_TRACE
 // Run units
 SET_TRACE

-       step = DO_MASK;
-       process_packages();
-       step = DO_Y_FEATHER;
-       process_packages();
-       step = DO_X_FEATHER;
-       process_packages();

        step = DO_APPLY;
        process_packages();
 SET_TRACE
        step = DO_APPLY;
        process_packages();
 SET_TRACE

-
-

 }
 
 void MaskEngine::init_packages()
 }
 
 void MaskEngine::init_packages()