X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fmaskengine.C;h=564d1fe895287b66f5e4ddca8bf3c145123af81e;hp=bb930def75947e13a81208c28ef429b65c0632fa;hb=3b4b6f588c4f2643316afcbc486ca6a35c16a431;hpb=7718f72da6995e7b2b2a59dcc61cc80a2f4bf38f

diff --git a/cinelerra-5.1/cinelerra/maskengine.C b/cinelerra-5.1/cinelerra/maskengine.C
index bb930def..564d1fe8 100644
--- a/cinelerra-5.1/cinelerra/maskengine.C
+++ b/cinelerra-5.1/cinelerra/maskengine.C
@@ -41,11 +41,19 @@ void write_mask(VFrame *vfrm, const char *fmt, ...)
   va_end(ap);
   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
   if( fp ) {
+    uint8_t **rows = (uint8_t**)vfrm->get_rows();
     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);
+    fprintf(fp,"P5\n%d %d\n%d\n",w,h,255);
+    for( int y=0; y<h; ++y ) {
+      uint8_t *bp = rows[y];
+      for( int x=0; x<w; ++x,bp+=bpp ) {
+        int b = m==BC_A8 ? *(uint8_t*)bp : *(uint16_t*)bp>>8;
+        putc(b,fp);
+      }
+    }
+    fflush(fp);
     if( fp != stdout ) fclose(fp);
   }
 }
@@ -62,15 +70,23 @@ MaskUnit::MaskUnit(MaskEngine *engine)
  : LoadClient(engine)
 {
 	this->engine = engine;
-	spot = 0;
-	r = 0;
 }
 
 MaskUnit::~MaskUnit()
 {
 }
 
-void MaskUnit::draw_line(int v, int ix1, int iy1, int ix2, int iy2)
+void MaskUnit::clear_mask(VFrame *msk, int a)
+{
+	temp_t **mrows = (temp_t **)msk->get_rows();
+	int w = msk->get_w();
+	for( int y=start_y; y<end_y; ++y ) {
+		temp_t *mrow = mrows[y];
+		for( int x=0; x<w; ++x ) mrow[x] = a;
+	}
+}
+
+void MaskUnit::draw_line(int ix1, int iy1, int ix2, int iy2)
 {
 	if( iy1 == iy2 ) return;
 	int x1 = iy1 < iy2 ? ix1 : ix2;
@@ -83,36 +99,36 @@ void MaskUnit::draw_line(int v, int ix1, int iy1, int ix2, int iy2)
 	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();
+	VFrame *in = engine->in;
+	int w1 = in->get_w()-1;
+	temp_t **irows = (temp_t **)in->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;
+		irows[y][x] = irows[y][x] == fc ? bc : fc;
 	}
 }
-
-void MaskUnit::draw_fill(int v)
+void MaskUnit::draw_fill()
 {
-	VFrame *temp = engine->temp;
-	int temp_w = temp->get_w();
-	temp_t **rows = (temp_t**)temp->get_rows();
+	VFrame *in = engine->in;
+	temp_t **irows = (temp_t**)in->get_rows();
+	int w = in->get_w();
 
 	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;
+		temp_t *irow = irows[y];
+		int total = 0;
+		for( int x=0; x<w; ++x )
+			if( irow[x] == fc ) ++total;
 		if( total < 2 ) continue;
 		if( total & 0x1 ) --total;
-		for( int x=0; x<temp_w; ++x ) {
-			if( row[x]==v && total>0 ) {
+		int inside = 0;
+		for( int x=0; x<w; ++x ) {
+			if( irow[x]==fc && total>0 ) {
 				--total;
-				value = value ? 0 : v;
+				inside = 1-inside;
 			}
-			else if( value )
-				row[x] = value;
+			else if( inside )
+				irow[x] = fc;
 		}
 	}
 }
@@ -123,174 +139,196 @@ void MaskUnit::draw_feather(int ix1,int iy1, int ix2,int iy2)
 	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();
+	VFrame *in = engine->in;
+	int h = in->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;
+	int m = dx > dy ? dx : dy, i = m;
 	if( dy >= dx ) {
 		if( dx2 >= 0 ) do {     /* +Y, +X */
-			draw_spot(x, y++);
+			draw_edge(x, y++);
 			if( (m -= dx2) < 0 ) { m += dy2;  ++x; }
-		} while( --n >= 0 );
+		} while( --i >= 0 );
 		else do {	       /* +Y, -X */
-			draw_spot(x, y++);
+			draw_edge(x, y++);
 			if( (m += dx2) < 0 ) { m += dy2;  --x; }
-		} while( --n >= 0 );
+		} while( --i >= 0 );
 	}
 	else {
 		if( dx2 >= 0 ) do {     /* +X, +Y */
-			draw_spot(x++, y);
+			draw_edge(x++, y);
 			if( (m -= dy2) < 0 ) { m += dx2;  ++y; }
-		} while( --n >= 0 );
+		} while( --i >= 0 );
 		else do {	       /* -X, +Y */
-			draw_spot(x--, y);
+			draw_edge(x--, y);
 			if( (m -= dy2) < 0 ) { m -= dx2;  ++y; }
-		} while( --n >= 0 );
+		} while( --i >= 0 );
 	}
 }
 
-void MaskUnit::draw_spot(int ix, int iy)
+void MaskUnit::draw_edge(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;
-		}
+	if( iy < start_y || iy >= end_y ) return;
+	VFrame *in = engine->in;
+	temp_t **irows = (temp_t **)in->get_rows();
+	irows[iy][ix] = fc;
+}
+void MaskUnit::draw_filled_polygon(MaskEdge &edge)
+{
+	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(a.x,a.y, b.x,b.y);
 	}
+	draw_fill();
 }
 
-void MaskUnit::process_package(LoadPackage *package)
+void MaskUnit::feather_x(VFrame *in, VFrame *out)
 {
-	MaskPackage *ptr = (MaskPackage*)package;
-	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);
+	float *psf = engine->psf;  int psz = engine->psz;
+	temp_t **orows = (temp_t**)out->get_rows();
+	temp_t **irows = (temp_t**)in->get_rows();
+	int w = in->get_w(), w1 = w-1;
+	for( int y=start_y; y<end_y; ++y ) {
+		temp_t *rp = irows[y]; 
+		for( int x=0; x<w; ++x ) {
+			temp_t c = rp[x], f = c * psf[0];
+			for( int i=1; i<psz; ++i ) {
+				int l = x-i;	if( l < 0 ) l = 0;
+				int r = x+i;	if( r > w1 ) r = w1;
+				temp_t g = bmax(rp[l], rp[r]) * psf[i];
+				if( f < g ) f = g;
 			}
-			draw_fill(v);
-		}
-// 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];
+			orows[y][x] = c > f ? c : f;
 		}
 	}
-	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;
-			}
-			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);
+}
+void MaskUnit::feather_y(VFrame *in, VFrame *out)
+{
+	float *psf = engine->psf;  int psz = engine->psz;
+	temp_t **orows = (temp_t**)out->get_rows();
+	temp_t **irows = (temp_t**)in->get_rows();
+	int h = in->get_h(), h1 = h-1;
+	for( int y=0; y<h; ++y ) {
+		temp_t *rp = irows[y];
+		for( int x=start_x; x<end_x; ++x ) {
+			temp_t c = rp[x], f = c * psf[0];
+			for( int i=1; i<psz; ++i ) {
+				int d = y-i;	if( d < 0 ) d = 0;
+				int u = y+i;	if( u > h1 ) u = h1;
+				temp_t *drow = irows[d], *urow = irows[u];
+				temp_t g = bmax(drow[x], urow[x]) * psf[i];
+				if( f < g ) f = g;
 			}
+			orows[y][x] = c > f ? c : f;
 		}
-
-#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);
+	}
+}
+void MaskUnit::mask_blend(VFrame *in, VFrame *mask, float r, float v)
+{
+	temp_t **irows = (temp_t**)in->get_rows();
+	temp_t **mrows = (temp_t**)mask->get_rows();
+	const int mn = 0x0000, mx = 0xffff;
+	int iv = v>=0 ? 1 : -1;
+	float rr = r!=0 ? r : 1;
+	float rv = rr*v>=0. ? 1 : -1;;
+	int vv = (v>=0. ? 1.-v : 1.+v) * mx;
+	unsigned fg = rv>0. ? vv : mx;
+	unsigned bg = rv>0. ? mx : vv;
+	int w = in->get_w();
+	int b = r<0 ? mx : mn;
+	for( int y=start_y; y<end_y; ++y ) {
+		temp_t *irow = irows[y], *mrow = mrows[y];
+		for( int x=0; x<w; ++x ) {
+			temp_t c = irow[x];
+			if( c == b ) continue;
+			temp_t a = (c*fg + (mx-c)*bg) / mx;
+			temp_t *cp = mrow + x, color = *cp;
+			if( iv*(color-a) > 0 ) *cp = a;
 		}
 	}
-
-// Apply mask
-	if( engine->step == DO_APPLY ) {
-		int mask_w = engine->mask->get_w();
-		uint8_t **out_rows = engine->output->get_rows();
-		uint8_t **msk_rows = engine->mask->get_rows();
+}
+void MaskUnit::apply_mask_alpha(VFrame *output, VFrame *mask)
+{
+	int w = mask->get_w();
+	uint8_t **orows = output->get_rows();
+	temp_t **mrows = (temp_t **)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; \
+for( int y=start_y; y<end_y; ++y ) { \
+	type *orow = (type*)orows[y]; \
+	temp_t *mrow = mrows[y]; \
+	for( int x=0; x<w; ++x ) { \
+		temp_t a = mrow[x]; \
 		if( components == 4 ) { \
-			out_row[x*4 + 3] = out_row[x*4 + 3]*b / max; \
+			orow[x*4 + 3] = orow[x*4 + 3]*a / 0xffff; \
 		} \
 		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; \
+			orow[x*3 + 0] = orow[x*3 + 0]*a / 0xffff; \
+			orow[x*3 + 1] = orow[x*3 + 1]*a / 0xffff; \
+			orow[x*3 + 2] = orow[x*3 + 2]*a / 0xffff; \
 			if( do_yuv ) { \
-				out_row[x*3 + 1] += chroma_offset*a / max; \
-				out_row[x*3 + 2] += chroma_offset*a / max; \
+				a = 0xffff-a; \
+				type chroma_offset = (int)(max + 1) / 2; \
+				orow[x*3 + 1] += chroma_offset*a / 0xffff; \
+				orow[x*3 + 2] += chroma_offset*a / 0xffff; \
 			} \
 		} \
 	} \
 } 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); \
-		}
+	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); \
+	}
+}
+
+
+void MaskUnit::process_package(LoadPackage *package)
+{
+	pkg = (MaskPackage*)package;
+	start_x = pkg->start_x;  end_x = pkg->end_x;
+	start_y = pkg->start_y;  end_y = pkg->end_y;
+	if( start_y >= end_y ) return;
+	MaskEdge *edge = engine->edge;
+	float r = engine->r, v = engine->v;
+	VFrame *in = engine->in;
+	VFrame *out = engine->out;
+	VFrame *mask = engine->mask;
+	switch( engine->step ) {
+	case DO_MASK: {
+// Draw masked region of polygons on in
+		if( edge->size() < 3 ) break;
+		bc = r>=0 ? 0 : 0xffff;
+		fc = r>=0 ? 0xffff : 0;
+		clear_mask(in, bc);
+		if( bc == fc ) break;
+		draw_filled_polygon(*edge);
+		break; }
+	case DO_FEATHER_X: {
+		feather_x(in, out);
+		break; }
+	case DO_FEATHER_Y: {
+		feather_y(out, in);
+		break; }
+	case DO_MASK_BLEND: {
+		mask_blend(in, mask, r, v);
+		break; }
+	case DO_APPLY: {
+		apply_mask_alpha(engine->output, mask);
+		break; }
 	}
 }
 
@@ -300,20 +338,19 @@ MaskEngine::MaskEngine(int cpus)
 // : LoadServer(1, 1)
 {
 	mask = 0;
-	temp = 0;
+	in = 0;
+	out = 0;
 }
 
 MaskEngine::~MaskEngine()
 {
 	delete mask;
-	delete temp;
-	for( int i = 0; i < point_sets.total; i++ )
-		point_sets[i]->remove_all_objects();
-	point_sets.remove_all_objects();
+	delete in;
+	delete out;
 }
 
-int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
-	ArrayList<MaskPoint*> *points)
+int MaskEngine::points_equivalent(MaskPoints *new_points,
+	MaskPoints *points)
 {
 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);
 	if( new_points->total != points->total ) return 0;
@@ -325,53 +362,21 @@ int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
 	return 1;
 }
 
-void MaskEngine::draw_edge(MaskEdge &edge, MaskPointSet &points)
+void MaskEngine::clear_mask(VFrame *msk, int a)
 {
-	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);
-		}
+	temp_t **mrows = (temp_t **)msk->get_rows();
+	int w = msk->get_w(), h = msk->get_h();
+	for( int y=0; y<h; ++y ) {
+		temp_t *mrow = mrows[y];
+		for( int x=0; x<w; ++x ) mrow[x] = a;
 	}
 }
+void MaskEngine::draw_point_spot(float r)
+{
+	double sig2 = -log(255.0)/((double)r*r);
+	for( int i=0; i<psz; ++i )
+		psf[i] = exp(i*i * sig2);
+}
 
 void MaskEngine::do_mask(VFrame *output,
 	int64_t start_position_project,
@@ -405,16 +410,15 @@ void MaskEngine::do_mask(VFrame *output,
 	}
 
 // Determine if recalculation is needed
-SET_TRACE
-
 	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;
 	}
-	if( temp && ( temp->get_w() != mask_w || temp->get_h() != mask_h ) ) {
-		delete temp;  temp = 0;
+	if( in && ( in->get_w() != mask_w || in->get_h() != mask_h ) ) {
+		delete in;  in = 0;
+		delete out; out = 0;
 	}
 
 	total_submasks = keyframe_set->total_submasks(start_position_project, PLAY_FORWARD);
@@ -426,75 +430,90 @@ SET_TRACE
 		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,
+		MaskPoints points;
+		keyframe_set->get_points(&points, i,
 				start_position_project, PLAY_FORWARD);
-		if( !points_equivalent(&new_points, point_sets[i]) )
+		if( !points_equivalent(&points, point_sets[i]) )
 			recalculate = 1;
-		new_points.remove_all_objects();
 	}
 
 	if( recalculate ) {
+		if( !in ) in = new VFrame(mask_w, mask_h, BC_A16, 0);
+		if( !out ) out = new VFrame(mask_w, mask_h, BC_A16, 0);
+		if( !mask ) mask = new VFrame(mask_w, mask_h, BC_A16, 0);
 		for( int i = 0; i < point_sets.total; i++ ) {
-			ArrayList<MaskPoint*> *points = point_sets[i];
+			MaskPoints *points = point_sets[i];
 			points->remove_all_objects();
 		}
 		point_sets.remove_all_objects();
 		edges.remove_all_objects();
 		faders.remove_all();
 		feathers.remove_all();
-		fade[0] = 0;
 
+		float cc = 1;
 		int show_mask = keyframe_set->track->masks;
 		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);
-			MaskEdge *edge = edges.append(new MaskEdge());
-			if( !((show_mask>>i) & 1) ) continue;
-			draw_edge(*edge, *new_points);
+			MaskPoints *points = new MaskPoints();
+			keyframe_set->get_points(points, i, start_position_project, PLAY_FORWARD);
+			point_sets.append(points);
+			MaskEdge &edge = *edges.append(new MaskEdge());
+			if( !fader || !((show_mask>>i) & 1) || !points->size() ) continue;
+			edge.load(*points, 0);
+			if( v >= 0 ) continue;
+			float vv = 1 + v;
+			if( cc > vv ) cc = vv;
 		}
+		clear_mask(mask, cc*0xffff);
 // 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();
+		for( int k=0; k<edges.size(); ++k ) {
+			this->edge = edges[k];
+			this->r = feathers[k];
+			this->v = faders[k];
+			if( !this->v ) continue;
+			if( this->edge->size() < 3 ) continue;
+			float rr = fabsf(r);
+			if( rr > 1024 ) rr = 1024; // MAX
+			psf = new float[psz = rr+1];
+			draw_point_spot(r);
+//write_mask(mask, "/tmp/mask%d.pgm", k);
+			step = DO_MASK;
+			process_packages();
+//write_mask(in, "/tmp/in0%d.pgm", k);
+			step = DO_FEATHER_X;
+			process_packages();
+//write_mask(out, "/tmp/out1%d.pgm", k);
+			step = DO_FEATHER_Y;
+			process_packages();
+			step = DO_MASK_BLEND;
+			process_packages();
+			delete [] psf;  psf = 0;
+//write_mask(in, "/tmp/in2%d.pgm", k);
+//printf("edge %d\n",k);
+		}
 	}
-// Run units
-SET_TRACE
-	step = DO_APPLY;
-	process_packages();
-SET_TRACE
+//write_mask(mask, "/tmp/mask.pgm");
+		step = DO_APPLY;
+		process_packages();
 }
 
 void MaskEngine::init_packages()
 {
 SET_TRACE
 //printf("MaskEngine::init_packages 1\n");
-	int x0 = 0, y0 = 0, i = 0, n = get_total_packages();
+	int x1 = 0, y1 = 0, i = 0, n = get_total_packages();
 	int out_w = output->get_w(), out_h = output->get_h();
 SET_TRACE
 	while( i < n ) {
-		MaskPackage *ptr = (MaskPackage*)get_package(i++);
-		int x1 = (out_w * i) / n, y1 = (out_h * i) / n;
-		ptr->start_x = x0;  ptr->end_x = x1;
-		ptr->start_y = y0;  ptr->end_y = y1;
-		x0 = x1;  y0 = y1;
+		MaskPackage *pkg = (MaskPackage*)get_package(i++);
+		int x2 = (out_w * i) / n, y2 = (out_h * i) / n;
+		pkg->start_x = x1;  pkg->end_x = x2;
+		pkg->start_y = y1;  pkg->end_y = y2;
+		x1 = x2;  y1 = y2;
 	}
 SET_TRACE
 //printf("MaskEngine::init_packages 2\n");