Andrew contribution to add preference method for Fast/Slow speed
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / descratch / descratch.C
1 /*
2 DeScratch - Scratches Removing Filter
3 Plugin for Avisynth 2.5
4 Copyright (c)2003-2016 Alexander G. Balakhnin aka Fizick
5 bag@hotmail.ru  http://avisynth.org.ru
6
7 This program is FREE software under GPL licence v2.
8
9 This plugin removes vertical scratches from digitized films.
10 Reworked for cin5 by GG. 03/2018, from the laws of Fizick's
11 Adapted strategy to mark, test, draw during port.
12 */
13
14
15 #include "clip.h"
16 #include "filexml.h"
17 #include "language.h"
18 #include "descratch.h"
19
20 #include <math.h>
21
22 REGISTER_PLUGIN(DeScratchMain)
23
24 DeScratchMain::DeScratchMain(PluginServer *server)
25  : PluginVClient(server)
26 {
27         inf = 0;  sz_inf = 0;
28         src = 0;  dst = 0;
29         tmpy = 0; blury = 0;
30         overlay_frame = 0;
31 }
32
33 DeScratchMain::~DeScratchMain()
34 {
35         delete [] inf;
36         delete src;
37         delete dst;
38         delete blury;
39         delete tmpy;
40         delete overlay_frame;
41 }
42
43 const char* DeScratchMain::plugin_title() { return N_("DeScratch"); }
44 int DeScratchMain::is_realtime() { return 1; }
45
46 void DeScratchConfig::reset()
47 {
48         threshold = 12;
49         asymmetry = 25;
50         min_width = 1;
51         max_width = 2;
52         min_len = 10;
53         max_len = 100;
54         max_angle = 5;
55         blur_len = 2;
56         gap_len = 0;
57         mode_y = MODE_ALL;
58         mode_u = MODE_NONE;
59         mode_v = MODE_NONE;
60         mark = 0;
61         ffade = 100;
62         border = 2;
63         edge_only = 0;
64 }
65
66 DeScratchConfig::DeScratchConfig()
67 {
68         reset();
69 }
70
71 DeScratchConfig::~DeScratchConfig()
72 {
73 }
74
75 int DeScratchConfig::equivalent(DeScratchConfig &that)
76 {
77         return threshold == that.threshold &&
78                 asymmetry == that.asymmetry &&
79                 min_width == that.min_width &&
80                 max_width == that.max_width &&
81                 min_len == that.min_len &&
82                 max_len == that.max_len &&
83                 max_angle == that.max_angle &&
84                 blur_len == that.blur_len &&
85                 gap_len == that.gap_len &&
86                 mode_y == that.mode_y &&
87                 mode_u == that.mode_u &&
88                 mode_v == that.mode_v &&
89                 mark == that.mark &&
90                 ffade == that.ffade &&
91                 border == that.border &&
92                 edge_only == that.edge_only;
93 }
94 void DeScratchConfig::copy_from(DeScratchConfig &that)
95 {
96         threshold = that.threshold;
97         asymmetry = that.asymmetry;
98         min_width = that.min_width;
99         max_width = that.max_width;
100         min_len = that.min_len;
101         max_len = that.max_len;
102         max_angle = that.max_angle;
103         blur_len = that.blur_len;
104         gap_len = that.gap_len;
105         mode_y = that.mode_y;
106         mode_u = that.mode_u;
107         mode_v = that.mode_v;
108         mark = that.mark;
109         ffade = that.ffade;
110         border = that.border;
111         edge_only = that.edge_only;
112 }
113
114 void DeScratchConfig::interpolate(DeScratchConfig &prev, DeScratchConfig &next,
115                 int64_t prev_frame, int64_t next_frame, int64_t current_frame)
116 {
117         copy_from(prev);
118 }
119
120 LOAD_CONFIGURATION_MACRO(DeScratchMain, DeScratchConfig)
121
122 void DeScratchMain::save_data(KeyFrame *keyframe)
123 {
124         FileXML output;
125 // cause data to be stored directly in text
126         output.set_shared_output(keyframe->xbuf);
127 // Store data
128         output.tag.set_title("DESCRATCH");
129         output.tag.set_property("THRESHOLD", config.threshold);
130         output.tag.set_property("ASYMMETRY", config.asymmetry);
131         output.tag.set_property("MIN_WIDTH", config.min_width);
132         output.tag.set_property("MAX_WIDTH", config.max_width);
133         output.tag.set_property("MIN_LEN", config.min_len);
134         output.tag.set_property("MAX_LEN", config.max_len);
135         output.tag.set_property("MAX_ANGLE", config.max_angle);
136         output.tag.set_property("BLUR_LEN", config.blur_len);
137         output.tag.set_property("GAP_LEN", config.gap_len);
138         output.tag.set_property("MODE_Y", config.mode_y);
139         output.tag.set_property("MODE_U", config.mode_u);
140         output.tag.set_property("MODE_V", config.mode_v);
141         output.tag.set_property("MARK", config.mark);
142         output.tag.set_property("FFADE", config.ffade);
143         output.tag.set_property("BORDER", config.border);
144         output.tag.set_property("EDGE_ONLY", config.edge_only);
145         output.append_tag();
146         output.tag.set_title("/DESCRATCH");
147         output.append_tag();
148         output.append_newline();
149         output.terminate_string();
150 }
151
152 void DeScratchMain::read_data(KeyFrame *keyframe)
153 {
154         FileXML input;
155         input.set_shared_input(keyframe->xbuf);
156
157         int result = 0;
158
159         while( !(result = input.read_tag()) ) {
160                 if(input.tag.title_is("DESCRATCH")) {
161                         config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
162                         config.asymmetry = input.tag.get_property("ASYMMETRY", config.asymmetry);
163                         config.min_width = input.tag.get_property("MIN_WIDTH", config.min_width);
164                         config.max_width = input.tag.get_property("MAX_WIDTH", config.max_width);
165                         config.min_len   = input.tag.get_property("MIN_LEN", config.min_len);
166                         config.max_len   = input.tag.get_property("MAX_LEN", config.max_len);
167                         config.max_angle = input.tag.get_property("MAX_ANGLE", config.max_angle);
168                         config.blur_len  = input.tag.get_property("BLUR_LEN", config.blur_len);
169                         config.gap_len   = input.tag.get_property("GAP_LEN", config.gap_len);
170                         config.mode_y    = input.tag.get_property("MODE_Y", config.mode_y);
171                         config.mode_u    = input.tag.get_property("MODE_U", config.mode_u);
172                         config.mode_v    = input.tag.get_property("MODE_V", config.mode_v);
173                         config.mark      = input.tag.get_property("MARK", config.mark);
174                         config.ffade     = input.tag.get_property("FFADE", config.ffade);
175                         config.border    = input.tag.get_property("BORDER", config.border);
176                         config.edge_only = input.tag.get_property("EDGE_ONLY", config.edge_only);
177                 }
178         }
179 }
180
181 void DeScratchMain::set_extrems_plane(int width, int comp, int thresh)
182 {
183         uint8_t **rows = blury->get_rows();
184         int r = width, r1 = r+1, wd = src_w - r1;
185         int bpp = 3, dsz = r * bpp;
186         int asym = config.asymmetry * 256 / 100;
187         if( thresh > 0 ) {      // black (low value) scratches
188                 for( int y=0; y<src_h; ++y ) {
189                         uint8_t *ip = inf + y*src_w + r1;
190                         uint8_t *dp = rows[y] + r1*bpp + comp;
191                         for( int x=r1; x<wd; ++x,++ip,dp+=bpp ) {
192                                 if( *ip != SD_NULL ) continue;
193                                 uint8_t *lp = dp-dsz, *rp = dp+dsz;
194                                 if( (lp[0]-*dp) > thresh && (rp[0]-*dp) > thresh &&
195                                     (abs(lp[-bpp]-rp[+bpp]) <= asym) &&
196                                     ((lp[0]-lp[+bpp]) + (rp[0]-rp[-bpp]) >
197                                      (lp[-bpp]-lp[0]) + (rp[bpp]-rp[0])) ) {
198                                         *ip = SD_EXTREM;
199                                         for( int i=1; i<r; ++i ) ip[i] = ip[-i] = SD_EXTREM;
200                                 }
201                         }
202                 }
203         }
204         else {                  // white (high value) scratches
205                 for( int y=0; y<src_h; ++y ) {
206                         uint8_t *ip = inf + y*src_w + r1;
207                         uint8_t *dp = rows[y] + r1*bpp + comp;
208                         for( int x=r1; x<wd; ++x,++ip,dp+=bpp ) {
209                                 if( *ip != SD_NULL ) continue;
210                                 uint8_t *lp = dp-dsz, *rp = dp+dsz;
211                                 if( (lp[0]-*dp) < thresh && (rp[0]-*dp) < thresh &&
212                                     (abs(lp[-bpp]-rp[+bpp]) <= asym) &&
213                                     ((lp[0]-lp[+bpp]) + (rp[0]-rp[-bpp]) <
214                                      (lp[-bpp]-lp[0]) + (rp[bpp]-rp[0])) ) {
215                                         *ip = SD_EXTREM;
216                                         for( int i=1; i<r; ++i ) ip[i] = ip[-i] = SD_EXTREM;
217                                 }
218                         }
219                 }
220         }
221 }
222
223 //
224 void DeScratchMain::close_gaps()
225 {
226         int len = config.gap_len * src_h / 100;
227         for( int y=0; y<src_h; ++y ) {
228                 uint8_t *ip = inf + y*src_w;
229                 for( int x=0; x<src_w; ++x,++ip ) {
230                         if( !(*ip & SD_EXTREM) ) continue;
231                         uint8_t *bp = ip, b = *bp;              // expand to previous lines in range
232                         int i = len < y ? len : y;
233                         while( --i>=0 ) *(bp-=src_w) = b;
234                 }
235         }
236 }
237
238 void DeScratchMain::test_scratches()
239 {
240         int w2 = src_w - 2;
241         int min_len = config.min_len * src_h / 100;
242         int max_len = config.max_len * src_h / 100;
243         int maxwidth = config.max_width;
244         float sin_mxa = sin(config.max_angle * M_PI/180.);
245
246         for( int y=0; y<src_h; ++y ) {
247                 for( int x=2; x<w2; ++x ) {
248                         int ofs = y*src_w + x;                  // first candidate
249                         if( !(inf[ofs] & SD_EXTREM) ) continue;
250                         int ctr = ofs, nctr = ctr;
251                         int hy = src_h - y, len;
252                         for( len=0; len<hy; ++len ) {           // check vertical aspect
253                                 uint8_t *ip = inf + ctr;
254                                 int n = 0;                      // number good points in row
255                                 if( ip[-1] & SD_EXTREM ) { ip[-1] |= SD_TESTED; nctr = ctr-1; ++n; }
256                                 if( ip[+1] & SD_EXTREM ) { ip[+1] |= SD_TESTED; nctr = ctr+1; ++n; }
257                                 if( ip[+0] & SD_EXTREM ) { ip[+0] |= SD_TESTED; nctr = ctr+0; ++n; }
258                                 if( !n ) break;
259                                 ctr = nctr + src_w;             // new center for next row test
260                         }
261                         int v = (!config.edge_only || y == 0 || y+len>=src_h) &&
262                                 abs(nctr%src_w - x) < maxwidth + len*sin_mxa &&
263                                 len >= min_len && len <= max_len ? SD_GOOD : SD_REJECT;
264                         ctr = ofs; nctr = ctr;                  // pass2
265                         for( len=0; len<hy; ++len ) {           // cycle along inf
266                                 uint8_t *ip = inf + ctr;
267                                 int n = 0;                      // number good points in row
268                                 if( ip[-1] & SD_TESTED ) { ip[-1] = v; nctr = ctr-1; ++n; }
269                                 if( ip[+1] & SD_TESTED ) { ip[+1] = v; nctr = ctr+1; ++n; }
270                                 if( ip[+0] & SD_TESTED ) { ip[+0] = v; nctr = ctr+0; ++n; }
271                                 if( !n ) break;
272                                 ctr = nctr + src_w;             // new center for next row test
273                         }
274                 }
275         }
276 }
277
278 void DeScratchMain::mark_scratches_plane()
279 {
280         int bpp = 3, dst_w = dst->get_w(), dst_h = dst->get_h();
281         uint8_t **rows = dst->get_rows();
282         for( int y=0; y<dst_h; ++y ) {
283                 uint8_t *ip = inf + y*src_w;
284                 for( int x=0; x<dst_w; ++x,++ip ) {
285                         if( *ip == SD_NULL ) continue;
286                         static uint8_t grn_yuv[3] = { 0xad, 0x28, 0x19, };
287                         static uint8_t ylw_yuv[3] = { 0xdb, 0x0f, 0x89, };
288                         static uint8_t red_yuv[3] = { 0x40, 0x66, 0xef, };
289                         for( int comp=0; comp<3; ++comp ) {
290                                 uint8_t *dp = rows[y] + comp + x*bpp;
291                                 if( *ip & SD_GOOD )
292                                         *dp = config.threshold > 0 ? grn_yuv[comp] : red_yuv[comp];
293                                 else if( *ip & SD_REJECT )
294                                         *dp = ylw_yuv[comp];
295                         }
296                 }
297         }
298 }
299
300 void DeScratchMain::remove_scratches_plane(int comp)
301 {
302         int bpp = 3, w1 = src_w-1;
303         int border = config.border;
304         uint8_t *ip = inf;
305         uint8_t **dst_rows = dst->get_rows();
306         uint8_t **blur_rows = blury->get_rows();
307         float a = config.ffade / 100, b = 1 - a;
308
309         for( int y=0; y<src_h; ++y ) {
310                 int left = -1;
311                 uint8_t *out = dst_rows[y] + comp;
312                 uint8_t *blur = blur_rows[y] + comp;
313                 for( int x=1; x<w1; ++x ) {
314                         uint8_t *dp = ip + x;
315                         if( !(dp[-1]&SD_GOOD) && (dp[0]&SD_GOOD) ) left = x;
316                         if( left < 0 || !(dp[0]&SD_GOOD) || (dp[1]&SD_GOOD) ) continue;
317                         int right = x;
318                         int ctr = (left + right) / 2;                   // scratch center
319                         int r = (right - left + border) / 2 + 1;
320                         left = 0;
321                         int ls = ctr - r, rs = ctr + r;                 // scratch edges
322                         int lt = ls - border, rt = rs + border;         // border edges
323                         if( ls < 0 ) ls = 0;
324                         if( rs > w1 ) rs = w1;
325                         if( lt < 0 ) lt = 0;
326                         if( rt > w1 ) rt = w1;
327                         ls *= bpp;  rs *= bpp;
328                         lt *= bpp;  rt *= bpp;
329                         if( rs > ls ) {
330                                 float s = 1. / (rs - ls);
331                                 for( int i=ls; (i+=bpp)<rs; ) {         // across the scratch
332                                         int lv = a * blur[ls] + b * out[i];
333                                         int rv = a * blur[rs] + b * out[i];
334                                         int v = s * (lv*(rs-i) + rv*(i-ls));
335                                         out[i] = CLIP(v, 0, 255);
336                                 }
337                         }
338                         if( !border ) continue;
339                         if( ls > lt ) {
340                                 float s = 1. / (ls - lt);
341                                 for( int i=lt; (i+=bpp)<=ls; ) {        // at left border
342                                         int lv = a * out[lt] + b * out[i];
343                                         int rv = a * blur[i] + b * out[i];
344                                         int v = s * (lv*(ls-i) + rv*(i-lt));
345                                         out[i] = CLIP(v, 0, 255);
346                                 }
347                         }
348                         if( rt > rs ) {
349                                 float s = 1. / (rt - rs);
350                                 for( int i=rt; (i-=bpp)>=rs; ) {        // at right border
351                                         int lv = a * blur[i] + b * out[i];
352                                         int rv = a * out[rt] + b * out[i];
353                                         int v = s * (rv*(i-rs) + lv*(rt-i));
354                                         out[i] = CLIP(v, 0, 255);
355                                 }
356                         }
357                 }
358                 ip += src_w;
359         }
360 }
361
362 void DeScratchMain::blur(int scale)
363 {
364         int th = (src_h / scale) & ~1;
365         if( tmpy&& (tmpy->get_w() != src_w || tmpy->get_h() != th) ) {
366                 delete tmpy;  tmpy= 0;
367         }
368         if( !tmpy ) tmpy = new VFrame(src_w, th, BC_YUV888);
369         if( blury && (blury->get_w() != src_w || blury->get_h() != src_h) ) {
370                 delete blury;  blury= 0;
371         }
372         if( !blury ) blury = new VFrame(src_w, src_h, BC_YUV888);
373         overlay_frame->overlay(tmpy, src,
374                 0,0,src_w,src_h, 0,0,src_w,th, 1.f, TRANSFER_NORMAL, LINEAR_LINEAR);
375         overlay_frame->overlay(blury, tmpy,
376                 0,0,src_w,th, 0,0,src_w,src_h, 1.f, TRANSFER_NORMAL, CUBIC_CUBIC);
377 }
378
379 void DeScratchMain::copy(int comp)
380 {
381         uint8_t **src_rows = src->get_rows();
382         uint8_t **dst_rows = dst->get_rows();
383         for( int y=0; y<src_h; ++y ) {
384                 uint8_t *sp = src_rows[y] + comp, *dp = dst_rows[y] + comp;
385                 for( int x=0; x<src_w; ++x,sp+=3,dp+=3 ) *sp = *dp;
386         }
387 }
388
389 void DeScratchMain::pass(int comp, int thresh)
390 {
391 // pass for current plane and current sign
392         int w0 = config.min_width, w1 = config.max_width;
393         if( w1 < w0 ) w1 = w0;
394         for( int iw=w0; iw<=w1; ++iw )
395                 set_extrems_plane(iw, comp, thresh);
396 }
397
398 void DeScratchMain::plane_pass(int comp, int mode)
399 {
400         int threshold = config.threshold;
401         if( comp != 0 ) threshold /= 2;  // fakey UV scaling
402         switch( mode ) {
403         case MODE_ALL:
404                 pass(comp, threshold);
405                 copy(comp);
406         case MODE_HIGH:         // fall thru
407                 threshold = -threshold;
408         case MODE_LOW:          // fall thru
409                 pass(comp, threshold);
410                 break;
411         }
412 }
413
414 void DeScratchMain::plane_proc(int comp, int mode)
415 {
416         if( mode == MODE_NONE ) return;
417         remove_scratches_plane(comp);
418 }
419
420 int DeScratchMain::process_realtime(VFrame *input, VFrame *output)
421 {
422         load_configuration();
423         src_w = input->get_w();
424         src_h = input->get_h();
425         if( src_w >= 2*config.max_width+3 ) {
426                 if( !overlay_frame ) {
427                         int cpus = PluginClient::smp + 1;
428                         if( cpus > 8 ) cpus = 8;
429                         overlay_frame = new OverlayFrame(cpus);
430                 }
431                 if( src && (src->get_w() != src_w || src->get_h() != src_h) ) {
432                         delete src;  src = 0;
433                 }
434                 if( !src ) src = new VFrame(src_w, src_h, BC_YUV888);
435                 src->transfer_from(input);
436                 if( dst && (dst->get_w() != src_w || dst->get_h() != src_h) ) {
437                         delete dst;  dst = 0;
438                 }
439                 if( !dst ) dst = new VFrame(src_w, src_h, BC_YUV888);
440                 dst->copy_from(src);
441                 int sz = src_w * src_h;
442                 if( sz_inf != sz ) {  delete [] inf;  inf = 0; }
443                 if( !inf ) inf = new uint8_t[sz_inf=sz];
444                 blur(config.blur_len + 1);
445                 memset(inf, SD_NULL, sz_inf);
446                 plane_pass(0, config.mode_y);
447                 plane_pass(1, config.mode_u);
448                 plane_pass(2, config.mode_v);
449                 close_gaps();
450                 test_scratches();
451                 if( !config.mark ) {
452                         plane_proc(0, config.mode_y);
453                         plane_proc(1, config.mode_u);
454                         plane_proc(2, config.mode_v);
455                 }
456                 else
457                         mark_scratches_plane();
458                 output->transfer_from(dst);
459         }
460         return 0;
461 }
462
463 void DeScratchMain::update_gui()
464 {
465         if( !thread ) return;
466         DeScratchWindow *window = (DeScratchWindow *)thread->get_window();
467         window->lock_window("DeScratchMain::update_gui");
468         if( load_configuration() )
469                 window->update_gui();
470         window->unlock_window();
471 }
472
473 NEW_WINDOW_MACRO(DeScratchMain, DeScratchWindow)
474
475
476 DeScratchWindow::DeScratchWindow(DeScratchMain *plugin)
477  : PluginClientWindow(plugin, xS(512), yS(270), xS(512), yS(270), 0)
478 {
479         this->plugin = plugin;
480 }
481
482 DeScratchWindow::~DeScratchWindow()
483 {
484 }
485
486 void DeScratchWindow::create_objects()
487 {
488         int xs10 = xS(10), xs15 = xS(15), xs16 = xS(16);
489         int ys10 = yS(10), ys15 = yS(15);
490         int x = xs10, y = ys10;
491         plugin->load_configuration();
492         DeScratchConfig &config = plugin->config;
493
494         BC_Title *title;
495         add_tool(title = new BC_Title(x, y, _("DeScratch:")));
496
497         int w1 = DeScratchReset::calculate_w(this, _("Reset"));
498         add_tool(reset = new DeScratchReset(this, get_w()-w1-xs15, y));
499
500         y += title->get_h() + ys15;
501         int x1 = x, x2 = get_w()/2;
502         add_tool(title = new BC_Title(x1=x, y, _("threshold:")));
503         x1 += title->get_w()+xs16;
504         add_tool(threshold = new DeScratchISlider(this, x1, y, x2-x1-xs10, 0,64, &config.threshold));
505         add_tool(title = new BC_Title(x1=x2, y, _("asymmetry:")));
506         x1 += title->get_w()+xs16;
507         add_tool(asymmetry = new DeScratchFSlider(this, x1, y, get_w()-x1-xs15, 0,100., &config.asymmetry));
508         y += threshold->get_h() + ys10;
509
510         add_tool(title = new BC_Title(x1=x, y, _("Mode:")));
511         x1 += title->get_w()+xs16;
512         add_tool(title = new BC_Title(x1, y, _("y:")));
513         w1 = title->get_w()+xs16;
514         add_tool(y_mode = new DeScratchMode(this, (x1+=w1), y, &config.mode_y));
515         y_mode->create_objects();  x1 += y_mode->get_w()+xs16;
516         add_tool(title = new BC_Title(x1, y, _("u:")));
517         add_tool(u_mode = new DeScratchMode(this, (x1+=w1), y, &config.mode_u));
518         u_mode->create_objects();  x1 += u_mode->get_w()+xs16;
519         add_tool(title = new BC_Title(x1, y, _("v:")));
520         add_tool(v_mode = new DeScratchMode(this, (x1+=w1), y, &config.mode_v));
521         v_mode->create_objects();
522         y += y_mode->get_h() + ys10;
523
524         add_tool(title = new BC_Title(x1=x, y, _("width:")));
525         w1 = title->get_w()+xs16;  x1 += w1;
526         add_tool(title = new BC_Title(x1, y, _("min:")));
527         x1 += title->get_w()+xs16;
528         add_tool(min_width = new DeScratchISlider(this, x1, y, x2-x1-xs10, 1,16, &config.min_width));
529         add_tool(title = new BC_Title(x1=x2, y, _("max:")));
530         x1 += title->get_w()+xs16;
531         add_tool(max_width = new DeScratchISlider(this, x1, y, get_w()-x1-xs15, 1,16, &config.max_width));
532         y += min_width->get_h() + ys10;
533
534         add_tool(title = new BC_Title(x1=x, y, _("len:")));
535         w1 = title->get_w()+xs16;  x1 += w1;
536         add_tool(title = new BC_Title(x1, y, _("min:")));
537         x1 += title->get_w()+xs16;
538         add_tool(min_len = new DeScratchFSlider(this, x1, y, x2-x1-xs10, 0.0,100.0, &config.min_len));
539         add_tool(title = new BC_Title(x1=x2, y, _("max:")));
540         x1 += title->get_w()+xs16;
541         add_tool(max_len = new DeScratchFSlider(this, x1, y, get_w()-x1-xs15, 0.0,100.0, &config.max_len));
542         y += min_len->get_h() + ys10;
543
544         add_tool(title = new BC_Title(x1=x, y, _("len:")));
545         w1 = title->get_w()+xs16;  x1 += w1;
546         add_tool(title = new BC_Title(x1, y, _("blur:")));
547         x1 += title->get_w()+xs16;
548         add_tool(blur_len = new DeScratchISlider(this, x1, y, x2-x1-xs10, 0,8, &config.blur_len));
549         add_tool(title = new BC_Title(x1=x2, y, _("gap:")));
550         x1 += title->get_w()+xs16;
551         add_tool(gap_len = new DeScratchFSlider(this, x1, y, get_w()-x1-xs15, 0.0,100.0, &config.gap_len));
552         y += blur_len->get_h() + ys10;
553
554         add_tool(title = new BC_Title(x1=x, y, _("max angle:")));
555         w1 = title->get_w()+xs16;  x1 += w1;
556         add_tool(max_angle = new DeScratchFSlider(this, x1, y, x2-x1-xs10, 0.0,15.0, &config.max_angle));
557         add_tool(title = new BC_Title(x1=x2, y, _("fade:")));
558         x1 += title->get_w()+xs16;
559         add_tool(ffade = new DeScratchFSlider(this, x1, y, get_w()-x1-xs15, 0.0,100.0, &config.ffade));
560         y += max_angle->get_h() + ys10;
561
562         add_tool(title = new BC_Title(x1=x, y, _("border:")));
563         x1 += title->get_w()+xs16;
564         add_tool(border = new DeScratchISlider(this, x1, y, x2-x1-xs10, 0,16, &config.border));
565         add_tool(mark = new DeScratchMark(this, x1=x2, y));
566         x1 += mark->get_w() + xs10;
567         add_tool(edge_only = new DeScratchEdgeOnly(this, x1, y));
568
569         show_window();
570 }
571
572 void DeScratchWindow::update_gui()
573 {
574         DeScratchConfig &config = plugin->config;
575         threshold->update(config.threshold);
576         asymmetry->update(config.asymmetry);
577         min_width->update(config.min_width);
578         max_width->update(config.max_width);
579         min_len->update(config.min_len);
580         max_len->update(config.max_len);
581         max_angle->update(config.max_angle);
582         blur_len->update(config.blur_len);
583         gap_len->update(config.gap_len);
584         y_mode->update(config.mode_y);
585         u_mode->update(config.mode_u);
586         v_mode->update(config.mode_v);
587         mark->update(config.mark);
588         ffade->update(config.ffade);
589         border->update(config.border);
590         edge_only->update(config.edge_only);
591 }
592
593
594 DeScratchModeItem::DeScratchModeItem(DeScratchMode *popup, int type, const char *text)
595  : BC_MenuItem(text)
596 {
597         this->popup = popup;
598         this->type = type;
599 }
600
601 DeScratchModeItem::~DeScratchModeItem()
602 {
603 }
604
605 int DeScratchModeItem::handle_event()
606 {
607         popup->update(type);
608         return popup->handle_event();
609 }
610
611 DeScratchMode::DeScratchMode(DeScratchWindow *win, int x, int y, int *value)
612  : BC_PopupMenu(x, y, xS(100), "", 1)
613 {
614         this->win = win;
615         this->value = value;
616 }
617
618 DeScratchMode::~DeScratchMode()
619 {
620 }
621
622 void DeScratchMode::create_objects()
623 {
624         add_item(new DeScratchModeItem(this, MODE_NONE, _("None")));
625         add_item(new DeScratchModeItem(this, MODE_LOW,  _("Low")));
626         add_item(new DeScratchModeItem(this, MODE_HIGH, _("High")));
627         add_item(new DeScratchModeItem(this, MODE_ALL,  _("All")));
628         set_value(*value);
629 }
630
631 int DeScratchMode::handle_event()
632 {
633         win->plugin->send_configure_change();
634         return 1;
635 }
636
637 void DeScratchMode::update(int v)
638 {
639         set_value(*value = v);
640 }
641
642 void DeScratchMode::set_value(int v)
643 {
644         int i = total_items();
645         while( --i >= 0 && ((DeScratchModeItem*)get_item(i))->type != v );
646         if( i >= 0 ) set_text(get_item(i)->get_text());
647 }
648
649 DeScratchISlider::DeScratchISlider(DeScratchWindow *win,
650                 int x, int y, int w, int min, int max, int *output)
651  : BC_ISlider(x, y, 0, w, w, min, max, *output)
652 {
653         this->win = win;
654         this->output = output;
655 }
656
657 DeScratchISlider::~DeScratchISlider()
658 {
659 }
660
661 int DeScratchISlider::handle_event()
662 {
663         *output = get_value();
664         win->plugin->send_configure_change();
665         return 1;
666 }
667
668 DeScratchFSlider::DeScratchFSlider(DeScratchWindow *win,
669                 int x, int y, int w, float min, float max, float *output)
670  : BC_FSlider(x, y, 0, w, w, min, max, *output)
671 {
672         this->win = win;
673         this->output = output;
674 }
675
676 DeScratchFSlider::~DeScratchFSlider()
677 {
678 }
679
680 int DeScratchFSlider::handle_event()
681 {
682         *output = get_value();
683         win->plugin->send_configure_change();
684         return 1;
685 }
686
687 DeScratchMark::DeScratchMark(DeScratchWindow *win, int x, int y)
688  : BC_CheckBox(x, y, &win->plugin->config.mark, _("Mark"))
689 {
690         this->win = win;
691 };
692
693 DeScratchMark::~DeScratchMark()
694 {
695 }
696
697 int DeScratchMark::handle_event()
698 {
699         int ret = BC_CheckBox::handle_event();
700         win->plugin->send_configure_change();
701         return ret;
702 }
703
704 DeScratchEdgeOnly::DeScratchEdgeOnly(DeScratchWindow *win, int x, int y)
705  : BC_CheckBox(x, y, &win->plugin->config.edge_only, _("Edge"))
706 {
707         this->win = win;
708 };
709
710 DeScratchEdgeOnly::~DeScratchEdgeOnly()
711 {
712 }
713
714 int DeScratchEdgeOnly::handle_event()
715 {
716         int ret = BC_CheckBox::handle_event();
717         win->plugin->send_configure_change();
718         return ret;
719 }
720
721 DeScratchReset::DeScratchReset(DeScratchWindow *win, int x, int y)
722  : BC_GenericButton(x, y, _("Reset"))
723 {
724         this->win = win;
725 }
726
727 int DeScratchReset::handle_event()
728 {
729         win->plugin->config.reset();
730         win->update_gui();
731         win->plugin->send_configure_change();
732         return 1;
733 }
734