bg/clr color tweaks, clear borders rework, fc31 depends
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / motion-cv / motion-cv.h
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 #ifndef MOTION_H
23 #define MOTION_H
24
25 #include <math.h>
26 #include <stdint.h>
27 #include <string.h>
28
29 #include "affine.inc"
30 #include "bchash.inc"
31 #include "filexml.inc"
32 #include "keyframe.inc"
33 #include "loadbalance.h"
34 #include "overlayframe.inc"
35 #include "pluginvclient.h"
36 #include "rotateframe.inc"
37 #include "vframe.inc"
38
39 class MotionCVMain;
40 class MotionCVWindow;
41 class MotionCVScan;
42 class RotateCVScan;
43
44
45 #define OVERSAMPLE 4
46
47
48 // Limits of global range in percent
49 #define MIN_RADIUS 1
50 #define MAX_RADIUS 50
51
52 // Limits of rotation range in degrees
53 #define MIN_ROTATION 1
54 #define MAX_ROTATION 25
55
56 // Limits of block size in percent.
57 #define MIN_BLOCK 1
58 #define MAX_BLOCK 100
59
60 // Limits of block count
61 #define MIN_BLOCKS 1
62 #define MAX_BLOCKS 200
63
64 // Precision of rotation
65 #define MIN_ANGLE 0.0001
66
67 #define TRACKING_FILE "/tmp/motion-cv"
68
69 class MotionCVConfig
70 {
71 public:
72         MotionCVConfig();
73
74         int equivalent(MotionCVConfig &that);
75         void copy_from(MotionCVConfig &that);
76         void interpolate(MotionCVConfig &prev, MotionCVConfig &next,
77                 int64_t prev_frame, int64_t next_frame, int64_t current_frame);
78         void boundaries();
79
80         int block_count;
81         int global_range_w;
82         int global_range_h;
83         int rotation_range;
84         int magnitude;
85         int return_speed;
86         int draw_vectors;
87 // Percent of image size
88         int global_block_w;
89         int global_block_h;
90         int rotation_block_w;
91         int rotation_block_h;
92 // Number of search positions in each refinement of the log search
93         int global_positions;
94         int rotate_positions;
95 // Block position in percentage 0 - 100
96         double block_x;
97         double block_y;
98
99         int horizontal_only;
100         int vertical_only;
101         int global;
102         int rotate;
103         int addtrackedframeoffset;
104         char tracking_file[BCTEXTLEN];
105 // Track or stabilize, single pixel, scan only, or nothing
106         int mode1;
107 // Recalculate, no calculate, save, or load coordinates from disk
108         int mode2;
109 // Track a single frame, previous frame, or previous frame same block
110         int mode3;
111         enum
112         {
113 // mode1
114                 TRACK,
115                 STABILIZE,
116                 TRACK_PIXEL,
117                 STABILIZE_PIXEL,
118                 NOTHING,
119 // mode2
120                 RECALCULATE,
121                 SAVE,
122                 LOAD,
123                 NO_CALCULATE,
124 // mode3
125                 TRACK_SINGLE,
126                 TRACK_PREVIOUS,
127                 PREVIOUS_SAME_BLOCK
128         };
129 // Number of single frame to track relative to timeline start
130         int64_t track_frame;
131 // Master layer
132         int bottom_is_master;
133 };
134
135
136
137
138 class MotionCVMain : public PluginVClient
139 {
140 public:
141         MotionCVMain(PluginServer *server);
142         ~MotionCVMain();
143
144         int process_buffer(VFrame **frame,
145                 int64_t start_position,
146                 double frame_rate);
147         void process_global();
148         void process_rotation();
149         void draw_vectors(VFrame *frame);
150         int is_multichannel();
151         int is_realtime();
152         void save_data(KeyFrame *keyframe);
153         void read_data(KeyFrame *keyframe);
154         void update_gui();
155 // Calculate frame to copy from and frame to move
156         void calculate_pointers(VFrame **frame, VFrame **src, VFrame **dst);
157         void allocate_temp(int w, int h, int color_model);
158
159         PLUGIN_CLASS_MEMBERS2(MotionCVConfig)
160
161
162         int64_t abs_diff(unsigned char *prev_ptr,
163                 unsigned char *current_ptr,
164                 int row_bytes,
165                 int w,
166                 int h,
167                 int color_model);
168         int64_t abs_diff_sub(unsigned char *prev_ptr,
169                 unsigned char *current_ptr,
170                 int row_bytes,
171                 int w,
172                 int h,
173                 int color_model,
174                 int sub_x,
175                 int sub_y);
176
177         static void clamp_scan(int w,
178                 int h,
179                 int *block_x1,
180                 int *block_y1,
181                 int *block_x2,
182                 int *block_y2,
183                 int *scan_x1,
184                 int *scan_y1,
185                 int *scan_x2,
186                 int *scan_y2,
187                 int use_absolute);
188         static void draw_pixel(VFrame *frame, int x, int y);
189         static void draw_line(VFrame *frame, int x1, int y1, int x2, int y2);
190         void draw_arrow(VFrame *frame, int x1, int y1, int x2, int y2);
191
192 // Number of the previous reference frame on the timeline.
193         int64_t previous_frame_number;
194 // The frame compared with the previous frame to get the motion.
195 // It is moved to compensate for motion and copied to the previous_frame.
196         VFrame *temp_frame;
197         MotionCVScan *engine;
198         RotateCVScan *motion_rotate;
199         OverlayFrame *overlayer;
200         AffineEngine *rotate_engine;
201
202 // Accumulation of all global tracks since the plugin start.
203 // Multiplied by OVERSAMPLE.
204         int total_dx;
205         int total_dy;
206
207 // Rotation motion tracking
208         float total_angle;
209
210 // Current motion vector for drawing vectors
211         int current_dx;
212         int current_dy;
213         float current_angle;
214
215         char cache_file[BCTEXTLEN];
216         FILE *cache_fp, *active_fp;
217         void reset_cache_file();
218         int open_cache_file();
219         void close_cache_file();
220         int load_cache_line();
221         int locate_cache_line(int64_t key);
222         int get_cache_line(int64_t key);
223         int put_cache_line(const char *line);
224         char cache_line[BCSTRLEN];
225         int64_t cache_key, active_key;
226 // add constant frame offset values
227         int dx_offset, dy_offset;
228         int64_t tracking_frame;
229 // save/load result values
230         int load_ok;
231         int save_dx, load_dx;
232         int save_dy, load_dy;
233         float save_dt, load_dt;
234 // Oversampled current frame for motion estimation
235         int32_t *search_area;
236         int search_size;
237
238
239 // The layer to track motion in.
240         int reference_layer;
241 // The layer to apply motion in.
242         int target_layer;
243
244 // Pointer to the source and destination of each operation.
245 // These are fully allocated buffers.
246
247 // The previous reference frame for global motion tracking
248         VFrame *prev_global_ref;
249 // The current reference frame for global motion tracking
250         VFrame *current_global_ref;
251 // The input target frame for global motion tracking
252         VFrame *global_target_src;
253 // The output target frame for global motion tracking
254         VFrame *global_target_dst;
255
256 // The previous reference frame for rotation tracking
257         VFrame *prev_rotate_ref;
258 // The current reference frame for rotation tracking
259         VFrame *current_rotate_ref;
260 // The input target frame for rotation tracking.
261         VFrame *rotate_target_src;
262 // The output target frame for rotation tracking.
263         VFrame *rotate_target_dst;
264
265 // The output of process_buffer
266         VFrame *output_frame;
267         int w;
268         int h;
269 };
270
271
272
273 class MotionCvVVFrame : public VFrame
274 {
275 public:
276         MotionCvVVFrame(VFrame *vfrm, int n);
277         int draw_pixel(int x, int y);
278         int n;
279 };
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303 class MotionCVScanPackage : public LoadPackage
304 {
305 public:
306         MotionCVScanPackage();
307
308 // For multiple blocks
309         int block_x1, block_y1, block_x2, block_y2;
310         int scan_x1, scan_y1, scan_x2, scan_y2;
311         int dx;
312         int dy;
313         int64_t max_difference;
314         int64_t min_difference;
315         int64_t min_pixel;
316         int is_border;
317         int valid;
318 // For single block
319         int pixel;
320         int64_t difference1;
321         int64_t difference2;
322 };
323
324 class MotionCVScanCache
325 {
326 public:
327         MotionCVScanCache(int x, int y, int64_t difference);
328         int x, y;
329         int64_t difference;
330 };
331
332 class MotionCVScanUnit : public LoadClient
333 {
334 public:
335         MotionCVScanUnit(MotionCVScan *server, MotionCVMain *plugin);
336         ~MotionCVScanUnit();
337
338         void process_package(LoadPackage *package);
339         int64_t get_cache(int x, int y);
340         void put_cache(int x, int y, int64_t difference);
341
342         MotionCVScan *server;
343         MotionCVMain *plugin;
344
345         ArrayList<MotionCVScanCache*> cache;
346         Mutex *cache_lock;
347 };
348
349 class MotionCVScan : public LoadServer
350 {
351 public:
352         MotionCVScan(MotionCVMain *plugin,
353                 int total_clients,
354                 int total_packages);
355         ~MotionCVScan();
356
357         friend class MotionCVScanUnit;
358
359         void init_packages();
360         LoadClient* new_client();
361         LoadPackage* new_package();
362
363 // Invoke the motion engine for a search
364 // Frame before motion
365         void scan_frame(VFrame *previous_frame,
366 // Frame after motion
367                 VFrame *current_frame);
368         int64_t get_cache(int x, int y);
369         void put_cache(int x, int y, int64_t difference);
370
371 // Change between previous frame and current frame multiplied by
372 // OVERSAMPLE
373         int dx_result;
374         int dy_result;
375
376 private:
377         VFrame *previous_frame;
378 // Frame after motion
379         VFrame *current_frame;
380         MotionCVMain *plugin;
381
382         int skip;
383 // For single block
384         int block_x1;
385         int block_x2;
386         int block_y1;
387         int block_y2;
388         int scan_x1;
389         int scan_y1;
390         int scan_x2;
391         int scan_y2;
392         int total_pixels;
393         int total_steps;
394         int subpixel;
395
396
397         ArrayList<MotionCVScanCache*> cache;
398         Mutex *cache_lock;
399 };
400
401
402
403
404
405
406
407
408
409
410
411
412
413 class RotateCVScanPackage : public LoadPackage
414 {
415 public:
416         RotateCVScanPackage();
417         float angle;
418         int64_t difference;
419 };
420
421 class RotateCVScanCache
422 {
423 public:
424         RotateCVScanCache(float angle, int64_t difference);
425         float angle;
426         int64_t difference;
427 };
428
429 class RotateCVScanUnit : public LoadClient
430 {
431 public:
432         RotateCVScanUnit(RotateCVScan *server, MotionCVMain *plugin);
433         ~RotateCVScanUnit();
434
435         void process_package(LoadPackage *package);
436
437         RotateCVScan *server;
438         MotionCVMain *plugin;
439         AffineEngine *rotater;
440         VFrame *temp;
441 };
442
443 class RotateCVScan : public LoadServer
444 {
445 public:
446         RotateCVScan(MotionCVMain *plugin,
447                 int total_clients,
448                 int total_packages);
449         ~RotateCVScan();
450
451         friend class RotateCVScanUnit;
452
453         void init_packages();
454         LoadClient* new_client();
455         LoadPackage* new_package();
456
457 // Invoke the motion engine for a search
458 // Frame before rotation
459         float scan_frame(VFrame *previous_frame,
460 // Frame after rotation
461                 VFrame *current_frame,
462 // Pivot
463                 int block_x,
464                 int block_y);
465         int64_t get_cache(float angle);
466         void put_cache(float angle, int64_t difference);
467
468
469 // Angle result
470         float result;
471
472 private:
473         VFrame *previous_frame;
474 // Frame after motion
475         VFrame *current_frame;
476
477         MotionCVMain *plugin;
478         int skip;
479
480 // Pivot
481         int block_x;
482         int block_y;
483 // Block to rotate
484         int block_x1;
485         int block_x2;
486         int block_y1;
487         int block_y2;
488 // Area to compare
489         int scan_x;
490         int scan_y;
491         int scan_w;
492         int scan_h;
493 // Range of angles to compare
494         float scan_angle1, scan_angle2;
495         int total_steps;
496
497         ArrayList<RotateCVScanCache*> cache;
498         Mutex *cache_lock;
499 };
500
501
502
503
504 #endif
505
506
507
508
509
510