#include "maskautos.h"
#include "maskengine.h"
#include "mutex.h"
+#include "track.h"
#include "transportque.inc"
#include "vframe.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()
{
}
{
}
-
-
-
-
-
-
MaskUnit::MaskUnit(MaskEngine *engine)
: LoadClient(engine)
{
this->engine = engine;
- this->temp = 0;
+ spot = 0;
+ r = 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::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;
-
- 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;
- }
-
- case BC_A_FLOAT:
- {
- float value;
- value = (float)engine->value / 100;
- DOWNSAMPLE(float, double, 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];
}
}
-
-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);
+ 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);
+ }
}
-//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);
+#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);
}
}
- if(engine->step == DO_APPLY)
- {
// Apply mask
+ if( engine->step == DO_APPLY ) {
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; \
+ 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; \
} \
- 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; \
+ 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; \
} \
} \
} \
-}
-
-#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; \
- } \
- } \
- } \
-}
-
-
-
-
-//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)
- : LoadServer(cpus, cpus * OVERSAMPLE * 2)
-// : LoadServer(1, OVERSAMPLE * 2)
+ : LoadServer(cpus, 2*cpus)
+// : LoadServer(1, 1)
{
mask = 0;
+ temp = 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();
- }
+ delete mask;
+ delete temp;
+ for( int i = 0; i < point_sets.total; i++ )
+ point_sets[i]->remove_all_objects();
point_sets.remove_all_objects();
}
-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;
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( 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; }
+ MaskPoints new_points;
+ keyframe_set->get_points(&new_points, i,
+ start_position_project, PLAY_FORWARD);
+ if( !points_equivalent(&new_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 ) {
+ 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);
+ edges.remove_all_objects();
+ faders.remove_all();
+ feathers.remove_all();
+ fade[0] = 0;
+
+ 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);
+ MaskPoints *new_points = new MaskPoints();
+ 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;
+ edge->load(*new_points, 0);
}
+// 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
- step = DO_MASK;
- process_packages();
- step = DO_Y_FEATHER;
- process_packages();
- step = DO_X_FEATHER;
- process_packages();
step = DO_APPLY;
process_packages();
SET_TRACE
-
-
}
void MaskEngine::init_packages()