ffmpeg versioning mods from Andrew
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / spherecam / spherecam.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2017 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 #ifndef FUSE360_H
23 #define FUSE360_H
24
25
26 #include "affine.inc"
27 #include "bchash.inc"
28 #include "guicast.h"
29 #include "loadbalance.h"
30 #include "pluginvclient.h"
31 #include "thread.h"
32
33
34 class SphereCamEngine;
35 class SphereCamGUI;
36 class SphereCamMain;
37 class SphereCamText;
38
39 #define EYES 2
40
41 class SphereCamSlider : public BC_FSlider
42 {
43 public:
44         SphereCamSlider(SphereCamMain *client, 
45                 SphereCamGUI *gui,
46                 SphereCamText *text,
47                 float *output, 
48                 int x, 
49                 int y, 
50                 float min,
51                 float max);
52         int handle_event();
53
54         SphereCamGUI *gui;
55         SphereCamMain *client;
56         SphereCamText *text;
57         float *output;
58 };
59
60 class SphereCamText : public BC_TextBox
61 {
62 public:
63         SphereCamText(SphereCamMain *client, 
64                 SphereCamGUI *gui,
65                 SphereCamSlider *slider,
66                 float *output, 
67                 int x, 
68                 int y);
69         int handle_event();
70
71         SphereCamGUI *gui;
72         SphereCamMain *client;
73         SphereCamSlider *slider;
74         float *output;
75 };
76
77
78 class SphereCamToggle : public BC_CheckBox
79 {
80 public:
81         SphereCamToggle(SphereCamMain *client, 
82                 int *output, 
83                 int x, 
84                 int y,
85                 const char *text);
86         int handle_event();
87
88         SphereCamMain *client;
89         int *output;
90 };
91
92
93 class SphereCamMode : public BC_PopupMenu
94 {
95 public:
96         SphereCamMode(SphereCamMain *plugin,  
97                 SphereCamGUI *gui,
98                 int x,
99                 int y);
100         int handle_event();
101         void create_objects();
102         static int calculate_w(SphereCamGUI *gui);
103         static int from_text(char *text);
104         static const char* to_text(int mode);
105         void update(int mode);
106         SphereCamMain *plugin;
107         SphereCamGUI *gui;
108 };
109
110
111 class SphereCamGUI : public PluginClientWindow
112 {
113 public:
114         SphereCamGUI(SphereCamMain *client);
115         ~SphereCamGUI();
116         
117         void create_objects();
118
119         SphereCamMain *client;
120         SphereCamToggle *enabled[EYES];
121         SphereCamSlider *fov_slider[EYES];
122         SphereCamText *fov_text[EYES];
123         SphereCamSlider *radius_slider[EYES];
124         SphereCamText *radius_text[EYES];
125         SphereCamSlider *centerx_slider[EYES];
126         SphereCamText *centerx_text[EYES];
127         SphereCamSlider *centery_slider[EYES];
128         SphereCamText *centery_text[EYES];
129         SphereCamSlider *rotatex_slider[EYES];
130         SphereCamText *rotatex_text[EYES];
131         SphereCamSlider *rotatey_slider[EYES];
132         SphereCamText *rotatey_text[EYES];
133         SphereCamSlider *rotatez_slider[EYES];
134         SphereCamText *rotatez_text[EYES];
135         SphereCamSlider *feather_slider;
136         SphereCamText *feather_text;
137         
138         SphereCamMode *mode;
139         SphereCamToggle *draw_guides;
140 };
141
142 class SphereCamConfig
143 {
144 public:
145         SphereCamConfig();
146         int equivalent(SphereCamConfig &that);
147         void copy_from(SphereCamConfig &that);
148         void interpolate(SphereCamConfig &prev, 
149                 SphereCamConfig &next, 
150                 int64_t prev_frame, 
151                 int64_t next_frame, 
152                 int64_t current_frame);
153         void boundaries();
154
155
156         int enabled[EYES];
157 // degrees 1-359
158         float fov[EYES];
159 // radius of each eye 1-150
160         float radius[EYES];
161 // center of 2 eyes  0-100
162         float center_x[EYES];
163         float center_y[EYES];
164 // rotation  0-359
165         float rotate_x[EYES];
166         float rotate_y[EYES];
167         float rotate_z[EYES];
168 // amount to feather eye edges 0-50
169         float feather;
170         int draw_guides;
171         int mode;
172         enum
173         {
174 // draw guides only
175                 DO_NOTHING,
176 // the standard algorithm
177                 EQUIRECT,
178 // alignment only
179                 ALIGN,
180         };
181 };
182
183
184
185
186
187 class SphereCamPackage : public LoadPackage
188 {
189 public:
190         SphereCamPackage();
191         int row1, row2;
192 };
193
194
195 class SphereCamUnit : public LoadClient
196 {
197 public:
198         SphereCamUnit(SphereCamEngine *engine, SphereCamMain *plugin);
199         ~SphereCamUnit();
200         
201         
202         void process_package(LoadPackage *package);
203         void process_equirect(SphereCamPackage *pkg);
204         void process_align(SphereCamPackage *pkg);
205         double calculate_max_z(double a, double r);
206
207         
208         SphereCamEngine *engine;
209         SphereCamMain *plugin;
210 };
211
212 class SphereCamEngine : public LoadServer
213 {
214 public:
215         SphereCamEngine(SphereCamMain *plugin);
216         ~SphereCamEngine();
217         
218         void init_packages();
219         LoadClient* new_client();
220         LoadPackage* new_package();
221         
222         SphereCamMain *plugin;
223 };
224
225 class SphereCamMain : public PluginVClient
226 {
227 public:
228         SphereCamMain(PluginServer *server);
229         ~SphereCamMain();
230
231         PLUGIN_CLASS_MEMBERS2(SphereCamConfig)
232         int process_buffer(VFrame *frame,
233                 int64_t start_position,
234                 double frame_rate);
235         void draw_feather(int left, int right, int eye, int y);
236         int is_realtime();
237         void update_gui();
238         void save_data(KeyFrame *keyframe);
239         void read_data(KeyFrame *keyframe);
240         void calculate_extents();
241         double calculate_max_z(double a, int r);
242
243 // config values converted to pixels
244         int w;
245         int h;
246
247 // the center of the output regions, shifted by the rotations
248         int output_x[EYES];
249         int output_y[EYES];
250 // The output of each eye is split into 2 halves so it can wrap around
251         int out_x1[EYES];
252         int out_y1[EYES];
253         int out_x2[EYES];
254         int out_y2[EYES];
255         int out_x3[EYES];
256         int out_y3[EYES];
257         int out_x4[EYES];
258         int out_y4[EYES];
259 // the center of the input regions
260         int input_x[EYES];
261         int input_y[EYES];
262 // radius of the input regions for drawing the guide only
263         int radius[EYES];
264 // pixels to add to the output regions
265         int feather;
266
267         SphereCamEngine *engine;
268         AffineEngine *affine;
269 };
270
271
272
273 #endif