deint_cv_fuctions_renaming.diff (21,331 bytes)

diff --git a/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.C b/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.C
index 4429d86..ab7fb82 100644
--- a/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.C
+++ b/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.C
@@ -40,12 +40,12 @@
 #include <string.h>
 #include <math.h>
 
-REGISTER_PLUGIN(DeInterlaceMain)
+REGISTER_PLUGIN(DeInterlaceCVMain)
 
 
 
 
-DeInterlaceConfig::DeInterlaceConfig()
+DeInterlaceCVConfig::DeInterlaceCVConfig()
 {
 	mode = DEINTERLACE_AVG;
 	dominance = 0;
@@ -53,7 +53,7 @@ DeInterlaceConfig::DeInterlaceConfig()
 	threshold = 40;
 }
 
-int DeInterlaceConfig::equivalent(DeInterlaceConfig &that)
+int DeInterlaceCVConfig::equivalent(DeInterlaceCVConfig &that)
 {
 	return mode == that.mode &&
 		dominance == that.dominance &&
@@ -61,7 +61,7 @@ int DeInterlaceConfig::equivalent(DeInterlaceConfig &that)
 		threshold == that.threshold;
 }
 
-void DeInterlaceConfig::copy_from(DeInterlaceConfig &that)
+void DeInterlaceCVConfig::copy_from(DeInterlaceCVConfig &that)
 {
 	mode = that.mode;
 	dominance = that.dominance;
@@ -69,8 +69,8 @@ void DeInterlaceConfig::copy_from(DeInterlaceConfig &that)
 	threshold = that.threshold;
 }
 
-void DeInterlaceConfig::interpolate(DeInterlaceConfig &prev,
-	DeInterlaceConfig &next,
+void DeInterlaceCVConfig::interpolate(DeInterlaceCVConfig &prev,
+	DeInterlaceCVConfig &next,
 	int64_t prev_frame,
 	int64_t next_frame,
 	int64_t current_frame)
@@ -81,21 +81,21 @@ void DeInterlaceConfig::interpolate(DeInterlaceConfig &prev,
 
 
 
-DeInterlaceMain::DeInterlaceMain(PluginServer *server)
+DeInterlaceCVMain::DeInterlaceCVMain(PluginServer *server)
  : PluginVClient(server)
 {
 //	temp = 0;
 	temp_prevframe=0;
 }
 
-DeInterlaceMain::~DeInterlaceMain()
+DeInterlaceCVMain::~DeInterlaceCVMain()
 {
 //	if(temp) delete temp;
 	if(temp_prevframe) delete temp_prevframe;
 }
 
-const char* DeInterlaceMain::plugin_title() { return N_("Deinterlace-CV"); }
-int DeInterlaceMain::is_realtime() { return 1; }
+const char* DeInterlaceCVMain::plugin_title() { return N_("Deinterlace-CV"); }
+int DeInterlaceCVMain::is_realtime() { return 1; }
 
 
 
@@ -344,7 +344,7 @@ static inline double FABS(double v) { return v<0 ? -v : v; }
 }
 
 
-void DeInterlaceMain::deinterlace_top(VFrame *input, VFrame *output, int dominance)
+void DeInterlaceCVMain::deinterlace_top(VFrame *input, VFrame *output, int dominance)
 {
 	switch(input->get_color_model())
 	{
@@ -373,7 +373,7 @@ void DeInterlaceMain::deinterlace_top(VFrame *input, VFrame *output, int dominan
 	}
 }
 
-void DeInterlaceMain::deinterlace_avg_top(VFrame *input, VFrame *output, int dominance)
+void DeInterlaceCVMain::deinterlace_avg_top(VFrame *input, VFrame *output, int dominance)
 {
 	switch(input->get_color_model())
 	{
@@ -402,7 +402,7 @@ void DeInterlaceMain::deinterlace_avg_top(VFrame *input, VFrame *output, int dom
 	}
 }
 
-void DeInterlaceMain::deinterlace_avg(VFrame *input, VFrame *output)
+void DeInterlaceCVMain::deinterlace_avg(VFrame *input, VFrame *output)
 {
 	switch(input->get_color_model())
 	{
@@ -431,7 +431,7 @@ void DeInterlaceMain::deinterlace_avg(VFrame *input, VFrame *output)
 	}
 }
 
-void DeInterlaceMain::deinterlace_swap(VFrame *input, VFrame *output, int dominance)
+void DeInterlaceCVMain::deinterlace_swap(VFrame *input, VFrame *output, int dominance)
 {
 	switch(input->get_color_model())
 	{
@@ -460,7 +460,7 @@ void DeInterlaceMain::deinterlace_swap(VFrame *input, VFrame *output, int domina
 	}
 }
 
-void DeInterlaceMain::deinterlace_temporalswap(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
+void DeInterlaceCVMain::deinterlace_temporalswap(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
 {
 	switch(input->get_color_model())
 	{
@@ -489,7 +489,7 @@ void DeInterlaceMain::deinterlace_temporalswap(VFrame *input, VFrame *prevframe,
 	}
 }
 
-void DeInterlaceMain::deinterlace_bobweave(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
+void DeInterlaceCVMain::deinterlace_bobweave(VFrame *input, VFrame *prevframe, VFrame *output, int dominance)
 {
 	int threshold=config.threshold;
 	int noise_threshold=0;
@@ -522,7 +522,7 @@ void DeInterlaceMain::deinterlace_bobweave(VFrame *input, VFrame *prevframe, VFr
 }
 
 
-int DeInterlaceMain::process_buffer(VFrame *frame,
+int DeInterlaceCVMain::process_buffer(VFrame *frame,
 	int64_t start_position,
 	double frame_rate)
 {
@@ -580,13 +580,13 @@ int DeInterlaceMain::process_buffer(VFrame *frame,
 }
 
 
-void DeInterlaceMain::render_gui(void *data)
+void DeInterlaceCVMain::render_gui(void *data)
 {
 	if(thread)
 	{
 		thread->window->lock_window();
 		char string[BCTEXTLEN];
-		DeInterlaceWindow *window = (DeInterlaceWindow *)thread->window;
+		DeInterlaceCVWindow *window = (DeInterlaceCVWindow *)thread->window;
 		window->get_status_string(string, *(int*)data);
 		window->status->update(string);
 		window->flush();
@@ -594,12 +594,12 @@ void DeInterlaceMain::render_gui(void *data)
 	}
 }
 
-NEW_WINDOW_MACRO(DeInterlaceMain, DeInterlaceWindow)
-LOAD_CONFIGURATION_MACRO(DeInterlaceMain, DeInterlaceConfig)
+NEW_WINDOW_MACRO(DeInterlaceCVMain, DeInterlaceCVWindow)
+LOAD_CONFIGURATION_MACRO(DeInterlaceCVMain, DeInterlaceCVConfig)
 
 
 
-void DeInterlaceMain::save_data(KeyFrame *keyframe)
+void DeInterlaceCVMain::save_data(KeyFrame *keyframe)
 {
 	FileXML output;
 	output.set_shared_output(keyframe->xbuf);
@@ -614,7 +614,7 @@ void DeInterlaceMain::save_data(KeyFrame *keyframe)
 	output.terminate_string();
 }
 
-void DeInterlaceMain::read_data(KeyFrame *keyframe)
+void DeInterlaceCVMain::read_data(KeyFrame *keyframe)
 {
 	FileXML input;
 	input.set_shared_input(keyframe->xbuf);
@@ -632,12 +632,12 @@ void DeInterlaceMain::read_data(KeyFrame *keyframe)
 
 }
 
-void DeInterlaceMain::update_gui()
+void DeInterlaceCVMain::update_gui()
 {
 	if(thread)
 	{
 		load_configuration();
-		DeInterlaceWindow *window = (DeInterlaceWindow *)thread->window;
+		DeInterlaceCVWindow *window = (DeInterlaceCVWindow *)thread->window;
 		window->lock_window();
 		window->set_mode(config.mode, 1);
 		if (window->dominance_top)
diff --git a/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.h b/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.h
index 8265a3b..9604871 100644
--- a/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.h
+++ b/cinelerra-5.1/plugins/deinterlace-cv/deinterlace-cv.h
@@ -24,7 +24,7 @@
 
 // the simplest plugin possible
 
-class DeInterlaceMain;
+class DeInterlaceCVMain;
 
 #include "bchash.inc"
 #include "deinterwindow-cv.h"
@@ -46,15 +46,15 @@ enum
 	DEINTERLACE_TEMPORALSWAP,
 };
 
-class DeInterlaceConfig
+class DeInterlaceCVConfig
 {
 public:
-	DeInterlaceConfig();
+	DeInterlaceCVConfig();
 
-	int equivalent(DeInterlaceConfig &that);
-	void copy_from(DeInterlaceConfig &that);
-	void interpolate(DeInterlaceConfig &prev,
-		DeInterlaceConfig &next,
+	int equivalent(DeInterlaceCVConfig &that);
+	void copy_from(DeInterlaceCVConfig &that);
+	void interpolate(DeInterlaceCVConfig &prev,
+		DeInterlaceCVConfig &next,
 		int64_t prev_frame,
 		int64_t next_frame,
 		int64_t current_frame);
@@ -65,14 +65,14 @@ public:
 	volatile int dominance; /* top or bottom field */
 };
 
-class DeInterlaceMain : public PluginVClient
+class DeInterlaceCVMain : public PluginVClient
 {
 public:
-	DeInterlaceMain(PluginServer *server);
-	~DeInterlaceMain();
+	DeInterlaceCVMain(PluginServer *server);
+	~DeInterlaceCVMain();
 
 
-	PLUGIN_CLASS_MEMBERS(DeInterlaceConfig);
+	PLUGIN_CLASS_MEMBERS(DeInterlaceCVConfig);
 
 
 // required for all realtime plugins
diff --git a/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.C b/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.C
index 068be6d..75235da 100644
--- a/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.C
+++ b/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.C
@@ -25,7 +25,7 @@
 #include <string.h>
 
 
-DeInterlaceWindow::DeInterlaceWindow(DeInterlaceMain *client)
+DeInterlaceCVWindow::DeInterlaceCVWindow(DeInterlaceCVMain *client)
  : PluginClientWindow(client,
 	xS(400),
 	yS(200),
@@ -38,18 +38,18 @@ DeInterlaceWindow::DeInterlaceWindow(DeInterlaceMain *client)
 
 }
 
-DeInterlaceWindow::~DeInterlaceWindow()
+DeInterlaceCVWindow::~DeInterlaceCVWindow()
 {
 }
 
-void DeInterlaceWindow::create_objects()
+void DeInterlaceCVWindow::create_objects()
 {
 	int xs10 = xS(10);
 	int ys10 = yS(10), ys25 = yS(25);
 	int x = xs10, y = ys10;
 	add_tool(new BC_Title(x, y, _("Select deinterlacing mode")));
 	y += ys25;
-	add_tool(mode = new DeInterlaceMode(client, this, x, y));
+	add_tool(mode = new DeInterlaceCVMode(client, this, x, y));
 	mode->create_objects();
 	y += ys25;
 	optional_controls_x=x;
@@ -63,12 +63,12 @@ void DeInterlaceWindow::create_objects()
 	set_mode(client->config.mode,0);
 }
 
-void DeInterlaceWindow::get_status_string(char *string, int changed_rows)
+void DeInterlaceCVWindow::get_status_string(char *string, int changed_rows)
 {
 	sprintf(string, _("Changed rows: %d\n"), changed_rows);
 }
 
-int DeInterlaceWindow::set_mode(int mode, int recursive)
+int DeInterlaceCVWindow::set_mode(int mode, int recursive)
 {
 	int x,y;
 	client->config.mode = mode;
@@ -86,27 +86,27 @@ int DeInterlaceWindow::set_mode(int mode, int recursive)
 	{
 		case DEINTERLACE_KEEP:
 		case DEINTERLACE_BOBWEAVE:
-			add_subwindow(dominance_top = new DeInterlaceDominanceTop(client, this, x, y, _("Keep top field")));
+			add_subwindow(dominance_top = new DeInterlaceCVDominanceTop(client, this, x, y, _("Keep top field")));
 			y+=yS(25);
-			add_subwindow(dominance_bottom = new DeInterlaceDominanceBottom(client, this, x, y, _("Keep bottom field")));
+			add_subwindow(dominance_bottom = new DeInterlaceCVDominanceBottom(client, this, x, y, _("Keep bottom field")));
 			y+=yS(25);
 			break;
 		case DEINTERLACE_AVG_1F:
-			add_subwindow(dominance_top = new DeInterlaceDominanceTop(client, this, x, y, _("Average top fields")));
+			add_subwindow(dominance_top = new DeInterlaceCVDominanceTop(client, this, x, y, _("Average top fields")));
 			y+=yS(25);
-			add_subwindow(dominance_bottom = new DeInterlaceDominanceBottom(client, this, x, y,_("Average bottom fields")));
+			add_subwindow(dominance_bottom = new DeInterlaceCVDominanceBottom(client, this, x, y,_("Average bottom fields")));
 			y+=yS(25);
 			break;
 		case DEINTERLACE_SWAP:
-			add_subwindow(dominance_top = new DeInterlaceDominanceTop(client, this, x, y, _("Top field first")));
+			add_subwindow(dominance_top = new DeInterlaceCVDominanceTop(client, this, x, y, _("Top field first")));
 			y+=yS(25);
-			add_subwindow(dominance_bottom = new DeInterlaceDominanceBottom(client, this, x, y, _("Bottom field first")));
+			add_subwindow(dominance_bottom = new DeInterlaceCVDominanceBottom(client, this, x, y, _("Bottom field first")));
 			y+=yS(25);
 			break;
 		case DEINTERLACE_TEMPORALSWAP:
-			add_subwindow(dominance_top = new DeInterlaceDominanceTop(client, this, x, y, _("Top field first")));
+			add_subwindow(dominance_top = new DeInterlaceCVDominanceTop(client, this, x, y, _("Top field first")));
 			y+=yS(25);
-			add_subwindow(dominance_bottom = new DeInterlaceDominanceBottom(client, this, x, y, _("Bottom field first")));
+			add_subwindow(dominance_bottom = new DeInterlaceCVDominanceBottom(client, this, x, y, _("Bottom field first")));
 			y+=yS(25);
 			break;
 		case DEINTERLACE_NONE:
@@ -123,14 +123,14 @@ int DeInterlaceWindow::set_mode(int mode, int recursive)
 /* Display Threshold and adaptive controls */
 	switch (mode) {
 		case  DEINTERLACE_AVG_1F:
-			add_subwindow(adaptive = new DeInterlaceAdaptive(client, x, y));
+			add_subwindow(adaptive = new DeInterlaceCVAdaptive(client, x, y));
 
-			add_subwindow(threshold = new DeInterlaceThreshold(client, x + xS(150), y));
+			add_subwindow(threshold = new DeInterlaceCVThreshold(client, x + xS(150), y));
 			add_subwindow(threshold->title_caption=new BC_Title(x+xS(150), y + yS(50), _("Threshold")));
 			adaptive->update(client->config.adaptive?BC_Toggle::TOGGLE_CHECKED:0);
 			break;
 		case DEINTERLACE_BOBWEAVE:
-			add_subwindow(threshold = new DeInterlaceThreshold(client, x + xS(150), y));
+			add_subwindow(threshold = new DeInterlaceCVThreshold(client, x + xS(150), y));
 			add_subwindow(threshold->title_caption=new BC_Title(x+xS(150), y + yS(50), _("Bob Threshold")));
 			break;
 		case DEINTERLACE_NONE:
@@ -150,8 +150,8 @@ int DeInterlaceWindow::set_mode(int mode, int recursive)
 }
 
 
-DeInterlaceOption::DeInterlaceOption(DeInterlaceMain *client,
-		DeInterlaceWindow *window,
+DeInterlaceCVOption::DeInterlaceCVOption(DeInterlaceCVMain *client,
+		DeInterlaceCVWindow *window,
 		int output,
 		int x,
 		int y,
@@ -163,36 +163,36 @@ DeInterlaceOption::DeInterlaceOption(DeInterlaceMain *client,
 	this->output = output;
 }
 
-DeInterlaceOption::~DeInterlaceOption()
+DeInterlaceCVOption::~DeInterlaceCVOption()
 {
 }
-int DeInterlaceOption::handle_event()
+int DeInterlaceCVOption::handle_event()
 {
 	window->set_mode(output, 0);
 	return 1;
 }
 
 
-DeInterlaceAdaptive::DeInterlaceAdaptive(DeInterlaceMain *client, int x, int y)
+DeInterlaceCVAdaptive::DeInterlaceCVAdaptive(DeInterlaceCVMain *client, int x, int y)
  : BC_CheckBox(x, y, client->config.adaptive, _("Adaptive"))
 {
 	this->client = client;
 }
-int DeInterlaceAdaptive::handle_event()
+int DeInterlaceCVAdaptive::handle_event()
 {
 	client->config.adaptive = get_value();
 	client->send_configure_change();
 	return 1;
 }
 
-DeInterlaceDominanceTop::DeInterlaceDominanceTop(DeInterlaceMain *client, DeInterlaceWindow *window, int x, int y, char * title)
+DeInterlaceCVDominanceTop::DeInterlaceCVDominanceTop(DeInterlaceCVMain *client, DeInterlaceCVWindow *window, int x, int y, char * title)
  : BC_Radial(x, y, client->config.dominance, title)
 {
 	this->client = client;
 	this->window = window;
 
 }
-int DeInterlaceDominanceTop::handle_event()
+int DeInterlaceCVDominanceTop::handle_event()
 {
 	client->config.dominance = (get_value()==0);
 	window->dominance_bottom->update(client->config.dominance?BC_Toggle::TOGGLE_CHECKED:0);
@@ -201,13 +201,13 @@ int DeInterlaceDominanceTop::handle_event()
 }
 
 
-DeInterlaceDominanceBottom::DeInterlaceDominanceBottom(DeInterlaceMain *client, DeInterlaceWindow *window, int x, int y, const char * title)
+DeInterlaceCVDominanceBottom::DeInterlaceCVDominanceBottom(DeInterlaceCVMain *client, DeInterlaceCVWindow *window, int x, int y, const char * title)
  : BC_Radial(x, y, client->config.dominance, title)
 {
 	this->client = client;
 	this->window = window;
 }
-int DeInterlaceDominanceBottom::handle_event()
+int DeInterlaceCVDominanceBottom::handle_event()
 {
 
 	client->config.dominance = (get_value() != 0 );
@@ -217,26 +217,26 @@ int DeInterlaceDominanceBottom::handle_event()
 }
 
 
-DeInterlaceThreshold::DeInterlaceThreshold(DeInterlaceMain *client, int x, int y)
+DeInterlaceCVThreshold::DeInterlaceCVThreshold(DeInterlaceCVMain *client, int x, int y)
  : BC_IPot(x, y, client->config.threshold, 0, 100)
 {
 	this->client = client;
 	title_caption=NULL;
 }
-int DeInterlaceThreshold::handle_event()
+int DeInterlaceCVThreshold::handle_event()
 {
 	client->config.threshold = get_value();
 	client->send_configure_change();
 	return 1;
 }
 
-DeInterlaceThreshold::~DeInterlaceThreshold()
+DeInterlaceCVThreshold::~DeInterlaceCVThreshold()
 {
   if (title_caption) delete title_caption;
 }
 
-DeInterlaceMode::DeInterlaceMode(DeInterlaceMain*plugin,
-	DeInterlaceWindow *gui,
+DeInterlaceCVMode::DeInterlaceCVMode(DeInterlaceCVMain*plugin,
+	DeInterlaceCVWindow *gui,
 	int x,
 	int y)
  : BC_PopupMenu(x, y, xS(200), to_text(plugin->config.mode), 1)
@@ -244,7 +244,7 @@ DeInterlaceMode::DeInterlaceMode(DeInterlaceMain*plugin,
 	this->plugin = plugin;
 	this->gui = gui;
 }
-void DeInterlaceMode::create_objects()
+void DeInterlaceCVMode::create_objects()
 {
 	add_item(new BC_MenuItem(to_text(DEINTERLACE_NONE)));
 	add_item(new BC_MenuItem(to_text(DEINTERLACE_KEEP)));
@@ -255,7 +255,7 @@ void DeInterlaceMode::create_objects()
 	add_item(new BC_MenuItem(to_text(DEINTERLACE_TEMPORALSWAP)));
 }
 
-char* DeInterlaceMode::to_text(int mode)
+char* DeInterlaceCVMode::to_text(int mode)
 {
 	switch(mode)
 	{
@@ -275,7 +275,7 @@ char* DeInterlaceMode::to_text(int mode)
 			return _("Do Nothing");
 	}
 }
-int DeInterlaceMode::from_text(char *text)
+int DeInterlaceCVMode::from_text(char *text)
 {
 	if(!strcmp(text, to_text(DEINTERLACE_KEEP)))
 		return DEINTERLACE_KEEP;
@@ -292,7 +292,7 @@ int DeInterlaceMode::from_text(char *text)
 	return DEINTERLACE_NONE;
 }
 
-int DeInterlaceMode::handle_event()
+int DeInterlaceCVMode::handle_event()
 {
 	plugin->config.mode = from_text(get_text());
 	gui->set_mode(plugin->config.mode,0);
diff --git a/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.h b/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.h
index a5e2262..999e076 100644
--- a/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.h
+++ b/cinelerra-5.1/plugins/deinterlace-cv/deinterwindow-cv.h
@@ -23,8 +23,8 @@
 #define DEINTERWINDOW_H
 
 
-class DeInterlaceThread;
-class DeInterlaceWindow;
+class DeInterlaceCVThread;
+class DeInterlaceCVWindow;
 
 #include "guicast.h"
 #include "mutex.h"
@@ -32,102 +32,102 @@ class DeInterlaceWindow;
 #include "pluginclient.h"
 
 
-class DeInterlaceOption;
-class DeInterlaceMode;
-class DeInterlaceDominanceTop;
-class DeInterlaceDominanceBottom;
-class DeInterlaceAdaptive;
-class DeInterlaceThreshold;
+class DeInterlaceCVOption;
+class DeInterlaceCVMode;
+class DeInterlaceCVDominanceTop;
+class DeInterlaceCVDominanceBottom;
+class DeInterlaceCVAdaptive;
+class DeInterlaceCVThreshold;
 
-class DeInterlaceWindow : public PluginClientWindow
+class DeInterlaceCVWindow : public PluginClientWindow
 {
 public:
-	DeInterlaceWindow(DeInterlaceMain *client);
-	~DeInterlaceWindow();
+	DeInterlaceCVWindow(DeInterlaceCVMain *client);
+	~DeInterlaceCVWindow();
 
 	void create_objects();
 	int set_mode(int mode, int recursive);
 	void get_status_string(char *string, int changed_rows);
 
-	DeInterlaceMain *client;
-	DeInterlaceMode *mode;
-	DeInterlaceAdaptive *adaptive;
-	DeInterlaceDominanceTop *dominance_top;
-	DeInterlaceDominanceBottom *dominance_bottom;
-	DeInterlaceThreshold *threshold;
+	DeInterlaceCVMain *client;
+	DeInterlaceCVMode *mode;
+	DeInterlaceCVAdaptive *adaptive;
+	DeInterlaceCVDominanceTop *dominance_top;
+	DeInterlaceCVDominanceBottom *dominance_bottom;
+	DeInterlaceCVThreshold *threshold;
 	int optional_controls_x,optional_controls_y;
 	BC_Title *status;
 };
 
-class DeInterlaceOption : public BC_Radial
+class DeInterlaceCVOption : public BC_Radial
 {
 public:
-	DeInterlaceOption(DeInterlaceMain *client,
-		DeInterlaceWindow *window,
+	DeInterlaceCVOption(DeInterlaceCVMain *client,
+		DeInterlaceCVWindow *window,
 		int output,
 		int x,
 		int y,
 		char *text);
-	~DeInterlaceOption();
+	~DeInterlaceCVOption();
 	int handle_event();
 
-	DeInterlaceMain *client;
-	DeInterlaceWindow *window;
+	DeInterlaceCVMain *client;
+	DeInterlaceCVWindow *window;
 	int output;
 };
 
-class DeInterlaceAdaptive : public BC_CheckBox
+class DeInterlaceCVAdaptive : public BC_CheckBox
 {
 public:
-	DeInterlaceAdaptive(DeInterlaceMain *client, int x, int y);
+	DeInterlaceCVAdaptive(DeInterlaceCVMain *client, int x, int y);
 	int handle_event();
-	DeInterlaceMain *client;
+	DeInterlaceCVMain *client;
 };
 
-class DeInterlaceDominanceTop : public BC_Radial
+class DeInterlaceCVDominanceTop : public BC_Radial
 {
 public:
-	DeInterlaceDominanceTop(DeInterlaceMain *client, DeInterlaceWindow *window, int x, int y, char * title);
+	DeInterlaceCVDominanceTop(DeInterlaceCVMain *client, DeInterlaceCVWindow *window, int x, int y, char * title);
 	int handle_event();
-	DeInterlaceMain *client;
-	DeInterlaceWindow *window;
+	DeInterlaceCVMain *client;
+	DeInterlaceCVWindow *window;
 
 };
-class DeInterlaceDominanceBottom : public BC_Radial
+class DeInterlaceCVDominanceBottom : public BC_Radial
 {
 public:
-	DeInterlaceDominanceBottom(DeInterlaceMain *client, DeInterlaceWindow *window, int x, int y, const char * title);
+	DeInterlaceCVDominanceBottom(DeInterlaceCVMain *client, DeInterlaceCVWindow *window, int x, int y, const char * title);
 	int handle_event();
-	DeInterlaceMain *client;
-	DeInterlaceWindow *window;
+	DeInterlaceCVMain *client;
+	DeInterlaceCVWindow *window;
 };
 
-class DeInterlaceThreshold : public BC_IPot
+class DeInterlaceCVThreshold : public BC_IPot
 {
 public:
-	DeInterlaceThreshold(DeInterlaceMain *client, int x, int y);
-	~DeInterlaceThreshold();
+	DeInterlaceCVThreshold(DeInterlaceCVMain *client, int x, int y);
+	~DeInterlaceCVThreshold();
 
 	int handle_event();
-	DeInterlaceMain *client;
+	DeInterlaceCVMain *client;
 	BC_Title *title_caption;
 };
 
 
 
-class DeInterlaceMode : public BC_PopupMenu
+class DeInterlaceCVMode : public BC_PopupMenu
 {
 public:
-	DeInterlaceMode(DeInterlaceMain *client,
-		DeInterlaceWindow *window,
+	DeInterlaceCVMode(DeInterlaceCVMain *client,
+		DeInterlaceCVWindow *window,
 		int x,
 		int y);
 	void create_objects();
 	static char* to_text(int shape);
 	static int from_text(char *text);
 	int handle_event();
-	DeInterlaceMain *plugin;
-	DeInterlaceWindow *gui;
+	DeInterlaceCVMain *plugin;
+	DeInterlaceCVWindow *gui;
 };