4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "bcsignals.h"
23 #include "condition.h"
26 #include "maskautos.h"
27 #include "maskengine.h"
29 #include "transportque.inc"
36 MaskPackage::MaskPackage()
40 MaskPackage::~MaskPackage()
44 MaskUnit::MaskUnit(MaskEngine *engine)
47 this->engine = engine;
53 if( temp ) delete temp;
59 void MaskUnit::draw_line_clamped(VFrame *frame,
60 int x1, int y1, int x2, int y2, unsigned char k)
66 draw_x1 = x2; draw_y1 = y2;
67 draw_x2 = x1; draw_y2 = y1;
70 draw_x1 = x1; draw_y1 = y1;
71 draw_x2 = x2; draw_y2 = y2;
74 unsigned char **rows = (unsigned char**)frame->get_rows();
76 if( draw_y2 != draw_y1 ) {
77 float slope = ((float)draw_x2 - draw_x1) / ((float)draw_y2 - draw_y1);
78 int w = frame->get_w() - 1;
79 int h = frame->get_h();
81 for( float y = draw_y1; y < draw_y2; y++ ) {
82 if( y >= 0 && y < h ) {
83 int x = (int)((y - draw_y1) * slope + draw_x1);
85 int x_i = CLIP(x, 0, w);
87 if( rows[y_i][x_i] == k )
96 void MaskUnit::blur_strip(double *val_p, double *val_m,
97 double *dst, double *src, int size, int max)
100 double *sp_m = src + size - 1;
102 double *vm = val_m + size - 1;
103 double initial_p = sp_p[0];
104 double initial_m = sp_m[0];
106 //printf("MaskUnit::blur_strip %d\n", size);
107 for( int k = 0; k < size; k++ ) {
108 int terms = (k < 4) ? k : 4;
110 for( l = 0; l <= terms; l++ ) {
111 *vp += n_p[l] * sp_p[-l] - d_p[l] * vp[-l];
112 *vm += n_m[l] * sp_m[l] - d_m[l] * vm[l];
115 for( ; l <= 4; l++) {
116 *vp += (n_p[l] - bd_p[l]) * initial_p;
117 *vm += (n_m[l] - bd_m[l]) * initial_m;
123 for( int i = 0; i < size; i++ ) {
124 double sum = val_p[i] + val_m[i];
130 void MaskUnit::do_feather(VFrame *output, VFrame *input, double feather,
131 int start_y, int end_y, int start_x, int end_x)
133 //printf("MaskUnit::do_feather %f\n", feather);
137 double std_dev = sqrt(-(double)(feather * feather) / (2 * log(1.0 / 255.0)));
138 div = sqrt(2 * M_PI) * std_dev;
139 constants[0] = -1.783 / std_dev;
140 constants[1] = -1.723 / std_dev;
141 constants[2] = 0.6318 / std_dev;
142 constants[3] = 1.997 / std_dev;
143 constants[4] = 1.6803 / div;
144 constants[5] = 3.735 / div;
145 constants[6] = -0.6803 / div;
146 constants[7] = -0.2598 / div;
148 n_p[0] = constants[4] + constants[6];
149 n_p[1] = exp(constants[1]) *
150 (constants[7] * sin(constants[3]) -
151 (constants[6] + 2 * constants[4]) * cos(constants[3])) +
153 (constants[5] * sin(constants[2]) -
154 (2 * constants[6] + constants[4]) * cos(constants[2]));
156 n_p[2] = 2 * exp(constants[0] + constants[1]) *
157 ((constants[4] + constants[6]) * cos(constants[3]) *
158 cos(constants[2]) - constants[5] *
159 cos(constants[3]) * sin(constants[2]) -
160 constants[7] * cos(constants[2]) * sin(constants[3])) +
161 constants[6] * exp(2 * constants[0]) +
162 constants[4] * exp(2 * constants[1]);
164 n_p[3] = exp(constants[1] + 2 * constants[0]) *
165 (constants[7] * sin(constants[3]) -
166 constants[6] * cos(constants[3])) +
167 exp(constants[0] + 2 * constants[1]) *
168 (constants[5] * sin(constants[2]) - constants[4] *
173 d_p[1] = -2 * exp(constants[1]) * cos(constants[3]) -
174 2 * exp(constants[0]) * cos(constants[2]);
176 d_p[2] = 4 * cos(constants[3]) * cos(constants[2]) *
177 exp(constants[0] + constants[1]) +
178 exp(2 * constants[1]) + exp (2 * constants[0]);
180 d_p[3] = -2 * cos(constants[2]) * exp(constants[0] + 2 * constants[1]) -
181 2 * cos(constants[3]) * exp(constants[1] + 2 * constants[0]);
183 d_p[4] = exp(2 * constants[0] + 2 * constants[1]);
185 for( int i = 0; i < 5; i++ ) d_m[i] = d_p[i];
188 for( int i = 1; i <= 4; i++ )
189 n_m[i] = n_p[i] - d_p[i] * n_p[0];
191 double sum_n_p, sum_n_m, sum_d;
197 for( int i = 0; i < 5; i++ ) {
203 a = sum_n_p / (1 + sum_d);
204 b = sum_n_m / (1 + sum_d);
206 for( int i = 0; i < 5; i++ ) {
207 bd_p[i] = d_p[i] * a;
208 bd_m[i] = d_m[i] * b;
210 #define DO_FEATHER(type, max) { \
211 int frame_w = input->get_w(); \
212 int frame_h = input->get_h(); \
213 int size = MAX(frame_w, frame_h); \
214 double *src = new double[size]; \
215 double *dst = new double[size]; \
216 double *val_p = new double[size]; \
217 double *val_m = new double[size]; \
218 type **in_rows = (type**)input->get_rows(); \
219 type **out_rows = (type**)output->get_rows(); \
222 /* printf("DO_FEATHER 1\n"); */ \
223 if( end_x > start_x ) { \
224 for( j = start_x; j < end_x; j++ ) { \
225 /* printf("DO_FEATHER 1.1 %d\n", j); */ \
226 bzero(val_p, sizeof(double) * frame_h); \
227 bzero(val_m, sizeof(double) * frame_h); \
228 for( int k = 0; k < frame_h; k++ ) { \
229 src[k] = (double)in_rows[k][j]; \
231 blur_strip(val_p, val_m, dst, src, frame_h, max); \
232 for( int k = 0; k < frame_h; k++ ) { \
233 out_rows[k][j] = (type)dst[k]; \
237 if( end_y > start_y ) { \
238 for( j = start_y; j < end_y; j++ ) { \
239 /* printf("DO_FEATHER 2 %d\n", j); */ \
240 bzero(val_p, sizeof(double) * frame_w); \
241 bzero(val_m, sizeof(double) * frame_w); \
242 for( int k = 0; k < frame_w; k++ ) { \
243 src[k] = (double)out_rows[j][k]; \
245 blur_strip(val_p, val_m, dst, src, frame_w, max); \
246 for( int k = 0; k < frame_w; k++ ) { \
247 out_rows[j][k] = (type)dst[k]; \
251 /* printf("DO_FEATHER 3\n"); */ \
256 /* printf("DO_FEATHER 4\n"); */ \
259 //printf("do_feather %d\n", frame->get_color_model());
260 switch( input->get_color_model() ) {
262 DO_FEATHER(unsigned char, 0xff);
265 DO_FEATHER(uint16_t, 0xffff);
268 DO_FEATHER(float, 1);
273 void MaskUnit::process_package(LoadPackage *package)
275 MaskPackage *ptr = (MaskPackage*)package;
276 float engine_value = engine->value;
277 int engine_mode = engine->mode;
279 if( engine->recalculate && engine->step == DO_MASK ) {
280 VFrame *mask = engine->feather > 0 ? engine->temp_mask : engine->mask;
281 // Generated oversampling frame
282 int mask_w = mask->get_w();
283 //int mask_h = mask->get_h();
284 int oversampled_package_w = mask_w * OVERSAMPLE;
285 int oversampled_package_h = (ptr->end_y - ptr->start_y) * OVERSAMPLE;
287 (temp->get_w() != oversampled_package_w ||
288 temp->get_h() != oversampled_package_h) ) {
289 delete temp; temp = 0;
292 temp = new VFrame(oversampled_package_w, oversampled_package_h, BC_A8, 0);
295 // Draw oversampled region of polygons on temp
296 for( int k=0; k<engine->point_sets.total; ++k ) {
298 unsigned char max = k + 1;
299 ArrayList<MaskPoint*> *points = engine->point_sets.values[k];
301 if( points->total < 3 ) continue;
302 //printf("MaskUnit::process_package 2 %d %d\n", k, points->total);
303 for( int i=0; i<points->total; ++i ) {
304 MaskPoint *point1 = points->values[i];
305 MaskPoint *point2 = (i >= points->total - 1) ?
307 points->values[i + 1];
310 int segments = (int)(sqrt(SQR(point1->x - point2->x) + SQR(point1->y - point2->y)));
311 if( point1->control_x2 == 0 &&
312 point1->control_y2 == 0 &&
313 point2->control_x1 == 0 &&
314 point2->control_y1 == 0 )
316 float x0 = point1->x;
317 float y0 = point1->y;
318 float x1 = point1->x + point1->control_x2;
319 float y1 = point1->y + point1->control_y2;
320 float x2 = point2->x + point2->control_x1;
321 float y2 = point2->y + point2->control_y1;
322 float x3 = point2->x;
323 float y3 = point2->y;
325 for( int j = 0; j <= segments; j++ ) {
326 float t = (float)j / segments;
328 float tpow3 = t * t * t;
330 float invtpow2 = invt * invt;
331 float invtpow3 = invt * invt * invt;
334 + 3 * t * invtpow2 * x1
335 + 3 * tpow2 * invt * x2
338 + 3 * t * invtpow2 * y1
339 + 3 * tpow2 * invt * y2
347 draw_line_clamped(temp, old_x, old_y, (int)x, (int)y, max);
354 // Fill in the polygon in the horizontal direction
355 for( int i=0; i<oversampled_package_h; ++i ) {
356 unsigned char *row = (unsigned char*)temp->get_rows()[i];
357 int value = 0, total = 0;
359 for( int j=0; j<oversampled_package_w; ++j )
360 if( row[j] == max ) ++total;
363 if( total & 0x1 ) --total;
364 for( int j=0; j<oversampled_package_w; ++j ) {
365 if( row[j]==max && total>0 ) {
367 value = value ? 0 : max;
375 #define DOWNSAMPLE(type, temp_type, value, v) do { \
376 for( int y=0; y<ptr->end_y-ptr->start_y; ++y ) { \
377 type *output_row = (type*)mask->get_rows()[y + ptr->start_y]; \
378 unsigned char **input_rows = (unsigned char**)temp->get_rows() + y * OVERSAMPLE; \
379 for( int x=0; x<mask_w; ++x ) { \
380 temp_type total = 0; \
381 /* Accumulate pixel */ \
382 for( int k=0; k<OVERSAMPLE; ++k ) { \
383 unsigned char *input_vector = input_rows[k] + x * OVERSAMPLE; \
384 for( int l=0; l<OVERSAMPLE; ++l ) { \
385 total += (input_vector[l] ? value : 0); \
389 total /= OVERSAMPLE * OVERSAMPLE; \
394 if( engine_value < 0 ) {
395 engine_value = -engine_value;
396 engine_mode = 1-engine_mode;
398 // Downsample polygon
399 switch( mask->get_color_model() ) {
402 value = (int)(engine_value / 100 * 0xff);
403 if( engine->value >= 0 )
404 DOWNSAMPLE(unsigned char, int64_t, value, total);
406 DOWNSAMPLE(unsigned char, int64_t, value, value-total);
411 value = (int)(engine_value / 100 * 0xffff);
412 if( engine->value >= 0 )
413 DOWNSAMPLE(uint16_t, int64_t, value, total);
415 DOWNSAMPLE(uint16_t, int64_t, value, value-total);
420 value = engine_value / 100;
421 if( engine->value >= 0 )
422 DOWNSAMPLE(float, double, value, total);
424 DOWNSAMPLE(float, double, value, value-total);
429 if( engine->step == DO_X_FEATHER && engine->recalculate && // Feather polygon
430 engine->feather > 0 ) {
431 do_feather(engine->mask,
432 engine->temp_mask, engine->feather,
433 ptr->start_y, ptr->end_y, 0, 0);
434 //printf("MaskUnit::process_package 3 %f\n", engine->feather);
437 if( engine->step == DO_Y_FEATHER && engine->recalculate && // Feather polygon
438 engine->feather > 0 ) {
439 do_feather(engine->mask,
440 engine->temp_mask, engine->feather,
441 0, 0, ptr->start_x, ptr->end_x);
444 if( engine->step == DO_APPLY ) { // Apply mask
445 #define APPLY_MASK_ALPHA(cmodel, type, max, components, do_yuv, a, b) \
447 for( int y=ptr->start_y; y<ptr->end_y; ++y ) { \
448 type *output_row = (type*)engine->output->get_rows()[y]; \
449 type *mask_row = (type*)engine->mask->get_rows()[y]; \
450 int chroma_offset = (int)(max + 1) / 2; \
451 for( int x=0; x<mask_w; ++x ) { \
452 int m = mask_row[x], n = max-m; \
453 if( components == 4 ) { \
454 output_row[x*4 + 3] = output_row[x*4 + 3]*a / max; \
457 output_row[x*3 + 0] = output_row[x*3 + 0]*a / max; \
458 output_row[x*3 + 1] = output_row[x*3 + 1]*a / max; \
459 output_row[x*3 + 2] = output_row[x*3 + 2]*a / max; \
461 output_row[x*3 + 1] += chroma_offset*b / max; \
462 output_row[x*3 + 2] += chroma_offset*b / max; \
468 #define MASK_ALPHA(mode, a, b) \
470 switch( engine->output->get_color_model() ) { \
471 APPLY_MASK_ALPHA(BC_RGB888, unsigned char, 0xff, 3, 0, a, b); \
472 APPLY_MASK_ALPHA(BC_RGB_FLOAT, float, 1.0, 3, 0, a, b); \
473 APPLY_MASK_ALPHA(BC_YUV888, unsigned char, 0xff, 3, 1, a, b); \
474 APPLY_MASK_ALPHA(BC_RGBA_FLOAT, float, 1.0, 4, 0, a, b); \
475 APPLY_MASK_ALPHA(BC_YUVA8888, unsigned char, 0xff, 4, 1, a, b); \
476 APPLY_MASK_ALPHA(BC_RGBA8888, unsigned char, 0xff, 4, 0, a, b); \
477 APPLY_MASK_ALPHA(BC_RGB161616, uint16_t, 0xffff, 3, 0, a, b); \
478 APPLY_MASK_ALPHA(BC_YUV161616, uint16_t, 0xffff, 3, 1, a, b); \
479 APPLY_MASK_ALPHA(BC_YUVA16161616, uint16_t, 0xffff, 4, 1, a, b); \
480 APPLY_MASK_ALPHA(BC_RGBA16161616, uint16_t, 0xffff, 4, 0, a, b); \
483 //printf("MaskUnit::process_package 1 %d\n", engine->mode);
484 int mask_w = engine->mask->get_w();
485 switch( engine_mode ) {
486 MASK_ALPHA(MASK_MULTIPLY_ALPHA, m, n);
487 MASK_ALPHA(MASK_SUBTRACT_ALPHA, n, m);
493 MaskEngine::MaskEngine(int cpus)
494 : LoadServer(cpus, cpus * OVERSAMPLE * 2)
495 // : LoadServer(1, OVERSAMPLE * 2)
500 MaskEngine::~MaskEngine()
507 for( int i = 0; i < point_sets.total; i++ ) {
508 ArrayList<MaskPoint*> *points = point_sets.values[i];
509 points->remove_all_objects();
511 point_sets.remove_all_objects();
514 int MaskEngine::points_equivalent(ArrayList<MaskPoint*> *new_points,
515 ArrayList<MaskPoint*> *points)
517 //printf("MaskEngine::points_equivalent %d %d\n", new_points->total, points->total);
518 if( new_points->total != points->total ) return 0;
520 for( int i = 0; i < new_points->total; i++ ) {
521 if( !(*new_points->values[i] == *points->values[i]) ) return 0;
527 void MaskEngine::do_mask(VFrame *output,
528 int64_t start_position_project,
529 MaskAutos *keyframe_set,
531 MaskAuto *default_auto)
533 int new_color_model = 0;
536 switch( output->get_color_model() ) {
539 new_color_model = BC_A_FLOAT;
546 new_color_model = BC_A8;
550 case BC_RGBA16161616:
552 case BC_YUVA16161616:
553 new_color_model = BC_A16;
557 // Determine if recalculation is needed
561 (mask->get_w() != output->get_w() ||
562 mask->get_h() != output->get_h() ||
563 mask->get_color_model() != new_color_model) ) {
571 if( point_sets.total != keyframe_set->total_submasks(start_position_project,
577 for( int i=0,n=keyframe_set->total_submasks(start_position_project, PLAY_FORWARD);
578 i<n && !recalculate; ++i ) {
579 ArrayList<MaskPoint*> new_points;
580 keyframe_set->get_points(&new_points, i,
581 start_position_project, PLAY_FORWARD);
582 if( !points_equivalent(&new_points, point_sets.values[i]) )
584 new_points.remove_all_objects();
588 int new_value = keyframe_set->get_value(start_position_project,
590 float new_feather = keyframe_set->get_feather(start_position_project,
594 !EQUIV(new_feather, feather) ||
595 !EQUIV(new_value, value) ) {
598 mask = new VFrame(output->get_w(), output->get_h(),
600 temp_mask = new VFrame(output->get_w(), output->get_h(),
603 if( new_feather > 0 )
604 temp_mask->clear_frame();
608 for( int i = 0; i < point_sets.total; i++ ) {
609 ArrayList<MaskPoint*> *points = point_sets.values[i];
610 points->remove_all_objects();
612 point_sets.remove_all_objects();
615 i < keyframe_set->total_submasks(start_position_project,
618 ArrayList<MaskPoint*> *new_points = new ArrayList<MaskPoint*>;
619 keyframe_set->get_points(new_points,
621 start_position_project,
623 point_sets.append(new_points);
629 this->output = output;
630 this->mode = default_auto->mode;
631 this->feather = new_feather;
632 this->value = new_value;
650 void MaskEngine::init_packages()
653 //printf("MaskEngine::init_packages 1\n");
654 int x0 = 0, y0 = 0, i = 0, n = get_total_packages();
655 int out_w = output->get_w(), out_h = output->get_h();
658 MaskPackage *ptr = (MaskPackage*)get_package(i++);
659 int x1 = (out_w * i) / n, y1 = (out_h * i) / n;
660 ptr->start_x = x0; ptr->end_x = x1;
661 ptr->start_y = y0; ptr->end_y = y1;
665 //printf("MaskEngine::init_packages 2\n");
668 LoadClient* MaskEngine::new_client()
670 return new MaskUnit(this);
673 LoadPackage* MaskEngine::new_package()
675 return new MaskPackage;