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=ed7cbaaebdbddfafcf72709f205eb891f5542e42;hb=3b4b6f588c4f2643316afcbc486ca6a35c16a431;hpb=7fd85fb66168f6b518c5f2d73e04036e87faa0e1

diff --git a/cinelerra-5.1/cinelerra/maskengine.C b/cinelerra-5.1/cinelerra/maskengine.C
index ed7cbaae..564d1fe8 100644
--- a/cinelerra-5.1/cinelerra/maskengine.C
+++ b/cinelerra-5.1/cinelerra/maskengine.C
@@ -26,6 +26,7 @@
 #include "maskautos.h"
 #include "maskengine.h"
 #include "mutex.h"
+#include "track.h"
 #include "transportque.inc"
 #include "vframe.h"
 
@@ -33,6 +34,30 @@
 #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 ) {
+    uint8_t **rows = (uint8_t**)vfrm->get_rows();
+    int w = vfrm->get_w(), h = vfrm->get_h();
+    int m = vfrm->get_color_model();
+    int bpp = m==BC_A8? 1 : 2;
+    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);
+  }
+}
+
 MaskPackage::MaskPackage()
 {
 }
@@ -41,892 +66,454 @@ MaskPackage::~MaskPackage()
 {
 }
 
-
-
-
-
-
-
 MaskUnit::MaskUnit(MaskEngine *engine)
  : LoadClient(engine)
 {
 	this->engine = engine;
-	this->temp = 0;
 }
 
-
 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::clear_mask(VFrame *msk, int a)
 {
-	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;
+	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;
 	}
+}
 
-	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;
-			}
-		}
+void MaskUnit::draw_line(int ix1, int iy1, int ix2, int iy2)
+{
+	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 *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);
+		irows[y][x] = irows[y][x] == fc ? bc : fc;
 	}
 }
-
-void MaskUnit::blur_strip(double *val_p,
-	double *val_m,
-	double *dst,
-	double *src,
-	int size,
-	int max)
+void MaskUnit::draw_fill()
 {
-	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 *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 *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;
+		int inside = 0;
+		for( int x=0; x<w; ++x ) {
+			if( irow[x]==fc && total>0 ) {
+				--total;
+				inside = 1-inside;
+			}
+			else if( inside )
+				irow[x] = fc;
 		}
-		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 *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, i = m;
+	if( dy >= dx ) {
+		if( dx2 >= 0 ) do {     /* +Y, +X */
+			draw_edge(x, y++);
+			if( (m -= dx2) < 0 ) { m += dy2;  ++x; }
+		} while( --i >= 0 );
+		else do {	       /* +Y, -X */
+			draw_edge(x, y++);
+			if( (m += dx2) < 0 ) { m += dy2;  --x; }
+		} while( --i >= 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_edge(x++, y);
+			if( (m -= dy2) < 0 ) { m += dx2;  ++y; }
+		} while( --i >= 0 );
+		else do {	       /* -X, +Y */
+			draw_edge(x--, y);
+			if( (m -= dy2) < 0 ) { m -= dx2;  ++y; }
+		} while( --i >= 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_edge(int ix, int iy)
+{
+	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;
-
-	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;
-						}
-					}
-				}
+	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;
 			}
+			orows[y][x] = c > f ? c : f;
 		}
-
-
-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;
-			}
-
-			case BC_A_FLOAT:
-			{
-				float value;
-				value = (float)engine->value / 100;
-				DOWNSAMPLE(float, double, value);
-				break;
+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;
 		}
 	}
-
-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);
-		}
-//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);
+}
+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;
 		}
 	}
-
-	if(engine->step == DO_APPLY)
-	{
-// Apply mask
-		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; \
-			} \
-		} \
-	} \
 }
-
-#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; \
+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=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 ) { \
+			orow[x*4 + 3] = orow[x*4 + 3]*a / 0xffff; \
 		} \
-		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 { \
+			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 ) { \
+				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); \
+	}
 }
 
 
-
-
-//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;
-			}
-		}
+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; }
 	}
 }
 
 
-
-
-
 MaskEngine::MaskEngine(int cpus)
- : LoadServer(cpus, cpus * OVERSAMPLE * 2)
-// : LoadServer(1, OVERSAMPLE * 2)
+ : LoadServer(cpus, 2*cpus)
+// : LoadServer(1, 1)
 {
 	mask = 0;
+	in = 0;
+	out = 0;
 }
 
 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();
-	}
-	point_sets.remove_all_objects();
+	delete mask;
+	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;
+	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;
 }
 
+void MaskEngine::clear_mask(VFrame *msk, int a)
+{
+	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,
 	MaskAutos *keyframe_set,
 	MaskAuto *keyframe,
 	MaskAuto *default_auto)
 {
-	int new_color_model = 0;
+	this->output = output;
 	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
-
-	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;
 	}
-
-	if(!recalculate)
-	{
-		if(point_sets.total != keyframe_set->total_submasks(start_position_project,
-			PLAY_FORWARD))
-			recalculate = 1;
+	if( in && ( in->get_w() != mask_w || in->get_h() != mask_h ) ) {
+		delete in;  in = 0;
+		delete out; out = 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; }
+		MaskPoints points;
+		keyframe_set->get_points(&points, i,
+				start_position_project, PLAY_FORWARD);
+		if( !points_equivalent(&points, point_sets[i]) )
+			recalculate = 1;
+	}
 
-	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 ) {
+		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++ ) {
+			MaskPoints *points = point_sets[i];
 			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);
-			point_sets.append(new_points);
+		edges.remove_all_objects();
+		faders.remove_all();
+		feathers.remove_all();
+
+		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);
+			float feather = keyframe_set->get_feather(start_position_project, i, PLAY_FORWARD);
+			feathers.append(feather);
+			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
+		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);
 		}
 	}
-
-
-
-	this->output = output;
-	this->mode = default_auto->mode;
-	this->feather = new_feather;
-	this->value = new_value;
-
-
-// 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
-
-
+//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");