minor changes; mostly for new Context Help feature
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / bluebanana / bluebanana.C
1 /*
2  * Cinelerra :: Blue Banana - color modification plugin for Cinelerra-CV
3  * Copyright (C) 2012-2013 Monty <monty@xiph.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  */
20
21 #include <math.h>
22 #include <stdint.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include "bcdisplayinfo.h"
27 #include "bcsignals.h"
28 #include "clip.h"
29 #include "bchash.h"
30 #include "filexml.h"
31 #include "bluebanana.h"
32 #include "bluebananaconfig.h"
33 #include "bluebananawindow.h"
34 #include "keyframe.h"
35 #include "language.h"
36 #include "loadbalance.h"
37 #include "playback3d.h"
38 #include "bccolors.h"
39 #include "vframe.h"
40 #include "workarounds.h"
41
42 class BluebananaMain;
43 class BluebananaEngine;
44 class BluebananaWindow;
45
46 REGISTER_PLUGIN(BluebananaMain)
47
48 BluebananaMain::BluebananaMain(PluginServer *server)
49  : PluginVClient(server)
50 {
51   engine = 0;
52
53   /* be sure a lookup update triggers */
54   lookup_cache.Hsel_lo=-999999;
55   lookup_cache.Ssel_lo=-999999;
56   lookup_cache.Vsel_lo=-999999;
57   lookup_cache.Fsel_lo=-999999;
58
59   lookup_cache.Sadj_lo=-999999;
60   lookup_cache.Vadj_lo=-999999;
61   lookup_cache.Radj_lo=-999999;
62   lookup_cache.Gadj_lo=-999999;
63   lookup_cache.Badj_lo=-999999;
64
65   colormodel=-1;
66
67   ants_counter=0;
68
69   memset(red_histogram,0,sizeof(red_histogram));
70   memset(green_histogram,0,sizeof(green_histogram));
71   memset(blue_histogram,0,sizeof(blue_histogram));
72   memset(hue_histogram,0,sizeof(hue_histogram));
73   memset(sat_histogram,0,sizeof(sat_histogram));
74   memset(value_histogram,0,sizeof(value_histogram));
75 }
76
77 BluebananaMain::~BluebananaMain() {
78
79   // if ants are running, run one more pane update to hide them (gui
80   // is already marked as closed)
81   //if(server && server->mwindow && ants_counter>0)
82   //  server->mwindow->sync_parameters();
83
84   delete engine;
85 }
86
87 const char* BluebananaMain::plugin_title() { return N_("Blue Banana"); }
88 int BluebananaMain::is_realtime() { return 1; }
89
90 NEW_WINDOW_MACRO(BluebananaMain, BluebananaWindow)
91 LOAD_CONFIGURATION_MACRO(BluebananaMain, BluebananaConfig)
92
93 void BluebananaMain::render_gui(void *data){
94   if(thread){
95     BluebananaMain *that = (BluebananaMain *)data; // that is server-side
96     BluebananaWindow *window = (BluebananaWindow *)thread->window;
97     window->lock_window("BluebananaMain::render_gui");
98
99     /* push histogram data to gui */
100     window->update_histograms(that);
101
102     /* push any colormodel update to gui */
103     if(that->frame && colormodel != that->frame->get_color_model()){
104       colormodel = that->frame->get_color_model();
105       window->update();
106     }
107
108     window->unlock_window();
109   }
110 }
111
112 void BluebananaMain::update_gui(){
113   if(thread){
114     BluebananaWindow *window = (BluebananaWindow *)thread->window;
115     window->lock_window("BluebananaMain::update_gui");
116     window->flush_config_change();
117     int reconfigure = load_configuration();
118     if(reconfigure)
119       window->update();
120
121     window->unlock_window();
122   }
123 }
124
125 void BluebananaMain::save_data(KeyFrame *keyframe){
126   FileXML output;
127
128   // cause data to be stored directly in text
129   output.set_shared_output(keyframe->xbuf);
130   output.tag.set_title("BLUEBANANA");
131
132   output.tag.set_property("ACTIVE", config.active);
133   output.tag.set_property("OP", config.op);
134   output.tag.set_property("INVERT_SELECTION", config.invert_selection);
135   output.tag.set_property("USE_MASK", config.use_mask);
136   output.tag.set_property("CAPTURE_MASK", config.capture_mask);
137
138   output.tag.set_property("HUE_ACTIVE", config.Hsel_active);
139   output.tag.set_property("HUE_LO", config.Hsel_lo);
140   output.tag.set_property("HUE_HI", config.Hsel_hi);
141   output.tag.set_property("HUE_OVERLAP", config.Hsel_over);
142
143   output.tag.set_property("SATURATION_ACTIVE", config.Ssel_active);
144   output.tag.set_property("SATURATION_LO", config.Ssel_lo);
145   output.tag.set_property("SATURATION_HI", config.Ssel_hi);
146   output.tag.set_property("SATURATION_OVERLAP", config.Ssel_over);
147
148   output.tag.set_property("VALUE_ACTIVE", config.Vsel_active);
149   output.tag.set_property("VALUE_LO", config.Vsel_lo);
150   output.tag.set_property("VALUE_HI", config.Vsel_hi);
151   output.tag.set_property("VALUE_OVERLAP", config.Vsel_over);
152
153   output.tag.set_property("FILL_ACTIVE", config.Fsel_active);
154   output.tag.set_property("FILL_ERODE", config.Fsel_erode);
155   output.tag.set_property("FILL_LO", config.Fsel_lo);
156   output.tag.set_property("FILL_MID", config.Fsel_mid);
157   output.tag.set_property("FILL_HI", config.Fsel_hi);
158   output.tag.set_property("FILL_FEATHER", config.Fsel_over);
159
160   output.tag.set_property("HUE_ADJUST_ACTIVE", config.Hadj_active);
161   output.tag.set_property("HUE_ADJUST", config.Hadj_val);
162
163   output.tag.set_property("SATURATION_ADJUST_ACTIVE", config.Sadj_active);
164   output.tag.set_property("SATURATION_ADJUST_GAMMA", config.Sadj_gamma);
165   output.tag.set_property("SATURATION_ADJUST_LO", config.Sadj_lo);
166   output.tag.set_property("SATURATION_ADJUST_HI", config.Sadj_hi);
167
168   output.tag.set_property("VALUE_ADJUST_ACTIVE", config.Vadj_active);
169   output.tag.set_property("VALUE_ADJUST_GAMMA", config.Vadj_gamma);
170   output.tag.set_property("VALUE_ADJUST_LO", config.Vadj_lo);
171   output.tag.set_property("VALUE_ADJUST_HI", config.Vadj_hi);
172
173   output.tag.set_property("RED_ADJUST_ACTIVE", config.Radj_active);
174   output.tag.set_property("RED_ADJUST_GAMMA", config.Radj_gamma);
175   output.tag.set_property("RED_ADJUST_LO", config.Radj_lo);
176   output.tag.set_property("RED_ADJUST_HI", config.Radj_hi);
177
178   output.tag.set_property("GREEN_ADJUST_ACTIVE", config.Gadj_active);
179   output.tag.set_property("GREEN_ADJUST_GAMMA", config.Gadj_gamma);
180   output.tag.set_property("GREEN_ADJUST_LO", config.Gadj_lo);
181   output.tag.set_property("GREEN_ADJUST_HI", config.Gadj_hi);
182
183   output.tag.set_property("BLUE_ADJUST_ACTIVE", config.Badj_active);
184   output.tag.set_property("BLUE_ADJUST_GAMMA", config.Badj_gamma);
185   output.tag.set_property("BLUE_ADJUST_LO", config.Badj_lo);
186   output.tag.set_property("BLUE_ADJUST_HI", config.Badj_hi);
187
188   output.tag.set_property("OPACITY_ADJUST_ACTIVE", config.Oadj_active);
189   output.tag.set_property("OPACITY_ADJUST", config.Oadj_val);
190   output.tag.set_property("ALPHA_ADJUST_ACTIVE", config.Aadj_active);
191   output.tag.set_property("ALPHA_ADJUST", config.Aadj_val);
192
193   output.append_tag();
194   output.append_newline();
195
196   output.tag.set_title("/BLUEBANANA");
197   output.append_tag();
198   output.append_newline();
199
200   if(keyframe->position==0){
201     /* this will otherwise overwrite the nonauto information as well */
202     output_nonauto(&output);
203   }
204
205   output.terminate_string();
206 }
207
208 // save non-auto data to the default keyframe at zero and does it
209 // without alerting the keyframing mechanism
210 void BluebananaMain::save_nonauto(){
211
212   KeyFrame *default_keyframe=get_prev_keyframe(0);
213   if(default_keyframe){
214     FileXML input;
215     FileXML output;
216     int result = 0;
217
218     input.read_from_string(default_keyframe->get_data());
219     output.set_shared_output(default_keyframe->xbuf);
220
221     while(!result){
222       result = input.read_tag();
223
224       if(!result &&
225          !input.tag.title_is("BLUEBANANA_NONAUTO") &&
226          !input.tag.title_is("/BLUEBANANA_NONAUTO")){
227         input.tag.write_tag(&output);
228         output.append_newline();
229       }
230     }
231
232     output_nonauto(&output);
233   }
234 }
235
236 void BluebananaMain::output_nonauto(FileXML *output){
237   output->tag.set_title("BLUEBANANA_NONAUTO");
238   output->tag.set_property("MARK", config.mark);
239   output->append_tag();
240   output->tag.set_title("/BLUEBANANA_NONAUTO");
241   output->append_tag();
242   output->append_newline();
243   output->terminate_string();
244 }
245
246 void BluebananaMain::load_nonauto(){
247   /* nonauto data stored in the default keyframe at position 0 */
248   KeyFrame *default_keyframe=get_prev_keyframe(0);
249   if(default_keyframe){
250     FileXML input;
251     int result = 0;
252     input.set_shared_input(default_keyframe->xbuf);
253
254     while(!result){
255       result = input.read_tag();
256
257       if(!result && input.tag.title_is("BLUEBANANA_NONAUTO")){
258         config.mark = input.tag.get_property("MARK", config.mark);
259       }
260     }
261   }
262 }
263
264
265 void BluebananaMain::read_data(KeyFrame *keyframe){
266   
267   int result = 0;
268 { FileXML input; // release xbuf-shared_lock before nonaauto
269   input.set_shared_input(keyframe->xbuf);
270
271   while(!result){
272     result = input.read_tag();
273
274     if(!result && input.tag.title_is("BLUEBANANA")){
275       config.active = input.tag.get_property("ACTIVE", config.active);
276       config.op = input.tag.get_property("OP", config.op);
277       config.invert_selection = input.tag.get_property("INVERT_SELECTION", config.invert_selection);
278       config.use_mask = input.tag.get_property("USE_MASK", config.use_mask);
279       config.capture_mask = input.tag.get_property("CAPTURE_MASK", config.capture_mask);
280
281       config.Hsel_active = input.tag.get_property("HUE_ACTIVE", config.Hsel_active);
282       config.Hsel_lo = input.tag.get_property("HUE_LO", config.Hsel_lo);
283       config.Hsel_hi = input.tag.get_property("HUE_HI", config.Hsel_hi);
284       config.Hsel_over = input.tag.get_property("HUE_OVERLAP", config.Hsel_over);
285
286       config.Ssel_active = input.tag.get_property("SATURATION_ACTIVE", config.Ssel_active);
287       config.Ssel_lo = input.tag.get_property("SATURATION_LO", config.Ssel_lo);
288       config.Ssel_hi = input.tag.get_property("SATURATION_HI", config.Ssel_hi);
289       config.Ssel_over = input.tag.get_property("SATURATION_OVERLAP", config.Ssel_over);
290
291       config.Vsel_active = input.tag.get_property("VALUE_ACTIVE", config.Vsel_active);
292       config.Vsel_lo = input.tag.get_property("VALUE_LO", config.Vsel_lo);
293       config.Vsel_hi = input.tag.get_property("VALUE_HI", config.Vsel_hi);
294       config.Vsel_over = input.tag.get_property("VALUE_OVERLAP", config.Vsel_over);
295
296       config.Fsel_active = input.tag.get_property("FILL_ACTIVE", config.Fsel_active);
297       config.Fsel_erode = input.tag.get_property("FILL_ERODE", config.Fsel_erode);
298       config.Fsel_lo = input.tag.get_property("FILL_LO", config.Fsel_lo);
299       config.Fsel_mid = input.tag.get_property("FILL_MID", config.Fsel_mid);
300       config.Fsel_hi = input.tag.get_property("FILL_HI", config.Fsel_hi);
301       config.Fsel_over = input.tag.get_property("FILL_FEATHER", config.Fsel_over);
302
303       config.Hadj_active = input.tag.get_property("HUE_ADJUST_ACTIVE", config.Hadj_active);
304       config.Hadj_val = input.tag.get_property("HUE_ADJUST", config.Hadj_val);
305
306       config.Sadj_active = input.tag.get_property("SATURATION_ADJUST_ACTIVE", config.Sadj_active);
307       config.Sadj_gamma = input.tag.get_property("SATURATION_ADJUST_GAMMA", config.Sadj_gamma);
308       config.Sadj_lo = input.tag.get_property("SATURATION_ADJUST_LO", config.Sadj_lo);
309       config.Sadj_hi = input.tag.get_property("SATURATION_ADJUST_HI", config.Sadj_hi);
310
311       config.Vadj_active = input.tag.get_property("VALUE_ADJUST_ACTIVE", config.Vadj_active);
312       config.Vadj_gamma = input.tag.get_property("VALUE_ADJUST_GAMMA", config.Vadj_gamma);
313       config.Vadj_lo = input.tag.get_property("VALUE_ADJUST_LO", config.Vadj_lo);
314       config.Vadj_hi = input.tag.get_property("VALUE_ADJUST_HI", config.Vadj_hi);
315
316       config.Radj_active = input.tag.get_property("RED_ADJUST_ACTIVE", config.Radj_active);
317       config.Radj_gamma = input.tag.get_property("RED_ADJUST_GAMMA", config.Radj_gamma);
318       config.Radj_lo = input.tag.get_property("RED_ADJUST_LO", config.Radj_lo);
319       config.Radj_hi = input.tag.get_property("RED_ADJUST_HI", config.Radj_hi);
320
321       config.Gadj_active = input.tag.get_property("GREEN_ADJUST_ACTIVE", config.Gadj_active);
322       config.Gadj_gamma = input.tag.get_property("GREEN_ADJUST_GAMMA", config.Gadj_gamma);
323       config.Gadj_lo = input.tag.get_property("GREEN_ADJUST_LO", config.Gadj_lo);
324       config.Gadj_hi = input.tag.get_property("GREEN_ADJUST_HI", config.Gadj_hi);
325
326       config.Badj_active = input.tag.get_property("BLUE_ADJUST_ACTIVE", config.Badj_active);
327       config.Badj_gamma = input.tag.get_property("BLUE_ADJUST_GAMMA", config.Badj_gamma);
328       config.Badj_lo = input.tag.get_property("BLUE_ADJUST_LO", config.Badj_lo);
329       config.Badj_hi = input.tag.get_property("BLUE_ADJUST_HI", config.Badj_hi);
330
331       config.Oadj_active = input.tag.get_property("OPACITY_ADJUST_ACTIVE", config.Oadj_active);
332       config.Oadj_val = input.tag.get_property("OPACITY_ADJUST", config.Oadj_val);
333       config.Aadj_active = input.tag.get_property("ALPHA_ADJUST_ACTIVE", config.Aadj_active);
334       config.Aadj_val = input.tag.get_property("ALPHA_ADJUST", config.Aadj_val);
335
336     }
337   }
338 }
339   load_nonauto();
340 }
341
342 static void select_grow_h(float *hrow, float *vrow, int width){
343   int i;
344
345   /* spread left */
346   for(i=0;i<width-1;i++){
347     if(hrow[i]<hrow[i+1])hrow[i]=hrow[i+1];
348     if(vrow[i]<hrow[i])vrow[i]=hrow[i];
349   }
350   /* spread right */
351   for(i=width-1;i>0;i--){
352     if(hrow[i]<hrow[i-1])hrow[i]=hrow[i-1];
353     if(vrow[i]<hrow[i])vrow[i]=hrow[i];
354   }
355 }
356
357 static void select_shrink_h(float *hrow, float *vrow, int width){
358   int i;
359
360   /* spread left */
361   for(i=0;i<width-1;i++){
362     if(hrow[i]>hrow[i+1])hrow[i]=hrow[i+1];
363     if(vrow[i]>hrow[i])vrow[i]=hrow[i];
364   }
365   /* spread right */
366   for(i=width-1;i>0;i--){
367     if(hrow[i]>hrow[i-1])hrow[i]=hrow[i-1];
368     if(vrow[i]>hrow[i])vrow[i]=hrow[i];
369   }
370 }
371
372 static void select_grow_v(float *row0, float *row1, int width){
373   int i;
374
375   /* spread into 0 */
376   for(i=0;i<width;i++)
377     if(row0[i]<row1[i])row0[i]=row1[i];
378 }
379
380 static void select_shrink_v(float *row0, float *row1, int width){
381   int i;
382
383   /* spread out of 0 */
384   for(i=0;i<width;i++)
385     if(row0[i]>row1[i])row0[i]=row1[i];
386 }
387
388 static void threaded_horizontal(float *in, float *work,
389                                 int width, int height,
390                                 BluebananaEngine *e, int tasks, int passes,
391                                 void(*func)(float *, float *, int)){
392
393   /* these are individually fast operations; here we do in fact make
394      cache region collisions as impossible as we can.  Live with the
395      overhead of the join. */
396   int i,j;
397   e->set_task(tasks,"H_even");
398   j = e->next_task();
399   {
400     int row = (j*2)*height/(tasks*2);
401     int end = (j*2+1)*height/(tasks*2);
402     for(;row<end;row++)
403       for(i=0;i<passes;i++)
404         func(in+row*width,work+row*width,width);
405   }
406   e->wait_task();
407
408   e->set_task(0,"H_odd");
409   {
410     int row = (j*2+1)*height/(tasks*2);
411     int end = (j*2+2)*height/(tasks*2);
412     for(;row<end;row++)
413       for(i=0;i<passes;i++)
414         func(in+row*width,work+row*width,width);
415   }
416   e->wait_task();
417 }
418
419 static void threaded_vertical(float *work, float *temp,
420                               int width, int height,
421                               BluebananaEngine *e, int tasks,
422                               void(*func)(float *, float *, int)){
423
424   /* regions overlap, so this becomes a bit more complex. */
425
426   /* rather than on-demand task allocation, we use the task engine to
427      grab a slot, then reuse this same slot through several joins */
428
429   e->set_task(tasks,"up_odd");
430   int region = e->next_task(); /* grab one slot */
431   int start_row = (region*2)*height/(tasks*2);
432   int mid_row = (region*2+1)*height/(tasks*2);
433   int end_row = (region*2+2)*height/(tasks*2);
434   int row;
435
436   /* spread up, starting at middle row, moving down */
437   /* first task is to save a copy of the un-transformed middle row, as
438      we'll need it for the even pass */
439   memcpy(temp,work+mid_row*width,sizeof(*temp)*width);
440
441   /* odd interleave */
442   for(row=mid_row;row<end_row-1;row++)
443     func(work+row*width,work+(row+1)*width,width);
444   if(end_row<height && row<end_row)
445     func(work+row*width,work+(row+1)*width,width);
446   e->wait_task();
447
448   /* even interleave */
449   e->set_task(0,"up_even");
450   for(row=start_row;row<mid_row-1;row++)
451     func(work+row*width,work+(row+1)*width,width);
452   if(row<mid_row)
453     func(work+row*width,temp,width);
454   e->wait_task();
455
456   /* spread down, starting at mid row and moving up */
457   /* once again, grab a temp vector for the second pass overlap */
458   memcpy(temp,work+mid_row*width,sizeof(*temp)*width);
459
460   /* even interleave */
461   e->set_task(0,"down_even");
462   for(row=mid_row;row>start_row;row--)
463     func(work+row*width,work+(row-1)*width,width);
464   if(start_row>0)
465     func(work+row*width,work+(row-1)*width,width);
466   e->wait_task();
467
468   /* odd interleave */
469   e->set_task(0,"down_odd");
470   for(row=end_row-1;row>mid_row+1;row--)
471     func(work+row*width,work+(row-1)*width,width);
472   if(row>mid_row)
473     func(work+row*width,temp,width);
474   e->wait_task();
475
476   /* done */
477 }
478
479 static float *fill_one(float *in, float *work,
480                       int width, int height,
481                       BluebananaEngine *e, // NULL if we're not threading
482                       char *pattern,
483                       int n){
484   int i,j;
485   int tasks = e?e->get_total_packages():0;
486   float temp[width];
487
488   if(n){
489
490     if(e){
491
492       /* multiple memcpys running at once is occasionally a total
493          cache disaster on Sandy Bridge.  So only one thread gets to
494          copy, the others wait. */
495       e->set_task(1,"fill_memcpy");
496       while((j = e->next_task())>=0){
497         memcpy(work,in,width*height*sizeof(*work));
498       }
499
500     }else{
501       memcpy(work,in,width*height*sizeof(*work));
502     }
503
504
505     for(i=0;i<n;i++){
506       switch(pattern[i]){
507       case 'H': /* grow horizontal */
508         if(e){
509           threaded_horizontal(in, work, width, height, e, tasks, 1, select_grow_h);
510         }else{
511           for(j=0;j<height;j++)
512             select_grow_h(in+j*width,work+j*width,width);
513         }
514         break;
515
516       case 'V': /* grow vertical */
517         if(e){
518           threaded_vertical(work, temp, width, height, e, tasks, select_grow_v);
519         }else{
520           for(j=0;j<height-1;j++)
521             select_grow_v(work+j*width,work+(j+1)*width,width);
522           for(j=height-1;j>0;j--)
523             select_grow_v(work+j*width,work+(j-1)*width,width);
524         }
525         break;
526
527       case 'h': /* shrink horizontal */
528         if(e){
529           threaded_horizontal(in, work, width, height, e, tasks, 1, select_shrink_h);
530         }else{
531           for(j=0;j<height;j++)
532             select_shrink_h(in+j*width,work+j*width,width);
533         }
534         break;
535
536       default: /* shrink vertical */
537
538         if(e){
539           threaded_vertical(work, temp, width, height, e, tasks, select_shrink_v);
540         }else{
541           for(j=0;j<height-1;j++)
542             select_shrink_v(work+j*width,work+(j+1)*width,width);
543           for(j=height-1;j>0;j--)
544             select_shrink_v(work+j*width,work+(j-1)*width,width);
545         }
546         break;
547       }
548     }
549     return work;
550   }else{
551     return in;
552   }
553 }
554
555 static void select_feather_h(float *p, float *dummy, int w){
556   for(int x=0;x<w-1;x++)
557     p[x] = (p[x]+p[x+1])*.5;
558   for(int x=w-1;x>0;x--)
559     p[x] = (p[x]+p[x-1])*.5;
560 }
561
562 static void select_feather_v(float *p0, float *p1, int w){
563   for(int x=0; x<w; x++)
564     p0[x] = (p0[x]+p1[x])*.5;
565 }
566
567 static void feather_one(float *in,
568                         int width, int height,
569                         BluebananaEngine *e, // NULL if we're not threading
570                         int n){
571   int i,j;
572   int tasks = e?e->get_total_packages():0;
573   float temp[width];
574
575   if(e){
576     threaded_horizontal(in, 0, width, height, e, tasks, n, select_feather_h);
577     for(int i=0;i<n;i++)
578       threaded_vertical(in, temp, width, height, e, tasks, select_feather_v);
579   }else{
580     for(j=0;j<height;j++)
581       for(i=0;i<n;i++)
582         select_feather_h(in+j*width,0,width);
583
584     for(i=0;i<n;i++){
585       for(j=0;j<height-1;j++)
586         select_feather_v(in+j*width,in+(j+1)*width,width);
587       for(j=height-1;j>0;j--)
588         select_feather_v(in+j*width,in+(j-1)*width,width);
589     }
590   }
591 }
592
593 /* here and not in the engine as the GUI also uses it (without
594    threading) */
595 float *BluebananaMain::fill_selection(float *in, float *work,
596                                          int width, int height,
597                                          BluebananaEngine *e){
598   float *A=in;
599   float *B=work;
600   float *C;
601
602   C=fill_one(A,B,width,height,e,select_one,select_one_n);
603   C=fill_one(C,(C==A?B:A),width,height,e,select_two,select_two_n);
604   C=fill_one(C,(C==A?B:A),width,height,e,select_three,select_three_n);
605
606   feather_one(C,width,height,e,config.Fsel_over);
607
608   return C;
609 }
610
611
612 int BluebananaMain::process_buffer(VFrame *frame,
613                                    int64_t start_position,
614                                    double frame_rate){
615   ants_counter++;
616   SET_TRACE
617   load_configuration();
618   this->frame = frame;
619
620   SET_TRACE
621   update_lookups(1);
622
623   SET_TRACE
624   read_frame(frame, 0, start_position, frame_rate, 0);
625
626   if(!engine)
627     engine = new BluebananaEngine(this, get_project_smp() + 1,
628                                   get_project_smp() + 1);
629   SET_TRACE
630   engine->process_packages(frame);
631
632   // push final histograms to UI if it's up
633   SET_TRACE
634   send_render_gui(this);
635
636   return 0;
637 }
638