configure.ac add with-cuda/nv, update cakewalk theme, add cuda/plugins=mandel+nbody...
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / rotate / rotate.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
23 #include "rotate.h"
24
25 #define MAXANGLE 360
26
27 REGISTER_PLUGIN(RotateEffect)
28
29
30
31
32 RotateConfig::RotateConfig()
33 {
34         reset();
35 }
36
37 void RotateConfig::reset()
38 {
39         angle = 0.0;
40         pivot_x = 50.0;
41         pivot_y = 50.0;
42         draw_pivot = 0;
43 }
44
45 int RotateConfig::equivalent(RotateConfig &that)
46 {
47         return EQUIV(angle, that.angle) &&
48                 EQUIV(pivot_x, that.pivot_y) &&
49                 EQUIV(pivot_y, that.pivot_y) &&
50                 draw_pivot == that.draw_pivot;
51 }
52
53 void RotateConfig::copy_from(RotateConfig &that)
54 {
55         angle = that.angle;
56         pivot_x = that.pivot_x;
57         pivot_y = that.pivot_y;
58         draw_pivot = that.draw_pivot;
59 //      bilinear = that.bilinear;
60 }
61
62 void RotateConfig::interpolate(RotateConfig &prev,
63                 RotateConfig &next,
64                 long prev_frame,
65                 long next_frame,
66                 long current_frame)
67 {
68         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
69         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
70
71         this->angle = prev.angle * prev_scale + next.angle * next_scale;
72         this->pivot_x = prev.pivot_x * prev_scale + next.pivot_x * next_scale;
73         this->pivot_y = prev.pivot_y * prev_scale + next.pivot_y * next_scale;
74         draw_pivot = prev.draw_pivot;
75 //      bilinear = prev.bilinear;
76 }
77
78
79
80
81
82
83
84
85
86
87
88 RotateToggle::RotateToggle(RotateWindow *window,
89         RotateEffect *plugin,
90         int init_value,
91         int x,
92         int y,
93         int value,
94         const char *string)
95  : BC_Radial(x, y, init_value, string)
96 {
97         this->value = value;
98         this->plugin = plugin;
99         this->window = window;
100 }
101
102 int RotateToggle::handle_event()
103 {
104         plugin->config.angle = (float)value;
105         window->update();
106         plugin->send_configure_change();
107         return 1;
108 }
109
110
111
112
113
114
115
116 RotateDrawPivot::RotateDrawPivot(RotateWindow *window,
117         RotateEffect *plugin,
118         int x,
119         int y)
120  : BC_CheckBox(x, y, plugin->config.draw_pivot, _("Draw pivot"))
121 {
122         this->plugin = plugin;
123         this->window = window;
124 }
125
126 int RotateDrawPivot::handle_event()
127 {
128         plugin->config.draw_pivot = get_value();
129         plugin->send_configure_change();
130         return 1;
131 }
132
133
134
135
136
137 // RotateInterpolate::RotateInterpolate(RotateEffect *plugin, int x, int y)
138 //  : BC_CheckBox(x, y, plugin->config.bilinear, _("Interpolate"))
139 // {
140 //      this->plugin = plugin;
141 // }
142 // int RotateInterpolate::handle_event()
143 // {
144 //      plugin->config.bilinear = get_value();
145 //      plugin->send_configure_change();
146 //      return 1;
147 // }
148 //
149
150
151
152 RotateFine::RotateFine(RotateWindow *window, RotateEffect *plugin, int x, int y)
153  : BC_FPot(x,
154         y,
155         (float)plugin->config.angle,
156         (float)-360,
157         (float)360)
158 {
159         this->window = window;
160         this->plugin = plugin;
161         set_precision(0.01);
162         set_use_caption(0);
163 }
164
165 int RotateFine::handle_event()
166 {
167         plugin->config.angle = get_value();
168         window->update_toggles();
169         window->update_text();
170         plugin->send_configure_change();
171         return 1;
172 }
173
174
175
176 RotateText::RotateText(RotateWindow *window,
177         RotateEffect *plugin,
178         int x,
179         int y)
180  : BC_TextBox(x,
181         y,
182         90,
183         1,
184         (float)plugin->config.angle)
185 {
186         this->window = window;
187         this->plugin = plugin;
188         set_precision(4);
189 }
190
191 int RotateText::handle_event()
192 {
193         plugin->config.angle = atof(get_text());
194         window->update_toggles();
195         window->update_fine();
196         plugin->send_configure_change();
197         return 1;
198 }
199
200
201
202 RotateX::RotateX(RotateWindow *window, RotateEffect *plugin, int x, int y)
203  : BC_FPot(x,
204         y,
205         (float)plugin->config.pivot_x,
206         (float)0,
207         (float)100)
208 {
209         this->window = window;
210         this->plugin = plugin;
211         set_precision(0.01);
212         set_use_caption(1);
213 }
214
215 int RotateX::handle_event()
216 {
217         plugin->config.pivot_x = get_value();
218         plugin->send_configure_change();
219         return 1;
220 }
221
222 RotateY::RotateY(RotateWindow *window, RotateEffect *plugin, int x, int y)
223  : BC_FPot(x,
224         y,
225         (float)plugin->config.pivot_y,
226         (float)0,
227         (float)100)
228 {
229         this->window = window;
230         this->plugin = plugin;
231         set_precision(0.01);
232         set_use_caption(1);
233 }
234
235 int RotateY::handle_event()
236 {
237         plugin->config.pivot_y = get_value();
238         plugin->send_configure_change();
239         return 1;
240 }
241
242
243 RotateReset::RotateReset(RotateEffect *plugin, RotateWindow *window, int x, int y)
244  : BC_GenericButton(x, y, _("Reset"))
245 {
246         this->plugin = plugin;
247         this->window = window;
248 }
249 RotateReset::~RotateReset()
250 {
251 }
252 int RotateReset::handle_event()
253 {
254         plugin->config.reset();
255         window->update();
256         plugin->send_configure_change();
257         return 1;
258 }
259
260
261
262
263
264
265 RotateWindow::RotateWindow(RotateEffect *plugin)
266  : PluginClientWindow(plugin, 300, 230, 300, 230, 0)
267 {
268         this->plugin = plugin;
269 }
270
271 #define RADIUS 30
272
273 void RotateWindow::create_objects()
274 {
275         int x = 10, y = 10;
276         BC_Title *title;
277         add_tool(new BC_Title(x, y, _("Rotate")));
278         x += 50;  y += 20;
279         add_tool(toggle0 = new RotateToggle(this, plugin,
280                 plugin->config.angle == 0, x, y, 0, "0"));
281     x += RADIUS;  y += RADIUS;
282         add_tool(toggle90 = new RotateToggle(this, plugin,
283                 plugin->config.angle == 90, x, y, 90, "90"));
284     x -= RADIUS;  y += RADIUS;
285         add_tool(toggle180 = new RotateToggle(this, plugin,
286                 plugin->config.angle == 180, x, y, 180, "180"));
287     x -= RADIUS;  y -= RADIUS;
288         add_tool(toggle270 = new RotateToggle(this, plugin,
289                 plugin->config.angle == 270, x, y, 270, "270"));
290 //      add_subwindow(bilinear = new RotateInterpolate(plugin, 10, y + 60));
291         x += 150;  y -= 50;
292         add_tool(fine = new RotateFine(this, plugin, x, y));
293         y += fine->get_h() + 10;
294         add_tool(text = new RotateText(this, plugin, x, y));
295         y += 25;
296         add_tool(new BC_Title(x, y, _("Degrees")));
297
298         y += text->get_h() + 10;
299         add_subwindow(title = new BC_Title(x, y, _("Pivot (x,y):")));
300         y += title->get_h() + 10;
301         add_subwindow(this->x = new RotateX(this, plugin, x, y));
302         x += this->x->get_w() + 10;
303         add_subwindow(this->y = new RotateY(this, plugin, x, y));
304
305 //      y += this->y->get_h() + 10;
306         x = 10;
307         add_subwindow(draw_pivot = new RotateDrawPivot(this, plugin, x, y));
308         y += 60;
309         add_subwindow(reset = new RotateReset(plugin, this, x, y));
310
311         show_window();
312 }
313
314
315
316 int RotateWindow::update()
317 {
318         update_fine();
319         update_toggles();
320         update_text();
321 //      bilinear->update(plugin->config.bilinear);
322         return 0;
323 }
324
325 int RotateWindow::update_fine()
326 {
327         fine->update(plugin->config.angle);
328         x->update(plugin->config.pivot_x);
329         y->update(plugin->config.pivot_y);
330         return 0;
331 }
332
333 int RotateWindow::update_text()
334 {
335         text->update(plugin->config.angle);
336         return 0;
337 }
338
339 int RotateWindow::update_toggles()
340 {
341         toggle0->update(EQUIV(plugin->config.angle, 0));
342         toggle90->update(EQUIV(plugin->config.angle, 90));
343         toggle180->update(EQUIV(plugin->config.angle, 180));
344         toggle270->update(EQUIV(plugin->config.angle, 270));
345         draw_pivot->update(plugin->config.draw_pivot);
346         return 0;
347 }
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382 RotateEffect::RotateEffect(PluginServer *server)
383  : PluginVClient(server)
384 {
385         engine = 0;
386         need_reconfigure = 1;
387
388 }
389
390 RotateEffect::~RotateEffect()
391 {
392
393         if(engine) delete engine;
394 }
395
396
397
398 const char* RotateEffect::plugin_title() { return N_("Rotate"); }
399 int RotateEffect::is_realtime() { return 1; }
400
401
402 NEW_WINDOW_MACRO(RotateEffect, RotateWindow)
403
404
405 void RotateEffect::update_gui()
406 {
407         if(thread)
408         {
409                 load_configuration();
410                 thread->window->lock_window();
411                 ((RotateWindow*)thread->window)->update();
412                 thread->window->unlock_window();
413         }
414 }
415
416 LOAD_CONFIGURATION_MACRO(RotateEffect, RotateConfig)
417
418
419
420
421 void RotateEffect::save_data(KeyFrame *keyframe)
422 {
423         FileXML output;
424
425 // cause data to be stored directly in text
426         output.set_shared_output(keyframe->xbuf);
427         output.tag.set_title("ROTATE");
428         output.tag.set_property("ANGLE", (float)config.angle);
429         output.tag.set_property("PIVOT_X", (float)config.pivot_x);
430         output.tag.set_property("PIVOT_Y", (float)config.pivot_y);
431         output.tag.set_property("DRAW_PIVOT", (int)config.draw_pivot);
432 //      output.tag.set_property("INTERPOLATE", (int)config.bilinear);
433         output.append_tag();
434         output.tag.set_title("/ROTATE");
435         output.append_tag();
436         output.append_newline();
437         output.terminate_string();
438 // data is now in *text
439 }
440
441 void RotateEffect::read_data(KeyFrame *keyframe)
442 {
443         FileXML input;
444
445         input.set_shared_input(keyframe->xbuf);
446
447         int result = 0;
448
449         while(!result)
450         {
451                 result = input.read_tag();
452
453                 if(!result)
454                 {
455                         if(input.tag.title_is("ROTATE"))
456                         {
457                                 config.angle = input.tag.get_property("ANGLE", (float)config.angle);
458                                 config.pivot_x = input.tag.get_property("PIVOT_X", (float)config.pivot_x);
459                                 config.pivot_y = input.tag.get_property("PIVOT_Y", (float)config.pivot_y);
460                                 config.draw_pivot = input.tag.get_property("DRAW_PIVOT", (int)config.draw_pivot);
461 //                              config.bilinear = input.tag.get_property("INTERPOLATE", (int)config.bilinear);
462                         }
463                 }
464         }
465 }
466
467 int RotateEffect::process_buffer(VFrame *frame,
468         int64_t start_position,
469         double frame_rate)
470 {
471         load_configuration();
472         int w = frame->get_w();
473         int h = frame->get_h();
474 //printf("RotateEffect::process_buffer %d\n", __LINE__);
475
476
477         if(config.angle == 0 && !config.draw_pivot)
478         {
479                 read_frame(frame,
480                         0,
481                         start_position,
482                         frame_rate,
483                         get_use_opengl());
484                 return 1;
485         }
486 //printf("RotateEffect::process_buffer %d\n", __LINE__);
487
488         if(!engine) engine = new AffineEngine(PluginClient::smp + 1,
489                 PluginClient::smp + 1);
490         int pivot_x = (int)(config.pivot_x * get_input()->get_w() / 100);
491         int pivot_y = (int)(config.pivot_y * get_input()->get_h() / 100);
492         engine->set_in_pivot(pivot_x, pivot_y);
493         engine->set_out_pivot(pivot_x, pivot_y);
494
495
496 // Test
497 // engine->set_out_viewport(0, 0, 320, 240);
498 // engine->set_out_pivot(160, 120);
499
500         if(get_use_opengl())
501         {
502                 read_frame(frame,
503                         0,
504                         start_position,
505                         frame_rate,
506                         get_use_opengl());
507                 return run_opengl();
508         }
509 //printf("RotateEffect::process_buffer %d\n", __LINE__);
510
511
512 // engine->set_viewport(50,
513 // 50,
514 // 100,
515 // 100);
516 // engine->set_pivot(100, 100);
517
518
519         VFrame *temp_frame = PluginVClient::new_temp(get_input()->get_w(),
520                 get_input()->get_h(),
521                 get_input()->get_color_model());
522         read_frame(temp_frame,
523                 0,
524                 start_position,
525                 frame_rate,
526                 get_use_opengl());
527         frame->clear_frame();
528         engine->rotate(frame,
529                 temp_frame,
530                 config.angle);
531
532 //printf("RotateEffect::process_buffer %d draw_pivot=%d\n", __LINE__, config.draw_pivot);
533
534 // Draw center
535 #define CENTER_H 20
536 #define CENTER_W 20
537 #define DRAW_CENTER(components, type, max) \
538 { \
539         type **rows = (type**)get_output()->get_rows(); \
540         if( (center_x >= 0 && center_x < w) && (center_y >= 0 && center_y < h) ) \
541         { \
542                 for(int i = center_x - CENTER_W / 2; i <= center_x + CENTER_W / 2; i++) \
543                 { \
544                         if(i >= 0 && i < w) \
545                         { \
546                                 type *hrow = rows[center_y] + components * i; \
547                                 hrow[0] = max - hrow[0]; \
548                                 hrow[1] = max - hrow[1]; \
549                                 hrow[2] = max - hrow[2]; \
550                                 hrow += components; \
551                         } \
552                 } \
553  \
554                 for(int i = center_y - CENTER_W / 2; i <= center_y + CENTER_W / 2; i++) \
555                 { \
556                         if(i >= 0 && i < h) \
557                         { \
558                                 type *vrow = rows[i] + center_x * components; \
559                                 vrow[0] = max - vrow[0]; \
560                                 vrow[1] = max - vrow[1]; \
561                                 vrow[2] = max - vrow[2]; \
562                         } \
563                 } \
564         } \
565 }
566
567         if(config.draw_pivot)
568         {
569                 int center_x = (int)(config.pivot_x * w / 100); \
570                 int center_y = (int)(config.pivot_y * h / 100); \
571
572 //printf("RotateEffect::process_buffer %d %d %d\n", __LINE__, center_x, center_y);
573                 switch(get_output()->get_color_model())
574                 {
575                         case BC_RGB_FLOAT:
576                                 DRAW_CENTER(3, float, 1.0)
577                                 break;
578                         case BC_RGBA_FLOAT:
579                                 DRAW_CENTER(4, float, 1.0)
580                                 break;
581                         case BC_RGB888:
582                                 DRAW_CENTER(3, unsigned char, 0xff)
583                                 break;
584                         case BC_RGBA8888:
585                                 DRAW_CENTER(4, unsigned char, 0xff)
586                                 break;
587                         case BC_YUV888:
588                                 DRAW_CENTER(3, unsigned char, 0xff)
589                                 break;
590                         case BC_YUVA8888:
591                                 DRAW_CENTER(4, unsigned char, 0xff)
592                                 break;
593                 }
594         }
595
596 // Conserve memory by deleting large frames
597         if(get_input()->get_w() > PLUGIN_MAX_W &&
598                 get_input()->get_h() > PLUGIN_MAX_H)
599         {
600                 delete engine;
601                 engine = 0;
602         }
603         return 0;
604 }
605
606
607
608 int RotateEffect::handle_opengl()
609 {
610 #ifdef HAVE_GL
611         engine->set_opengl(1);
612         engine->rotate(get_output(),
613                 get_output(),
614                 config.angle);
615         engine->set_opengl(0);
616
617         if(config.draw_pivot)
618         {
619                 int w = get_output()->get_w();
620                 int h = get_output()->get_h();
621                 int center_x = (int)(config.pivot_x * w / 100);
622                 int center_y = (int)(config.pivot_y * h / 100);
623
624                 glDisable(GL_TEXTURE_2D);
625                 glColor4f(0.0, 0.0, 0.0, 1.0);
626                 glBegin(GL_LINES);
627                 glVertex3f(center_x, -h + center_y - CENTER_H / 2, 0.0);
628                 glVertex3f(center_x, -h + center_y + CENTER_H / 2, 0.0);
629                 glEnd();
630                 glBegin(GL_LINES);
631                 glVertex3f(center_x - CENTER_W / 2, -h + center_y, 0.0);
632                 glVertex3f(center_x + CENTER_W / 2, -h + center_y, 0.0);
633                 glEnd();
634                 glColor4f(1.0, 1.0, 1.0, 1.0);
635                 glBegin(GL_LINES);
636                 glVertex3f(center_x - 1, -h + center_y - CENTER_H / 2 - 1, 0.0);
637                 glVertex3f(center_x - 1, -h + center_y + CENTER_H / 2 - 1, 0.0);
638                 glEnd();
639                 glBegin(GL_LINES);
640                 glVertex3f(center_x - CENTER_W / 2 - 1, -h + center_y - 1, 0.0);
641                 glVertex3f(center_x + CENTER_W / 2 - 1, -h + center_y - 1, 0.0);
642                 glEnd();
643         }
644 #endif
645         return 0;
646 }
647
648