4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include "histogramengine.h"
31 #include "threshold.h"
32 #include "thresholdwindow.h"
40 ThresholdConfig::ThresholdConfig()
45 int ThresholdConfig::equivalent(ThresholdConfig &that)
47 return EQUIV(min, that.min) &&
48 EQUIV(max, that.max) &&
50 low_color == that.low_color &&
51 mid_color == that.mid_color &&
52 high_color == that.high_color;
55 void ThresholdConfig::copy_from(ThresholdConfig &that)
60 low_color = that.low_color;
61 mid_color = that.mid_color;
62 high_color = that.high_color;
65 // General purpose scale function.
67 T interpolate(const T & prev, const double & prev_scale, const T & next, const double & next_scale)
69 return static_cast<T>(prev * prev_scale + next * next_scale);
72 void ThresholdConfig::interpolate(ThresholdConfig &prev,
73 ThresholdConfig &next,
76 int64_t current_frame)
78 double next_scale = (double)(current_frame - prev_frame) /
79 (next_frame - prev_frame);
80 double prev_scale = (double)(next_frame - current_frame) /
81 (next_frame - prev_frame);
83 min = ::interpolate(prev.min, prev_scale, next.min, next_scale);
84 max = ::interpolate(prev.max, prev_scale, next.max, next_scale);
87 low_color = ::interpolate(prev.low_color, prev_scale, next.low_color, next_scale);
88 mid_color = ::interpolate(prev.mid_color, prev_scale, next.mid_color, next_scale);
89 high_color = ::interpolate(prev.high_color, prev_scale, next.high_color, next_scale);
92 void ThresholdConfig::reset()
97 low_color.set (0x0, 0x0, 0x0, 0xff);
98 mid_color.set (0xff, 0xff, 0xff, 0xff);
99 high_color.set(0x0, 0x0, 0x0, 0xff);
102 void ThresholdConfig::boundaries()
104 CLAMP(min, HISTOGRAM_MIN, max);
105 CLAMP(max, min, HISTOGRAM_MAX);
115 REGISTER_PLUGIN(ThresholdMain)
117 ThresholdMain::ThresholdMain(PluginServer *server)
118 : PluginVClient(server)
121 threshold_engine = 0;
124 ThresholdMain::~ThresholdMain()
127 delete threshold_engine;
130 const char* ThresholdMain::plugin_title() { return _("Threshold"); }
131 int ThresholdMain::is_realtime() { return 1; }
135 LOAD_CONFIGURATION_MACRO(ThresholdMain, ThresholdConfig)
143 int ThresholdMain::process_buffer(VFrame *frame,
144 int64_t start_position,
147 load_configuration();
149 int use_opengl = get_use_opengl() &&
150 (!config.plot || !gui_open());
154 get_source_position(),
158 if(use_opengl) return run_opengl();
160 send_render_gui(frame);
162 if(!threshold_engine)
163 threshold_engine = new ThresholdEngine(this);
164 threshold_engine->process_packages(frame);
169 void ThresholdMain::save_data(KeyFrame *keyframe)
172 output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
173 output.tag.set_title("THRESHOLD");
174 output.tag.set_property("MIN", config.min);
175 output.tag.set_property("MAX", config.max);
176 output.tag.set_property("PLOT", config.plot);
177 config.low_color.set_property(output.tag, "LOW_COLOR");
178 config.mid_color.set_property(output.tag, "MID_COLOR");
179 config.high_color.set_property(output.tag, "HIGH_COLOR");
181 output.tag.set_title("/THRESHOLD");
183 output.append_newline();
184 output.terminate_string();
187 void ThresholdMain::read_data(KeyFrame *keyframe)
190 const char *data = keyframe->get_data();
191 input.set_shared_input((char *)data, strlen(data));
195 result = input.read_tag();
198 config.min = input.tag.get_property("MIN", config.min);
199 config.max = input.tag.get_property("MAX", config.max);
200 config.plot = input.tag.get_property("PLOT", config.plot);
201 config.low_color = config.low_color.get_property(input.tag, "LOW_COLOR");
202 config.mid_color = config.mid_color.get_property(input.tag, "MID_COLOR");
203 config.high_color = config.high_color.get_property(input.tag, "HIGH_COLOR");
209 NEW_WINDOW_MACRO(ThresholdMain,ThresholdWindow);
211 void ThresholdMain::update_gui()
215 thread->window->lock_window("ThresholdMain::update_gui");
216 if(load_configuration())
218 ThresholdWindow *window = (ThresholdWindow*) thread->window;
219 window->min->update(config.min);
220 window->max->update(config.max);
221 window->plot->update(config.plot);
222 window->update_low_color();
223 window->update_mid_color();
224 window->update_high_color();
225 window->low_color_thread->update_gui(config.low_color.getRGB(), config.low_color.a);
226 window->mid_color_thread->update_gui(config.mid_color.getRGB(), config.mid_color.a);
227 window->high_color_thread->update_gui(config.high_color.getRGB(), config.high_color.a);
229 thread->window->unlock_window();
233 void ThresholdMain::render_gui(void *data)
237 calculate_histogram((VFrame*)data);
238 ThresholdWindow *window = (ThresholdWindow*) thread->window;
239 window->lock_window("ThresholdMain::render_gui");
240 window->canvas->draw();
241 window->unlock_window();
245 void ThresholdMain::calculate_histogram(VFrame *frame)
247 if(!engine) engine = new HistogramEngine(get_project_smp() + 1,
248 get_project_smp() + 1);
249 engine->process_packages(frame);
252 int ThresholdMain::handle_opengl()
255 static const char *rgb_shader =
256 "uniform sampler2D tex;\n"
257 "uniform float min;\n"
258 "uniform float max;\n"
259 "uniform vec4 low_color;\n"
260 "uniform vec4 mid_color;\n"
261 "uniform vec4 high_color;\n"
264 " vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
265 " float v = dot(pixel.rgb, vec3(0.299, 0.587, 0.114));\n"
267 " pixel = low_color;\n"
268 " else if(v < max)\n"
269 " pixel = mid_color;\n"
271 " pixel = high_color;\n"
272 " gl_FragColor = pixel;\n"
275 static const char *yuv_shader =
276 "uniform sampler2D tex;\n"
277 "uniform float min;\n"
278 "uniform float max;\n"
279 "uniform vec4 low_color;\n"
280 "uniform vec4 mid_color;\n"
281 "uniform vec4 high_color;\n"
284 " vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
285 " if(pixel.r < min)\n"
286 " pixel = low_color;\n"
287 " else if(pixel.r < max)\n"
288 " pixel = mid_color;\n"
290 " pixel = high_color;\n"
291 " gl_FragColor = pixel;\n"
294 get_output()->to_texture();
295 get_output()->enable_opengl();
297 unsigned int shader = 0;
298 int color_model = get_output()->get_color_model();
299 bool is_yuv = BC_CModels::is_yuv(color_model);
300 bool has_alpha = BC_CModels::has_alpha(color_model);
302 shader = VFrame::make_shader(0, yuv_shader, 0);
304 shader = VFrame::make_shader(0, rgb_shader, 0);
308 glUseProgram(shader);
309 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
310 glUniform1f(glGetUniformLocation(shader, "min"), config.min);
311 glUniform1f(glGetUniformLocation(shader, "max"), config.max);
315 float y_low, u_low, v_low;
316 float y_mid, u_mid, v_mid;
317 float y_high, u_high, v_high;
319 YUV::yuv.rgb_to_yuv_f((float)config.low_color.r / 0xff,
320 (float)config.low_color.g / 0xff,
321 (float)config.low_color.b / 0xff,
327 YUV::yuv.rgb_to_yuv_f((float)config.mid_color.r / 0xff,
328 (float)config.mid_color.g / 0xff,
329 (float)config.mid_color.b / 0xff,
335 YUV::yuv.rgb_to_yuv_f((float)config.high_color.r / 0xff,
336 (float)config.high_color.g / 0xff,
337 (float)config.high_color.b / 0xff,
344 glUniform4f(glGetUniformLocation(shader, "low_color"),
346 has_alpha ? (float)config.low_color.a / 0xff : 1.0);
347 glUniform4f(glGetUniformLocation(shader, "mid_color"),
349 has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
350 glUniform4f(glGetUniformLocation(shader, "high_color"),
351 y_high, u_high, v_high,
352 has_alpha ? (float)config.high_color.a / 0xff : 1.0);
354 glUniform4f(glGetUniformLocation(shader, "low_color"),
355 (float)config.low_color.r / 0xff,
356 (float)config.low_color.g / 0xff,
357 (float)config.low_color.b / 0xff,
358 has_alpha ? (float)config.low_color.a / 0xff : 1.0);
359 glUniform4f(glGetUniformLocation(shader, "mid_color"),
360 (float)config.mid_color.r / 0xff,
361 (float)config.mid_color.g / 0xff,
362 (float)config.mid_color.b / 0xff,
363 has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
364 glUniform4f(glGetUniformLocation(shader, "high_color"),
365 (float)config.high_color.r / 0xff,
366 (float)config.high_color.g / 0xff,
367 (float)config.high_color.b / 0xff,
368 has_alpha ? (float)config.high_color.a / 0xff : 1.0);
372 get_output()->init_screen();
373 get_output()->bind_texture(0);
374 get_output()->draw_texture();
376 get_output()->set_opengl_state(VFrame::SCREEN);
402 ThresholdPackage::ThresholdPackage()
418 ThresholdUnit::ThresholdUnit(ThresholdEngine *server)
421 this->server = server;
424 // Coerces pixel component to int.
425 static inline int get_component(unsigned char v)
430 static inline int get_component(float v)
432 return (int)(v * 0xffff);
435 static inline int get_component(uint16_t v)
440 // Rescales value in range [0, 255] to range appropriate to TYPE.
441 template<typename TYPE>
442 static TYPE scale_to_range(int v)
444 return v; // works for unsigned char, override for the rest.
448 inline float scale_to_range(int v)
450 return (float) v / 0xff;
454 inline uint16_t scale_to_range(int v)
459 static inline void rgb_to_yuv(unsigned char r, unsigned char g, unsigned char b,
460 unsigned char & y, unsigned char & u, unsigned char & v)
462 YUV::yuv.rgb_to_yuv_8(r, g, b, y, u, v);
465 static inline void rgb_to_yuv(float r, float g, float b,
466 float & y, float & u, float & v)
468 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
471 static inline void rgb_to_yuv(uint16_t r, uint16_t g, uint16_t b,
472 uint16_t & y, uint16_t & u, uint16_t & v)
474 YUV::yuv.rgb_to_yuv_16(r, g, b, y, u, v);
477 template<typename TYPE, int COMPONENTS, bool USE_YUV>
478 void ThresholdUnit::render_data(LoadPackage *package)
480 const ThresholdPackage *pkg = (ThresholdPackage*)package;
481 const ThresholdConfig *config = & server->plugin->config;
482 VFrame *data = server->data;
483 const int min = (int)(config->min * 0xffff);
484 const int max = (int)(config->max * 0xffff);
485 const int w = data->get_w();
486 //const int h = data->get_h();
488 const TYPE r_low = scale_to_range<TYPE>(config->low_color.r);
489 const TYPE g_low = scale_to_range<TYPE>(config->low_color.g);
490 const TYPE b_low = scale_to_range<TYPE>(config->low_color.b);
491 const TYPE a_low = scale_to_range<TYPE>(config->low_color.a);
493 const TYPE r_mid = scale_to_range<TYPE>(config->mid_color.r);
494 const TYPE g_mid = scale_to_range<TYPE>(config->mid_color.g);
495 const TYPE b_mid = scale_to_range<TYPE>(config->mid_color.b);
496 const TYPE a_mid = scale_to_range<TYPE>(config->mid_color.a);
498 const TYPE r_high = scale_to_range<TYPE>(config->high_color.r);
499 const TYPE g_high = scale_to_range<TYPE>(config->high_color.g);
500 const TYPE b_high = scale_to_range<TYPE>(config->high_color.b);
501 const TYPE a_high = scale_to_range<TYPE>(config->high_color.a);
503 TYPE y_low, u_low, v_low;
504 TYPE y_mid, u_mid, v_mid;
505 TYPE y_high, u_high, v_high;
509 rgb_to_yuv(r_low, g_low, b_low, y_low, u_low, v_low);
510 rgb_to_yuv(r_mid, g_mid, b_mid, y_mid, u_mid, v_mid);
511 rgb_to_yuv(r_high, g_high, b_high, y_high, u_high, v_high);
514 for(int i = pkg->start; i < pkg->end; i++)
516 TYPE *in_row = (TYPE*)data->get_rows()[i];
517 TYPE *out_row = in_row;
518 for(int j = 0; j < w; j++)
522 const int y = get_component(in_row[0]);
528 if(COMPONENTS == 4) *out_row++ = a_low;
535 if(COMPONENTS == 4) *out_row++ = a_mid;
542 if(COMPONENTS == 4) *out_row++ = a_high;
547 const int r = get_component(in_row[0]);
548 const int g = get_component(in_row[1]);
549 const int b = get_component(in_row[2]);
550 const int y = (r * 76 + g * 150 + b * 29) >> 8;
556 if(COMPONENTS == 4) *out_row++ = a_low;
563 if(COMPONENTS == 4) *out_row++ = a_mid;
570 if(COMPONENTS == 4) *out_row++ = a_high;
573 in_row += COMPONENTS;
578 void ThresholdUnit::process_package(LoadPackage *package)
580 switch(server->data->get_color_model())
583 render_data<unsigned char, 3, false>(package);
587 render_data<float, 3, false>(package);
591 render_data<unsigned char, 4, false>(package);
595 render_data<float, 4, false>(package);
599 render_data<unsigned char, 3, true>(package);
603 render_data<unsigned char, 4, true>(package);
607 render_data<uint16_t, 3, true>(package);
610 case BC_YUVA16161616:
611 render_data<uint16_t, 4, true>(package);
626 ThresholdEngine::ThresholdEngine(ThresholdMain *plugin)
627 : LoadServer(plugin->get_project_smp() + 1,
628 plugin->get_project_smp() + 1)
630 this->plugin = plugin;
633 ThresholdEngine::~ThresholdEngine()
637 void ThresholdEngine::process_packages(VFrame *data)
640 LoadServer::process_packages();
643 void ThresholdEngine::init_packages()
645 for(int i = 0; i < get_total_packages(); i++)
647 ThresholdPackage *package = (ThresholdPackage*)get_package(i);
648 package->start = data->get_h() * i / get_total_packages();
649 package->end = data->get_h() * (i + 1) / get_total_packages();
653 LoadClient* ThresholdEngine::new_client()
655 return (LoadClient*)new ThresholdUnit(this);
658 LoadPackage* ThresholdEngine::new_package()
660 return (LoadPackage*)new HistogramPackage;
675 RGBA::RGBA(int r, int g, int b, int a)
683 void RGBA::set(int r, int g, int b, int a)
691 void RGBA::set(int rgb, int alpha)
693 r = (rgb & 0xff0000) >> 16;
694 g = (rgb & 0xff00) >> 8;
699 int RGBA::getRGB() const
701 return r << 16 | g << 8 | b;
704 static void init_RGBA_keys(const char * prefix,
721 void RGBA::set_property(XMLTag & tag, const char * prefix) const
723 string r_s, g_s, b_s, a_s;
724 init_RGBA_keys(prefix, r_s, g_s, b_s, a_s);
726 tag.set_property(const_cast<char *>(r_s.c_str()), r);
727 tag.set_property(const_cast<char *>(g_s.c_str()), g);
728 tag.set_property(const_cast<char *>(b_s.c_str()), b);
729 tag.set_property(const_cast<char *>(a_s.c_str()), a);
732 RGBA RGBA::get_property(XMLTag & tag, const char * prefix) const
734 string r_s, g_s, b_s, a_s;
735 init_RGBA_keys(prefix, r_s, g_s, b_s, a_s);
737 return RGBA(tag.get_property(const_cast<char *>(r_s.c_str()), r),
738 tag.get_property(const_cast<char *>(g_s.c_str()), g),
739 tag.get_property(const_cast<char *>(b_s.c_str()), b),
740 tag.get_property(const_cast<char *>(a_s.c_str()), a));
743 bool operator==(const RGBA & a, const RGBA & b)
752 RGBA interpolate(const RGBA & prev_color, const double & prev_scale, const RGBA &next_color, const double & next_scale)
754 return RGBA(interpolate(prev_color.r, prev_scale, next_color.r, next_scale),
755 interpolate(prev_color.g, prev_scale, next_color.g, next_scale),
756 interpolate(prev_color.b, prev_scale, next_color.b, next_scale),
757 interpolate(prev_color.a, prev_scale, next_color.a, next_scale));