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 int ThresholdMain::is_realtime()
135 const char* ThresholdMain::plugin_title()
137 return _("Threshold");
142 LOAD_CONFIGURATION_MACRO(ThresholdMain, ThresholdConfig)
150 int ThresholdMain::process_buffer(VFrame *frame,
151 int64_t start_position,
154 load_configuration();
156 int use_opengl = get_use_opengl() &&
157 (!config.plot || !gui_open());
161 get_source_position(),
165 if(use_opengl) return run_opengl();
167 send_render_gui(frame);
169 if(!threshold_engine)
170 threshold_engine = new ThresholdEngine(this);
171 threshold_engine->process_packages(frame);
176 void ThresholdMain::save_data(KeyFrame *keyframe)
179 file.set_shared_output(keyframe->get_data(), MESSAGESIZE);
180 file.tag.set_title("THRESHOLD");
181 file.tag.set_property("MIN", config.min);
182 file.tag.set_property("MAX", config.max);
183 file.tag.set_property("PLOT", config.plot);
184 config.low_color.set_property(file.tag, "LOW_COLOR");
185 config.mid_color.set_property(file.tag, "MID_COLOR");
186 config.high_color.set_property(file.tag, "HIGH_COLOR");
188 file.tag.set_title("/THRESHOLD");
190 file.terminate_string();
193 void ThresholdMain::read_data(KeyFrame *keyframe)
196 const char *data = keyframe->get_data();
197 file.set_shared_input((char *)data, strlen(data));
201 result = file.read_tag();
204 config.min = file.tag.get_property("MIN", config.min);
205 config.max = file.tag.get_property("MAX", config.max);
206 config.plot = file.tag.get_property("PLOT", config.plot);
207 config.low_color = config.low_color.get_property(file.tag, "LOW_COLOR");
208 config.mid_color = config.mid_color.get_property(file.tag, "MID_COLOR");
209 config.high_color = config.high_color.get_property(file.tag, "HIGH_COLOR");
215 NEW_WINDOW_MACRO(ThresholdMain,ThresholdWindow);
217 void ThresholdMain::update_gui()
221 thread->window->lock_window("ThresholdMain::update_gui");
222 if(load_configuration())
224 ThresholdWindow *window = (ThresholdWindow*) thread->window;
225 window->min->update(config.min);
226 window->max->update(config.max);
227 window->plot->update(config.plot);
228 window->update_low_color();
229 window->update_mid_color();
230 window->update_high_color();
231 window->low_color_thread->update_gui(config.low_color.getRGB(), config.low_color.a);
232 window->mid_color_thread->update_gui(config.mid_color.getRGB(), config.mid_color.a);
233 window->high_color_thread->update_gui(config.high_color.getRGB(), config.high_color.a);
235 thread->window->unlock_window();
239 void ThresholdMain::render_gui(void *data)
243 calculate_histogram((VFrame*)data);
244 ThresholdWindow *window = (ThresholdWindow*) thread->window;
245 window->lock_window("ThresholdMain::render_gui");
246 window->canvas->draw();
247 window->unlock_window();
251 void ThresholdMain::calculate_histogram(VFrame *frame)
253 if(!engine) engine = new HistogramEngine(get_project_smp() + 1,
254 get_project_smp() + 1);
255 engine->process_packages(frame);
258 int ThresholdMain::handle_opengl()
261 static const char *rgb_shader =
262 "uniform sampler2D tex;\n"
263 "uniform float min;\n"
264 "uniform float max;\n"
265 "uniform vec4 low_color;\n"
266 "uniform vec4 mid_color;\n"
267 "uniform vec4 high_color;\n"
270 " vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
271 " float v = dot(pixel.rgb, vec3(0.299, 0.587, 0.114));\n"
273 " pixel = low_color;\n"
274 " else if(v < max)\n"
275 " pixel = mid_color;\n"
277 " pixel = high_color;\n"
278 " gl_FragColor = pixel;\n"
281 static const char *yuv_shader =
282 "uniform sampler2D tex;\n"
283 "uniform float min;\n"
284 "uniform float max;\n"
285 "uniform vec4 low_color;\n"
286 "uniform vec4 mid_color;\n"
287 "uniform vec4 high_color;\n"
290 " vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
291 " if(pixel.r < min)\n"
292 " pixel = low_color;\n"
293 " else if(pixel.r < max)\n"
294 " pixel = mid_color;\n"
296 " pixel = high_color;\n"
297 " gl_FragColor = pixel;\n"
300 get_output()->to_texture();
301 get_output()->enable_opengl();
303 unsigned int shader = 0;
304 int color_model = get_output()->get_color_model();
305 bool is_yuv = BC_CModels::is_yuv(color_model);
306 bool has_alpha = BC_CModels::has_alpha(color_model);
308 shader = VFrame::make_shader(0, yuv_shader, 0);
310 shader = VFrame::make_shader(0, rgb_shader, 0);
314 glUseProgram(shader);
315 glUniform1i(glGetUniformLocation(shader, "tex"), 0);
316 glUniform1f(glGetUniformLocation(shader, "min"), config.min);
317 glUniform1f(glGetUniformLocation(shader, "max"), config.max);
321 float y_low, u_low, v_low;
322 float y_mid, u_mid, v_mid;
323 float y_high, u_high, v_high;
325 YUV::rgb_to_yuv_f((float)config.low_color.r / 0xff,
326 (float)config.low_color.g / 0xff,
327 (float)config.low_color.b / 0xff,
333 YUV::rgb_to_yuv_f((float)config.mid_color.r / 0xff,
334 (float)config.mid_color.g / 0xff,
335 (float)config.mid_color.b / 0xff,
341 YUV::rgb_to_yuv_f((float)config.high_color.r / 0xff,
342 (float)config.high_color.g / 0xff,
343 (float)config.high_color.b / 0xff,
350 glUniform4f(glGetUniformLocation(shader, "low_color"),
352 has_alpha ? (float)config.low_color.a / 0xff : 1.0);
353 glUniform4f(glGetUniformLocation(shader, "mid_color"),
355 has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
356 glUniform4f(glGetUniformLocation(shader, "high_color"),
357 y_high, u_high, v_high,
358 has_alpha ? (float)config.high_color.a / 0xff : 1.0);
360 glUniform4f(glGetUniformLocation(shader, "low_color"),
361 (float)config.low_color.r / 0xff,
362 (float)config.low_color.g / 0xff,
363 (float)config.low_color.b / 0xff,
364 has_alpha ? (float)config.low_color.a / 0xff : 1.0);
365 glUniform4f(glGetUniformLocation(shader, "mid_color"),
366 (float)config.mid_color.r / 0xff,
367 (float)config.mid_color.g / 0xff,
368 (float)config.mid_color.b / 0xff,
369 has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
370 glUniform4f(glGetUniformLocation(shader, "high_color"),
371 (float)config.high_color.r / 0xff,
372 (float)config.high_color.g / 0xff,
373 (float)config.high_color.b / 0xff,
374 has_alpha ? (float)config.high_color.a / 0xff : 1.0);
378 get_output()->init_screen();
379 get_output()->bind_texture(0);
380 get_output()->draw_texture();
382 get_output()->set_opengl_state(VFrame::SCREEN);
408 ThresholdPackage::ThresholdPackage()
424 ThresholdUnit::ThresholdUnit(ThresholdEngine *server)
427 this->server = server;
430 // Coerces pixel component to int.
431 static inline int get_component(unsigned char v)
436 static inline int get_component(float v)
438 return (int)(v * 0xffff);
441 static inline int get_component(uint16_t v)
446 // Rescales value in range [0, 255] to range appropriate to TYPE.
447 template<typename TYPE>
448 static TYPE scale_to_range(int v)
450 return v; // works for unsigned char, override for the rest.
454 inline float scale_to_range(int v)
456 return (float) v / 0xff;
460 inline uint16_t scale_to_range(int v)
465 static inline void rgb_to_yuv(YUV & yuv,
466 unsigned char r, unsigned char g, unsigned char b,
467 unsigned char & y, unsigned char & u, unsigned char & v)
469 yuv.rgb_to_yuv_8(r, g, b, y, u, v);
472 static inline void rgb_to_yuv(YUV & yuv,
473 float r, float g, float b,
474 float & y, float & u, float & v)
476 yuv.rgb_to_yuv_f(r, g, b, y, u, v);
479 static inline void rgb_to_yuv(YUV & yuv,
480 uint16_t r, uint16_t g, uint16_t b,
481 uint16_t & y, uint16_t & u, uint16_t & v)
483 yuv.rgb_to_yuv_16(r, g, b, y, u, v);
486 template<typename TYPE, int COMPONENTS, bool USE_YUV>
487 void ThresholdUnit::render_data(LoadPackage *package)
489 const ThresholdPackage *pkg = (ThresholdPackage*)package;
490 const ThresholdConfig *config = & server->plugin->config;
491 VFrame *data = server->data;
492 const int min = (int)(config->min * 0xffff);
493 const int max = (int)(config->max * 0xffff);
494 const int w = data->get_w();
495 //const int h = data->get_h();
497 const TYPE r_low = scale_to_range<TYPE>(config->low_color.r);
498 const TYPE g_low = scale_to_range<TYPE>(config->low_color.g);
499 const TYPE b_low = scale_to_range<TYPE>(config->low_color.b);
500 const TYPE a_low = scale_to_range<TYPE>(config->low_color.a);
502 const TYPE r_mid = scale_to_range<TYPE>(config->mid_color.r);
503 const TYPE g_mid = scale_to_range<TYPE>(config->mid_color.g);
504 const TYPE b_mid = scale_to_range<TYPE>(config->mid_color.b);
505 const TYPE a_mid = scale_to_range<TYPE>(config->mid_color.a);
507 const TYPE r_high = scale_to_range<TYPE>(config->high_color.r);
508 const TYPE g_high = scale_to_range<TYPE>(config->high_color.g);
509 const TYPE b_high = scale_to_range<TYPE>(config->high_color.b);
510 const TYPE a_high = scale_to_range<TYPE>(config->high_color.a);
512 TYPE y_low, u_low, v_low;
513 TYPE y_mid, u_mid, v_mid;
514 TYPE y_high, u_high, v_high;
518 rgb_to_yuv(*server->yuv, r_low, g_low, b_low, y_low, u_low, v_low);
519 rgb_to_yuv(*server->yuv, r_mid, g_mid, b_mid, y_mid, u_mid, v_mid);
520 rgb_to_yuv(*server->yuv, r_high, g_high, b_high, y_high, u_high, v_high);
523 for(int i = pkg->start; i < pkg->end; i++)
525 TYPE *in_row = (TYPE*)data->get_rows()[i];
526 TYPE *out_row = in_row;
527 for(int j = 0; j < w; j++)
531 const int y = get_component(in_row[0]);
537 if(COMPONENTS == 4) *out_row++ = a_low;
544 if(COMPONENTS == 4) *out_row++ = a_mid;
551 if(COMPONENTS == 4) *out_row++ = a_high;
556 const int r = get_component(in_row[0]);
557 const int g = get_component(in_row[1]);
558 const int b = get_component(in_row[2]);
559 const int y = (r * 76 + g * 150 + b * 29) >> 8;
565 if(COMPONENTS == 4) *out_row++ = a_low;
572 if(COMPONENTS == 4) *out_row++ = a_mid;
579 if(COMPONENTS == 4) *out_row++ = a_high;
582 in_row += COMPONENTS;
587 void ThresholdUnit::process_package(LoadPackage *package)
589 switch(server->data->get_color_model())
592 render_data<unsigned char, 3, false>(package);
596 render_data<float, 3, false>(package);
600 render_data<unsigned char, 4, false>(package);
604 render_data<float, 4, false>(package);
608 render_data<unsigned char, 3, true>(package);
612 render_data<unsigned char, 4, true>(package);
616 render_data<uint16_t, 3, true>(package);
619 case BC_YUVA16161616:
620 render_data<uint16_t, 4, true>(package);
635 ThresholdEngine::ThresholdEngine(ThresholdMain *plugin)
636 : LoadServer(plugin->get_project_smp() + 1,
637 plugin->get_project_smp() + 1)
639 this->plugin = plugin;
643 ThresholdEngine::~ThresholdEngine()
648 void ThresholdEngine::process_packages(VFrame *data)
651 LoadServer::process_packages();
654 void ThresholdEngine::init_packages()
656 for(int i = 0; i < get_total_packages(); i++)
658 ThresholdPackage *package = (ThresholdPackage*)get_package(i);
659 package->start = data->get_h() * i / get_total_packages();
660 package->end = data->get_h() * (i + 1) / get_total_packages();
664 LoadClient* ThresholdEngine::new_client()
666 return (LoadClient*)new ThresholdUnit(this);
669 LoadPackage* ThresholdEngine::new_package()
671 return (LoadPackage*)new HistogramPackage;
686 RGBA::RGBA(int r, int g, int b, int a)
694 void RGBA::set(int r, int g, int b, int a)
702 void RGBA::set(int rgb, int alpha)
704 r = (rgb & 0xff0000) >> 16;
705 g = (rgb & 0xff00) >> 8;
710 int RGBA::getRGB() const
712 return r << 16 | g << 8 | b;
715 static void init_RGBA_keys(const char * prefix,
732 void RGBA::set_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 tag.set_property(const_cast<char *>(r_s.c_str()), r);
738 tag.set_property(const_cast<char *>(g_s.c_str()), g);
739 tag.set_property(const_cast<char *>(b_s.c_str()), b);
740 tag.set_property(const_cast<char *>(a_s.c_str()), a);
743 RGBA RGBA::get_property(XMLTag & tag, const char * prefix) const
745 string r_s, g_s, b_s, a_s;
746 init_RGBA_keys(prefix, r_s, g_s, b_s, a_s);
748 return RGBA(tag.get_property(const_cast<char *>(r_s.c_str()), r),
749 tag.get_property(const_cast<char *>(g_s.c_str()), g),
750 tag.get_property(const_cast<char *>(b_s.c_str()), b),
751 tag.get_property(const_cast<char *>(a_s.c_str()), a));
754 bool operator==(const RGBA & a, const RGBA & b)
763 RGBA interpolate(const RGBA & prev_color, const double & prev_scale, const RGBA &next_color, const double & next_scale)
765 return RGBA(interpolate(prev_color.r, prev_scale, next_color.r, next_scale),
766 interpolate(prev_color.g, prev_scale, next_color.g, next_scale),
767 interpolate(prev_color.b, prev_scale, next_color.b, next_scale),
768 interpolate(prev_color.a, prev_scale, next_color.a, next_scale));