cinelerra-5.1/plugins/videoscope/videoscope.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2011 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 "bcdisplayinfo.h"
  23 #include "bccolors.h"
  24 #include "clip.h"
  25 #include "bchash.h"
  26 #include "filexml.h"
  27 #include "guicast.h"
  28 #include "language.h"
  29 #include "loadbalance.h"
  30 #include "bccolors.h"
  31 #include "pluginvclient.h"
  32 #include "fonts.h"
  33 #include "scopewindow.h"
  34 #include "theme.h"
  35 #include "vframe.h"
  36
  37 #include <math.h>
  38 #include <stdint.h>
  39 #include <string.h>
  40
  41
  42 class VideoScopeEffect;
  43 class VideoScopeWindow;
  44
  45 class VideoScopeConfig
  46 {
  47 public:
  48         VideoScopeConfig();
  49 };
  50
  51 class VideoScopeWindow : public ScopeGUI
  52 {
  53 public:
  54         VideoScopeWindow(VideoScopeEffect *plugin);
  55         ~VideoScopeWindow();
  56
  57         void create_objects();
  58         void toggle_event();
  59         int resize_event(int w, int h);
  60
  61         VideoScopeEffect *plugin;
  62 };
  63
  64 class VideoScopeEffect : public PluginVClient
  65 {
  66 public:
  67         VideoScopeEffect(PluginServer *server);
  68         ~VideoScopeEffect();
  69
  70
  71         PLUGIN_CLASS_MEMBERS2(VideoScopeConfig)
  72         int process_realtime(VFrame *input, VFrame *output);
  73         int is_realtime();
  74         void render_gui(void *input);
  75         void save_data(KeyFrame *keyframe);
  76         void read_data(KeyFrame *keyframe);
  77
  78         int use_hist, use_wave, use_vector;
  79         int use_hist_parade, use_wave_parade;
  80         int use_wave_gain, use_vect_gain;
  81         int use_smooth, use_graticule;
  82
  83         int w, h;
  84         VFrame *input;
  85 };
  86
  87
  88 VideoScopeConfig::VideoScopeConfig()
  89 {
  90 }
  91
  92 VideoScopeWindow::VideoScopeWindow(VideoScopeEffect *plugin)
  93  : ScopeGUI(plugin, plugin->w, plugin->h)
  94 {
  95         this->plugin = plugin;
  96 }
  97
  98 VideoScopeWindow::~VideoScopeWindow()
  99 {
 100 }
 101
 102 void VideoScopeWindow::create_objects()
 103 {
 104         use_hist = plugin->use_hist;
 105         use_wave = plugin->use_wave;
 106         use_vector = plugin->use_vector;
 107         use_hist_parade = plugin->use_hist_parade;
 108         use_wave_parade = plugin->use_wave_parade;
 109         use_wave_gain = plugin->use_wave_gain;
 110         use_vect_gain = plugin->use_vect_gain;
 111         use_smooth = plugin->use_smooth;
 112         use_graticule = plugin->use_graticule;
 113
 114         ScopeGUI::create_objects();
 115 }
 116
 117 void VideoScopeWindow::toggle_event()
 118 {
 119         plugin->use_hist = use_hist;
 120         plugin->use_wave = use_wave;
 121         plugin->use_vector = use_vector;
 122         plugin->use_hist_parade = use_hist_parade;
 123         plugin->use_wave_parade = use_wave_parade;
 124         plugin->use_wave_gain = use_wave_gain;
 125         plugin->use_vect_gain = use_vect_gain;
 126         plugin->use_smooth = use_smooth;
 127         plugin->use_graticule = use_graticule;
 128 // Make it reprocess
 129         plugin->send_configure_change();
 130 }
 131
 132
 133 int VideoScopeWindow::resize_event(int w, int h)
 134 {
 135         ScopeGUI::resize_event(w, h);
 136         plugin->w = w;
 137         plugin->h = h;
 138 // Make it reprocess
 139         plugin->send_configure_change();
 140         return 1;
 141 }
 142
 143 REGISTER_PLUGIN(VideoScopeEffect)
 144
 145 VideoScopeEffect::VideoScopeEffect(PluginServer *server)
 146  : PluginVClient(server)
 147 {
 148         w = MIN_SCOPE_W;
 149         h = MIN_SCOPE_H;
 150         use_hist = 0;
 151         use_wave = 0;
 152         use_vector = 1;
 153         use_hist_parade = 1;
 154         use_wave_parade = 1;
 155         use_wave_gain = 5;
 156         use_vect_gain = 5;
 157         use_smooth = 1;
 158         use_graticule = 0;
 159 }
 160
 161 VideoScopeEffect::~VideoScopeEffect()
 162 {
 163 }
 164
 165 const char* VideoScopeEffect::plugin_title() { return N_("VideoScope"); }
 166 int VideoScopeEffect::is_realtime() { return 1; }
 167
 168 int VideoScopeEffect::load_configuration()
 169 {
 170         return 0;
 171 }
 172
 173 void VideoScopeEffect::save_data(KeyFrame *keyframe)
 174 {
 175         FileXML output;
 176
 177 // cause data to be stored directly in text
 178         output.set_shared_output(keyframe->xbuf);
 179         output.tag.set_title("VIDEOSCOPE");
 180         if( is_defaults() ) {
 181                 output.tag.set_property("W", w);
 182                 output.tag.set_property("H", h);
 183                 output.tag.set_property("USE_HIST", use_hist);
 184                 output.tag.set_property("USE_WAVE", use_wave);
 185                 output.tag.set_property("USE_VECTOR", use_vector);
 186                 output.tag.set_property("USE_HIST_PARADE", use_hist_parade);
 187                 output.tag.set_property("USE_WAVE_PARADE", use_wave_parade);
 188                 output.tag.set_property("USE_WAVE_GAIN", use_wave_gain);
 189                 output.tag.set_property("USE_VECT_GAIN", use_vect_gain);
 190                 output.tag.set_property("USE_SMOOTH", use_smooth);
 191                 output.tag.set_property("USE_GRATICULE", use_graticule);
 192
 193         }
 194         output.append_tag();
 195         output.tag.set_title("/VIDEOSCOPE");
 196         output.append_tag();
 197         output.append_newline();
 198         output.terminate_string();
 199 }
 200
 201 void VideoScopeEffect::read_data(KeyFrame *keyframe)
 202 {
 203         FileXML input;
 204         input.set_shared_input(keyframe->xbuf);
 205         int result = 0;
 206
 207         while( !(result = input.read_tag()) ) {
 208                 if( input.tag.title_is("VIDEOSCOPE") ) {
 209                         if( is_defaults() ) {
 210                                 w = input.tag.get_property("W", w);
 211                                 h = input.tag.get_property("H", h);
 212                                 use_hist = input.tag.get_property("USE_HIST", use_hist);
 213                                 use_wave = input.tag.get_property("USE_WAVE", use_wave);
 214                                 use_vector = input.tag.get_property("USE_VECTOR", use_vector);
 215                                 use_hist_parade = input.tag.get_property("USE_HIST_PARADE", use_hist_parade);
 216                                 use_wave_parade = input.tag.get_property("USE_WAVE_PARADE", use_wave_parade);
 217                                 use_wave_gain = input.tag.get_property("USE_WAVE_GAIN", use_wave_gain);
 218                                 use_vect_gain = input.tag.get_property("USE_VECT_GAIN", use_vect_gain);
 219                                 use_smooth = input.tag.get_property("USE_SMOOTH", use_smooth);
 220                                 use_graticule = input.tag.get_property("USE_GRATICULE", use_graticule);
 221                         }
 222                 }
 223         }
 224 }
 225
 226 NEW_WINDOW_MACRO(VideoScopeEffect, VideoScopeWindow)
 227
 228 int VideoScopeEffect::process_realtime(VFrame *input, VFrame *output)
 229 {
 230
 231         send_render_gui(input);
 232         if( input->get_rows()[0] != output->get_rows()[0] )
 233                 output->copy_from(input);
 234         return 1;
 235 }
 236
 237 void VideoScopeEffect::render_gui(void *input)
 238 {
 239         if( !thread ) return;
 240         VideoScopeWindow *window = ((VideoScopeWindow*)thread->window);
 241         window->lock_window();
 242         this->input = (VFrame*)input;
 243         window->process(this->input);
 244         window->unlock_window();
 245 }
 246