Credit Andrea/Andrew - allow for out-of-range values for HDR video; so no clipping...
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / histogram / histogram.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008-2012 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 <math.h>
23 #include <stdint.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "bcdisplayinfo.h"
28 #include "bchash.h"
29 #include "bcprogressbox.h"
30 #include "bcsignals.h"
31 #include "clip.h"
32 #include "edl.h"
33 #include "filexml.h"
34 #include "histogram.h"
35 #include "histogramconfig.h"
36 #include "histogramwindow.h"
37 #include "keyframe.h"
38 #include "language.h"
39 #include "loadbalance.h"
40 #include "localsession.h"
41 #include "mainsession.h"
42 #include "mwindow.h"
43 #include "playback3d.h"
44 #include "pluginserver.h"
45 #include "bccolors.h"
46 #include "vframe.h"
47 #include "workarounds.h"
48
49 #include "aggregated.h"
50 #include "../colorbalance/aggregated.h"
51 #include "../interpolate/aggregated.h"
52 #include "../gamma/aggregated.h"
53
54 class HistogramMain;
55 class HistogramEngine;
56 class HistogramWindow;
57
58
59 REGISTER_PLUGIN(HistogramMain)
60
61 HistogramMain::HistogramMain(PluginServer *server)
62  : PluginVClient(server)
63 {
64         engine = 0;
65         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
66                 lookup[i] = new int[0x10000];
67                 preview_lookup[i] = new int[0x10000];
68                 accum[i] = new int64_t[HISTOGRAM_SLOTS];
69                 bzero(accum[i], sizeof(int64_t)*HISTOGRAM_SLOTS);
70         }
71         current_point = -1;
72         mode = HISTOGRAM_VALUE;
73         last_position = -1;
74         need_reconfigure = 1;
75         sum_frames = 0;
76         frames = 1;
77         dragging_point = 0;
78         input = 0;
79         output = 0;
80         w = 440;
81         h = 500;
82         parade = 0;
83 }
84
85 HistogramMain::~HistogramMain()
86 {
87
88         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
89                 delete [] lookup[i];
90                 delete [] preview_lookup[i];
91                 delete [] accum[i];
92         }
93         delete engine;
94 }
95
96 const char* HistogramMain::plugin_title() { return N_("Histogram"); }
97 int HistogramMain::is_realtime() { return 1; }
98
99
100
101 NEW_WINDOW_MACRO(HistogramMain, HistogramWindow)
102
103 LOAD_CONFIGURATION_MACRO(HistogramMain, HistogramConfig)
104
105 void HistogramMain::render_gui(void *data)
106 {
107         if( !thread ) return;
108         HistogramWindow *window = (HistogramWindow*)thread->window;
109         HistogramMain *plugin = (HistogramMain*)data;
110 //update gui client instance, needed for drawing
111         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
112                 config.low_input[i] = plugin->config.low_input[i];
113                 config.high_input[i] = plugin->config.high_input[i];
114                 memcpy(accum[i], plugin->accum[i], HISTOGRAM_SLOTS*sizeof(*accum));
115         }
116         window->lock_window("HistogramMain::render_gui 2");
117 // draw all if reconfigure
118         int reconfig = plugin->need_reconfigure;
119 // Always draw the histogram but don't update widgets if automatic
120         int auto_rgb = reconfig ? 1 : config.automatic && mode != HISTOGRAM_VALUE ? 1 : 0;
121         window->update(1, auto_rgb, auto_rgb, reconfig);
122         window->unlock_window();
123 }
124
125 void HistogramMain::update_gui()
126 {
127         if( thread ) {
128                 ((HistogramWindow*)thread->window)->lock_window("HistogramMain::update_gui");
129                 int reconfigure = load_configuration();
130                 if( reconfigure )
131                         ((HistogramWindow*)thread->window)->update(1, 1, 1, 1);
132                 ((HistogramWindow*)thread->window)->unlock_window();
133         }
134 }
135
136
137 void HistogramMain::save_data(KeyFrame *keyframe)
138 {
139         FileXML output;
140 // cause data to be stored directly in text
141         output.set_shared_output(keyframe->xbuf);
142         output.tag.set_title("HISTOGRAM");
143
144         char string[BCTEXTLEN];
145
146         output.tag.set_property("AUTOMATIC", config.automatic);
147         output.tag.set_property("THRESHOLD", config.threshold);
148         output.tag.set_property("PLOT", config.plot);
149         output.tag.set_property("SUM_FRAMES", config.sum_frames);
150         output.tag.set_property("SPLIT", config.split);
151         output.tag.set_property("LOG_SLIDER", config.log_slider);
152         output.tag.set_property("W", w);
153         output.tag.set_property("H", h);
154         output.tag.set_property("PARADE", parade);
155         output.tag.set_property("MODE", mode);
156
157         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
158                 sprintf(string, "LOW_OUTPUT_%d", i);
159                 output.tag.set_property(string, config.low_output[i]);
160                 sprintf(string, "HIGH_OUTPUT_%d", i);
161                 output.tag.set_property(string, config.high_output[i]);
162                 sprintf(string, "LOW_INPUT_%d", i);
163                 output.tag.set_property(string, config.low_input[i]);
164                 sprintf(string, "HIGH_INPUT_%d", i);
165                 output.tag.set_property(string, config.high_input[i]);
166                 sprintf(string, "GAMMA_%d", i);
167                 output.tag.set_property(string, config.gamma[i]);
168         }
169
170         output.append_tag();
171         output.tag.set_title("/HISTOGRAM");
172         output.append_tag();
173         output.append_newline();
174         output.terminate_string();
175 }
176
177 void HistogramMain::read_data(KeyFrame *keyframe)
178 {
179         FileXML input;
180
181         input.set_shared_input(keyframe->xbuf);
182
183         int result = 0;
184         while( !(result = input.read_tag()) ) {
185                 if( input.tag.title_is("HISTOGRAM") ) {
186                         config.automatic = input.tag.get_property("AUTOMATIC", config.automatic);
187                         config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
188                         config.plot = input.tag.get_property("PLOT", config.plot);
189                         config.sum_frames = input.tag.get_property("SUM_FRAMES", config.sum_frames);
190                         config.split = input.tag.get_property("SPLIT", config.split);
191                         config.log_slider = input.tag.get_property("LOG_SLIDER", config.log_slider);
192
193                         if( is_defaults() ) {
194                                 w = input.tag.get_property("W", w);
195                                 h = input.tag.get_property("H", h);
196                                 parade = input.tag.get_property("PARADE", parade);
197                                 mode = input.tag.get_property("MODE", mode);
198                         }
199
200                         char string[BCTEXTLEN];
201                         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
202                                 sprintf(string, "LOW_OUTPUT_%d", i);
203                                 config.low_output[i] = input.tag.get_property(string, config.low_output[i]);
204                                 sprintf(string, "HIGH_OUTPUT_%d", i);
205                                 config.high_output[i] = input.tag.get_property(string, config.high_output[i]);
206                                 sprintf(string, "GAMMA_%d", i);
207                                 config.gamma[i] = input.tag.get_property(string, config.gamma[i]);
208
209                                 if( i == HISTOGRAM_VALUE || !config.automatic ) {
210                                         sprintf(string, "LOW_INPUT_%d", i);
211                                         config.low_input[i] = input.tag.get_property(string, config.low_input[i]);
212                                         sprintf(string, "HIGH_INPUT_%d", i);
213                                         config.high_input[i] = input.tag.get_property(string, config.high_input[i]);
214                                 }
215                         }
216                 }
217         }
218
219         config.boundaries();
220 }
221
222 float HistogramMain::calculate_level(float input, int mode, int use_value)
223 {
224         float output = 0.0;
225
226 // Scale to input range
227         if( !EQUIV(config.high_input[mode], config.low_input[mode]) ) {
228                 output = input < config.low_input[mode] ? 0 :
229                     (input - config.low_input[mode]) /
230                         (config.high_input[mode] - config.low_input[mode]);
231         }
232         else
233                 output = input;
234
235         if( !EQUIV(config.gamma[mode], 0) ) {
236                 output = pow(output, 1.0 / config.gamma[mode]);
237                 CLAMP(output, 0, 100.0);
238         }
239
240 // Apply value curve
241         if( use_value && mode != HISTOGRAM_VALUE )
242                 output = calculate_level(output, HISTOGRAM_VALUE, 0);
243
244 // scale to output range
245         if( !EQUIV(config.low_output[mode], config.high_output[mode]) ) {
246                 output = output * (config.high_output[mode] - config.low_output[mode]) +
247                         config.low_output[mode];
248         }
249
250         CLAMP(output, 0, 1.0);
251         return output;
252 }
253
254 void HistogramMain::calculate_histogram(VFrame *data, int do_value)
255 {
256         if( !engine ) {
257                 int cpus = data->get_w() * data->get_h() / 0x80000 + 2;
258                 int smps = get_project_smp();
259                 if( cpus > smps ) cpus = smps;
260                 engine = new HistogramEngine(this, cpus, cpus);
261         }
262
263         engine->process_packages(HistogramEngine::HISTOGRAM, data, do_value);
264
265         int k = 0;
266         HistogramUnit *unit = (HistogramUnit*)engine->get_client(0);
267         if( !sum_frames ) {
268                 frames = 0;
269                 for( int i=0; i<HISTOGRAM_MODES; ++i )
270                         memcpy(accum[i], unit->accum[i], sizeof(int64_t)*HISTOGRAM_SLOTS);
271                 k = 1;
272         }
273
274         for( int i=k,n=engine->get_total_clients(); i<n; ++i ) {
275                 unit = (HistogramUnit*)engine->get_client(i);
276                 for( int j=0; j<HISTOGRAM_MODES; ++j ) {
277                         int64_t *in = unit->accum[j], *out = accum[j];
278                         for( int k=HISTOGRAM_SLOTS; --k>=0; ) *out++ += *in++;
279                 }
280         }
281
282 // Remove top and bottom from calculations.  Doesn't work in high
283 // precision colormodels.
284         for( int i=0; i<HISTOGRAM_MODES; ++i ) {
285                 accum[i][0] = 0;
286                 accum[i][HISTOGRAM_SLOTS - 1] = 0;
287         }
288         ++frames;
289 }
290
291
292 void HistogramMain::calculate_automatic(VFrame *data)
293 {
294         calculate_histogram(data, 0);
295         config.reset_points(1);
296
297 // Do each channel
298         for( int i=0; i<3; ++i ) {
299                 int64_t *accum = this->accum[i];
300                 int64_t sz = data->get_w() * data->get_h();
301                 int64_t pixels = sz * frames;
302                 float white_fraction = 1.0 - (1.0 - config.threshold) / 2;
303                 int threshold = (int)(white_fraction * pixels);
304                 float min_level = 0.0, max_level = 1.0;
305
306 // Get histogram slot above threshold of pixels
307                 int64_t total = 0;
308                 for( int j=0; j<HISTOGRAM_SLOTS; ++j ) {
309                         total += accum[j];
310                         if( total >= threshold ) {
311                                 max_level = (float)j / HISTOGRAM_SLOTS * FLOAT_RANGE + HIST_MIN_INPUT;
312                                 break;
313                         }
314                 }
315
316 // Get histogram slot below threshold of pixels
317                 total = 0;
318                 for( int j=HISTOGRAM_SLOTS; --j> 0; ) {
319                         total += accum[j];
320                         if( total >= threshold ) {
321                                 min_level = (float)j / HISTOGRAM_SLOTS * FLOAT_RANGE + HIST_MIN_INPUT;
322                                 break;
323                         }
324                 }
325
326                 config.low_input[i] = min_level;
327                 config.high_input[i] = max_level;
328         }
329 }
330
331
332 int HistogramMain::calculate_use_opengl()
333 {
334 // glHistogram doesn't work.
335         int result = get_use_opengl() &&
336                 !config.automatic &&
337                 (!config.plot || !gui_open());
338         return result;
339 }
340
341
342 int HistogramMain::process_buffer(VFrame *frame,
343         int64_t start_position,
344         double frame_rate)
345 {
346         need_reconfigure = load_configuration();
347         int use_opengl = calculate_use_opengl();
348         sum_frames = last_position == start_position ? config.sum_frames : 0;
349         last_position = get_direction() == PLAY_FORWARD ?
350                         start_position+1 : start_position-1;
351         this->input = frame;
352         this->output = frame;
353         int cpus = input->get_w() * input->get_h() / 0x80000 + 2;
354         int smps = get_project_smp();
355         if( cpus > smps ) cpus = smps;
356         if( !engine )
357                 engine = new HistogramEngine(this, cpus, cpus);
358         read_frame(frame, 0, start_position, frame_rate, use_opengl);
359         if( config.automatic )
360                 calculate_automatic(frame);
361         if( config.plot ) {
362 // Generate curves for value histogram
363                 tabulate_curve(lookup, 0);
364                 tabulate_curve(preview_lookup, 0, 0x10000);
365 // Need to get the luminance values.
366                 calculate_histogram(input, 1);
367                 send_render_gui(this);
368         }
369
370         if( need_reconfigure || config.automatic || config.plot ) {
371 // Calculate new curves
372 // Generate transfer tables with value function for integer colormodels.
373                 tabulate_curve(lookup, 1);
374         }
375
376 // Apply histogram in hardware
377         if( use_opengl )
378                 return run_opengl();
379
380 // Apply histogram
381         engine->process_packages(HistogramEngine::APPLY, input, 0);
382         return 0;
383 }
384
385 void HistogramMain::tabulate_curve(int **table, int idx, int use_value, int len)
386 {
387         int len1 = len - 1;
388         int *curve = table[idx];
389         for( int i=0; i<len; ++i ) {
390                 curve[i] = calculate_level((float)i/len1, idx, use_value) * len1;
391                 CLAMP(curve[i], 0, len1);
392         }
393 }
394
395 void HistogramMain::tabulate_curve(int **table, int use_value, int len)
396 {
397 // uint8 rgb is 8 bit, all others are converted to 16 bit RGB
398         if( len < 0 ) {
399                 int color_model = input->get_color_model();
400                 len = color_model == BC_RGB888 || color_model == BC_RGBA8888 ?
401                         0x100 : 0x10000;
402         }
403         for( int i=0; i<3; ++i )
404                 tabulate_curve(table, i, use_value, len);
405 }
406
407 int HistogramMain::handle_opengl()
408 {
409 #ifdef HAVE_GL
410 // Functions to get pixel from either previous effect or texture
411         static const char *histogram_get_pixel1 =
412                 "vec4 histogram_get_pixel()\n"
413                 "{\n"
414                 "       return gl_FragColor;\n"
415                 "}\n";
416
417         static const char *histogram_get_pixel2 =
418                 "uniform sampler2D tex;\n"
419                 "vec4 histogram_get_pixel()\n"
420                 "{\n"
421                 "       return texture2D(tex, gl_TexCoord[0].st);\n"
422                 "}\n";
423
424         static const char *head_frag =
425                 "uniform vec4 low_input;\n"
426                 "uniform vec4 high_input;\n"
427                 "uniform vec4 gamma;\n"
428                 "uniform vec4 low_output;\n"
429                 "uniform vec4 output_scale;\n"
430                 "void main()\n"
431                 "{\n"
432                 "       float temp = 0.0;\n";
433
434         static const char *get_rgb_frag =
435                 "       vec4 pixel = histogram_get_pixel();\n";
436
437         static const char *get_yuv_frag =
438                 "       vec4 pixel = histogram_get_pixel();\n"
439                         YUV_TO_RGB_FRAG("pixel");
440
441 #define APPLY_INPUT_CURVE(PIXEL, LOW_INPUT, HIGH_INPUT, GAMMA) \
442                 "// apply input curve\n" \
443                 "       temp = (" PIXEL " - " LOW_INPUT ") / \n" \
444                 "               (" HIGH_INPUT " - " LOW_INPUT ");\n" \
445                 "       temp = max(temp, 0.0);\n" \
446                 "       " PIXEL " = pow(temp, 1.0 / " GAMMA ");\n"
447
448
449
450         static const char *apply_histogram_frag =
451                 APPLY_INPUT_CURVE("pixel.r", "low_input.r", "high_input.r", "gamma.r")
452                 APPLY_INPUT_CURVE("pixel.g", "low_input.g", "high_input.g", "gamma.g")
453                 APPLY_INPUT_CURVE("pixel.b", "low_input.b", "high_input.b", "gamma.b")
454                 "// apply output curve\n"
455                 "       pixel.rgb *= output_scale.rgb;\n"
456                 "       pixel.rgb += low_output.rgb;\n"
457                 APPLY_INPUT_CURVE("pixel.r", "low_input.a", "high_input.a", "gamma.a")
458                 APPLY_INPUT_CURVE("pixel.g", "low_input.a", "high_input.a", "gamma.a")
459                 APPLY_INPUT_CURVE("pixel.b", "low_input.a", "high_input.a", "gamma.a")
460                 "// apply output curve\n"
461                 "       pixel.rgb *= vec3(output_scale.a, output_scale.a, output_scale.a);\n"
462                 "       pixel.rgb += vec3(low_output.a, low_output.a, low_output.a);\n";
463
464         static const char *put_rgb_frag =
465                 "       gl_FragColor = pixel;\n"
466                 "}\n";
467
468         static const char *put_yuv_frag =
469                         RGB_TO_YUV_FRAG("pixel")
470                 "       gl_FragColor = pixel;\n"
471                 "}\n";
472
473
474
475         get_output()->to_texture();
476         get_output()->enable_opengl();
477
478         const char *shader_stack[16];
479         memset(shader_stack,0, sizeof(shader_stack));
480         int current_shader = 0;
481
482         int need_color_matrix = BC_CModels::is_yuv(get_output()->get_color_model()) ? 1 : 0;
483         if( need_color_matrix )
484                 shader_stack[current_shader++] = bc_gl_colors;
485
486         int aggregate_interpolation = 0;
487         int aggregate_gamma = 0;
488         int aggregate_colorbalance = 0;
489 // All aggregation possibilities must be accounted for because unsupported
490 // effects can get in between the aggregation members.
491         if(!strcmp(get_output()->get_prev_effect(2), _("Interpolate Pixels")) &&
492                 !strcmp(get_output()->get_prev_effect(1), _("Gamma")) &&
493                 !strcmp(get_output()->get_prev_effect(0), _("Color Balance")))
494         {
495                 aggregate_interpolation = 1;
496                 aggregate_gamma = 1;
497                 aggregate_colorbalance = 1;
498         }
499         else
500         if(!strcmp(get_output()->get_prev_effect(1), _("Gamma")) &&
501                 !strcmp(get_output()->get_prev_effect(0), _("Color Balance")))
502         {
503                 aggregate_gamma = 1;
504                 aggregate_colorbalance = 1;
505         }
506         else
507         if(!strcmp(get_output()->get_prev_effect(1), _("Interpolate Pixels")) &&
508                 !strcmp(get_output()->get_prev_effect(0), _("Gamma")))
509         {
510                 aggregate_interpolation = 1;
511                 aggregate_gamma = 1;
512         }
513         else
514         if(!strcmp(get_output()->get_prev_effect(1), _("Interpolate Pixels")) &&
515                 !strcmp(get_output()->get_prev_effect(0), _("Color Balance")))
516         {
517                 aggregate_interpolation = 1;
518                 aggregate_colorbalance = 1;
519         }
520         else
521         if(!strcmp(get_output()->get_prev_effect(0), _("Interpolate Pixels")))
522                 aggregate_interpolation = 1;
523         else
524         if(!strcmp(get_output()->get_prev_effect(0), _("Gamma")))
525                 aggregate_gamma = 1;
526         else
527         if(!strcmp(get_output()->get_prev_effect(0), _("Color Balance")))
528                 aggregate_colorbalance = 1;
529
530 // The order of processing is fixed by this sequence
531         if(aggregate_interpolation)
532                 INTERPOLATE_COMPILE(shader_stack, current_shader);
533
534         if(aggregate_gamma)
535                 GAMMA_COMPILE(shader_stack, current_shader,
536                         aggregate_interpolation);
537
538         if(aggregate_colorbalance)
539                 COLORBALANCE_COMPILE(shader_stack, current_shader,
540                         aggregate_interpolation || aggregate_gamma);
541
542         shader_stack[current_shader++] = 
543                 aggregate_interpolation || aggregate_gamma || aggregate_colorbalance ?
544                         histogram_get_pixel1 : histogram_get_pixel2;
545
546         shader_stack[current_shader++] = head_frag;
547         shader_stack[current_shader++] = BC_CModels::is_yuv(get_output()->get_color_model()) ?
548                         get_yuv_frag : get_rgb_frag;
549         shader_stack[current_shader++] = apply_histogram_frag;
550         shader_stack[current_shader++] = BC_CModels::is_yuv(get_output()->get_color_model()) ?
551                         put_yuv_frag : put_rgb_frag;
552
553         shader_stack[current_shader] = 0;
554         unsigned int shader = VFrame::make_shader(shader_stack);
555
556 // printf("HistogramMain::handle_opengl %d %d %d %d shader=%d\n",
557 // aggregate_interpolation,
558 // aggregate_gamma,
559 // aggregate_colorbalance,
560 // current_shader,
561 // shader);
562
563         float low_input[4];
564         float high_input[4];
565         float gamma[4];
566         float low_output[4];
567         float output_scale[4];
568
569
570 // printf("min x    min y    max x    max y\n");
571 // printf("%f %f %f %f\n", input_min_r[0], input_min_r[1], input_max_r[0], input_max_r[1]);
572 // printf("%f %f %f %f\n", input_min_g[0], input_min_g[1], input_max_g[0], input_max_g[1]);
573 // printf("%f %f %f %f\n", input_min_b[0], input_min_b[1], input_max_b[0], input_max_b[1]);
574 // printf("%f %f %f %f\n", input_min_v[0], input_min_v[1], input_max_v[0], input_max_v[1]);
575
576         for(int i = 0; i < HISTOGRAM_MODES; i++)
577         {
578                 low_input[i] = config.low_input[i];
579                 high_input[i] = config.high_input[i];
580                 gamma[i] = config.gamma[i];
581                 low_output[i] = config.low_output[i];
582                 output_scale[i] = config.high_output[i] - config.low_output[i];
583         }
584
585         if(shader > 0)
586         {
587                 glUseProgram(shader);
588                 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
589                 if(aggregate_gamma) GAMMA_UNIFORMS(shader);
590                 if(aggregate_interpolation) INTERPOLATE_UNIFORMS(shader);
591                 if(aggregate_colorbalance) COLORBALANCE_UNIFORMS(shader);
592                 glUniform4fv(glGetUniformLocation(shader, "low_input"), 1, low_input);
593                 glUniform4fv(glGetUniformLocation(shader, "high_input"), 1, high_input);
594                 glUniform4fv(glGetUniformLocation(shader, "gamma"), 1, gamma);
595                 glUniform4fv(glGetUniformLocation(shader, "low_output"), 1, low_output);
596                 glUniform4fv(glGetUniformLocation(shader, "output_scale"), 1, output_scale);
597                 if( need_color_matrix ) BC_GL_COLORS(shader);
598         }
599
600         get_output()->init_screen();
601         get_output()->bind_texture(0);
602
603         glDisable(GL_BLEND);
604
605 // Draw the affected half
606         if(config.split)
607         {
608                 glBegin(GL_TRIANGLES);
609                 glNormal3f(0, 0, 1.0);
610
611                 glTexCoord2f(0.0 / get_output()->get_texture_w(),
612                         0.0 / get_output()->get_texture_h());
613                 glVertex3f(0.0, -(float)get_output()->get_h(), 0);
614
615
616                 glTexCoord2f((float)get_output()->get_w() / get_output()->get_texture_w(),
617                         (float)get_output()->get_h() / get_output()->get_texture_h());
618                 glVertex3f((float)get_output()->get_w(), -0.0, 0);
619
620                 glTexCoord2f(0.0 / get_output()->get_texture_w(),
621                         (float)get_output()->get_h() / get_output()->get_texture_h());
622                 glVertex3f(0.0, -0.0, 0);
623
624
625                 glEnd();
626         }
627         else
628         {
629                 get_output()->draw_texture();
630         }
631
632         glUseProgram(0);
633
634 // Draw the unaffected half
635         if(config.split)
636         {
637                 glBegin(GL_TRIANGLES);
638                 glNormal3f(0, 0, 1.0);
639
640
641                 glTexCoord2f(0.0 / get_output()->get_texture_w(),
642                         0.0 / get_output()->get_texture_h());
643                 glVertex3f(0.0, -(float)get_output()->get_h(), 0);
644
645                 glTexCoord2f((float)get_output()->get_w() / get_output()->get_texture_w(),
646                         0.0 / get_output()->get_texture_h());
647                 glVertex3f((float)get_output()->get_w(),
648                         -(float)get_output()->get_h(), 0);
649
650                 glTexCoord2f((float)get_output()->get_w() / get_output()->get_texture_w(),
651                         (float)get_output()->get_h() / get_output()->get_texture_h());
652                 glVertex3f((float)get_output()->get_w(), -0.0, 0);
653
654
655                 glEnd();
656         }
657
658         get_output()->set_opengl_state(VFrame::SCREEN);
659 #endif
660         return 0;
661 }
662
663
664 HistogramPackage::HistogramPackage()
665  : LoadPackage()
666 {
667 }
668
669 HistogramUnit::HistogramUnit(HistogramEngine *server,
670         HistogramMain *plugin)
671  : LoadClient(server)
672 {
673         this->plugin = plugin;
674         this->server = server;
675         for(int i = 0; i < HISTOGRAM_MODES; i++)
676                 accum[i] = new int64_t[HISTOGRAM_SLOTS];
677 }
678
679 HistogramUnit::~HistogramUnit()
680 {
681         for(int i = 0; i < HISTOGRAM_MODES; i++)
682                 delete [] accum[i];
683 }
684
685 void HistogramUnit::process_package(LoadPackage *package)
686 {
687         HistogramPackage *pkg = (HistogramPackage*)package;
688         switch( server->operation ) {
689         case HistogramEngine::HISTOGRAM: {
690                 int do_value = server->do_value;
691                 const int hmin = HISTOGRAM_MIN * 0xffff / 100;
692                 const int slots1 = HISTOGRAM_SLOTS-1;
693
694 #define HISTOGRAM_HEAD(type) { \
695         type **rows = (type**)data->get_rows(); \
696         for( int iy=pkg->start; iy<pkg->end; ++iy ) { \
697                 type *row = rows[iy]; \
698                 for( int ix=0; ix<w; ++ix ) {
699
700 #define HISTOGRAM_TAIL(components) \
701                         if( do_value ) { \
702                                 r_out = preview_r[bclip(r, 0, 0xffff)]; \
703                                 g_out = preview_g[bclip(g, 0, 0xffff)]; \
704                                 b_out = preview_b[bclip(b, 0, 0xffff)]; \
705 /*                              v = (r * 76 + g * 150 + b * 29) >> 8; */ \
706 /* Value takes the maximum of the output RGB values */ \
707                                 int v = MAX(r_out, g_out); v = MAX(v, b_out); \
708                                 ++accum_v[bclip(v -= hmin, 0, slots1)]; \
709                         } \
710  \
711                         ++accum_r[bclip(r -= hmin, 0, slots1)]; \
712                         ++accum_g[bclip(g -= hmin, 0, slots1)]; \
713                         ++accum_b[bclip(b -= hmin, 0, slots1)]; \
714                         row += components; \
715                 } \
716         } \
717 }
718
719                 VFrame *data = server->data;
720                 int w = data->get_w();
721                 //int h = data->get_h();
722                 int64_t *accum_r = accum[HISTOGRAM_RED];
723                 int64_t *accum_g = accum[HISTOGRAM_GREEN];
724                 int64_t *accum_b = accum[HISTOGRAM_BLUE];
725                 int64_t *accum_v = accum[HISTOGRAM_VALUE];
726                 int32_t r, g, b, y, u, v;
727                 int r_out, g_out, b_out;
728                 int *preview_r = plugin->preview_lookup[HISTOGRAM_RED];
729                 int *preview_g = plugin->preview_lookup[HISTOGRAM_GREEN];
730                 int *preview_b = plugin->preview_lookup[HISTOGRAM_BLUE];
731
732                 switch( data->get_color_model() ) {
733                 case BC_RGB888:
734                         HISTOGRAM_HEAD(unsigned char)
735                         r = (row[0] << 8) | row[0];
736                         g = (row[1] << 8) | row[1];
737                         b = (row[2] << 8) | row[2];
738                         HISTOGRAM_TAIL(3)
739                         break;
740                 case BC_RGB_FLOAT:
741                         HISTOGRAM_HEAD(float)
742                         r = (int)(row[0] * 0xffff);
743                         g = (int)(row[1] * 0xffff);
744                         b = (int)(row[2] * 0xffff);
745                         HISTOGRAM_TAIL(3)
746                         break;
747                 case BC_YUV888:
748                         HISTOGRAM_HEAD(unsigned char)
749                         y = (row[0] << 8) | row[0];
750                         u = (row[1] << 8) | row[1];
751                         v = (row[2] << 8) | row[2];
752                         YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);
753                         HISTOGRAM_TAIL(3)
754                         break;
755                 case BC_RGBA8888:
756                         HISTOGRAM_HEAD(unsigned char)
757                         r = (row[0] << 8) | row[0];
758                         g = (row[1] << 8) | row[1];
759                         b = (row[2] << 8) | row[2];
760                         HISTOGRAM_TAIL(4)
761                         break;
762                 case BC_RGBA_FLOAT:
763                         HISTOGRAM_HEAD(float)
764                         r = (int)(row[0] * 0xffff);
765                         g = (int)(row[1] * 0xffff);
766                         b = (int)(row[2] * 0xffff);
767                         HISTOGRAM_TAIL(4)
768                         break;
769                 case BC_YUVA8888:
770                         HISTOGRAM_HEAD(unsigned char)
771                         y = (row[0] << 8) | row[0];
772                         u = (row[1] << 8) | row[1];
773                         v = (row[2] << 8) | row[2];
774                         YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);
775                         HISTOGRAM_TAIL(4)
776                         break;
777                 case BC_RGB161616:
778                         HISTOGRAM_HEAD(uint16_t)
779                         r = row[0];
780                         g = row[1];
781                         b = row[2];
782                         HISTOGRAM_TAIL(3)
783                         break;
784                 case BC_YUV161616:
785                         HISTOGRAM_HEAD(uint16_t)
786                         y = row[0];
787                         u = row[1];
788                         v = row[2];
789                         YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);
790                         HISTOGRAM_TAIL(3)
791                         break;
792                 case BC_RGBA16161616:
793                         HISTOGRAM_HEAD(uint16_t)
794                         r = row[0];
795                         g = row[1];
796                         b = row[2];
797                         HISTOGRAM_TAIL(3)
798                         break;
799                 case BC_YUVA16161616:
800                         HISTOGRAM_HEAD(uint16_t)
801                         y = row[0];
802                         u = row[1];
803                         v = row[2];
804                         YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);
805                         HISTOGRAM_TAIL(4)
806                         break;
807                 }
808                 break; }
809         case HistogramEngine::APPLY: {
810
811 #define PROCESS(type, components) { \
812         type **rows = (type**)input->get_rows(); \
813         for( int iy=pkg->start; iy<pkg->end; ++iy ) { \
814                 type *row = rows[iy]; \
815                 for( int ix=0; ix<w; ++ix ) { \
816                         if( plugin->config.split && ((ix + (iy*w)/h) < w) ) \
817                                 continue; \
818                         row[0] = lookup_r[row[0]]; \
819                         row[1] = lookup_g[row[1]]; \
820                         row[2] = lookup_b[row[2]]; \
821                         row += components; \
822                 } \
823         } \
824 }
825
826 #define PROCESS_YUV(type, components, max) { \
827         type **rows = (type**)input->get_rows(); \
828         for( int iy=pkg->start; iy<pkg->end; ++iy ) { \
829                 type *row = rows[iy]; \
830                 for( int ix=0; ix<w; ++ix ) { \
831                         if( plugin->config.split && ((ix + (iy*w)/h) < w) ) \
832                                 continue; \
833                         if( max == 0xff ) { /* Convert to 16 bit RGB */ \
834                                 y = (row[0] << 8) | row[0]; \
835                                 u = (row[1] << 8) | row[1]; \
836                                 v = (row[2] << 8) | row[2]; \
837                         } \
838                         else { \
839                                 y = row[0]; \
840                                 u = row[1]; \
841                                 v = row[2]; \
842                         } \
843                         YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v); \
844 /* Look up in RGB domain */ \
845                         r = lookup_r[r]; \
846                         g = lookup_g[g]; \
847                         b = lookup_b[b]; \
848 /* Convert to 16 bit YUV */ \
849                         YUV::yuv.rgb_to_yuv_16(r, g, b, y, u, v); \
850                         if( max == 0xff ) { \
851                                 row[0] = y >> 8; \
852                                 row[1] = u >> 8; \
853                                 row[2] = v >> 8; \
854                         } \
855                         else { \
856                                 row[0] = y; \
857                                 row[1] = u; \
858                                 row[2] = v; \
859                         } \
860                         row += components; \
861                 } \
862         } \
863 }
864
865 #define PROCESS_FLOAT(components) { \
866         float **rows = (float**)input->get_rows(); \
867         for( int iy=pkg->start; iy<pkg->end; ++iy ) { \
868                 float *row = rows[iy]; \
869                 for( int ix=0; ix<w; ++ix ) { \
870                         if( plugin->config.split && ((ix + (iy*w)/h) < w) ) \
871                                 continue; \
872                         float fr = row[0]; \
873                         float fg = row[1]; \
874                         float fb = row[2]; \
875                         row[0]  = plugin->calculate_level(fr, HISTOGRAM_RED, 1); \
876                         row[1]  = plugin->calculate_level(fg, HISTOGRAM_GREEN, 1); \
877                         row[2]  = plugin->calculate_level(fb, HISTOGRAM_BLUE, 1); \
878                         row += components; \
879                 } \
880         } \
881 }
882
883                 VFrame *input = plugin->input;
884                 //VFrame *output = plugin->output;
885                 int w = input->get_w();
886                 int h = input->get_h();
887                 int *lookup_r = plugin->lookup[0];
888                 int *lookup_g = plugin->lookup[1];
889                 int *lookup_b = plugin->lookup[2];
890                 int r, g, b, y, u, v;
891                 switch( input->get_color_model() ) {
892                 case BC_RGB888:
893                         PROCESS(unsigned char, 3)
894                         break;
895                 case BC_RGB_FLOAT:
896                         PROCESS_FLOAT(3);
897                         break;
898                 case BC_RGBA8888:
899                         PROCESS(unsigned char, 4)
900                         break;
901                 case BC_RGBA_FLOAT:
902                         PROCESS_FLOAT(4);
903                         break;
904                 case BC_RGB161616:
905                         PROCESS(uint16_t, 3)
906                         break;
907                 case BC_RGBA16161616:
908                         PROCESS(uint16_t, 4)
909                         break;
910                 case BC_YUV888:
911                         PROCESS_YUV(unsigned char, 3, 0xff)
912                         break;
913                 case BC_YUVA8888:
914                         PROCESS_YUV(unsigned char, 4, 0xff)
915                         break;
916                 case BC_YUV161616:
917                         PROCESS_YUV(uint16_t, 3, 0xffff)
918                         break;
919                 case BC_YUVA16161616:
920                         PROCESS_YUV(uint16_t, 4, 0xffff)
921                         break;
922                 }
923                 break; }
924         }
925 }
926
927
928 HistogramEngine::HistogramEngine(HistogramMain *plugin,
929         int total_clients, int total_packages)
930  : LoadServer(total_clients, total_packages)
931 {
932         this->plugin = plugin;
933 }
934
935 void HistogramEngine::init_packages()
936 {
937         switch(operation) {
938         case HISTOGRAM:
939                 total_size = data->get_h();
940                 break;
941         case APPLY:
942                 total_size = data->get_h();
943                 break;
944         }
945
946         int start = 0;
947         for( int i=0,n=get_total_packages(); i<n; ++i ) {
948                 HistogramPackage *package = (HistogramPackage*)get_package(i);
949                 package->start = start;
950                 package->end = total_size * (i+1)/n;
951                 start = package->end;
952         }
953
954 // Initialize clients here in case some don't get run.
955         for( int i=0,n=get_total_clients(); i<n; ++i ) {
956                 HistogramUnit *unit = (HistogramUnit*)get_client(i);
957                 for( int j=0; j<HISTOGRAM_MODES; ++j )
958                         bzero(unit->accum[j], sizeof(int64_t) * HISTOGRAM_SLOTS);
959         }
960 }
961
962 LoadClient* HistogramEngine::new_client()
963 {
964         return new HistogramUnit(this, plugin);
965 }
966
967 LoadPackage* HistogramEngine::new_package()
968 {
969         return new HistogramPackage;
970 }
971
972 void HistogramEngine::process_packages(int operation, VFrame *data, int do_value)
973 {
974         this->data = data;
975         this->operation = operation;
976         this->do_value = do_value;
977         LoadServer::process_packages();
978 }
979
980