4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
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.
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.
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
23 #include "../motion/motionscan.h"
24 #include "bcdisplayinfo.h"
25 #include "bcsignals.h"
33 #include "motionwindow.h"
35 #include "overlayframe.h"
36 #include "rotateframe.h"
37 #include "transportque.h"
43 REGISTER_PLUGIN(MotionMain2)
52 MotionConfig::MotionConfig()
54 for(int i = 0; i < TOTAL_POINTS; i++)
57 global_range_w[i] = 5;
58 global_range_h[i] = 5;
59 global_origin_x[i] = 0;
60 global_origin_y[i] = 0;
61 global_block_w[i] = MIN_BLOCK;
62 global_block_h[i] = MIN_BLOCK;
68 global_positions = 256;
71 action = MotionScan::STABILIZE;
72 calculation = MotionScan::NO_CALCULATE;
73 tracking_object = MotionScan::TRACK_SINGLE;
80 void MotionConfig::boundaries()
82 for(int i = 0; i < TOTAL_POINTS; i++)
84 CLAMP(global_range_w[i], MIN_RADIUS, MAX_RADIUS);
85 CLAMP(global_range_h[i], MIN_RADIUS, MAX_RADIUS);
86 CLAMP(global_origin_x[i], MIN_ORIGIN, MAX_ORIGIN);
87 CLAMP(global_origin_y[i], MIN_ORIGIN, MAX_ORIGIN);
88 CLAMP(global_block_w[i], MIN_BLOCK, MAX_BLOCK);
89 CLAMP(global_block_h[i], MIN_BLOCK, MAX_BLOCK);
94 int MotionConfig::equivalent(MotionConfig &that)
97 for(int i = 0; i < TOTAL_POINTS; i++)
99 if(global[i] != that.global[i] ||
100 global_range_w[i] != that.global_range_w[i] ||
101 global_range_h[i] != that.global_range_h[i] ||
102 draw_vectors[i] != that.draw_vectors[i] ||
103 global_block_w[i] != that.global_block_w[i] ||
104 global_block_h[i] != that.global_block_h[i] ||
105 global_origin_x[i] != that.global_origin_x[i] ||
106 global_origin_y[i] != that.global_origin_y[i] ||
107 !EQUIV(block_x[i], that.block_x[i]) ||
108 !EQUIV(block_y[i], that.block_y[i]))
112 if(magnitude != that.magnitude ||
113 return_speed != that.return_speed ||
114 action != that.action ||
115 calculation != that.calculation ||
116 tracking_object != that.tracking_object ||
117 track_frame != that.track_frame ||
118 bottom_is_master != that.bottom_is_master ||
119 horizontal_only != that.horizontal_only ||
120 vertical_only != that.vertical_only ||
121 global_positions != that.global_positions) result = 0;
126 void MotionConfig::copy_from(MotionConfig &that)
128 for(int i = 0; i < TOTAL_POINTS; i++)
130 global[i] = that.global[i];
131 global_range_w[i] = that.global_range_w[i];
132 global_range_h[i] = that.global_range_h[i];
133 global_origin_x[i] = that.global_origin_x[i];
134 global_origin_y[i] = that.global_origin_y[i];
135 draw_vectors[i] = that.draw_vectors[i];
136 block_x[i] = that.block_x[i];
137 block_y[i] = that.block_y[i];
138 global_block_w[i] = that.global_block_w[i];
139 global_block_h[i] = that.global_block_h[i];
142 global_positions = that.global_positions;
143 magnitude = that.magnitude;
144 return_speed = that.return_speed;
145 action = that.action;
146 calculation = that.calculation;
147 tracking_object = that.tracking_object;
148 track_frame = that.track_frame;
149 bottom_is_master = that.bottom_is_master;
150 horizontal_only = that.horizontal_only;
151 vertical_only = that.vertical_only;
154 void MotionConfig::interpolate(MotionConfig &prev,
158 int64_t current_frame)
160 //double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
161 //double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
163 for(int i = 0; i < TOTAL_POINTS; i++)
165 this->global[i] = prev.global[i];
166 this->block_x[i] = prev.block_x[i];
167 this->block_y[i] = prev.block_y[i];
168 this->global_range_w[i] = prev.global_range_w[i];
169 this->global_range_h[i] = prev.global_range_h[i];
170 this->global_origin_x[i] = prev.global_origin_x[i];
171 this->global_origin_y[i] = prev.global_origin_y[i];
172 this->draw_vectors[i] = prev.draw_vectors[i];
173 this->global_block_w[i] = prev.global_block_w[i];
174 this->global_block_h[i] = prev.global_block_h[i];
177 this->global_positions = prev.global_positions;
178 magnitude = prev.magnitude;
179 return_speed = prev.return_speed;
180 action = prev.action;
181 calculation = prev.calculation;
182 tracking_object = prev.tracking_object;
183 track_frame = prev.track_frame;
184 bottom_is_master = prev.bottom_is_master;
185 horizontal_only = prev.horizontal_only;
186 vertical_only = prev.vertical_only;
207 MotionMain2::MotionMain2(PluginServer *server)
208 : PluginVClient(server)
213 for(int i = 0; i < TOTAL_POINTS; i++)
222 previous_frame_number = -1;
225 current_global_ref = 0;
226 global_target_src = 0;
227 global_target_dst = 0;
230 MotionMain2::~MotionMain2()
236 delete [] search_area;
240 delete prev_global_ref;
241 delete current_global_ref;
242 delete global_target_src;
243 delete global_target_dst;
246 const char* MotionMain2::plugin_title() { return _("Motion 2 Point"); }
247 int MotionMain2::is_realtime() { return 1; }
248 int MotionMain2::is_multichannel() { return 1; }
251 NEW_WINDOW_MACRO(MotionMain2, MotionWindow)
253 LOAD_CONFIGURATION_MACRO(MotionMain2, MotionConfig)
257 void MotionMain2::update_gui()
261 if(load_configuration())
263 thread->window->lock_window("MotionMain2::update_gui");
265 char string[BCTEXTLEN];
267 for(int i = 0; i < TOTAL_POINTS; i++)
269 ((MotionWindow*)thread->window)->global[i]->update(config.global[i]);
271 ((MotionWindow*)thread->window)->global_block_w[i]->update(config.global_block_w[i]);
272 ((MotionWindow*)thread->window)->global_block_h[i]->update(config.global_block_h[i]);
273 ((MotionWindow*)thread->window)->global_origin_x[i]->update(config.global_origin_x[i]);
274 ((MotionWindow*)thread->window)->global_origin_y[i]->update(config.global_origin_y[i]);
275 ((MotionWindow*)thread->window)->block_x[i]->update(config.block_x[i]);
276 ((MotionWindow*)thread->window)->block_y[i]->update(config.block_y[i]);
277 ((MotionWindow*)thread->window)->block_x_text[i]->update((float)config.block_x[i]);
278 ((MotionWindow*)thread->window)->block_y_text[i]->update((float)config.block_y[i]);
279 ((MotionWindow*)thread->window)->vectors[i]->update(config.draw_vectors[i]);
282 sprintf(string, "%d", config.global_positions);
283 ((MotionWindow*)thread->window)->global_search_positions->set_text(string);
284 ((MotionWindow*)thread->window)->magnitude->update(config.magnitude);
285 ((MotionWindow*)thread->window)->return_speed->update(config.return_speed);
288 ((MotionWindow*)thread->window)->track_single->update(config.tracking_object == MotionScan::TRACK_SINGLE);
289 ((MotionWindow*)thread->window)->track_frame_number->update(config.track_frame);
290 ((MotionWindow*)thread->window)->track_previous->update(config.tracking_object == MotionScan::TRACK_PREVIOUS);
291 ((MotionWindow*)thread->window)->previous_same->update(config.tracking_object == MotionScan::PREVIOUS_SAME_BLOCK);
292 if(config.tracking_object != MotionScan::TRACK_SINGLE)
293 ((MotionWindow*)thread->window)->track_frame_number->disable();
295 ((MotionWindow*)thread->window)->track_frame_number->enable();
297 ((MotionWindow*)thread->window)->action->set_text(
298 Action::to_text(config.action));
299 ((MotionWindow*)thread->window)->calculation->set_text(
300 Calculation::to_text(config.calculation));
301 ((MotionWindow*)thread->window)->tracking_direction->set_text(
302 TrackingDirection::to_text(config.horizontal_only, config.vertical_only));
303 ((MotionWindow*)thread->window)->master_layer->set_text(
304 MasterLayer::to_text(config.bottom_is_master));
307 ((MotionWindow*)thread->window)->update_mode();
308 thread->window->unlock_window();
317 void MotionMain2::save_data(KeyFrame *keyframe)
321 // cause data to be stored directly in text
322 output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
323 output.tag.set_title("MOTION2");
325 char string[BCTEXTLEN];
326 for(int i = 0; i < TOTAL_POINTS; i++)
328 sprintf(string, "GLOBAL%d", i);
329 output.tag.set_property(string, config.global[i]);
330 sprintf(string, "GLOBAL_BLOCK_W%d", i);
331 output.tag.set_property(string, config.global_block_w[i]);
332 sprintf(string, "GLOBAL_BLOCK_H%d", i);
333 output.tag.set_property(string, config.global_block_h[i]);
334 sprintf(string, "BLOCK_X%d", i);
335 output.tag.set_property(string, config.block_x[i]);
336 sprintf(string, "BLOCK_Y%d", i);
337 output.tag.set_property(string, config.block_y[i]);
338 sprintf(string, "GLOBAL_RANGE_W%d", i);
339 output.tag.set_property(string, config.global_range_w[i]);
340 sprintf(string, "GLOBAL_RANGE_H%d", i);
341 output.tag.set_property(string, config.global_range_h[i]);
342 sprintf(string, "GLOBAL_ORIGIN_X%d", i);
343 output.tag.set_property(string, config.global_origin_x[i]);
344 sprintf(string, "GLOBAL_ORIGIN_Y%d", i);
345 output.tag.set_property(string, config.global_origin_y[i]);
346 sprintf(string, "DRAW_VECTORS%d", i);
347 output.tag.set_property(string, config.draw_vectors[i]);
350 output.tag.set_property("GLOBAL_POSITIONS", config.global_positions);
351 output.tag.set_property("MAGNITUDE", config.magnitude);
352 output.tag.set_property("RETURN_SPEED", config.return_speed);
353 output.tag.set_property("ACTION_TYPE", config.action);
354 output.tag.set_property("TRACKING_TYPE", config.calculation);
355 output.tag.set_property("TRACKING_OBJECT", config.tracking_object);
356 output.tag.set_property("TRACK_FRAME", config.track_frame);
357 output.tag.set_property("BOTTOM_IS_MASTER", config.bottom_is_master);
358 output.tag.set_property("HORIZONTAL_ONLY", config.horizontal_only);
359 output.tag.set_property("VERTICAL_ONLY", config.vertical_only);
361 output.tag.set_title("/MOTION2");
363 output.append_newline();
364 output.terminate_string();
367 void MotionMain2::read_data(KeyFrame *keyframe)
371 input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
377 result = input.read_tag();
381 if(input.tag.title_is("MOTION2"))
383 char string[BCTEXTLEN];
384 for(int i = 0; i < TOTAL_POINTS; i++)
386 sprintf(string, "GLOBAL%d", i);
387 config.global[i] = input.tag.get_property(string, config.global[i]);
388 sprintf(string, "GLOBAL_BLOCK_W%d", i);
389 config.global_block_w[i] = input.tag.get_property(string, config.global_block_w[i]);
390 sprintf(string, "GLOBAL_BLOCK_H%d", i);
391 config.global_block_h[i] = input.tag.get_property(string, config.global_block_h[i]);
392 sprintf(string, "BLOCK_X%d", i);
393 config.block_x[i] = input.tag.get_property(string, config.block_x[i]);
394 sprintf(string, "BLOCK_Y%d", i);
395 config.block_y[i] = input.tag.get_property(string, config.block_y[i]);
396 sprintf(string, "GLOBAL_RANGE_W%d", i);
397 config.global_range_w[i] = input.tag.get_property(string, config.global_range_w[i]);
398 sprintf(string, "GLOBAL_RANGE_H%d", i);
399 config.global_range_h[i] = input.tag.get_property(string, config.global_range_h[i]);
400 sprintf(string, "GLOBAL_ORIGIN_X%d", i);
401 config.global_origin_x[i] = input.tag.get_property(string, config.global_origin_x[i]);
402 sprintf(string, "GLOBAL_ORIGIN_Y%d", i);
403 config.global_origin_y[i] = input.tag.get_property(string, config.global_origin_y[i]);
404 sprintf(string, "DRAW_VECTORS%d", i);
405 config.draw_vectors[i] = input.tag.get_property(string, config.draw_vectors[i]);
408 config.global_positions = input.tag.get_property("GLOBAL_POSITIONS", config.global_positions);
409 config.magnitude = input.tag.get_property("MAGNITUDE", config.magnitude);
410 config.return_speed = input.tag.get_property("RETURN_SPEED", config.return_speed);
411 config.action = input.tag.get_property("ACTION_TYPE", config.action);
412 config.calculation = input.tag.get_property("TRACKING_TYPE", config.calculation);
413 config.tracking_object = input.tag.get_property("TRACKING_OBJECT", config.tracking_object);
414 config.track_frame = input.tag.get_property("TRACK_FRAME", config.track_frame);
415 config.bottom_is_master = input.tag.get_property("BOTTOM_IS_MASTER", config.bottom_is_master);
416 config.horizontal_only = input.tag.get_property("HORIZONTAL_ONLY", config.horizontal_only);
417 config.vertical_only = input.tag.get_property("VERTICAL_ONLY", config.vertical_only);
432 void MotionMain2::allocate_temp(int w, int h, int color_model)
435 (temp_frame->get_w() != w ||
436 temp_frame->get_h() != h))
442 temp_frame = new VFrame(w, h, color_model);
447 void MotionMain2::scan_motion(int point)
449 if(!engine) engine = new MotionScan(PluginClient::get_project_smp() + 1,
450 PluginClient::get_project_smp() + 1);
452 // Get the current motion vector between the previous and current frame
453 engine->scan_frame(current_global_ref,
455 config.global_range_w[point],
456 config.global_range_h[point],
457 config.global_block_w[point],
458 config.global_block_h[point],
459 config.block_x[point],
460 config.block_y[point],
461 config.tracking_object,
464 config.horizontal_only,
465 config.vertical_only,
466 get_source_position(),
467 config.global_positions,
470 config.global_origin_x[point],
471 config.global_origin_y[point]);
477 current_dx[point] = engine->dx_result;
478 current_dy[point] = engine->dy_result;
480 // Add current motion vector to accumulation vector.
481 if(config.tracking_object != MotionScan::TRACK_SINGLE)
484 total_dx[point] = (int64_t)total_dx[point] * (100 - config.return_speed) / 100;
485 total_dy[point] = (int64_t)total_dy[point] * (100 - config.return_speed) / 100;
486 total_dx[point] += engine->dx_result;
487 total_dy[point] += engine->dy_result;
490 // Make accumulation vector current
492 total_dx[point] = engine->dx_result;
493 total_dy[point] = engine->dy_result;
494 // printf("MotionMain2::scan_motion %d %d %d %d\n",
501 // Clamp accumulation vector
502 if(config.magnitude < 100)
504 //int block_w = (int64_t)config.global_block_w[point] *
505 // current_global_ref->get_w() / 100;
506 //int block_h = (int64_t)config.global_block_h[point] *
507 // current_global_ref->get_h() / 100;
508 int block_x_orig = (int64_t)(config.block_x[point] *
509 current_global_ref->get_w() /
511 int block_y_orig = (int64_t)(config.block_y[point] *
512 current_global_ref->get_h() /
515 int max_block_x = (int64_t)(current_global_ref->get_w() - block_x_orig) *
519 int max_block_y = (int64_t)(current_global_ref->get_h() - block_y_orig) *
523 int min_block_x = (int64_t)-block_x_orig *
527 int min_block_y = (int64_t)-block_y_orig *
532 CLAMP(total_dx[point], min_block_x, max_block_x);
533 CLAMP(total_dy[point], min_block_y, max_block_y);
536 // printf("MotionMain2::scan_motion %d %d %d %d\n",
548 void MotionMain2::apply_motion()
550 if(config.tracking_object != MotionScan::TRACK_SINGLE)
552 // Transfer current reference frame to previous reference frame and update
554 prev_global_ref->copy_from(current_global_ref);
555 previous_frame_number = get_source_position();
558 // Decide what to do with target based on requested operation
559 //int interpolation; // variable set but not used
560 float origin_x[TOTAL_POINTS];
561 float origin_y[TOTAL_POINTS];
562 float end_x[TOTAL_POINTS];
563 float end_y[TOTAL_POINTS];
564 for(int i = 0; i < TOTAL_POINTS; i++)
566 get_current_vector(&origin_x[i],
575 // Calculate rotation if 2 points
579 if(config.global[ROTATION_POINT])
581 if(origin_x[1] - origin_x[0])
582 angle0 = atan((double)(origin_y[0] - origin_y[1]) /
583 (double)(origin_x[0] - origin_x[1]));
584 if(end_x[1] - end_x[0])
585 angle = atan((double)(end_y[0] - end_y[1]) /
586 (double)(end_x[0] - end_x[1]));
587 // printf("MotionMain2::apply_motion %d angle0=%f angle=%f\n",
589 // angle0 * 360 / 2 / M_PI,
590 // angle * 360 / 2 / M_PI);
595 // zoom = DISTANCE(origin_x[1], origin_y[1], origin_x[0], origin_y[0]) /
596 // DISTANCE(end_x[1], end_y[1], end_x[0], end_y[0]);
600 printf("MotionMain2::apply_motion %d total_dx=%.02f total_dy=%.02f angle=%f zoom=%f\n",
602 (float)total_dx[TRANSLATION_POINT] / OVERSAMPLE,
603 (float)total_dy[TRANSLATION_POINT] / OVERSAMPLE,
604 angle * 360 / 2 / M_PI,
607 // Calculate translation
610 switch(config.action)
612 case MotionScan::NOTHING:
613 global_target_dst->copy_from(global_target_src);
615 case MotionScan::TRACK:
616 //interpolation = CUBIC_LINEAR;
617 dx = (float)total_dx[0] / OVERSAMPLE;
618 dy = (float)total_dy[0] / OVERSAMPLE;
620 case MotionScan::TRACK_PIXEL:
621 //interpolation = NEAREST_NEIGHBOR;
622 dx = (int)(total_dx[0] / OVERSAMPLE);
623 dy = (int)(total_dy[0] / OVERSAMPLE);
625 //interpolation = NEAREST_NEIGHBOR;
626 dx = -(int)(total_dx[0] / OVERSAMPLE);
627 dy = -(int)(total_dy[0] / OVERSAMPLE);
630 case MotionScan::STABILIZE:
631 //interpolation = CUBIC_LINEAR;
632 dx = -(float)total_dx[0] / OVERSAMPLE;
633 dy = -(float)total_dy[0] / OVERSAMPLE;
642 if(config.action != MotionScan::NOTHING)
644 double w = get_output()->get_w();
645 double h = get_output()->get_h();
646 double pivot_x = end_x[0];
647 double pivot_y = end_y[0];
648 double angle1 = atan((double)pivot_y / (double)pivot_x) + angle;
649 double angle2 = atan((double)(w - pivot_x) / (double)pivot_y) + angle;
650 double angle3 = atan((double)(h - pivot_y) / (double)(w - pivot_x)) + angle;
651 double angle4 = atan((double)pivot_x / (double)(h - pivot_y)) + angle;
652 double radius1 = DISTANCE(0, 0, pivot_x, pivot_y) * zoom;
653 double radius2 = DISTANCE(w, 0, pivot_x, pivot_y) * zoom;
654 double radius3 = DISTANCE(w, h, pivot_x, pivot_y) * zoom;
655 double radius4 = DISTANCE(0, h, pivot_x, pivot_y) * zoom;
658 float x1 = (dx + pivot_x - cos(angle1) * radius1) * 100 / w;
659 float y1 = (dy + pivot_y - sin(angle1) * radius1) * 100 / h;
660 float x2 = (dx + pivot_x + sin(angle2) * radius2) * 100 / w;
661 float y2 = (dy + pivot_y - cos(angle2) * radius2) * 100 / h;
662 float x3 = (dx + pivot_x + cos(angle3) * radius3) * 100 / w;
663 float y3 = (dy + pivot_y + sin(angle3) * radius3) * 100 / h;
664 float x4 = (dx + pivot_x - sin(angle4) * radius4) * 100 / w;
665 float y4 = (dy + pivot_y + cos(angle4) * radius4) * 100 / h;
669 affine = new AffineEngine(PluginClient::get_project_smp() + 1,
670 PluginClient::get_project_smp() + 1);
671 global_target_dst->clear_frame();
674 // printf("MotionMain2::apply_motion %d %.02f %.02f %.02f %.02f %.02f %.02f %.02f %.02f\n",
685 affine->process(global_target_dst,
688 AffineEngine::PERSPECTIVE,
706 int MotionMain2::process_buffer(VFrame **frame,
707 int64_t start_position,
710 int need_reconfigure = load_configuration();
711 int color_model = frame[0]->get_color_model();
712 w = frame[0]->get_w();
713 h = frame[0]->get_h();
717 printf("MotionMain2::process_buffer 1 start_position=%jd\n", start_position);
721 // Calculate the source and destination pointers for each of the operations.
722 // Get the layer to track motion in.
723 reference_layer = config.bottom_is_master ?
724 PluginClient::total_in_buffers - 1 :
726 // Get the layer to apply motion in.
727 target_layer = config.bottom_is_master ?
729 PluginClient::total_in_buffers - 1;
732 output_frame = frame[target_layer];
735 // Get the position of previous reference frame.
736 int64_t actual_previous_number;
737 // Skip if match frame not available
738 int skip_current = 0;
741 if(config.tracking_object == MotionScan::TRACK_SINGLE)
743 actual_previous_number = config.track_frame;
744 if(get_direction() == PLAY_REVERSE)
745 actual_previous_number++;
746 if(actual_previous_number == start_position)
751 actual_previous_number = start_position;
752 if(get_direction() == PLAY_FORWARD)
754 actual_previous_number--;
755 if(actual_previous_number < get_source_start())
759 KeyFrame *keyframe = get_prev_keyframe(start_position, 1);
760 if(keyframe->position > 0 &&
761 actual_previous_number < keyframe->position)
767 actual_previous_number++;
768 if(actual_previous_number >= get_source_start() + get_total_len())
772 KeyFrame *keyframe = get_next_keyframe(start_position, 1);
773 if(keyframe->position > 0 &&
774 actual_previous_number >= keyframe->position)
779 // Only count motion since last keyframe
785 // Point 0 must be tracked for any other points to be tracked
786 // Action and Calculation must be something
787 if( !config.global[0] || ( config.action == MotionScan::NOTHING &&
788 config.calculation == MotionScan::NO_CALCULATE) )
792 // printf("process_buffer %d %lld %lld %d\n",
794 // previous_frame_number,
795 // actual_previous_number,
796 // need_reconfigure);
797 // Load match frame and reset vectors
798 int need_reload = !skip_current &&
799 (previous_frame_number != actual_previous_number ||
803 for(int i = 0; i < TOTAL_POINTS; i++)
808 previous_frame_number = actual_previous_number;
814 for(int i = 0; i < TOTAL_POINTS; i++)
826 // Get the global pointers. Here we walk through the sequence of events.
829 // Global reads previous frame and compares
830 // with current frame to get the current translation.
831 // The center of the search area is fixed in compensate mode or
832 // the user value + the accumulation vector in track mode.
834 prev_global_ref = new VFrame(w, h, color_model);
835 if(!current_global_ref)
836 current_global_ref = new VFrame(w, h, color_model);
838 // Global loads the current target frame into the src and
839 // writes it to the dst frame with desired translation.
840 if(!global_target_src)
841 global_target_src = new VFrame(w, h, color_model);
842 if(!global_target_dst)
843 global_target_dst = new VFrame(w, h, color_model);
846 // Load the global frames
849 read_frame(prev_global_ref,
851 previous_frame_number,
856 read_frame(current_global_ref,
861 read_frame(global_target_src,
877 // Get position change from previous frame to current frame
880 for(int i = 0; i < TOTAL_POINTS; i++)
881 if(config.global[i]) scan_motion(i);
890 //printf("MotionMain2::process_buffer 90 %d\n", skip_current);
892 // Transfer the relevant target frame to the output
895 frame[target_layer]->copy_from(global_target_dst);
898 // Read the target destination directly
900 read_frame(frame[target_layer],
907 if(config.draw_vectors)
909 for(int i = 0; i < TOTAL_POINTS; i++)
910 draw_vectors(frame[target_layer], i);
914 printf("MotionMain2::process_buffer 100 skip_current=%d\n", skip_current);
923 void MotionMain2::clamp_scan(int w,
935 // printf("MotionMain2::clamp_scan 1 w=%d h=%d block=%d %d %d %d scan=%d %d %d %d absolute=%d\n",
950 // scan is always out of range before block.
953 int difference = -*scan_x1;
954 *block_x1 += difference;
960 int difference = -*scan_y1;
961 *block_y1 += difference;
967 int difference = *scan_x2 - w;
968 *block_x2 -= difference;
969 *scan_x2 -= difference;
974 int difference = *scan_y2 - h;
975 *block_y2 -= difference;
976 *scan_y2 -= difference;
979 CLAMP(*scan_x1, 0, w);
980 CLAMP(*scan_y1, 0, h);
981 CLAMP(*scan_x2, 0, w);
982 CLAMP(*scan_y2, 0, h);
988 int difference = -*scan_x1;
989 *block_x1 += difference;
990 *scan_x2 += difference;
996 int difference = -*scan_y1;
997 *block_y1 += difference;
998 *scan_y2 += difference;
1002 if(*scan_x2 - *block_x1 + *block_x2 > w)
1004 int difference = *scan_x2 - *block_x1 + *block_x2 - w;
1005 *block_x2 -= difference;
1008 if(*scan_y2 - *block_y1 + *block_y2 > h)
1010 int difference = *scan_y2 - *block_y1 + *block_y2 - h;
1011 *block_y2 -= difference;
1014 // CLAMP(*scan_x1, 0, w - (*block_x2 - *block_x1));
1015 // CLAMP(*scan_y1, 0, h - (*block_y2 - *block_y1));
1016 // CLAMP(*scan_x2, 0, w - (*block_x2 - *block_x1));
1017 // CLAMP(*scan_y2, 0, h - (*block_y2 - *block_y1));
1020 // Sanity checks which break the calculation but should never happen if the
1021 // center of the block is inside the frame.
1022 CLAMP(*block_x1, 0, w);
1023 CLAMP(*block_x2, 0, w);
1024 CLAMP(*block_y1, 0, h);
1025 CLAMP(*block_y2, 0, h);
1027 // printf("MotionMain2::clamp_scan 2 w=%d h=%d block=%d %d %d %d scan=%d %d %d %d absolute=%d\n",
1044 void MotionMain2::get_current_vector(float *origin_x,
1052 int w = get_output()->get_w();
1053 int h = get_output()->get_h();
1060 if(!origin_x) origin_x = &temp1;
1061 if(!origin_y) origin_y = &temp2;
1062 if(!current_x1) current_x1 = &temp3;
1063 if(!current_y1) current_y1 = &temp4;
1064 if(!current_x2) current_x2 = &temp5;
1065 if(!current_y2) current_y2 = &temp6;
1075 if(config.global[point])
1078 // Start of vector is center of previous block.
1079 // End of vector is total accumulation.
1080 if(config.tracking_object == MotionScan::TRACK_SINGLE)
1082 (*origin_x) = (*current_x1) = ((float)config.block_x[point] *
1085 (*origin_y) = (*current_y1) = ((float)config.block_y[point] *
1088 (*current_x2) = (*current_x1) + (float)total_dx[point] / OVERSAMPLE;
1089 (*current_y2) = (*current_y1) + (float)total_dy[point] / OVERSAMPLE;
1092 // Start of vector is center of previous block.
1093 // End of vector is current change.
1094 if(config.tracking_object == MotionScan::PREVIOUS_SAME_BLOCK)
1096 (*origin_x) = (*current_x1) = ((float)config.block_x[point] *
1099 (*origin_y) = (*current_y1) = ((float)config.block_y[point] *
1102 (*current_x2) = (*origin_x) + (float)current_dx[point] / OVERSAMPLE;
1103 (*current_y2) = (*origin_y) + (float)current_dy[point] / OVERSAMPLE;
1107 (*origin_x) = (float)config.block_x[point] *
1110 (*origin_y) = (float)config.block_y[point] *
1113 (*current_x1) = ((*origin_x) +
1114 (float)(total_dx[point] - current_dx[point]) /
1116 (*current_y1) = ((*origin_y) +
1117 (float)(total_dy[point] - current_dy[point]) /
1119 (*current_x2) = ((*origin_x) +
1120 (float)total_dx[point] /
1122 (*current_y2) = ((*origin_y) +
1123 (float)total_dy[point] /
1130 void MotionMain2::draw_vectors(VFrame *frame, int point)
1132 int w = frame->get_w();
1133 int h = frame->get_h();
1134 float global_x1, global_y1;
1135 float global_x2, global_y2;
1136 int block_x, block_y;
1137 int block_w, block_h;
1138 int block_x1, block_y1;
1139 int block_x2, block_y2;
1140 int search_w, search_h;
1141 int search_x1, search_y1;
1142 int search_x2, search_y2;
1143 int origin_offset_x;
1144 int origin_offset_y;
1146 if(!config.draw_vectors[point]) return;
1149 if(config.global[point])
1152 get_current_vector(0,
1161 // Draw destination rectangle
1162 if(config.action == MotionScan::NOTHING ||
1163 config.action == MotionScan::TRACK)
1165 block_x = (int)global_x2;
1166 block_y = (int)global_y2;
1169 // Draw source rectangle
1171 block_x = (int)global_x1;
1172 block_y = (int)global_y1;
1174 block_w = config.global_block_w[point] * w / 100;
1175 block_h = config.global_block_h[point] * h / 100;
1176 origin_offset_x = config.global_origin_x[point] * w / 100;
1177 origin_offset_y = config.global_origin_y[point] * h / 100;
1178 block_x1 = block_x - block_w / 2;
1179 block_y1 = block_y - block_h / 2;
1180 block_x2 = block_x + block_w / 2;
1181 block_y2 = block_y + block_h / 2;
1182 search_w = config.global_range_w[point] * w / 100;
1183 search_h = config.global_range_h[point] * h / 100;
1184 search_x1 = block_x1 + origin_offset_x - search_w / 2;
1185 search_y1 = block_y1 + origin_offset_y - search_h / 2;
1186 search_x2 = block_x2 + origin_offset_x + search_w / 2;
1187 search_y2 = block_y2 + origin_offset_y + search_h / 2;
1189 // printf("MotionMain2::draw_vectors %d %d %d %d %d %d %d %d %d %d %d %d\n",
1203 MotionScan::clamp_scan(w,
1216 draw_arrow(frame, (int)global_x1, (int)global_y1, (int)global_x2, (int)global_y2);
1219 draw_line(frame, block_x1, block_y1, block_x2, block_y1);
1220 draw_line(frame, block_x2, block_y1, block_x2, block_y2);
1221 draw_line(frame, block_x2, block_y2, block_x1, block_y2);
1222 draw_line(frame, block_x1, block_y2, block_x1, block_y1);
1226 draw_line(frame, search_x1, search_y1, search_x2, search_y1);
1227 draw_line(frame, search_x2, search_y1, search_x2, search_y2);
1228 draw_line(frame, search_x2, search_y2, search_x1, search_y2);
1229 draw_line(frame, search_x1, search_y2, search_x1, search_y1);
1235 void MotionMain2::draw_pixel(VFrame *frame, int x, int y)
1237 if(!(x >= 0 && y >= 0 && x < frame->get_w() && y < frame->get_h())) return;
1239 #define DRAW_PIXEL(x, y, components, do_yuv, max, type) \
1241 type **rows = (type**)frame->get_rows(); \
1242 rows[y][x * components] = max - rows[y][x * components]; \
1245 rows[y][x * components + 1] = max - rows[y][x * components + 1]; \
1246 rows[y][x * components + 2] = max - rows[y][x * components + 2]; \
1250 rows[y][x * components + 1] = (max / 2 + 1) - rows[y][x * components + 1]; \
1251 rows[y][x * components + 2] = (max / 2 + 1) - rows[y][x * components + 2]; \
1253 if(components == 4) \
1254 rows[y][x * components + 3] = max; \
1258 switch(frame->get_color_model())
1261 DRAW_PIXEL(x, y, 3, 0, 0xff, unsigned char);
1264 DRAW_PIXEL(x, y, 4, 0, 0xff, unsigned char);
1267 DRAW_PIXEL(x, y, 3, 0, 1.0, float);
1270 DRAW_PIXEL(x, y, 4, 0, 1.0, float);
1273 DRAW_PIXEL(x, y, 3, 1, 0xff, unsigned char);
1276 DRAW_PIXEL(x, y, 4, 1, 0xff, unsigned char);
1279 DRAW_PIXEL(x, y, 3, 0, 0xffff, uint16_t);
1282 DRAW_PIXEL(x, y, 3, 1, 0xffff, uint16_t);
1284 case BC_RGBA16161616:
1285 DRAW_PIXEL(x, y, 4, 0, 0xffff, uint16_t);
1287 case BC_YUVA16161616:
1288 DRAW_PIXEL(x, y, 4, 1, 0xffff, uint16_t);
1294 void MotionMain2::draw_line(VFrame *frame, int x1, int y1, int x2, int y2)
1296 int w = labs(x2 - x1);
1297 int h = labs(y2 - y1);
1298 //printf("MotionMain2::draw_line 1 %d %d %d %d\n", x1, y1, x2, y2);
1302 draw_pixel(frame, x1, y1);
1307 // Flip coordinates so x1 < x2
1317 int numerator = y2 - y1;
1318 int denominator = x2 - x1;
1319 for(int i = x1; i < x2; i++)
1321 int y = y1 + (int64_t)(i - x1) * (int64_t)numerator / (int64_t)denominator;
1322 draw_pixel(frame, i, y);
1327 // Flip coordinates so y1 < y2
1337 int numerator = x2 - x1;
1338 int denominator = y2 - y1;
1339 for(int i = y1; i < y2; i++)
1341 int x = x1 + (int64_t)(i - y1) * (int64_t)numerator / (int64_t)denominator;
1342 draw_pixel(frame, x, i);
1345 //printf("MotionMain2::draw_line 2\n");
1348 #define ARROW_SIZE 10
1349 void MotionMain2::draw_arrow(VFrame *frame, int x1, int y1, int x2, int y2)
1351 double angle = atan((float)(y2 - y1) / (float)(x2 - x1));
1352 double angle1 = angle + (float)145 / 360 * 2 * 3.14159265;
1353 double angle2 = angle - (float)145 / 360 * 2 * 3.14159265;
1360 x3 = x2 - (int)(ARROW_SIZE * cos(angle1));
1361 y3 = y2 - (int)(ARROW_SIZE * sin(angle1));
1362 x4 = x2 - (int)(ARROW_SIZE * cos(angle2));
1363 y4 = y2 - (int)(ARROW_SIZE * sin(angle2));
1367 x3 = x2 + (int)(ARROW_SIZE * cos(angle1));
1368 y3 = y2 + (int)(ARROW_SIZE * sin(angle1));
1369 x4 = x2 + (int)(ARROW_SIZE * cos(angle2));
1370 y4 = y2 + (int)(ARROW_SIZE * sin(angle2));
1374 draw_line(frame, x1, y1, x2, y2);
1375 // draw_line(frame, x1, y1 + 1, x2, y2 + 1);
1378 if(abs(y2 - y1) || abs(x2 - x1)) draw_line(frame, x2, y2, x3, y3);
1379 // draw_line(frame, x2, y2 + 1, x3, y3 + 1);
1381 if(abs(y2 - y1) || abs(x2 - x1)) draw_line(frame, x2, y2, x4, y4);
1382 // draw_line(frame, x2, y2 + 1, x4, y4 + 1);
1398 #define ABS_DIFF(type, temp_type, multiplier, components) \
1400 temp_type result_temp = 0; \
1401 for(int i = 0; i < h; i++) \
1403 type *prev_row = (type*)prev_ptr; \
1404 type *current_row = (type*)current_ptr; \
1405 for(int j = 0; j < w; j++) \
1407 for(int k = 0; k < 3; k++) \
1409 temp_type difference; \
1410 difference = *prev_row++ - *current_row++; \
1411 if(difference < 0) \
1412 result_temp -= difference; \
1414 result_temp += difference; \
1416 if(components == 4) \
1422 prev_ptr += row_bytes; \
1423 current_ptr += row_bytes; \
1425 result = (int64_t)(result_temp * multiplier); \
1428 int64_t MotionMain2::abs_diff(unsigned char *prev_ptr,
1429 unsigned char *current_ptr,
1439 ABS_DIFF(unsigned char, int64_t, 1, 3)
1442 ABS_DIFF(unsigned char, int64_t, 1, 4)
1445 ABS_DIFF(float, double, 0x10000, 3)
1448 ABS_DIFF(float, double, 0x10000, 4)
1451 ABS_DIFF(unsigned char, int64_t, 1, 3)
1454 ABS_DIFF(unsigned char, int64_t, 1, 4)
1457 ABS_DIFF(uint16_t, int64_t, 1, 3)
1459 case BC_YUVA16161616:
1460 ABS_DIFF(uint16_t, int64_t, 1, 4)
1468 #define ABS_DIFF_SUB(type, temp_type, multiplier, components) \
1470 temp_type result_temp = 0; \
1471 temp_type y2_fraction = sub_y * 0x100 / OVERSAMPLE; \
1472 temp_type y1_fraction = 0x100 - y2_fraction; \
1473 temp_type x2_fraction = sub_x * 0x100 / OVERSAMPLE; \
1474 temp_type x1_fraction = 0x100 - x2_fraction; \
1475 for(int i = 0; i < h_sub; i++) \
1477 type *prev_row1 = (type*)prev_ptr; \
1478 type *prev_row2 = (type*)prev_ptr + components; \
1479 type *prev_row3 = (type*)(prev_ptr + row_bytes); \
1480 type *prev_row4 = (type*)(prev_ptr + row_bytes) + components; \
1481 type *current_row = (type*)current_ptr; \
1482 for(int j = 0; j < w_sub; j++) \
1484 for(int k = 0; k < 3; k++) \
1486 temp_type difference; \
1487 temp_type prev_value = \
1488 (*prev_row1++ * x1_fraction * y1_fraction + \
1489 *prev_row2++ * x2_fraction * y1_fraction + \
1490 *prev_row3++ * x1_fraction * y2_fraction + \
1491 *prev_row4++ * x2_fraction * y2_fraction) / \
1493 temp_type current_value = *current_row++; \
1494 difference = prev_value - current_value; \
1495 if(difference < 0) \
1496 result_temp -= difference; \
1498 result_temp += difference; \
1501 if(components == 4) \
1510 prev_ptr += row_bytes; \
1511 current_ptr += row_bytes; \
1513 result = (int64_t)(result_temp * multiplier); \
1519 int64_t MotionMain2::abs_diff_sub(unsigned char *prev_ptr,
1520 unsigned char *current_ptr,
1535 ABS_DIFF_SUB(unsigned char, int64_t, 1, 3)
1538 ABS_DIFF_SUB(unsigned char, int64_t, 1, 4)
1541 ABS_DIFF_SUB(float, double, 0x10000, 3)
1544 ABS_DIFF_SUB(float, double, 0x10000, 4)
1547 ABS_DIFF_SUB(unsigned char, int64_t, 1, 3)
1550 ABS_DIFF_SUB(unsigned char, int64_t, 1, 4)
1553 ABS_DIFF_SUB(uint16_t, int64_t, 1, 3)
1555 case BC_YUVA16161616:
1556 ABS_DIFF_SUB(uint16_t, int64_t, 1, 4)
1566 MotionScanPackage::MotionScanPackage()
1577 MotionScanUnit::MotionScanUnit(MotionScan *server,
1578 MotionMain2 *plugin)
1579 : LoadClient(server)
1581 this->plugin = plugin;
1582 this->server = server;
1583 cache_lock = new Mutex("MotionScanUnit::cache_lock");
1586 MotionScanUnit::~MotionScanUnit()
1593 void MotionScanUnit::process_package(LoadPackage *package)
1595 MotionScanPackage *pkg = (MotionScanPackage*)package;
1596 int w = server->current_frame->get_w();
1597 int h = server->current_frame->get_h();
1598 int color_model = server->current_frame->get_color_model();
1599 int pixel_size = cmodel_calculate_pixelsize(color_model);
1600 int row_bytes = server->current_frame->get_bytes_per_line();
1615 if(!server->subpixel)
1617 int search_x = pkg->scan_x1 + (pkg->pixel % (pkg->scan_x2 - pkg->scan_x1));
1618 int search_y = pkg->scan_y1 + (pkg->pixel / (pkg->scan_x2 - pkg->scan_x1));
1621 pkg->difference1 = server->get_cache(search_x, search_y);
1622 if(pkg->difference1 < 0)
1624 //printf("MotionScanUnit::process_package 1 %d %d\n",
1625 //search_x, search_y, pkg->block_x2 - pkg->block_x1, pkg->block_y2 - pkg->block_y1);
1626 // Pointers to first pixel in each block
1627 unsigned char *prev_ptr = server->previous_frame->get_rows()[
1629 search_x * pixel_size;
1630 unsigned char *current_ptr = server->current_frame->get_rows()[
1632 pkg->block_x1 * pixel_size;
1634 pkg->difference1 = plugin->abs_diff(prev_ptr,
1637 pkg->block_x2 - pkg->block_x1,
1638 pkg->block_y2 - pkg->block_y1,
1640 //printf("MotionScanUnit::process_package 2\n");
1641 server->put_cache(search_x, search_y, pkg->difference1);
1662 int sub_x = pkg->pixel % (OVERSAMPLE * 2 - 1) + 1;
1663 int sub_y = pkg->pixel / (OVERSAMPLE * 2 - 1) + 1;
1665 if(plugin->config.horizontal_only)
1670 if(plugin->config.vertical_only)
1675 int search_x = pkg->scan_x1 + sub_x / OVERSAMPLE;
1676 int search_y = pkg->scan_y1 + sub_y / OVERSAMPLE;
1677 sub_x %= OVERSAMPLE;
1678 sub_y %= OVERSAMPLE;
1681 unsigned char *prev_ptr = server->previous_frame->get_rows()[
1683 search_x * pixel_size;
1684 unsigned char *current_ptr = server->current_frame->get_rows()[
1686 pkg->block_x1 * pixel_size;
1688 // With subpixel, there are two ways to compare each position, one by shifting
1689 // the previous frame and two by shifting the current frame.
1690 pkg->difference1 = plugin->abs_diff_sub(prev_ptr,
1693 pkg->block_x2 - pkg->block_x1,
1694 pkg->block_y2 - pkg->block_y1,
1698 pkg->difference2 = plugin->abs_diff_sub(current_ptr,
1701 pkg->block_x2 - pkg->block_x1,
1702 pkg->block_y2 - pkg->block_y1,
1706 // printf("MotionScanUnit::process_package sub_x=%d sub_y=%d search_x=%d search_y=%d diff1=%lld diff2=%lld\n",
1711 // pkg->difference1,
1712 // pkg->difference2);
1730 int64_t MotionScanUnit::get_cache(int x, int y)
1732 int64_t result = -1;
1733 cache_lock->lock("MotionScanUnit::get_cache");
1734 for(int i = 0; i < cache.total; i++)
1736 MotionScanCache *ptr = cache.values[i];
1737 if(ptr->x == x && ptr->y == y)
1739 result = ptr->difference;
1743 cache_lock->unlock();
1747 void MotionScanUnit::put_cache(int x, int y, int64_t difference)
1749 MotionScanCache *ptr = new MotionScanCache(x, y, difference);
1750 cache_lock->lock("MotionScanUnit::put_cache");
1752 cache_lock->unlock();
1765 MotionScan::MotionScan(MotionMain2 *plugin,
1770 total_clients, total_packages
1773 this->plugin = plugin;
1774 cache_lock = new Mutex("MotionScan::cache_lock");
1777 MotionScan::~MotionScan()
1783 void MotionScan::init_packages()
1785 // Set package coords
1786 for(int i = 0; i < get_total_packages(); i++)
1788 MotionScanPackage *pkg = (MotionScanPackage*)get_package(i);
1790 pkg->block_x1 = block_x1;
1791 pkg->block_x2 = block_x2;
1792 pkg->block_y1 = block_y1;
1793 pkg->block_y2 = block_y2;
1794 pkg->scan_x1 = scan_x1;
1795 pkg->scan_x2 = scan_x2;
1796 pkg->scan_y1 = scan_y1;
1797 pkg->scan_y2 = scan_y2;
1798 pkg->pixel = (int64_t)i * (int64_t)total_pixels / (int64_t)total_steps;
1799 pkg->difference1 = 0;
1800 pkg->difference2 = 0;
1807 LoadClient* MotionScan::new_client()
1809 return new MotionScanUnit(this, plugin);
1812 LoadPackage* MotionScan::new_package()
1814 return new MotionScanPackage;
1818 void MotionScan::scan_frame(VFrame *previous_frame,
1819 VFrame *current_frame,
1822 this->previous_frame = previous_frame;
1823 this->current_frame = current_frame;
1824 this->point = point;
1827 cache.remove_all_objects();
1830 // Single macroblock
1831 int w = current_frame->get_w();
1832 int h = current_frame->get_h();
1834 // Initial search parameters
1835 int scan_w = w * plugin->config.global_range_w[point] / 100;
1836 int scan_h = h * plugin->config.global_range_h[point] / 100;
1837 int block_w = w * plugin->config.global_block_w[point] / 100;
1838 int block_h = h * plugin->config.global_block_h[point] / 100;
1840 // Location of block in previous frame
1841 block_x1 = (int)(w * plugin->config.block_x[point] / 100 - block_w / 2);
1842 block_y1 = (int)(h * plugin->config.block_y[point] / 100 - block_h / 2);
1843 block_x2 = (int)(w * plugin->config.block_x[point] / 100 + block_w / 2);
1844 block_y2 = (int)(h * plugin->config.block_y[point] / 100 + block_h / 2);
1846 // Offset to location of previous block. This offset needn't be very accurate
1847 // since it's the offset of the previous image and current image we want.
1848 if(plugin->config.tracking_object == MotionScan::TRACK_PREVIOUS)
1850 block_x1 += plugin->total_dx[point] / OVERSAMPLE;
1851 block_y1 += plugin->total_dy[point] / OVERSAMPLE;
1852 block_x2 += plugin->total_dx[point] / OVERSAMPLE;
1853 block_y2 += plugin->total_dy[point] / OVERSAMPLE;
1858 switch(plugin->config.calculation)
1861 case MotionScan::NO_CALCULATE:
1867 case MotionScan::LOAD:
1869 printf("MotionScan::scan_frame %d\n", __LINE__);
1870 // Load result from disk
1871 char string[BCTEXTLEN];
1872 sprintf(string, "%s%06d",
1874 plugin->get_source_position());
1876 input = fopen(string, "r");
1879 for(int i = 0; i <= point; i++)
1892 // Scan from scratch
1901 printf("MotionScan::scan_frame %d\n", __LINE__);
1902 // Calculate center of search area in current frame
1903 int origin_offset_x = plugin->config.global_origin_x[point] * w / 100;
1904 int origin_offset_y = plugin->config.global_origin_y[point] * h / 100;
1905 int x_result = block_x1 + origin_offset_x;
1906 int y_result = block_y1 + origin_offset_y;
1908 // printf("MotionScan::scan_frame 1 %d %d %d %d %d %d %d %d\n",
1909 // block_x1 + block_w / 2,
1910 // block_y1 + block_h / 2,
1920 scan_x1 = x_result - scan_w / 2;
1921 scan_y1 = y_result - scan_h / 2;
1922 scan_x2 = x_result + scan_w / 2;
1923 scan_y2 = y_result + scan_h / 2;
1927 // Zero out requested values
1928 if(plugin->config.horizontal_only)
1931 scan_y2 = block_y1 + 1;
1933 if(plugin->config.vertical_only)
1936 scan_x2 = block_x1 + 1;
1939 // printf("MotionScan::scan_frame 1 %d %d %d %d %d %d %d %d\n",
1948 // Clamp the block coords before the scan so we get useful scan coords.
1949 MotionScan::clamp_scan(w,
1960 // printf("MotionScan::scan_frame 1\n block_x1=%d block_y1=%d block_x2=%d block_y2=%d\n scan_x1=%d scan_y1=%d scan_x2=%d scan_y2=%d\n x_result=%d y_result=%d\n",
1973 // Give up if invalid coords.
1974 if(scan_y2 <= scan_y1 ||
1975 scan_x2 <= scan_x1 ||
1976 block_x2 <= block_x1 ||
1977 block_y2 <= block_y1)
1981 // For subpixel, the top row and left column are skipped
1985 if(plugin->config.horizontal_only ||
1986 plugin->config.vertical_only)
1988 total_pixels = 4 * OVERSAMPLE * OVERSAMPLE - 4 * OVERSAMPLE;
1992 total_pixels = 4 * OVERSAMPLE;
1995 total_steps = total_pixels;
1997 set_package_count(total_steps);
2000 // Get least difference
2001 int64_t min_difference = -1;
2002 for(int i = 0; i < get_total_packages(); i++)
2004 MotionScanPackage *pkg = (MotionScanPackage*)get_package(i);
2005 if(pkg->difference1 < min_difference || min_difference == -1)
2007 min_difference = pkg->difference1;
2009 if(plugin->config.vertical_only)
2010 x_result = scan_x1 * OVERSAMPLE;
2012 x_result = scan_x1 * OVERSAMPLE +
2013 (pkg->pixel % (OVERSAMPLE * 2 - 1)) + 1;
2015 if(plugin->config.horizontal_only)
2016 y_result = scan_y1 * OVERSAMPLE;
2018 y_result = scan_y1 * OVERSAMPLE +
2019 (pkg->pixel / (OVERSAMPLE * 2 - 1)) + 1;
2023 dx_result = block_x1 * OVERSAMPLE - x_result;
2024 dy_result = block_y1 * OVERSAMPLE - y_result;
2027 if(pkg->difference2 < min_difference)
2029 min_difference = pkg->difference2;
2031 if(plugin->config.vertical_only)
2032 x_result = scan_x1 * OVERSAMPLE;
2034 x_result = scan_x2 * OVERSAMPLE -
2035 ((pkg->pixel % (OVERSAMPLE * 2 - 1)) + 1);
2037 if(plugin->config.horizontal_only)
2038 y_result = scan_y1 * OVERSAMPLE;
2040 y_result = scan_y2 * OVERSAMPLE -
2041 ((pkg->pixel / (OVERSAMPLE * 2 - 1)) + 1);
2043 dx_result = block_x1 * OVERSAMPLE - x_result;
2044 dy_result = block_y1 * OVERSAMPLE - y_result;
2049 //printf("MotionScan::scan_frame 1 %d %d %d %d\n", block_x1, block_y1, x_result, y_result);
2055 total_pixels = (scan_x2 - scan_x1) * (scan_y2 - scan_y1);
2056 total_steps = MIN(plugin->config.global_positions, total_pixels);
2058 set_package_count(total_steps);
2061 // Get least difference
2062 int64_t min_difference = -1;
2063 for(int i = 0; i < get_total_packages(); i++)
2065 MotionScanPackage *pkg = (MotionScanPackage*)get_package(i);
2066 if(pkg->difference1 < min_difference || min_difference == -1)
2068 min_difference = pkg->difference1;
2069 x_result = scan_x1 + (pkg->pixel % (scan_x2 - scan_x1));
2070 y_result = scan_y1 + (pkg->pixel / (scan_x2 - scan_x1));
2071 x_result *= OVERSAMPLE;
2072 y_result *= OVERSAMPLE;
2078 // printf("MotionScan::scan_frame 10 total_steps=%d total_pixels=%d subpixel=%d\n",
2083 // printf(" scan w=%d h=%d scan x1=%d y1=%d x2=%d y2=%d\n",
2091 // printf("MotionScan::scan_frame 2 block x1=%d y1=%d x2=%d y2=%d result x=%.2f y=%.2f\n",
2096 // (float)x_result / 4,
2097 // (float)y_result / 4);
2100 // If a new search is required, rescale results back to pixels.
2101 if(total_steps >= total_pixels)
2103 // Single pixel accuracy reached. Now do exhaustive subpixel search.
2104 if(plugin->config.action == MotionScan::STABILIZE ||
2105 plugin->config.action == MotionScan::TRACK ||
2106 plugin->config.action == MotionScan::NOTHING)
2108 x_result /= OVERSAMPLE;
2109 y_result /= OVERSAMPLE;
2116 // Fill in results and quit
2117 dx_result = block_x1 * OVERSAMPLE - x_result;
2118 dy_result = block_y1 * OVERSAMPLE - y_result;
2123 // Reduce scan area and try again
2125 scan_w = (scan_x2 - scan_x1) / 2;
2126 scan_h = (scan_y2 - scan_y1) / 2;
2127 x_result /= OVERSAMPLE;
2128 y_result /= OVERSAMPLE;
2143 if(plugin->config.calculation == MotionScan::SAVE)
2145 char string[BCTEXTLEN];
2149 plugin->get_source_position());
2152 output = fopen(string, "w");
2154 output = fopen(string, "a");
2165 perror("MotionScan::scan_frame SAVE 1");
2170 printf("MotionScan::scan_frame 10 point=%d dx=%.2f dy=%.2f\n",
2172 (float)this->dx_result / OVERSAMPLE,
2173 (float)this->dy_result / OVERSAMPLE);
2193 int64_t MotionScan::get_cache(int x, int y)
2195 int64_t result = -1;
2196 cache_lock->lock("MotionScan::get_cache");
2197 for(int i = 0; i < cache.total; i++)
2199 MotionScanCache *ptr = cache.values[i];
2200 if(ptr->x == x && ptr->y == y)
2202 result = ptr->difference;
2206 cache_lock->unlock();
2210 void MotionScan::put_cache(int x, int y, int64_t difference)
2212 MotionScanCache *ptr = new MotionScanCache(x, y, difference);
2213 cache_lock->lock("MotionScan::put_cache");
2215 cache_lock->unlock();
2222 MotionScanCache::MotionScanCache(int x, int y, int64_t difference)
2226 this->difference = difference;