interp bilinear fix
[goodguy/history.git] / cinelerra-5.1 / plugins / deinterlace-cv / deinterlace-cv.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
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.
10  *
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.
15  *
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
19  *
20  */
21
22 #include "clip.h"
23 #include "bchash.h"
24 #include "deinterlace-cv.h"
25 #include "deinterwindow-cv.h"
26 #include "filexml.h"
27 #include "keyframe.h"
28 #include "language.h"
29 #include "vframe.h"
30
31
32
33
34
35
36
37
38
39 #include <stdint.h>
40 #include <string.h>
41 #include <math.h>
42
43 REGISTER_PLUGIN(DeInterlaceMain)
44
45
46
47
48 DeInterlaceConfig::DeInterlaceConfig()
49 {
50         mode = DEINTERLACE_AVG;
51         dominance = 0;
52         adaptive = 1;
53         threshold = 40;
54 }
55
56 int DeInterlaceConfig::equivalent(DeInterlaceConfig &that)
57 {
58         return mode == that.mode &&
59                 dominance == that.dominance &&
60                 adaptive == that.adaptive &&
61                 threshold == that.threshold;
62 }
63
64 void DeInterlaceConfig::copy_from(DeInterlaceConfig &that)
65 {
66         mode = that.mode;
67         dominance = that.dominance;
68         adaptive = that.adaptive;
69         threshold = that.threshold;
70 }
71
72 void DeInterlaceConfig::interpolate(DeInterlaceConfig &prev,
73         DeInterlaceConfig &next,
74         int64_t prev_frame,
75         int64_t next_frame,
76         int64_t current_frame)
77 {
78         copy_from(prev);
79 }
80
81
82
83
84 DeInterlaceMain::DeInterlaceMain(PluginServer *server)
85  : PluginVClient(server)
86 {
87 //      temp = 0;
88         temp_prevframe=0;
89 }
90
91 DeInterlaceMain::~DeInterlaceMain()
92 {
93 //      if(temp) delete temp;
94         if(temp_prevframe) delete temp_prevframe;
95 }
96
97 const char* DeInterlaceMain::plugin_title() { return _("Deinterlace-CV"); }
98 int DeInterlaceMain::is_realtime() { return 1; }
99
100
101
102 #define DEINTERLACE_TOP_MACRO(type, components, dominance) \
103 { \
104         int w = input->get_w(); \
105         int h = input->get_h(); \
106  \
107         for(int i = 0; i < h - 1; i += 2) \
108         { \
109                 type *input_row = (type*)input->get_rows()[dominance ? i + 1 : i]; \
110                 type *output_row1 = (type*)output->get_rows()[i]; \
111                 type *output_row2 = (type*)output->get_rows()[i + 1]; \
112                 memcpy(output_row1, input_row, w * components * sizeof(type)); \
113                 memcpy(output_row2, input_row, w * components * sizeof(type)); \
114         } \
115 }
116
117 #define DEINTERLACE_AVG_TOP_MACRO(type, temp_type, components, dominance) \
118 { \
119         int w = input->get_w(); \
120         int h = input->get_h(); \
121         changed_rows = 0; \
122  \
123         type **in_rows = (type**)input->get_rows(); \
124         type **out_rows = (type**)temp->get_rows(); \
125         int max_h = h - 1; \
126         temp_type abs_diff = 0, total = 0; \
127  \
128         for(int i = 0; i < max_h; i += 2) \
129         { \
130                 int in_number1 = dominance ? i - 1 : i + 0; \
131                 int in_number2 = dominance ? i + 1 : i + 2; \
132                 int out_number1 = dominance ? i - 1 : i; \
133                 int out_number2 = dominance ? i : i + 1; \
134                 in_number1 = MAX(in_number1, 0); \
135                 in_number2 = MIN(in_number2, max_h); \
136                 out_number1 = MAX(out_number1, 0); \
137                 out_number2 = MIN(out_number2, max_h); \
138  \
139                 type *input_row1 = in_rows[in_number1]; \
140                 type *input_row2 = in_rows[in_number2]; \
141                 type *input_row3 = in_rows[out_number2]; \
142                 type *temp_row1 = out_rows[out_number1]; \
143                 type *temp_row2 = out_rows[out_number2]; \
144                 temp_type sum = 0; \
145                 temp_type accum_r, accum_b, accum_g, accum_a; \
146  \
147                 memcpy(temp_row1, input_row1, w * components * sizeof(type)); \
148                 for(int j = 0; j < w; j++) \
149                 { \
150                         accum_r = (*input_row1++) + (*input_row2++); \
151                         accum_g = (*input_row1++) + (*input_row2++); \
152                         accum_b = (*input_row1++) + (*input_row2++); \
153                         if(components == 4) \
154                                 accum_a = (*input_row1++) + (*input_row2++); \
155                         accum_r /= 2; \
156                         accum_g /= 2; \
157                         accum_b /= 2; \
158                         accum_a /= 2; \
159  \
160                         total += *input_row3; \
161                         sum = ((temp_type)*input_row3++) - accum_r; \
162                         abs_diff += (sum < 0 ? -sum : sum); \
163                         *temp_row2++ = accum_r; \
164  \
165                         total += *input_row3; \
166                         sum = ((temp_type)*input_row3++) - accum_g; \
167                         abs_diff += (sum < 0 ? -sum : sum); \
168                         *temp_row2++ = accum_g; \
169  \
170                         total += *input_row3; \
171                         sum = ((temp_type)*input_row3++) - accum_b; \
172                         abs_diff += (sum < 0 ? -sum : sum); \
173                         *temp_row2++ = accum_b; \
174  \
175                         if(components == 4) \
176                         { \
177                                 total += *input_row3; \
178                                 sum = ((temp_type)*input_row3++) - accum_a; \
179                                 abs_diff += (sum < 0 ? -sum : sum); \
180                                 *temp_row2++ = accum_a; \
181                         } \
182                 } \
183         } \
184  \
185         temp_type threshold = (temp_type)total * config.threshold / THRESHOLD_SCALAR; \
186 /* printf("total=%lld threshold=%lld abs_diff=%lld\n", total, threshold, abs_diff); */ \
187         if(abs_diff > threshold || !config.adaptive) \
188         { \
189                 output->copy_from(temp); \
190                 changed_rows = 240; \
191         } \
192         else \
193         { \
194                 output->copy_from(input); \
195                 changed_rows = 0; \
196         } \
197  \
198 }
199
200 #define DEINTERLACE_AVG_MACRO(type, temp_type, components) \
201 { \
202         int w = input->get_w(); \
203         int h = input->get_h(); \
204  \
205         for(int i = 0; i < h - 1; i += 2) \
206         { \
207                 type *input_row1 = (type*)input->get_rows()[i]; \
208                 type *input_row2 = (type*)input->get_rows()[i + 1]; \
209                 type *output_row1 = (type*)output->get_rows()[i]; \
210                 type *output_row2 = (type*)output->get_rows()[i + 1]; \
211                 type result; \
212  \
213                 for(int j = 0; j < w * components; j++) \
214                 { \
215                         result = ((temp_type)input_row1[j] + input_row2[j]) / 2; \
216                         output_row1[j] = result; \
217                         output_row2[j] = result; \
218                 } \
219         } \
220 }
221
222 #define DEINTERLACE_SWAP_MACRO(type, components, dominance) \
223 { \
224         int w = input->get_w(); \
225         int h = input->get_h(); \
226  \
227         for(int i = dominance; i < h - 1; i += 2) \
228         { \
229                 type *input_row1 = (type*)input->get_rows()[i]; \
230                 type *input_row2 = (type*)input->get_rows()[i + 1]; \
231                 type *output_row1 = (type*)output->get_rows()[i]; \
232                 type *output_row2 = (type*)output->get_rows()[i + 1]; \
233                 type temp1, temp2; \
234  \
235                 for(int j = 0; j < w * components; j++) \
236                 { \
237                         temp1 = input_row1[j]; \
238                         temp2 = input_row2[j]; \
239                         output_row1[j] = temp2; \
240                         output_row2[j] = temp1; \
241                 } \
242         } \
243 }
244
245
246 #define DEINTERLACE_TEMPORALSWAP_MACRO(type, components, dominance) \
247 { \
248         int w = input->get_w(); \
249         int h = input->get_h(); \
250  \
251         for(int i = 0; i < h - 1; i += 2) \
252         { \
253                 type *input_row1;\
254                 type *input_row2; \
255                 type *output_row1 = (type*)output->get_rows()[i]; \
256                 type *output_row2 = (type*)output->get_rows()[i + 1]; \
257                 type temp1, temp2; \
258                 \
259                 if (dominance) { \
260                         input_row1 = (type*)input->get_rows()[i]; \
261                         input_row2 = (type*)prevframe->get_rows()[i+1]; \
262                 } \
263                 else  {\
264                         input_row1 = (type*)prevframe->get_rows()[i]; \
265                         input_row2 = (type*)input->get_rows()[i+1]; \
266                 } \
267  \
268                 for(int j = 0; j < w * components; j++) \
269                 { \
270                         temp1 = input_row1[j]; \
271                         temp2 = input_row2[j]; \
272                         output_row1[j] = temp1; \
273                         output_row2[j] = temp2; \
274                 } \
275         } \
276 }
277
278
279 /* Bob & Weave deinterlacer:
280
281 For each pixel,
282         if it's similar to the previous frame
283         then keep it
284         else average with line above and below
285
286 Similar is defined as in abs(difference)/(sum) < threshold
287 */
288 // cplr warns, #define FABS(a) (((a)<0)?(0-(a)):(a))
289 static inline int FABS(int8_t v) { return v<0 ? -v : v; }
290 static inline int FABS(uint8_t v) { return v; }
291 static inline int FABS(int16_t v) { return v<0 ? -v : v; }
292 static inline int FABS(uint16_t v) { return v; }
293 static inline int FABS(int32_t v) { return v<0 ? -v : v; }
294 static inline int64_t FABS(uint32_t v) { return v; }
295 static inline int64_t FABS(int64_t v) { return v<0 ? -v : v; }
296 static inline int64_t FABS(uint64_t v) { return v; }
297 static inline float FABS(float v) { return v<0 ? -v : v; }
298 static inline double FABS(double v) { return v<0 ? -v : v; }
299 #define FMAX(a,b) (((a)>(b))?(a):(b))
300 #define FMIN(a,b) (((a)<(b))?(a):(b))
301
302 #define SQ(a) ((a)*(a))
303 // threshold < 100 -> a-b/a+b <
304
305
306 #define DEINTERLACE_BOBWEAVE_MACRO(type, temp_type, components, dominance, threshold, noise_threshold) \
307 { \
308         /* Ooooohh, I like fudge factors */ \
309         double exp_threshold=exp(((double)threshold - 50 )/2);\
310         int w = input->get_w(); \
311         int h = input->get_h(); \
312         type *row_above=(type*)input->get_rows()[0]; \
313         for(int i = dominance ?0:1; i < h - 1; i += 2) \
314         { \
315                 type *input_row;\
316                 type *input_row2; \
317                 type *old_row; \
318                 type *output_row1 = (type*)output->get_rows()[i]; \
319                 type *output_row2 = (type*)output->get_rows()[i + 1]; \
320                 temp_type pixel, below, old, above; \
321                 \
322                 input_row = (type*)input->get_rows()[i]; \
323                 input_row2 = (type*)input->get_rows()[i+1]; \
324                 old_row = (type*)prevframe->get_rows()[i]; \
325 \
326                 for(int j = 0; j < w * components; j++) \
327                 { \
328                         pixel = input_row[j]; \
329                         below = input_row2[j]; \
330                         old = old_row[j]; \
331                         above = row_above[j]; \
332 \
333                         if  ( ( FABS(pixel-old) <= noise_threshold )  \
334                         || ((pixel+old != 0) && (((FABS((double) pixel-old))/((double) pixel+old)) >= exp_threshold )) \
335                         || ((above+below != 0) && (((FABS((double) pixel-old))/((double) above+below)) >= exp_threshold )) \
336                         ) {\
337                                 pixel=(above+below)/2 ;\
338                         }\
339                         output_row1[j] = pixel; \
340                         output_row2[j] = below; \
341                 } \
342                 row_above=input_row2; \
343         } \
344 }
345
346
347 void DeInterlaceMain::deinterlace_top(VFrame *input, VFrame *output, int dominance)
348 {
349         switch(input->get_color_model())
350         {
351                 case BC_RGB888:
352                 case BC_YUV888:
353                         DEINTERLACE_TOP_MACRO(unsigned char, 3, dominance);
354                         break;
355                 case BC_RGB_FLOAT:
356                         DEINTERLACE_TOP_MACRO(float, 3, dominance);
357                         break;
358                 case BC_RGBA8888:
359                 case BC_YUVA8888:
360                         DEINTERLACE_TOP_MACRO(unsigned char, 4, dominance);
361                         break;
362                 case BC_RGBA_FLOAT:
363                         DEINTERLACE_TOP_MACRO(float, 4, dominance);
364                         break;
365                 case BC_RGB161616:
366                 case BC_YUV161616:
367                         DEINTERLACE_TOP_MACRO(uint16_t, 3, dominance);
368                         break;
369                 case BC_RGBA16161616:
370                 case BC_YUVA16161616:
371                         DEINTERLACE_TOP_MACRO(uint16_t, 4, dominance);
372                         break;
373         }
374 }
375
376 void DeInterlaceMain::deinterlace_avg_top(VFrame *input, VFrame *output, int dominance)
377 {
378         switch(input->get_color_model())
379         {
380                 case BC_RGB888:
381                 case BC_YUV888:
382                         DEINTERLACE_AVG_TOP_MACRO(unsigned char, int64_t, 3, dominance);
383                         break;
384                 case BC_RGB_FLOAT:
385                         DEINTERLACE_AVG_TOP_MACRO(float, double, 3, dominance);
386                         break;
387                 case BC_RGBA8888:
388                 case BC_YUVA8888:
389                         DEINTERLACE_AVG_TOP_MACRO(unsigned char, int64_t, 4, dominance);
390                         break;
391                 case BC_RGBA_FLOAT:
392                         DEINTERLACE_AVG_TOP_MACRO(float, double, 4, dominance);
393                         break;
394                 case BC_RGB161616:
395                 case BC_YUV161616:
396                         DEINTERLACE_AVG_TOP_MACRO(uint16_t, int64_t, 3, dominance);
397                         break;
398                 case BC_RGBA16161616:
399                 case BC_YUVA16161616:
400                         DEINTERLACE_AVG_TOP_MACRO(uint16_t, int64_t, 4, dominance);
401                         break;
402         }
403 }
404
405 void DeInterlaceMain::deinterlace_avg(VFrame *input, VFrame *output)
406 {
407         switch(input->get_color_model())
408         {
409                 case BC_RGB888:
410                 case BC_YUV888:
411                         DEINTERLACE_AVG_MACRO(unsigned char, uint64_t, 3);
412                         break;
413                 case BC_RGB_FLOAT:
414                         DEINTERLACE_AVG_MACRO(float, double, 3);
415                         break;
416                 case BC_RGBA8888:
417                 case BC_YUVA8888:
418                         DEINTERLACE_AVG_MACRO(unsigned char, uint64_t, 4);
419                         break;
420                 case BC_RGBA_FLOAT:
421                         DEINTERLACE_AVG_MACRO(float, double, 4);
422                         break;
423                 case BC_RGB161616:
424                 case BC_YUV161616:
425                         DEINTERLACE_AVG_MACRO(uint16_t, uint64_t, 3);
426                         break;
427                 case BC_RGBA16161616:
428                 case BC_YUVA16161616:
429                         DEINTERLACE_AVG_MACRO(uint16_t, uint64_t, 4);
430                         break;
431         }
432 }
433
434 void DeInterlaceMain::deinterlace_swap(VFrame *input, VFrame *output, int dominance)
435 {
436         switch(input->get_color_model())
437         {
438                 case BC_RGB888:
439                 case BC_YUV888:
440                         DEINTERLACE_SWAP_MACRO(unsigned char, 3, dominance);
441                         break;
442                 case BC_RGB_FLOAT:
443                         DEINTERLACE_SWAP_MACRO(float, 3, dominance);
444                         break;
445                 case BC_RGBA8888:
446                 case BC_YUVA8888:
447                         DEINTERLACE_SWAP_MACRO(unsigned char, 4, dominance);
448                         break;
449                 case BC_RGBA_FLOAT:
450                         DEINTERLACE_SWAP_MACRO(float, 4, dominance);
451                         break;
452                 case BC_RGB161616:
453                 case BC_YUV161616:
454                         DEINTERLACE_SWAP_MACRO(uint16_t, 3, dominance);
455                         break;
456                 case BC_RGBA16161616:
457                 case BC_YUVA16161616:
458                         DEINTERLACE_SWAP_MACRO(uint16_t, 4, dominance);
459                         break;
460         }
461 }
462
463 void DeInterlaceMain::deinterlace_temporalswap(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
464 {
465         switch(input->get_color_model())
466         {
467                 case BC_RGB888:
468                 case BC_YUV888:
469                         DEINTERLACE_TEMPORALSWAP_MACRO(unsigned char, 3, dominance);
470                         break;
471                 case BC_RGB_FLOAT:
472                         DEINTERLACE_TEMPORALSWAP_MACRO(float, 3, dominance);
473                         break;
474                 case BC_RGBA8888:
475                 case BC_YUVA8888:
476                         DEINTERLACE_TEMPORALSWAP_MACRO(unsigned char, 4, dominance);
477                         break;
478                 case BC_RGBA_FLOAT:
479                         DEINTERLACE_TEMPORALSWAP_MACRO(float, 4, dominance);
480                         break;
481                 case BC_RGB161616:
482                 case BC_YUV161616:
483                         DEINTERLACE_TEMPORALSWAP_MACRO(uint16_t, 3, dominance);
484                         break;
485                 case BC_RGBA16161616:
486                 case BC_YUVA16161616:
487                         DEINTERLACE_TEMPORALSWAP_MACRO(uint16_t, 4, dominance);
488                         break;
489         }
490 }
491
492 void DeInterlaceMain::deinterlace_bobweave(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
493 {
494         int threshold=config.threshold;
495         int noise_threshold=0;
496
497         switch(input->get_color_model())
498         {
499                 case BC_RGB888:
500                 case BC_YUV888:
501                         DEINTERLACE_BOBWEAVE_MACRO(unsigned char, uint64_t, 3, dominance, threshold, noise_threshold);
502                         break;
503                 case BC_RGB_FLOAT:
504                         DEINTERLACE_BOBWEAVE_MACRO(float, double, 3, dominance, threshold, noise_threshold);
505                         break;
506                 case BC_RGBA8888:
507                 case BC_YUVA8888:
508                         DEINTERLACE_BOBWEAVE_MACRO(unsigned char, uint64_t, 4, dominance, threshold, noise_threshold);
509                         break;
510                 case BC_RGBA_FLOAT:
511                         DEINTERLACE_BOBWEAVE_MACRO(float, double, 4, dominance, threshold, noise_threshold);
512                         break;
513                 case BC_RGB161616:
514                 case BC_YUV161616:
515                         DEINTERLACE_BOBWEAVE_MACRO(uint16_t, uint64_t, 3, dominance, threshold, noise_threshold);
516                         break;
517                 case BC_RGBA16161616:
518                 case BC_YUVA16161616:
519                         DEINTERLACE_BOBWEAVE_MACRO(uint16_t, uint64_t, 4, dominance, threshold, noise_threshold);
520                         break;
521         }
522 }
523
524
525 int DeInterlaceMain::process_buffer(VFrame *frame,
526         int64_t start_position,
527         double frame_rate)
528 {
529         changed_rows = frame->get_h();
530         load_configuration();
531
532
533         read_frame(frame, 0, start_position, frame_rate, 0);
534
535 // Temp was used for adaptive deinterlacing where it took deinterlacing
536 // an entire frame to decide if the deinterlaced output should be used.
537         temp = frame;
538
539 //      if(!temp)
540 //              temp = new VFrame(
541 //                      frame->get_w(),
542 //                      frame->get_h(),
543 //                      frame->get_color_model());
544         if(!temp_prevframe)
545                 temp_prevframe = new VFrame(
546                         frame->get_w(),
547                         frame->get_h(),
548                         frame->get_color_model());
549
550         switch(config.mode)
551         {
552                 case DEINTERLACE_NONE:
553 //                      output->copy_from(input);
554                         break;
555                 case DEINTERLACE_KEEP:
556                         deinterlace_top(frame, frame, config.dominance);
557                         break;
558                 case DEINTERLACE_AVG:
559                         deinterlace_avg(frame, frame);
560                         break;
561                 case DEINTERLACE_AVG_1F:
562                         deinterlace_avg_top(frame, frame, config.dominance);
563                         break;
564                 case DEINTERLACE_SWAP:
565                         deinterlace_swap(frame, frame, config.dominance);
566                         break;
567                 case DEINTERLACE_BOBWEAVE:
568                         if (get_source_position()==0)
569                                 read_frame(temp_prevframe,0, get_source_position(), get_framerate(), 0);
570                         else
571                                 read_frame(temp_prevframe,0, get_source_position()-1, get_framerate(), 0);
572                         deinterlace_bobweave(frame, temp_prevframe, frame, config.dominance);
573                         break;
574                 case DEINTERLACE_TEMPORALSWAP:
575                         if (get_source_position()==0)
576                                 read_frame(temp_prevframe,0, get_source_position(), get_framerate(), 0);
577                         else
578                                 read_frame(temp_prevframe,0, get_source_position()-1, get_framerate(), 0);
579                         deinterlace_temporalswap(frame, temp_prevframe, frame, config.dominance);
580                         break;
581         }
582         send_render_gui(&changed_rows);
583         return 0;
584 }
585
586
587 void DeInterlaceMain::render_gui(void *data)
588 {
589         if(thread)
590         {
591                 thread->window->lock_window();
592                 char string[BCTEXTLEN];
593                 DeInterlaceWindow *window = (DeInterlaceWindow *)thread->window;
594                 window->get_status_string(string, *(int*)data);
595                 window->status->update(string);
596                 window->flush();
597                 window->unlock_window();
598         }
599 }
600
601 NEW_WINDOW_MACRO(DeInterlaceMain, DeInterlaceWindow)
602 LOAD_CONFIGURATION_MACRO(DeInterlaceMain, DeInterlaceConfig)
603
604
605
606 void DeInterlaceMain::save_data(KeyFrame *keyframe)
607 {
608         FileXML output;
609         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
610         output.tag.set_title("DEINTERLACE");
611         output.tag.set_property("MODE", config.mode);
612         output.tag.set_property("DOMINANCE", config.dominance);
613         output.tag.set_property("ADAPTIVE", config.adaptive);
614         output.tag.set_property("THRESHOLD", config.threshold);
615         output.append_tag();
616         output.tag.set_title("/DEINTERLACE");
617         output.append_tag();
618         output.terminate_string();
619 }
620
621 void DeInterlaceMain::read_data(KeyFrame *keyframe)
622 {
623         FileXML input;  char *data = keyframe->get_data();
624         input.set_shared_input(data, strlen(data));
625
626         while(!input.read_tag())
627         {
628                 if(input.tag.title_is("DEINTERLACE"))
629                 {
630                         config.mode = input.tag.get_property("MODE", config.mode);
631                         config.dominance = input.tag.get_property("DOMINANCE", config.dominance);
632                         config.adaptive = input.tag.get_property("ADAPTIVE", config.adaptive);
633                         config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
634                 }
635         }
636
637 }
638
639 void DeInterlaceMain::update_gui()
640 {
641         if(thread)
642         {
643                 load_configuration();
644                 DeInterlaceWindow *window = (DeInterlaceWindow *)thread->window;
645                 window->lock_window();
646                 window->set_mode(config.mode, 1);
647                 if (window->dominance_top)
648                         window->dominance_top->update(config.dominance?0:BC_Toggle::TOGGLE_CHECKED);
649                 if (window->dominance_bottom)
650                         window->dominance_bottom->update(config.dominance?BC_Toggle::TOGGLE_CHECKED:0);
651                 if (window->adaptive)
652                         window->adaptive->update(config.adaptive);
653                 if (window->threshold)
654                         window->threshold->update(config.threshold);
655                 window->unlock_window();
656         }
657 }
658