X-Git-Url: http://git.cinelerra-gg.org/git/?a=blobdiff_plain;f=cinelerra-5.1%2Fplugins%2Fvideoscope%2Fvideoscope.C;fp=cinelerra-5.1%2Fplugins%2Fvideoscope%2Fvideoscope.C;h=178091cf680d6eb3b21bd08ea4dbef7c1f7b9d09;hb=30bdb85eb33a8ee7ba675038a86c6be59c43d7bd;hp=0000000000000000000000000000000000000000;hpb=52fcc46226f9df46f9ce9d0566dc568455a7db0b;p=goodguy%2Fhistory.git diff --git a/cinelerra-5.1/plugins/videoscope/videoscope.C b/cinelerra-5.1/plugins/videoscope/videoscope.C new file mode 100644 index 00000000..178091cf --- /dev/null +++ b/cinelerra-5.1/plugins/videoscope/videoscope.C @@ -0,0 +1,654 @@ + +/* + * CINELERRA + * Copyright (C) 1997-2011 Adam Williams + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "bcdisplayinfo.h" +#include "clip.h" +#include "bchash.h" +#include "filexml.h" +#include "guicast.h" +#include "language.h" +#include "loadbalance.h" +#include "cicolors.h" +#include "pluginvclient.h" +#include "fonts.h" +#include "scopewindow.h" +#include "theme.h" +#include "vframe.h" + +#include +#include +#include + + + + + +class VideoScopeEffect; +class VideoScopeEngine; +class VideoScopeWindow; + +class VideoScopeConfig +{ +public: + VideoScopeConfig(); +}; + +class VideoScopeWindow : public ScopeGUI +{ +public: + VideoScopeWindow(VideoScopeEffect *plugin); + ~VideoScopeWindow(); + + void create_objects(); + void toggle_event(); + int resize_event(int w, int h); + void update(); + + VideoScopeEffect *plugin; +}; + + + + + +class VideoScopePackage : public LoadPackage +{ +public: + VideoScopePackage(); + int row1, row2; +}; + + +class VideoScopeUnit : public LoadClient +{ +public: + VideoScopeUnit(VideoScopeEffect *plugin, VideoScopeEngine *server); + void process_package(LoadPackage *package); + VideoScopeEffect *plugin; + YUV yuv; +}; + +class VideoScopeEngine : public LoadServer +{ +public: + VideoScopeEngine(VideoScopeEffect *plugin, int cpus); + ~VideoScopeEngine(); + void init_packages(); + LoadClient* new_client(); + LoadPackage* new_package(); + VideoScopeEffect *plugin; +}; + +class VideoScopeEffect : public PluginVClient +{ +public: + VideoScopeEffect(PluginServer *server); + ~VideoScopeEffect(); + + + PLUGIN_CLASS_MEMBERS2(VideoScopeConfig) + int process_realtime(VFrame *input, VFrame *output); + int is_realtime(); + void render_gui(void *input); + void save_data(KeyFrame *keyframe); + void read_data(KeyFrame *keyframe); + + int use_hist, use_wave, use_vector; + int use_hist_parade, use_wave_parade; + int w, h; + VFrame *input; +}; + + + + + + + + + + + + + + +VideoScopeConfig::VideoScopeConfig() +{ +} + + + + + + + + + + + + +VideoScopeWindow::VideoScopeWindow(VideoScopeEffect *plugin) + : ScopeGUI(plugin, + plugin->w, + plugin->h) +{ + this->plugin = plugin; +} + +VideoScopeWindow::~VideoScopeWindow() +{ +} + +void VideoScopeWindow::create_objects() +{ + use_hist = plugin->use_hist; + use_wave = plugin->use_wave; + use_vector = plugin->use_vector; + use_hist_parade = plugin->use_hist_parade; + use_wave_parade = plugin->use_wave_parade; + ScopeGUI::create_objects(); +} + +void VideoScopeWindow::toggle_event() +{ + plugin->use_hist = use_hist; + plugin->use_wave = use_wave; + plugin->use_vector = use_vector; + plugin->use_hist_parade = use_hist_parade; + plugin->use_wave_parade = use_wave_parade; +// Make it reprocess + plugin->send_configure_change(); +} + + +int VideoScopeWindow::resize_event(int w, int h) +{ + ScopeGUI::resize_event(w, h); + plugin->w = w; + plugin->h = h; +// Make it reprocess + plugin->send_configure_change(); + return 1; +} + + + + + + + + + + + + + + + + + + + + +REGISTER_PLUGIN(VideoScopeEffect) + + + + + + +VideoScopeEffect::VideoScopeEffect(PluginServer *server) + : PluginVClient(server) +{ + w = MIN_SCOPE_W; + h = MIN_SCOPE_H; + use_hist = 0; + use_wave = 0; + use_vector = 1; + use_hist_parade = 1; + use_wave_parade = 1; +} + +VideoScopeEffect::~VideoScopeEffect() +{ + + +} + + + +const char* VideoScopeEffect::plugin_title() { return _("VideoScope"); } +int VideoScopeEffect::is_realtime() { return 1; } + +int VideoScopeEffect::load_configuration() +{ + return 0; +} + +void VideoScopeEffect::save_data(KeyFrame *keyframe) +{ + FileXML output; + +// cause data to be stored directly in text + output.set_shared_output(keyframe->get_data(), MESSAGESIZE); + output.tag.set_title("VIDEOSCOPE"); + + + if(is_defaults()) + { + output.tag.set_property("W", w); + output.tag.set_property("H", h); + output.tag.set_property("USE_HIST", use_hist); + output.tag.set_property("USE_WAVE", use_wave); + output.tag.set_property("USE_VECTOR", use_vector); + output.tag.set_property("USE_HIST_PARADE", use_hist_parade); + output.tag.set_property("USE_WAVE_PARADE", use_wave_parade); + } + + output.append_tag(); + output.tag.set_title("/VIDEOSCOPE"); + output.append_tag(); + output.append_newline(); + output.terminate_string(); +} + +void VideoScopeEffect::read_data(KeyFrame *keyframe) +{ + FileXML input; + input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data())); + + int result = 0; + + + while(!result) + { + result = input.read_tag(); + + if(!result) + { + if(input.tag.title_is("VIDEOSCOPE")) + { + if(is_defaults()) + { + w = input.tag.get_property("W", w); + h = input.tag.get_property("H", h); + use_hist = input.tag.get_property("USE_HIST", use_hist); + use_wave = input.tag.get_property("USE_WAVE", use_wave); + use_vector = input.tag.get_property("USE_VECTOR", use_vector); + use_hist_parade = input.tag.get_property("USE_HIST_PARADE", use_hist_parade); + use_wave_parade = input.tag.get_property("USE_WAVE_PARADE", use_wave_parade); + } + } + } + } +} + + + + +NEW_WINDOW_MACRO(VideoScopeEffect, VideoScopeWindow) + + +int VideoScopeEffect::process_realtime(VFrame *input, VFrame *output) +{ + + send_render_gui(input); +//printf("VideoScopeEffect::process_realtime 1\n"); + if(input->get_rows()[0] != output->get_rows()[0]) + output->copy_from(input); + return 1; +} + +void VideoScopeEffect::render_gui(void *input) +{ + if(thread) + { + VideoScopeWindow *window = ((VideoScopeWindow*)thread->window); + window->lock_window(); + +//printf("VideoScopeEffect::process_realtime 1\n"); + this->input = (VFrame*)input; +//printf("VideoScopeEffect::process_realtime 1\n"); + window->process(this->input); + + + window->unlock_window(); + } +} + + + + + +VideoScopePackage::VideoScopePackage() + : LoadPackage() +{ +} + + + + + + +VideoScopeUnit::VideoScopeUnit(VideoScopeEffect *plugin, + VideoScopeEngine *server) + : LoadClient(server) +{ + this->plugin = plugin; +} + + +#define INTENSITY(p) ((unsigned int)(((p)[0]) * 77+ \ + ((p)[1] * 150) + \ + ((p)[2] * 29)) >> 8) + + +static void draw_point(unsigned char **rows, + int color_model, + int x, + int y, + int r, + int g, + int b) +{ + switch(color_model) + { + case BC_BGR8888: + { + unsigned char *pixel = rows[y] + x * 4; + pixel[0] = b; + pixel[1] = g; + pixel[2] = r; + break; + } + case BC_BGR888: + break; + case BC_RGB565: + { + unsigned char *pixel = rows[y] + x * 2; + pixel[0] = (r & 0xf8) | (g >> 5); + pixel[1] = ((g & 0xfc) << 5) | (b >> 3); + break; + } + case BC_BGR565: + break; + case BC_RGB8: + break; + } +} + + + +#define VIDEOSCOPE(type, temp_type, max, components, use_yuv) \ +{ \ + for(int i = pkg->row1; i < pkg->row2; i++) \ + { \ + type *in_row = (type*)plugin->input->get_rows()[i]; \ + for(int j = 0; j < w; j++) \ + { \ + type *in_pixel = in_row + j * components; \ + float intensity; \ + \ +/* Analyze pixel */ \ + if(use_yuv) intensity = (float)*in_pixel / max; \ + \ + float h, s, v; \ + temp_type r, g, b; \ + if(use_yuv) \ + { \ + if(sizeof(type) == 2) \ + { \ + yuv.yuv_to_rgb_16(r, \ + g, \ + b, \ + in_pixel[0], \ + in_pixel[1], \ + in_pixel[2]); \ + } \ + else \ + { \ + yuv.yuv_to_rgb_8(r, \ + g, \ + b, \ + in_pixel[0], \ + in_pixel[1], \ + in_pixel[2]); \ + } \ + } \ + else \ + { \ + r = in_pixel[0]; \ + g = in_pixel[1]; \ + b = in_pixel[2]; \ + } \ + \ + HSV::rgb_to_hsv((float)r / max, \ + (float)g / max, \ + (float)b / max, \ + h, \ + s, \ + v); \ + \ +/* Calculate waveform */ \ + if(parade) \ + { \ +/* red */ \ + int x = j * waveform_w / w / 3; \ + int y = waveform_h - (int)(((float)r / max - FLOAT_MIN) / \ + (FLOAT_MAX - FLOAT_MIN) * \ + waveform_h); \ + if(x >= 0 && x < waveform_w / 3 && y >= 0 && y < waveform_h) \ + draw_point(waveform_rows, \ + waveform_cmodel, \ + x, \ + y, \ + 0xff, \ + 0x0, \ + 0x0); \ + \ +/* green */ \ + x = waveform_w / 3 + j * waveform_w / w / 3; \ + y = waveform_h - (int)(((float)g / max - FLOAT_MIN) / \ + (FLOAT_MAX - FLOAT_MIN) * \ + waveform_h); \ + if(x >= waveform_w / 3 && x < waveform_w * 2 / 3 && \ + y >= 0 && y < waveform_h) \ + draw_point(waveform_rows, \ + waveform_cmodel, \ + x, \ + y, \ + 0x0, \ + 0xff, \ + 0x0); \ + \ +/* blue */ \ + x = waveform_w * 2 / 3 + j * waveform_w / w / 3; \ + y = waveform_h - (int)(((float)b / max - FLOAT_MIN) / \ + (FLOAT_MAX - FLOAT_MIN) * \ + waveform_h); \ + if(x >= waveform_w * 2 / 3 && x < waveform_w && \ + y >= 0 && y < waveform_h) \ + draw_point(waveform_rows, \ + waveform_cmodel, \ + x, \ + y, \ + 0x0, \ + 0x0, \ + 0xff); \ + } \ + else \ + { \ + if(!use_yuv) intensity = v; \ + intensity = (intensity - FLOAT_MIN) / (FLOAT_MAX - FLOAT_MIN) * \ + waveform_h; \ + int y = waveform_h - (int)intensity; \ + int x = j * waveform_w / w; \ + if(x >= 0 && x < waveform_w && y >= 0 && y < waveform_h) \ + draw_point(waveform_rows, \ + waveform_cmodel, \ + x, \ + y, \ + 0xff, \ + 0xff, \ + 0xff); \ + } \ + \ +/* Calculate vectorscope */ \ + float adjacent = cos((h + 90) / 360 * 2 * M_PI); \ + float opposite = sin((h + 90) / 360 * 2 * M_PI); \ + int x = (int)(vector_w / 2 + \ + adjacent * (s - FLOAT_MIN) / (FLOAT_MAX - FLOAT_MIN) * radius); \ + \ + int y = (int)(vector_h / 2 - \ + opposite * (s - FLOAT_MIN) / (FLOAT_MAX - FLOAT_MIN) * radius); \ + \ + \ + CLAMP(x, 0, vector_w - 1); \ + CLAMP(y, 0, vector_h - 1); \ +/* Get color with full saturation & value */ \ + float r_f, g_f, b_f; \ + HSV::hsv_to_rgb(r_f, \ + g_f, \ + b_f, \ + h, \ + s, \ + 1); \ + r = (int)(r_f * 255); \ + g = (int)(g_f * 255); \ + b = (int)(b_f * 255); \ + \ + /* float */ \ + if(sizeof(type) == 4) \ + { \ + r = CLIP(r, 0, 0xff); \ + g = CLIP(g, 0, 0xff); \ + b = CLIP(b, 0, 0xff); \ + } \ + \ + draw_point(vector_rows, \ + vector_cmodel, \ + x, \ + y, \ + (int)r, \ + (int)g, \ + (int)b); \ + \ + } \ + } \ +} + +void VideoScopeUnit::process_package(LoadPackage *package) +{ + VideoScopeWindow *window = (VideoScopeWindow*)plugin->thread->window; + VideoScopePackage *pkg = (VideoScopePackage*)package; + int w = plugin->input->get_w(); +// int h = plugin->input->get_h(); + int waveform_h = window->wave_h; + int waveform_w = window->wave_w; + int waveform_cmodel = window->waveform_bitmap->get_color_model(); + unsigned char **waveform_rows = window->waveform_bitmap->get_row_pointers(); + int vector_h = window->vector_bitmap->get_h(); + int vector_w = window->vector_bitmap->get_w(); + int vector_cmodel = window->vector_bitmap->get_color_model(); + unsigned char **vector_rows = window->vector_bitmap->get_row_pointers(); + float radius = MIN(vector_w / 2, vector_h / 2); + int parade = 1; + + switch(plugin->input->get_color_model()) + { + case BC_RGB888: + VIDEOSCOPE(unsigned char, int, 0xff, 3, 0) + break; + + case BC_RGB_FLOAT: + VIDEOSCOPE(float, float, 1, 3, 0) + break; + + case BC_YUV888: + VIDEOSCOPE(unsigned char, int, 0xff, 3, 1) + break; + + case BC_RGB161616: + VIDEOSCOPE(uint16_t, int, 0xffff, 3, 0) + break; + + case BC_YUV161616: + VIDEOSCOPE(uint16_t, int, 0xffff, 3, 1) + break; + + case BC_RGBA8888: + VIDEOSCOPE(unsigned char, int, 0xff, 4, 0) + break; + + case BC_RGBA_FLOAT: + VIDEOSCOPE(float, float, 1, 4, 0) + break; + + case BC_YUVA8888: + VIDEOSCOPE(unsigned char, int, 0xff, 4, 1) + break; + + case BC_RGBA16161616: + VIDEOSCOPE(uint16_t, int, 0xffff, 4, 0) + break; + + case BC_YUVA16161616: + VIDEOSCOPE(uint16_t, int, 0xffff, 4, 1) + break; + } +} + + + + + + +VideoScopeEngine::VideoScopeEngine(VideoScopeEffect *plugin, int cpus) + : LoadServer(cpus, cpus) +{ + this->plugin = plugin; +} + +VideoScopeEngine::~VideoScopeEngine() +{ +} + +void VideoScopeEngine::init_packages() +{ + for(int i = 0; i < LoadServer::get_total_packages(); i++) + { + VideoScopePackage *pkg = (VideoScopePackage*)get_package(i); + pkg->row1 = plugin->input->get_h() * i / LoadServer::get_total_packages(); + pkg->row2 = plugin->input->get_h() * (i + 1) / LoadServer::get_total_packages(); + } +} + + +LoadClient* VideoScopeEngine::new_client() +{ + return new VideoScopeUnit(plugin, this); +} + +LoadPackage* VideoScopeEngine::new_package() +{ + return new VideoScopePackage; +} +