+int MotionMain::open_cache_file()
+{
+ if( cache_fp ) return 0;
+ if( !cache_file[0] ) return 1;
+ if( !(cache_fp = fopen(cache_file, "r")) ) return 1;
+ return 0;
+}
+
+void MotionMain::close_cache_file()
+{
+ if( !cache_fp ) return;
+ fclose(cache_fp);
+ cache_fp = 0; cache_key = -1; tracking_frame = -1;
+}
+
+int MotionMain::load_cache_line()
+{
+ cache_key = -1;
+ if( open_cache_file() ) return 1;
+ if( !fgets(cache_line, sizeof(cache_line), cache_fp) ) return 1;
+ cache_key = strtol(cache_line, 0, 0);
+ return 0;
+}
+
+int MotionMain::get_cache_line(int64_t key)
+{
+ if( cache_key == key ) return 0;
+ if( open_cache_file() ) return 1;
+ if( cache_key >= 0 && key > cache_key ) {
+ if( load_cache_line() ) return 1;
+ if( cache_key == key ) return 0;
+ if( cache_key > key ) return 1;
+ }
+// binary search file
+ fseek(cache_fp, 0, SEEK_END);
+ int64_t l = -1, r = ftell(cache_fp);
+ while( (r - l) > 1 ) {
+ int64_t m = (l + r) / 2;
+ fseek(cache_fp, m, SEEK_SET);
+ if( m > 0 && !fgets(cache_line, sizeof(cache_line), cache_fp) )
+ return -1;
+ if( !load_cache_line() ) {
+ if( cache_key == key )
+ return 0;
+ if( cache_key < key ) { l = m; continue; }
+ }
+ r = m;
+ }
+ return 1;
+}
+
+int MotionMain::locate_cache_line(int64_t key)
+{
+ int ret = 1;
+ if( key < 0 || !(ret=get_cache_line(key)) ||
+ ( cache_key >= 0 && cache_key < key ) )
+ ret = load_cache_line();
+ return ret;
+}
+
+int MotionMain::put_cache_line(const char *line)
+{
+ int64_t key = strtol(line, 0, 0);
+ if( key == active_key ) return 1;
+ if( !active_fp ) {
+ close_cache_file();
+ snprintf(cache_file, sizeof(cache_file), "%s.bak", config.tracking_file);
+ ::rename(config.tracking_file, cache_file);
+ if( !(active_fp = fopen(config.tracking_file, "w")) ) {
+ perror(config.tracking_file);
+ fprintf(stderr, "err writing key %jd\n", key);
+ return -1;
+ }
+ active_key = -1;
+ }
+
+ if( active_key < key ) {
+ locate_cache_line(active_key);
+ while( cache_key >= 0 && key >= cache_key ) {
+ if( key > cache_key )
+ fputs(cache_line, active_fp);
+ load_cache_line();
+ }
+ }
+
+ active_key = key;
+ fputs(line, active_fp);
+ fflush(active_fp);
+ return 0;
+}
+
+void MotionMain::reset_cache_file()
+{
+ if( active_fp ) {
+ locate_cache_line(active_key);
+ while( cache_key >= 0 ) {
+ fputs(cache_line, active_fp);
+ load_cache_line();
+ }
+ close_cache_file(); ::remove(cache_file);
+ fclose(active_fp); active_fp = 0; active_key = -1;
+ }
+ else
+ close_cache_file();
+ strcpy(cache_file, config.tracking_file);
+}
+
+
+RotateScanPackage::RotateScanPackage()
+{
+}
+
+RotateScanUnit::RotateScanUnit(RotateScan *server, MotionMain *plugin)
+ : LoadClient(server)
+{
+ this->server = server;
+ this->plugin = plugin;
+ rotater = 0;
+ temp = 0;
+}
+
+RotateScanUnit::~RotateScanUnit()
+{
+ delete rotater;
+ delete temp;
+}
+
+void RotateScanUnit::process_package(LoadPackage *package)
+{
+ if( server->skip ) return;
+ RotateScanPackage *pkg = (RotateScanPackage*)package;
+
+ if( (pkg->difference = server->get_cache(pkg->angle)) < 0 ) {
+//printf("RotateScanUnit::process_package %d\n", __LINE__);
+ int color_model = server->previous_frame->get_color_model();
+ int pixel_size = BC_CModels::calculate_pixelsize(color_model);
+ int row_bytes = server->previous_frame->get_bytes_per_line();
+
+ if( !rotater )
+ rotater = new AffineEngine(1, 1);
+ if( !temp ) temp = new VFrame(0,
+ -1,
+ server->previous_frame->get_w(),
+ server->previous_frame->get_h(),
+ color_model,
+ -1);
+//printf("RotateScanUnit::process_package %d\n", __LINE__);
+
+
+// Rotate original block size
+// rotater->set_viewport(server->block_x1, server->block_y1,
+// server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
+ rotater->set_in_viewport(server->block_x1, server->block_y1,
+ server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
+ rotater->set_out_viewport(server->block_x1, server->block_y1,
+ server->block_x2 - server->block_x1, server->block_y2 - server->block_y1);
+// rotater->set_pivot(server->block_x, server->block_y);
+ rotater->set_in_pivot(server->block_x, server->block_y);
+ rotater->set_out_pivot(server->block_x, server->block_y);
+//printf("RotateScanUnit::process_package %d\n", __LINE__);
+ rotater->rotate(temp, server->previous_frame, pkg->angle);
+
+// Scan reduced block size
+//plugin->output_frame->copy_from(server->current_frame);
+//plugin->output_frame->copy_from(temp);
+//printf("RotateScanUnit::process_package %d %d %d %d %d\n",
+// __LINE__, server->scan_x, server->scan_y, server->scan_w, server->scan_h);
+// Clamp coordinates
+ int x1 = server->scan_x;
+ int y1 = server->scan_y;
+ int x2 = x1 + server->scan_w;
+ int y2 = y1 + server->scan_h;
+ x2 = MIN(temp->get_w(), x2);
+ y2 = MIN(temp->get_h(), y2);
+ x2 = MIN(server->current_frame->get_w(), x2);
+ y2 = MIN(server->current_frame->get_h(), y2);
+ x1 = MAX(0, x1); y1 = MAX(0, y1);
+
+ if( x2 > x1 && y2 > y1 ) {
+ pkg->difference = MotionScan::abs_diff(
+ temp->get_rows()[y1] + x1 * pixel_size,
+ server->current_frame->get_rows()[y1] + x1 * pixel_size,
+ row_bytes, x2 - x1, y2 - y1, color_model);
+//printf("RotateScanUnit::process_package %d\n", __LINE__);
+ server->put_cache(pkg->angle, pkg->difference);
+ }
+#if 0
+ VFrame png(x2-x1, y2-y1, BC_RGB888, -1);
+ png.transfer_from(temp, 0, x1, y1, x2-x1, y2-y1);
+ char fn[64];
+ sprintf(fn,"%s%f.png","/tmp/temp",pkg->angle); png.write_png(fn);
+ png.transfer_from(server->current_frame, 0, x1, y1, x2-x1, y2-y1);
+ sprintf(fn,"%s%f.png","/tmp/curr",pkg->angle); png.write_png(fn);
+printf("RotateScanUnit::process_package 10 x=%d y=%d w=%d h=%d block_x=%d block_y=%d angle=%f scan_w=%d scan_h=%d diff=%jd\n",
+ server->block_x1, server->block_y1, server->block_x2 - server->block_x1, server->block_y2 - server->block_y1,
+ server->block_x, server->block_y, pkg->angle, server->scan_w, server->scan_h, pkg->difference);
+#endif
+ }
+}
+
+
+RotateScan::RotateScan(MotionMain *plugin,
+ int total_clients,
+ int total_packages)
+ : LoadServer( //1, 1)
+ total_clients, total_packages)
+{
+ this->plugin = plugin;
+ cache_lock = new Mutex("RotateScan::cache_lock");
+}
+
+
+RotateScan::~RotateScan()
+{
+ delete cache_lock;
+}
+
+void RotateScan::init_packages()
+{
+ for( int i = 0; i < get_total_packages(); i++ ) {
+ RotateScanPackage *pkg = (RotateScanPackage*)get_package(i);
+ pkg->angle = scan_angle1 +
+ i * (scan_angle2 - scan_angle1) / (total_steps - 1);
+ }
+}
+
+LoadClient* RotateScan::new_client()
+{
+ return new RotateScanUnit(this, plugin);
+}
+
+LoadPackage* RotateScan::new_package()
+{
+ return new RotateScanPackage;
+}
+
+
+float RotateScan::scan_frame(VFrame *previous_frame, VFrame *current_frame,
+ int block_x, int block_y)
+{
+ skip = 0;
+ this->block_x = block_x;
+ this->block_y = block_y;
+
+//printf("RotateScan::scan_frame %d\n", __LINE__);
+ switch(plugin->config.tracking_type) {
+ case MotionScan::NO_CALCULATE:
+ result = plugin->config.rotation_center;
+ skip = 1;
+ break;
+
+ case MotionScan::LOAD:
+ case MotionScan::SAVE:
+ if( plugin->load_ok ) {
+ result = plugin->load_dt;
+ skip = 1;
+ }
+ break;
+ }