detect missing transitions, dont draw transitions if show off, obey audio transition...
[goodguy/cinelerra.git] / 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_refresh = -1;
113         use_release = 0;
114         use_graticule = plugin->use_graticule;
115
116         ScopeGUI::create_objects();
117 }
118
119 void VideoScopeWindow::toggle_event()
120 {
121         plugin->use_hist = use_hist;
122         plugin->use_wave = use_wave;
123         plugin->use_vector = use_vector;
124         plugin->use_hist_parade = use_hist_parade;
125         plugin->use_wave_parade = use_wave_parade;
126         plugin->use_wave_gain = use_wave_gain;
127         plugin->use_vect_gain = use_vect_gain;
128         plugin->use_smooth = use_smooth;
129         plugin->use_graticule = use_graticule;
130 // Make it reprocess
131         plugin->send_configure_change();
132 }
133
134
135 int VideoScopeWindow::resize_event(int w, int h)
136 {
137         ScopeGUI::resize_event(w, h);
138         plugin->w = w;
139         plugin->h = h;
140 // Make it reprocess
141         plugin->send_configure_change();
142         return 1;
143 }
144
145 REGISTER_PLUGIN(VideoScopeEffect)
146
147 VideoScopeEffect::VideoScopeEffect(PluginServer *server)
148  : PluginVClient(server)
149 {
150         w = MIN_SCOPE_W;
151         h = MIN_SCOPE_H;
152         use_hist = 0;
153         use_wave = 0;
154         use_vector = 1;
155         use_hist_parade = 1;
156         use_wave_parade = 1;
157         use_wave_gain = 5;
158         use_vect_gain = 5;
159         use_smooth = 1;
160         use_graticule = 0;
161 }
162
163 VideoScopeEffect::~VideoScopeEffect()
164 {
165 }
166
167 const char* VideoScopeEffect::plugin_title() { return N_("VideoScope"); }
168 int VideoScopeEffect::is_realtime() { return 1; }
169
170 int VideoScopeEffect::load_configuration()
171 {
172         return 0;
173 }
174
175 void VideoScopeEffect::save_data(KeyFrame *keyframe)
176 {
177         FileXML output;
178
179 // cause data to be stored directly in text
180         output.set_shared_output(keyframe->xbuf);
181         output.tag.set_title("VIDEOSCOPE");
182         if( is_defaults() ) {
183                 output.tag.set_property("W", w);
184                 output.tag.set_property("H", h);
185                 output.tag.set_property("USE_HIST", use_hist);
186                 output.tag.set_property("USE_WAVE", use_wave);
187                 output.tag.set_property("USE_VECTOR", use_vector);
188                 output.tag.set_property("USE_HIST_PARADE", use_hist_parade);
189                 output.tag.set_property("USE_WAVE_PARADE", use_wave_parade);
190                 output.tag.set_property("USE_WAVE_GAIN", use_wave_gain);
191                 output.tag.set_property("USE_VECT_GAIN", use_vect_gain);
192                 output.tag.set_property("USE_SMOOTH", use_smooth);
193                 output.tag.set_property("USE_GRATICULE", use_graticule);
194
195         }
196         output.append_tag();
197         output.tag.set_title("/VIDEOSCOPE");
198         output.append_tag();
199         output.append_newline();
200         output.terminate_string();
201 }
202
203 void VideoScopeEffect::read_data(KeyFrame *keyframe)
204 {
205         FileXML input;
206         input.set_shared_input(keyframe->xbuf);
207         int result = 0;
208
209         while( !(result = input.read_tag()) ) {
210                 if( input.tag.title_is("VIDEOSCOPE") ) {
211                         if( is_defaults() ) {
212                                 w = input.tag.get_property("W", w);
213                                 h = input.tag.get_property("H", h);
214                                 use_hist = input.tag.get_property("USE_HIST", use_hist);
215                                 use_wave = input.tag.get_property("USE_WAVE", use_wave);
216                                 use_vector = input.tag.get_property("USE_VECTOR", use_vector);
217                                 use_hist_parade = input.tag.get_property("USE_HIST_PARADE", use_hist_parade);
218                                 use_wave_parade = input.tag.get_property("USE_WAVE_PARADE", use_wave_parade);
219                                 use_wave_gain = input.tag.get_property("USE_WAVE_GAIN", use_wave_gain);
220                                 use_vect_gain = input.tag.get_property("USE_VECT_GAIN", use_vect_gain);
221                                 use_smooth = input.tag.get_property("USE_SMOOTH", use_smooth);
222                                 use_graticule = input.tag.get_property("USE_GRATICULE", use_graticule);
223                         }
224                 }
225         }
226 }
227
228 NEW_WINDOW_MACRO(VideoScopeEffect, VideoScopeWindow)
229
230 int VideoScopeEffect::process_realtime(VFrame *input, VFrame *output)
231 {
232
233         send_render_gui(input);
234         if( input->get_rows()[0] != output->get_rows()[0] )
235                 output->copy_from(input);
236         return 1;
237 }
238
239 void VideoScopeEffect::render_gui(void *input)
240 {
241         if( !thread ) return;
242         VideoScopeWindow *window = ((VideoScopeWindow*)thread->window);
243         window->lock_window();
244         this->input = (VFrame*)input;
245         window->process(this->input);
246         window->unlock_window();
247 }
248