update cin.po, goog xlat update xx.po
[goodguy/history.git] / cinelerra-5.1 / plugins / despike / despike.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 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 "clip.h"
23 #include "confirmsave.h"
24 #include "bchash.h"
25 #include "errorbox.h"
26 #include "filexml.h"
27 #include "language.h"
28 #include "despike.h"
29 #include "despikewindow.h"
30 #include "samples.h"
31
32 #include "vframe.h"
33
34 #include <string.h>
35
36
37
38 REGISTER_PLUGIN(Despike)
39
40
41
42 Despike::Despike(PluginServer *server)
43  : PluginAClient(server)
44 {
45         
46         last_sample = 0;
47 }
48
49 Despike::~Despike()
50 {
51         
52 }
53
54 const char* Despike::plugin_title() { return _("Despike"); }
55 int Despike::is_realtime() { return 1; }
56
57 NEW_WINDOW_MACRO(Despike, DespikeWindow)
58
59 LOAD_CONFIGURATION_MACRO(Despike, DespikeConfig)
60
61
62 int Despike::process_realtime(int64_t size, Samples *input_ptr, Samples *output_ptr)
63 {
64         load_configuration();
65
66         double threshold = db.fromdb(config.level);
67         double change = db.fromdb(config.slope);
68
69 //printf("Despike::process_realtime 1\n");
70         double *output_samples = output_ptr->get_data();
71         double *input_samples = input_ptr->get_data();
72         for(int64_t i = 0; i < size; i++)
73         {
74                 if(fabs(input_samples[i]) > threshold || 
75                         fabs(input_samples[i]) - fabs(last_sample) > change) 
76                 {
77                         output_samples[i] = last_sample;
78                 }
79                 else
80                 {
81                         output_samples[i] = input_samples[i];
82                         last_sample = input_samples[i];
83                 }
84         }
85 //printf("Despike::process_realtime 2\n");
86
87         return 0;
88 }
89
90
91
92 void Despike::save_data(KeyFrame *keyframe)
93 {
94         FileXML output;
95
96 // cause xml file to store data directly in text
97         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
98
99         output.tag.set_title("DESPIKE");
100         output.tag.set_property("LEVEL", config.level);
101         output.tag.set_property("SLOPE", config.slope);
102         output.append_tag();
103         output.tag.set_title("/DESPIKE");
104         output.append_tag();
105         output.append_newline();
106         output.terminate_string();
107 }
108
109 void Despike::read_data(KeyFrame *keyframe)
110 {
111         FileXML input;
112 // cause xml file to read directly from text
113         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
114         int result = 0;
115
116         result = input.read_tag();
117
118         if(!result)
119         {
120                 if(input.tag.title_is("DESPIKE"))
121                 {
122                         config.level = input.tag.get_property("LEVEL", config.level);
123                         config.slope = input.tag.get_property("SLOPE", config.slope);
124                 }
125         }
126 }
127
128 void Despike::update_gui()
129 {
130         if(thread)
131         {
132                 load_configuration();
133                 ((DespikeWindow*)thread->window)->lock_window();
134                 ((DespikeWindow*)thread->window)->level->update(config.level);
135                 ((DespikeWindow*)thread->window)->slope->update(config.slope);
136                 ((DespikeWindow*)thread->window)->unlock_window();
137         }
138 }
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155 DespikeConfig::DespikeConfig()
156 {
157         level = 0;
158         slope = 0;
159 }
160
161 int DespikeConfig::equivalent(DespikeConfig &that)
162 {
163         return EQUIV(level, that.level) && 
164                 EQUIV(slope, that.slope);
165 }
166
167 void DespikeConfig::copy_from(DespikeConfig &that)
168 {
169         level = that.level;
170         slope = that.slope;
171 }
172
173 void DespikeConfig::interpolate(DespikeConfig &prev, 
174                 DespikeConfig &next, 
175                 int64_t prev_frame, 
176                 int64_t next_frame, 
177                 int64_t current_frame)
178 {
179         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
180         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
181
182         this->level = prev.level * prev_scale + next.level * next_scale;
183         this->slope = prev.slope * prev_scale + next.slope * next_scale;
184 }
185
186
187
188
189
190