diff options
Diffstat (limited to '')
| -rwxr-xr-x | project/src/lib-kmp-diff.c | 2788 |
1 files changed, 2788 insertions, 0 deletions
diff --git a/project/src/lib-kmp-diff.c b/project/src/lib-kmp-diff.c new file mode 100755 index 0000000..b242bf9 --- /dev/null +++ b/project/src/lib-kmp-diff.c @@ -0,0 +1,2788 @@ + +/*************************************************************************** + * _______ _______ _______ * + * | ___ |____ | ___ | * + * | | |_| / /| | |_| * + * | |_____ / / | |_____ * + * |_____ | / / |_____ | * + * _ | | / / _ | | * + * | |___| |/ /____| |___| | * + * |_______|_______|_______| * + * * + * Wiimms SZS Tools * + * https://szs.wiimm.de/ * + * * + *************************************************************************** + * * + * This file is part of the SZS project. * + * Visit https://szs.wiimm.de/ for project details and sources. * + * * + * Copyright (c) 2011-2020 by Dirk Clemens <wiimm@wiimm.de> * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt * + * * + ***************************************************************************/ + +#include "lib-kmp.h" +//#include "lib-szs.h" +//#include "dclib-xdump.h" + +#include <stddef.h> + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// definitions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define COL_OK reset +#define COL_HINT yellow +#define COL_WARN red +#define COL_DIFF magenta +#define COL_SRC1 cyan +#define COL_SRC2 b_blue + +#define OK_WARN0(a,b,n) a->n == b->n ? ok : warn +#define OK_WARN1(a,b,n) a->n == b->n ? ok : warn, a->n + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// section_info_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[section_info_t]] + +typedef struct section_info_t +{ + kmp_entry_t sect; // section to compare + + kmp_t *kmp1; // first kmp to compare + kmp_t *kmp2; // first kmp to compare + uint verbose; // 0:quiet, 1:summary only, 2:full report + + char sect_name[5]; // section name + char subject[16]; // subject for status messages +} +section_info_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// helper functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static void print_float + ( uint n, const float *f1, const float *f2, double epsilon ) +{ + while ( n-- > 0 ) + { + printf(" %s%11.3f", + *f1 == *f2 ? colout->COL_OK + : fabsf(*f1-*f2) > epsilon ? colout->COL_WARN : colout->COL_HINT, + *f1 ); + f1++; + f2++; + } +} + +//----------------------------------------------------------------------------- + +static void print_rot ( uint n, const float *f1, const float *f2 ) +{ + while ( n-- > 0 ) + { + printf(" %s%7.2f", + *f1 == *f2 ? colout->COL_OK + : fabsf(*f1-*f2) > epsilon_rot ? colout->COL_WARN : colout->COL_HINT, + *f1 ); + f1++; + f2++; + } +} + +//----------------------------------------------------------------------------- + +static void print_hex16 ( uint n, const u16 *u1, const u16 *u2 ) +{ + while ( n-- > 0 ) + { + printf(" %s%#6x", + *u1 == *u2 ? colout->COL_OK : colout->COL_WARN, *u1 ); + u1++; + u2++; + } +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ph: helper for CKPH, ENPH, ITPH /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sort_ph_t]] + +typedef struct sort_ph_t +{ + int rank; // previous rank order + kmp_enph_entry_t data; // original object data + +} sort_ph_t; + +//----------------------------------------------------------------------------- + +static sort_ph_t * sort_ph ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_ph_t *res = CALLOC(list->used,sizeof(*res)); + sort_ph_t *ptr = res; + kmp_enph_entry_t *e = (kmp_enph_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_ph ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_ph + ( char mode, const kmp_enph_entry_t *p1, const kmp_enph_entry_t *p2 ) +{ + if ( p2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + const uint end1 = p1->pt_start + p1->pt_len - 1; + const uint end2 = p2->pt_start + p2->pt_len - 1; + printf("%c %s%3u %s%3u %s%3u %s:", + mode, + p1->pt_start == p2->pt_start ? ok : warn, p1->pt_start, + end1 == end2 ? ok : colout->COL_HINT, end1, + p1->pt_len == p2->pt_len ? ok : warn, p1->pt_len, + colout->reset ); + + uint j; + const u8 *d1 = p1->prev; + const u8 *d2 = p2->prev; + for ( j = 0; j < 12; j++, d1++, d2++ ) + { + if ( j == 6 ) + printf(" %s:",colout->reset); + fputs( *d1 == *d2 ? ok : warn, stdout ); + if ( *d1 == 0xff ) + fputs(" -",stdout); + else + printf("%4u",*d1); + } + putchar('\n'); + } + else + { + printf("%c %3u %3u %3u :", + mode, p1->pt_start, p1->pt_start + p1->pt_len - 1, p1->pt_len ); + + uint j; + const u8 *d1 = p1->prev; + for ( j = 0; j < 12; j++, d1++ ) + { + if ( j == 6 ) + fputs(" :",stdout); + if ( *d1 == 0xff ) + fputs(" -",stdout); + else + printf("%4u",*d1); + } + putchar('\n'); + } +} + +//----------------------------------------------------------------------------- + +static sort_ph_t * print_ph_single ( const section_info_t *si, + char mode, const sort_ph_t *e, sort_ph_t *end ) +{ + DASSERT(si); + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%s%s: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + si->sect_name, mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_ph(mode,&e->data,0); + e++; + } + return (sort_ph_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_ph ( const sort_ph_t *e1, const sort_ph_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.pt_start != e2->data.pt_start ) + + ( e1->data.pt_len != e2->data.pt_len ); + + if (memcmp(e1->data.prev,e2->data.prev,sizeof(e1->data.prev))) + count++; + if (memcmp(e1->data.next,e2->data.next,sizeof(e1->data.next))) + count++; + if (memcmp(e1->data.setting,e2->data.setting,sizeof(e1->data.setting))) + count++; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_ph_si ( const section_info_t *si ) +{ + DASSERT(si); + DASSERT(si->kmp1); + DASSERT(si->kmp2); + + uint diff_count = 0; + List_t *l1 = si->kmp1->dlist + si->sect; + List_t *l2 = si->kmp2->dlist + si->sect; + + if ( l1->used != l2->used ) + { + if (!si->verbose) + return 1; + printf("%s%s: Number of %s groups differ: Have %u and %u.%s\n", + colout->COL_DIFF, + si->sect_name, si->subject, l1->used, l2->used, + colout->reset ); + if (si->verbose==1) + return 1; + diff_count++; + } + + sort_ph_t *s1 = sort_ph(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_ph_t *s2 = sort_ph(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_ph(e1,e2); + if (stat) + { + if ( si->verbose < 2 ) + { + if (si->verbose) + printf("%s%s: Data differ%s\n", + colout->COL_DIFF, si->sect_name, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_ph_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_ph(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_ph_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_ph(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_ph_single(si,'<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_ph_single(si,'>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%s%s: %c%s group @%u:%u differ%s\n", + colout->COL_DIFF, + si->sect_name, + toupper((int)si->subject[0]), si->subject+1, + e1->rank, e2->rank, colout->reset ); + print_ph('<',&e1->data,&e2->data); + print_ph('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_ph_single(si,'<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_ph_single(si,'>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (si->verbose) + printf("%s%s: Order of groups differ%s\n", + colout->COL_DIFF, si->sect_name, colout->reset ); + if ( si->verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// pt: helper for ENPT, ITPT /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sort_pt_t]] + +typedef struct sort_pt_t +{ + int rank; // previous rank order + kmp_enpt_entry_t data; // original object data + +} sort_pt_t; + +//----------------------------------------------------------------------------- + +static sort_pt_t * sort_pt ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_pt_t *res = CALLOC(list->used,sizeof(*res)); + sort_pt_t *ptr = res; + kmp_enpt_entry_t *e = (kmp_enpt_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_pt ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_pt + ( char mode, const kmp_enpt_entry_t *p1, const kmp_enpt_entry_t *p2 ) +{ + if ( p2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + putchar(mode); + putchar(' '); + print_float(3,p1->position,p2->position,epsilon_pos); + + printf(" %s%7.3f %s%#6x %s%#6x%s\n", + p1->scale == p2->scale ? ok + : fabsf(p1->scale-p2->scale) > epsilon_scale ? colout->COL_WARN + : colout->COL_HINT, + p1->scale, + p1->prop[0] == p2->prop[0] ? ok : warn, p1->prop[0], + p1->prop[1] == p2->prop[1] ? ok : warn, p1->prop[1], + colout->reset ); + } + else + { + printf("%c %11.3f %11.3f %11.3f %7.3f %#6x %#6x\n", + mode, + p1->position[0], p1->position[1], p1->position[2], + p1->scale, + p1->prop[0], p1->prop[1] ); + } +} + +//----------------------------------------------------------------------------- + +static sort_pt_t * print_pt_single ( const section_info_t *si, + char mode, const sort_pt_t *e, sort_pt_t *end ) +{ + DASSERT(si); + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%s%s: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + si->sect_name, mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_pt(mode,&e->data,0); + e++; + } + return (sort_pt_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_pt ( const sort_pt_t *e1, const sort_pt_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.prop[0] != e2->data.prop[0] ) + + ( e1->data.prop[1] != e2->data.prop[1] ); + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.scale - e2->data.scale ) > epsilon_scale; + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_pt_si ( const section_info_t *si ) +{ + DASSERT(si); + DASSERT(si->kmp1); + DASSERT(si->kmp2); + + uint diff_count = 0; + List_t *l1 = si->kmp1->dlist + si->sect; + List_t *l2 = si->kmp2->dlist + si->sect; + + if ( l1->used != l2->used ) + { + if (!si->verbose) + return 1; + printf("%s%s: Number of %ss differ: Have %u and %u.%s\n", + colout->COL_DIFF, + si->sect_name, si->subject, l1->used, l2->used, + colout->reset ); + if (si->verbose==1) + return 1; + diff_count++; + } + + sort_pt_t *s1 = sort_pt(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_pt_t *s2 = sort_pt(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_pt(e1,e2); + if (stat) + { + if ( si->verbose < 2 ) + { + if (si->verbose) + printf("%s%s: Data differ%s\n", + colout->COL_DIFF, si->sect_name, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_pt_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_pt(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_pt_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_pt(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_pt_single(si,'<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_pt_single(si,'>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%s%s: %s @%u:%u differ%s\n", + colout->COL_DIFF, + si->sect_name, si->subject, + e1->rank, e2->rank, colout->reset ); + print_pt('<',&e1->data,&e2->data); + print_pt('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_pt_single(si,'<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_pt_single(si,'>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (si->verbose) + printf("%s%s: Order of %ss differ%s\n", + colout->COL_DIFF, si->sect_name, + si->subject, colout->reset ); + if ( si->verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// pt2: helper for CNPT, JGPT, MSPT /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sort_pt2_t]] + +typedef struct sort_pt2_t +{ + int rank; // previous rank order + kmp_jgpt_entry_t data; // original object data + +} sort_pt2_t; + +//----------------------------------------------------------------------------- + +static sort_pt2_t * sort_pt2 ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_pt2_t *res = CALLOC(list->used,sizeof(*res)); + sort_pt2_t *ptr = res; + kmp_jgpt_entry_t *e = (kmp_jgpt_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_pt2 ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_pt2 + ( char mode, const kmp_jgpt_entry_t *p1, const kmp_jgpt_entry_t *p2 ) +{ + if ( p2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + + putchar(mode); + print_float(3,p1->position,p2->position,epsilon_pos); + putchar(' '); + print_rot(3,p1->rotation,p2->rotation); + + printf(" %s%6d %s%#6x%s\n", + p1->id == p2->id ? ok : colout->COL_HINT, p1->id, + p1->effect == p2->effect ? ok : colout->COL_WARN, p1->effect, + colout->reset ); + } + else + { + printf("%c %11.3f %11.3f %11.3f %7.2f %7.2f %7.2f %6d %#6x\n", + mode, + p1->position[0], p1->position[1], p1->position[2], + p1->rotation[0], p1->rotation[1], p1->rotation[2], + p1->id, p1->effect ); + } +} + +//----------------------------------------------------------------------------- + +static sort_pt2_t * print_pt2_single ( const section_info_t *si, + char mode, const sort_pt2_t *e, sort_pt2_t *end ) +{ + DASSERT(si); + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%s%s: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + si->sect_name, mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_pt2(mode,&e->data,0); + e++; + } + return (sort_pt2_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_pt2 ( const sort_pt2_t *e1, const sort_pt2_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + // 'data.id' ignored! + uint count = e1->data.effect != e2->data.effect; + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.rotation[0] - e2->data.rotation[0] ) > epsilon_rot + || fabsf( e1->data.rotation[1] - e2->data.rotation[1] ) > epsilon_rot + || fabsf( e1->data.rotation[2] - e2->data.rotation[2] ) > epsilon_rot; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_pt2_si ( const section_info_t *si ) +{ + DASSERT(si); + DASSERT(si->kmp1); + DASSERT(si->kmp2); + + uint diff_count = 0; + List_t *l1 = si->kmp1->dlist + si->sect; + List_t *l2 = si->kmp2->dlist + si->sect; + + if ( l1->used != l2->used ) + { + if (!si->verbose) + return 1; + printf("%s%s: Number of %s points differ: Have %u and %u.%s\n", + colout->COL_DIFF, + si->sect_name, si->subject, l1->used, l2->used, + colout->reset ); + if (si->verbose==1) + return 1; + diff_count++; + } + + sort_pt2_t *s1 = sort_pt2(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_pt2_t *s2 = sort_pt2(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_pt2(e1,e2); + if (stat) + { + if ( si->verbose < 2 ) + { + if (si->verbose) + printf("%s%s: Data differ%s\n", + colout->COL_DIFF, si->sect_name, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_pt2_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_pt2(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_pt2_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_pt2(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_pt2_single(si,'<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_pt2_single(si,'>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%s%s: %s group @%u:%u differ%s\n", + colout->COL_DIFF, + si->sect_name, si->subject, + e1->rank, e2->rank, colout->reset ); + print_pt2('<',&e1->data,&e2->data); + print_pt2('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_pt2_single(si,'<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_pt2_single(si,'>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (si->verbose) + printf("%s%s: Order of %s points differ%s\n", + colout->COL_DIFF, si->sect_name, + si->subject, colout->reset ); + if ( si->verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_AREA() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct sort_area_t +{ + int rank; // previous rank order + kmp_area_entry_t data; // original object data + +} sort_area_t; + +//----------------------------------------------------------------------------- + +static sort_area_t * sort_area ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_area_t *res = CALLOC(list->used,sizeof(*res)); + sort_area_t *ptr = res; + kmp_area_entry_t *e = (kmp_area_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_area ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_area + ( char mode, const kmp_area_entry_t *e1, const kmp_area_entry_t *e2 ) +{ + if ( e2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + printf("%c %s%5u %s%5u", + mode, OK_WARN1(e1,e2,mode), OK_WARN1(e1,e2,type) ); + print_float(3,e1->position,e2->position,epsilon_pos); + putchar(' '); + print_hex16(4,e1->setting,e2->setting); + + printf("%s\n%c %s%5u %s%5u", + colout->reset, mode, + OK_WARN1(e1,e2,dest_id), OK_WARN1(e1,e2,unknown) ); + print_float(3,e1->rotation,e2->rotation,epsilon_rot); + + printf("%s\n%-14c", colout->reset, mode ); + print_float(3,e1->scale,e2->scale,epsilon_scale); + + printf("%s\n",colout->reset); + } + else + { + printf( "%c %5u %5u %11.3f %11.3f %11.3f %#6x %#6x %#6x %#6x\n" + "%c %5u %5u %11.3f %11.3f %11.3f\n" + "%c %24.3f %11.3f %11.3f\n", + mode, + e1->mode, e1->type, + e1->position[0], e1->position[1], e1->position[2], + e1->setting[0], e1->setting[1], e1->setting[2], e1->setting[3], + mode, + e1->dest_id, e1->unknown, + e1->rotation[0], e1->rotation[1], e1->rotation[2], + mode, + e1->scale[0], e1->scale[1], e1->scale[2] ); + } +} + +//----------------------------------------------------------------------------- + +static sort_area_t * print_area_single + ( char mode, const sort_area_t *e, sort_area_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%sAREA: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_area(mode,&e->data,0); + e++; + } + return (sort_area_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_area ( const sort_area_t *e1, const sort_area_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.mode != e2->data.mode ) + + ( e1->data.type != e2->data.type ) + + ( e1->data.dest_id != e2->data.dest_id ) + + ( e1->data.unknown != e2->data.unknown ); + + uint i; + for ( i = 0; i < 4; i++ ) + count += e1->data.setting[i] != e2->data.setting[i]; + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.rotation[0] - e2->data.rotation[0] ) > epsilon_rot + || fabsf( e1->data.rotation[1] - e2->data.rotation[1] ) > epsilon_rot + || fabsf( e1->data.rotation[2] - e2->data.rotation[2] ) > epsilon_rot; + + count += fabsf( e1->data.scale[0] - e2->data.scale[0] ) > epsilon_scale + || fabsf( e1->data.scale[1] - e2->data.scale[1] ) > epsilon_scale + || fabsf( e1->data.scale[2] - e2->data.scale[2] ) > epsilon_scale; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_AREA +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_AREA; + List_t *l2 = kmp2->dlist + KMP_AREA; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sAREA: Number of areas differ: Have %u and %u.%s\n", + colout->COL_WARN, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_area_t *s1 = sort_area(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_area_t *s2 = sort_area(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_area(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sAREA: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_area_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_area(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_area_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_area(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_area_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_area_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%sAREA: Area @%u:%u differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + colout->reset ); + print_area('<',&e1->data,&e2->data); + print_area('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_area_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_area_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sAREA: Order of areas differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_CAME() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct sort_came_t +{ + int rank; // previous rank order + kmp_came_entry_t data; // original object data + +} sort_came_t; + +//----------------------------------------------------------------------------- + +static sort_came_t * sort_came ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_came_t *res = CALLOC(list->used,sizeof(*res)); + sort_came_t *ptr = res; + kmp_came_entry_t *e = (kmp_came_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_came ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_came + ( char mode, const kmp_came_entry_t *e1, const kmp_came_entry_t *e2 ) +{ + if ( e2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + printf("%c %s%5u %s%5u ", + mode, + OK_WARN1(e1,e2,type), + OK_WARN1(e1,e2,came_speed) ); + print_float(3,e1->position,e2->position,epsilon_pos); + putchar(' '); + print_float(1,&e1->zoom_begin,&e2->zoom_begin,epsilon_pos); + + printf("%s\n%c %s%5s %s%5u ", + colout->reset, + mode, + OK_WARN0(e1,e2,next),PrintU8M1(e1->next), + OK_WARN1(e1,e2,zoom_speed) ); + print_float(3,e1->rotation,e2->rotation,epsilon_pos); + putchar(' '); + print_float(1,&e1->zoom_end,&e2->zoom_end,epsilon_pos); + + printf("%s\n%c %s%5u %s%5u ", + colout->reset, + mode, + OK_WARN1(e1,e2,unknown_0x02), + OK_WARN1(e1,e2,viewpt_speed) ); + print_float(3,e1->viewpt_begin,e2->viewpt_begin,epsilon_pos); + + printf("%s\n%c %s%5s %s%5u ", + colout->reset, + mode, + OK_WARN0(e1,e2,route),PrintU8M1(e1->route), + OK_WARN1(e1,e2,unknown_0x0a) ); + print_float(3,e1->viewpt_end,e2->viewpt_end,epsilon_pos); + putchar(' '); + print_float(1,&e1->time,&e2->time,epsilon_time); + + printf("%s\n",colout->reset); + } + else + { + printf( "%c %5u %5u %11.3f %11.3f %11.3f %11.3f\n" + "%c %5s %5u %11.3f %11.3f %11.3f %11.3f\n" + "%c %5u %5u %11.3f %11.3f %11.3f\n" + "%c %5s %5u %11.3f %11.3f %11.3f %11.3f\n", + mode, + e1->type, e1->came_speed, + e1->position[0], e1->position[1], e1->position[2], + e1->zoom_begin, + mode, + PrintU8M1(e1->next), e1->zoom_speed, + e1->rotation[0], e1->rotation[1], e1->rotation[2], + e1->zoom_end, + mode, + e1->unknown_0x02, e1->viewpt_speed, + e1->viewpt_begin[0], e1->viewpt_begin[1], e1->viewpt_begin[2], + mode, + PrintU8M1(e1->route), e1->unknown_0x0a, + e1->viewpt_end[0], e1->viewpt_end[1], e1->viewpt_end[2], + e1->time ); + } +} + +//----------------------------------------------------------------------------- + +static sort_came_t * print_came_single + ( char mode, const sort_came_t *e, sort_came_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%sCAME: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_came(mode,&e->data,0); + e++; + } + return (sort_came_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_came ( const sort_came_t *e1, const sort_came_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.type != e2->data.type ) + + ( e1->data.next != e2->data.next ) + + ( e1->data.unknown_0x02 != e2->data.unknown_0x02 ) + + ( e1->data.route != e2->data.route ) + + ( e1->data.came_speed != e2->data.came_speed ) + + ( e1->data.zoom_speed != e2->data.zoom_speed ) + + ( e1->data.viewpt_speed != e2->data.viewpt_speed ) + + ( e1->data.unknown_0x0a != e2->data.unknown_0x0a ); + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.rotation[0] - e2->data.rotation[0] ) > epsilon_rot + || fabsf( e1->data.rotation[1] - e2->data.rotation[1] ) > epsilon_rot + || fabsf( e1->data.rotation[2] - e2->data.rotation[2] ) > epsilon_rot; + + count += fabsf( e1->data.zoom_begin - e2->data.zoom_begin ) > epsilon_scale + || fabsf( e1->data.zoom_end - e2->data.zoom_end ) > epsilon_scale; + + count += fabsf( e1->data.viewpt_begin[0] - e2->data.viewpt_begin[0] ) > epsilon_pos + || fabsf( e1->data.viewpt_begin[1] - e2->data.viewpt_begin[1] ) > epsilon_pos + || fabsf( e1->data.viewpt_begin[2] - e2->data.viewpt_begin[2] ) > epsilon_pos; + + + count += fabsf( e1->data.viewpt_end[0] - e2->data.viewpt_end[0] ) > epsilon_pos + || fabsf( e1->data.viewpt_end[1] - e2->data.viewpt_end[1] ) > epsilon_pos + || fabsf( e1->data.viewpt_end[2] - e2->data.viewpt_end[2] ) > epsilon_pos; + + count += fabsf( e1->data.time - e2->data.time ) > epsilon_time; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_CAME +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_CAME; + List_t *l2 = kmp2->dlist + KMP_CAME; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sCAME: Number of cameras differ: Have %u and %u.%s\n", + colout->COL_WARN, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_came_t *s1 = sort_came(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_came_t *s2 = sort_came(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_came(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sCAME: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_came_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_came(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_came_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_came(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_came_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_came_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%sCAME: Camera @%u:%u differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + colout->reset ); + print_came('<',&e1->data,&e2->data); + print_came('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_came_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_came_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sCAME: Order of cameras differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_CKPH() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_CKPH +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_CKPH,kmp1,kmp2,verbose,"CKPH","check point"}; + return diff_ph_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_CKPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct sort_ckpt_t +{ + int rank; // previous rank order + kmp_ckpt_entry_t data; // original object data + +} sort_ckpt_t; + +//----------------------------------------------------------------------------- + +static sort_ckpt_t * sort_ckpt ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_ckpt_t *res = CALLOC(list->used,sizeof(*res)); + sort_ckpt_t *ptr = res; + kmp_ckpt_entry_t *e = (kmp_ckpt_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_ckpt ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static void print_ckpt + ( char mode, const kmp_ckpt_entry_t *e1, const kmp_ckpt_entry_t *e2 ) +{ + if ( e2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + putchar(mode); + print_float(2,e1->left,e2->left,epsilon_pos); + putchar(' '); + print_float(2,e1->right,e2->right,epsilon_pos); + + printf(" %s%3d %s%3s %s%3s %s%3s%s\n", + OK_WARN1(e1,e2,respawn), + OK_WARN0(e1,e2,mode), PrintU8M1(e1->mode), + OK_WARN0(e1,e2,prev), PrintU8M1(e1->prev), + OK_WARN0(e1,e2,next), PrintU8M1(e1->next), + colout->reset ); + } + else + { + printf("%c %11.3f %11.3f %11.3f %11.3f %3d %3s %3s %3s\n", + mode, + e1->left[0], e1->left[1], + e1->right[0], e1->right[1], + e1->respawn, + PrintU8M1(e1->mode), + PrintU8M1(e1->prev), + PrintU8M1(e1->next) ); + } +} + +//----------------------------------------------------------------------------- + +static sort_ckpt_t * print_ckpt_single + ( char mode, const sort_ckpt_t *e, sort_ckpt_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%sCKPT: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_ckpt(mode,&e->data,0); + e++; + } + return (sort_ckpt_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_ckpt ( const sort_ckpt_t *e1, const sort_ckpt_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.respawn != e2->data.respawn ) + + ( e1->data.mode != e2->data.mode ) + + ( e1->data.prev != e2->data.prev ) + + ( e1->data.next != e2->data.next ); + + count += fabsf( e1->data.left[0] - e2->data.left[0] ) > epsilon_pos + || fabsf( e1->data.left[1] - e2->data.left[1] ) > epsilon_pos; + + count += fabsf( e1->data.right[0] - e2->data.right[0] ) > epsilon_pos + || fabsf( e1->data.right[1] - e2->data.right[1] ) > epsilon_pos; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_CKPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_CKPT; + List_t *l2 = kmp2->dlist + KMP_CKPT; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sCKPT: Number of check points differ: Have %u and %u.%s\n", + colout->COL_WARN, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_ckpt_t *s1 = sort_ckpt(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_ckpt_t *s2 = sort_ckpt(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_ckpt(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sCKPT: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_ckpt_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_ckpt(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_ckpt_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_ckpt(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_ckpt_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_ckpt_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%sCKPT: CKPT @%u:%u differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + colout->reset ); + print_ckpt('<',&e1->data,&e2->data); + print_ckpt('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_ckpt_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_ckpt_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sCKPT: Order of check points differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_CNPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_CNPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_CNPT,kmp1,kmp2,verbose,"CNPT","cannon"}; + return diff_pt2_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_ENPH() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_ENPH +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_ENPH,kmp1,kmp2,verbose,"ENPH","enemy point"}; + return diff_ph_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_ENPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_ENPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_ENPT,kmp1,kmp2,verbose,"ENPT","enemy point"}; + return diff_pt_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_GOBJ() /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sort_gobj_t]] + +typedef struct sort_gobj_t +{ + int obj_id; // relevant object id + int rank; // previous rank order + kmp_gobj_entry_t data; // original object data + +} sort_gobj_t; + +//----------------------------------------------------------------------------- + +static int compare_sort_gobj ( const sort_gobj_t * a, const sort_gobj_t * b ) +{ + int stat = a->obj_id - b->obj_id; + if (!stat) + stat = a->rank - b->rank; + return stat; +} + +//----------------------------------------------------------------------------- + +static sort_gobj_t * sort_gobj ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_gobj_t *res = CALLOC(list->used,sizeof(*res)); + sort_gobj_t *sg = res; + kmp_gobj_entry_t *e = (kmp_gobj_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, sg++ ) + { + sg->obj_id = e->obj_id & ~GOBJ_M_LECODE; + sg->rank = i; + memcpy(&sg->data,e,sizeof(sg->data)); + } + + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_gobj ); + return res; +} + +//----------------------------------------------------------------------------- + +static void print_gobj ( char mode, const kmp_gobj_entry_t *g1, + const kmp_gobj_entry_t *g2, const ObjectInfo_t *oi ) +{ + char buf1[32], buf2[32]; + if (!oi) + oi = GetObjectInfo(g1->obj_id); + DASSERT(oi); + + if ( g2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + printf("%c %s%#6x", + mode, g1->obj_id == g2->obj_id ? ok : warn, g1->obj_id ); + print_float(3,g1->position,g2->position,epsilon_pos); + + fputs(" ",stdout); + printf( oi->format1 ? oi->format1->col : settings_format_uuuu.col, + g1->setting[0] == g2->setting[0] ? ok : warn , g1->setting[0], + g1->setting[1] == g2->setting[1] ? ok : warn , g1->setting[1], + g1->setting[2] == g2->setting[2] ? ok : warn , g1->setting[2], + g1->setting[3] == g2->setting[3] ? ok : warn , g1->setting[3] ); + + printf(" %s%6s%s\n%c %s%#6x", + g1->route_id == g2->route_id ? ok : warn, PrintU16M1(g1->route_id), + colout->reset, + mode, + g1->ref_id == g2->ref_id ? ok : warn, g1->ref_id ); + print_float(3,g1->rotation,g2->rotation,epsilon_rot); + + fputs(" ",stdout); + printf( oi->format2 ? oi->format2->col : settings_format_uuuu.col, + g1->setting[4] == g2->setting[4] ? ok : warn , g1->setting[4], + g1->setting[5] == g2->setting[5] ? ok : warn , g1->setting[5], + g1->setting[6] == g2->setting[6] ? ok : warn , g1->setting[6], + g1->setting[7] == g2->setting[7] ? ok : warn , g1->setting[7] ); + + printf(" %s%#6x%s\n%c ", + g1->pflags == g2->pflags ? ok : warn, g1->pflags, + colout->reset, mode ); + print_float(3,g1->scale,g2->scale,epsilon_scale); + + printf( "%s\n",colout->reset); + } + else + { + snprintf( buf1, sizeof(buf1), + oi->format1 ? oi->format1->std : settings_format_uuuu.std, + g1->setting[0], g1->setting[1], g1->setting[2], g1->setting[3] ); + + snprintf( buf2, sizeof(buf2), + oi->format2 ? oi->format2->std : settings_format_uuuu.std, + g1->setting[4], g1->setting[5], g1->setting[6], g1->setting[7] ); + + printf( "%c %#6x %11.3f %11.3f %11.3f %s %6s\n" + "%c %#6x %11.3f %11.3f %11.3f %s %#6x\n" + "%c %11.3f %11.3f %11.3f\n", + mode, g1->obj_id, + g1->position[0], g1->position[1], g1->position[2], + buf1, PrintU16M1(g1->route_id), + mode, g1->ref_id, + g1->rotation[0], g1->rotation[1], g1->rotation[2], + buf2, g1->pflags, + mode, g1->scale[0], g1->scale[1], g1->scale[2] + ); + } +} + +//----------------------------------------------------------------------------- + +static sort_gobj_t * print_gobj_single + ( char mode, const sort_gobj_t *e, sort_gobj_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + const ObjectInfo_t *oi = GetObjectInfo(e->data.obj_id); + printf("%sGOBJ: Only found in source %c (@%u,%s)%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + oi->name ? oi->name : "?", + colout->reset ); + print_gobj(mode,&e->data,0,0); + e++; + } + return (sort_gobj_t*)e; +} + +//----------------------------------------------------------------------------- +// return 0:equal, >0:number of different elements, 99:different relevant obj_id + +static int diff_gobj ( const sort_gobj_t *e1, const sort_gobj_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + if ( e1->obj_id != e2->obj_id ) + return 99; + + uint count = ( e1->data.obj_id != e2->data.obj_id ) + + ( e1->data.ref_id != e2->data.ref_id ) + + ( e1->data.route_id != e2->data.route_id ) + + ( e1->data.pflags != e2->data.pflags ); + + uint i; + for ( i = 0; i < 8; i++ ) + count += e1->data.setting[i] != e2->data.setting[i]; + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.rotation[0] - e2->data.rotation[0] ) > epsilon_rot + || fabsf( e1->data.rotation[1] - e2->data.rotation[1] ) > epsilon_rot + || fabsf( e1->data.rotation[2] - e2->data.rotation[2] ) > epsilon_rot; + + count += fabsf( e1->data.scale[0] - e2->data.scale[0] ) > epsilon_scale + || fabsf( e1->data.scale[1] - e2->data.scale[1] ) > epsilon_scale + || fabsf( e1->data.scale[2] - e2->data.scale[2] ) > epsilon_scale; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_GOBJ +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_GOBJ; + List_t *l2 = kmp2->dlist + KMP_GOBJ; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sGOBJ: Number of objects differ: Have %u and %u.%s\n", + colout->COL_DIFF, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_gobj_t *sg1 = sort_gobj(l1), *e1 = sg1, *end1 = e1 + l1->used; + sort_gobj_t *sg2 = sort_gobj(l2), *e2 = sg2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + if ( e1->obj_id < e2->obj_id ) + { + e1 = print_gobj_single('<',e1,e1+1); + diff_count++; + continue; + } + + if ( e2->obj_id < e1->obj_id ) + { + e2 = print_gobj_single('>',e2,e2+1); + diff_count++; + continue; + } + + const int stat = diff_gobj(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sGOBJ: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_gobj_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_gobj(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_gobj_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_gobj(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + //e1 = print_gobj_single('<',e1,p1); + e1 = print_gobj_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + //e2 = print_gobj_single('>',e2,p2); + e2 = print_gobj_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + const ObjectInfo_t *oi = GetObjectInfo(e1->data.obj_id); + printf("%sGOBJ: Object @%u:%u (%s) differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + oi->name ? oi->name : "?", colout->reset ); + print_gobj('<',&e1->data,&e2->data,oi); + print_gobj('>',&e2->data,&e1->data,oi); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_gobj_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_gobj_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sGOBJ: Order of objects differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(sg1); + FREE(sg2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_ITPH() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_ITPH +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_ITPH,kmp1,kmp2,verbose,"ITPH","item point"}; + return diff_ph_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_ITPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_ITPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_ITPT,kmp1,kmp2,verbose,"ITPT","item point"}; + return diff_pt_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_JGPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_JGPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_JGPT,kmp1,kmp2,verbose,"JGPT","respawn"}; + return diff_pt2_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_KTPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct sort_ktpt_t +{ + int rank; // previous rank order + kmp_ktpt_entry_t data; // original object data + +} sort_ktpt_t; + +//----------------------------------------------------------------------------- + +static sort_ktpt_t * sort_ktpt ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_ktpt_t *res = CALLOC(list->used,sizeof(*res)); + sort_ktpt_t *ptr = res; + kmp_ktpt_entry_t *e = (kmp_ktpt_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_ktpt ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static inline void print_ktpt + ( char mode, const kmp_ktpt_entry_t *e1, const kmp_ktpt_entry_t *e2 ) +{ + print_pt2(mode,(kmp_jgpt_entry_t*)e1,(kmp_jgpt_entry_t*)e2); +} + +//----------------------------------------------------------------------------- + +static sort_ktpt_t * print_ktpt_single + ( char mode, const sort_ktpt_t *e, sort_ktpt_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%sKTPT: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_ktpt(mode,&e->data,0); + e++; + } + return (sort_ktpt_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_ktpt ( const sort_ktpt_t *e1, const sort_ktpt_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + uint count = ( e1->data.player_index != e2->data.player_index ) + + ( e1->data.unknown != e2->data.unknown ); + + count += fabsf( e1->data.position[0] - e2->data.position[0] ) > epsilon_pos + || fabsf( e1->data.position[1] - e2->data.position[1] ) > epsilon_pos + || fabsf( e1->data.position[2] - e2->data.position[2] ) > epsilon_pos; + + count += fabsf( e1->data.rotation[0] - e2->data.rotation[0] ) > epsilon_rot + || fabsf( e1->data.rotation[1] - e2->data.rotation[1] ) > epsilon_rot + || fabsf( e1->data.rotation[2] - e2->data.rotation[2] ) > epsilon_rot; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_KTPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_KTPT; + List_t *l2 = kmp2->dlist + KMP_KTPT; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sKTPT: Number of start positions differ: Have %u and %u.%s\n", + colout->COL_WARN, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_ktpt_t *s1 = sort_ktpt(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_ktpt_t *s2 = sort_ktpt(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_ktpt(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sKTPT: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_ktpt_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_ktpt(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_ktpt_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_ktpt(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_ktpt_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_ktpt_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%sKTPT: KTPT @%u:%u differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + colout->reset ); + print_ktpt('<',&e1->data,&e2->data); + print_ktpt('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_ktpt_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_ktpt_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sKTPT: Order of start positions differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_MSPT() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint diff_KMP_MSPT +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + section_info_t si = {KMP_MSPT,kmp1,kmp2,verbose,"MSPT","mission success"}; + return diff_pt2_si(&si); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_POTI() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static int diff_poti_group ( const kmp_poti_group_t *e1, const kmp_poti_group_t *e2 ) +{ + if (!memcmp(e1,e2,sizeof(*e1))) + return 0; + + return ( e1->n_point != e2->n_point ) + + ( e1->smooth != e2->smooth ) + + ( e1->back != e2->back ); +} + +//----------------------------------------------------------------------------- + +static int diff_poti_point ( const kmp_poti_point_t *e1, const kmp_poti_point_t *e2 ) +{ + if (!memcmp(e1,e2,sizeof(*e1))) + return 0; + + uint count = ( e1->speed != e2->speed ) + + ( e1->unknown != e2->unknown ); + + count += fabsf( e1->position[0] - e2->position[0] ) > epsilon_pos + || fabsf( e1->position[1] - e2->position[1] ) > epsilon_pos + || fabsf( e1->position[2] - e2->position[2] ) > epsilon_pos; + + return count; +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_POTI +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *gl1 = kmp1->dlist + KMP_POTI; + List_t *pl1 = &kmp1->poti_point; + List_t *gl2 = kmp2->dlist + KMP_POTI; + List_t *pl2 = &kmp2->poti_point; + + + if ( gl1->used != gl2->used ) + { + if (!verbose) + return 1; + printf("POTI: Number of routes differ: Have %u and %u.\n", + gl1->used, gl2->used ); + if (verbose==1) + return 1; + diff_count++; + } + + if ( pl1->used != pl2->used ) + { + if (!verbose) + return 1; + printf("POTI: Number of total route points differ: Have %u and %u.\n", + pl1->used, pl2->used ); + if (verbose==1) + return 1; + diff_count++; + } + +// [[2do]] ??? qqq + + uint i; + const uint gn = gl1->used < gl2->used ? gl1->used : gl2->used; + kmp_poti_group_t *ge1 = (kmp_poti_group_t*)gl1->list; + kmp_poti_group_t *ge2 = (kmp_poti_group_t*)gl2->list; + + for ( i = 0; i < gn; i++, ge1++, ge2++ ) + { + if (diff_poti_group(ge1,ge2)) + { + if ( verbose < 2 ) + { + if (verbose) + fputs("POTI: Groups differ\n",stdout); + return 1; + } + + printf("POTI: Group #%u differ\n",i); + diff_count++; + } + } + + +// [[2do]] ??? qqq + + const uint pn = pl1->used < pl2->used ? pl1->used : pl2->used; + kmp_poti_point_t *pe1 = (kmp_poti_point_t*)pl1->list; + kmp_poti_point_t *pe2 = (kmp_poti_point_t*)pl2->list; + + for ( i = 0; i < pn; i++, pe1++, pe2++ ) + { + if (diff_poti_point(pe1,pe2)) + { + if ( verbose < 2 ) + { + if (verbose) + fputs("POTI: Route points differ\n",stdout); + return 1; + } + + printf("POTI: Route point #%u differ\n",i); + diff_count++; + } + } + + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// diff_KMP_STGI() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct sort_stgi_t +{ + int rank; // previous rank order + kmp_stgi_entry_t data; // original object data + +} sort_stgi_t; + +//----------------------------------------------------------------------------- + +static sort_stgi_t * sort_stgi ( const List_t *list ) +{ + DASSERT(list); + if (!list->used) + return 0; + + sort_stgi_t *res = CALLOC(list->used,sizeof(*res)); + sort_stgi_t *ptr = res; + kmp_stgi_entry_t *e = (kmp_stgi_entry_t*)list->list; + const uint n = list->used; + + uint i; + for ( i = 0; i < n; i++, e++, ptr++ ) + { + ptr->rank = i; + memcpy(&ptr->data,e,sizeof(ptr->data)); + } + + #if 0 + if ( n > 1 && KMP_DIFF_MODE & KDMD_SORT ) + qsort( res, n, sizeof(*res), (qsort_func)compare_sort_stgi ); + #endif + return res; +} + +//----------------------------------------------------------------------------- + +static inline void print_stgi + ( char mode, const kmp_stgi_entry_t *e1, const kmp_stgi_entry_t *e2 ) +{ + if ( e2 && colout->colorize ) + { + ccp ok = colout->COL_OK; + ccp warn = colout->COL_WARN; + + printf("%c %s%5u %s%4u %s%5u %s%5u %s%#10x %s0x%02x %s%#5x %s%#6x", + mode, + OK_WARN1(e1,e2,lap_count), + OK_WARN1(e1,e2,pole_pos), + OK_WARN1(e1,e2,narrow_start), + OK_WARN1(e1,e2,enable_lens_flare), + OK_WARN1(e1,e2,flare_color), + OK_WARN1(e1,e2,flare_alpha), + OK_WARN1(e1,e2,unknown_09), + OK_WARN1(e1,e2,speed_mod) ); + + if (e1->speed_mod) + printf(" (%5.3f)",SpeedMod2float(e1->speed_mod)); + printf("%s\n",colout->reset); + } + else + { + printf("%c %5u %4u %5u %5u %#10x 0x%02x %#5x %#6x", + mode, + e1->lap_count, e1->pole_pos, + e1->narrow_start, e1->enable_lens_flare, + e1->flare_color, + e1->flare_alpha, e1->unknown_09, + e1->speed_mod ); + if (e1->speed_mod) + printf(" (%5.3f)\n",SpeedMod2float(e1->speed_mod)); + else + putchar('\n'); + } +} + +//----------------------------------------------------------------------------- + +static sort_stgi_t * print_stgi_single + ( char mode, const sort_stgi_t *e, sort_stgi_t *end ) +{ + DASSERT(e); + DASSERT(end); + + while ( e < end ) + { + printf("%sSTGI: Only found in source %c @%u%s\n", + mode == '<' ? colout->COL_SRC1 : colout->COL_SRC2, + mode == '<' ? '1' : '2', e->rank, + colout->reset ); + print_stgi(mode,&e->data,0); + e++; + } + return (sort_stgi_t*)e; +} + +//----------------------------------------------------------------------------- + +static int diff_stgi ( const sort_stgi_t *e1, const sort_stgi_t *e2 ) +{ + if (!memcmp(&e1->data,&e2->data,sizeof(e1->data))) + return 0; + + return ( e1->data.lap_count != e2->data.lap_count ) + + ( e1->data.pole_pos != e2->data.pole_pos ) + + ( e1->data.narrow_start != e2->data.narrow_start ) + + ( e1->data.enable_lens_flare != e2->data.enable_lens_flare ) + + ( e1->data.flare_color != e2->data.flare_color ) + + ( e1->data.flare_alpha != e2->data.flare_alpha ) + + ( e1->data.unknown_09 != e2->data.unknown_09 ) + + ( e1->data.speed_mod != e2->data.speed_mod ); +} + +//----------------------------------------------------------------------------- + +static uint diff_KMP_STGI +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + + uint diff_count = 0; + List_t *l1 = kmp1->dlist + KMP_STGI; + List_t *l2 = kmp2->dlist + KMP_STGI; + + if ( l1->used != l2->used ) + { + if (!verbose) + return 1; + printf("%sSTGI: Number of stage info records differ: Have %u and %u.%s\n", + colout->COL_WARN, l1->used, l2->used, colout->reset ); + if (verbose==1) + return 1; + diff_count++; + } + + sort_stgi_t *s1 = sort_stgi(l1), *e1 = s1, *end1 = e1 + l1->used; + sort_stgi_t *s2 = sort_stgi(l2), *e2 = s2, *end2 = e2 + l2->used; + uint order_differ = 0; + + while ( e1 < end1 && e2 < end2 ) + { + const int stat = diff_stgi(e1,e2); + if (stat) + { + if ( verbose < 2 ) + { + if (verbose) + printf("%sSTGI: Data differ%s\n", + colout->COL_DIFF, colout->reset ); + return 1; + } + + const int trigger = 2; + if ( stat >= trigger ) + { + //--- try to sync + + int dist1 = 99999; + sort_stgi_t *p1; + for ( p1 = e1+1; p1 < end1; p1++ ) + if ( diff_stgi(p1,e2) < trigger ) + { + dist1 = p1 - e1; + break; + } + + int dist2 = 99999; + sort_stgi_t *p2; + for ( p2 = e2+1; p2 < end2; p2++ ) + if ( diff_stgi(p2,e1) < trigger ) + { + dist2 = p2 - e2; + break; + } + + PRINT0("DIST: %d %d\n",dist1,dist2); + + if ( dist1 < 99999 && dist1 < dist2 ) + { + e1 = print_stgi_single('<',e1,e1+1); + diff_count++; + continue; + } + else if ( dist2 < 99999 && dist2 < dist1 ) + { + e2 = print_stgi_single('>',e2,e2+1); + diff_count++; + continue; + } + } + + //--- print data + + printf("%sSTGI: Stage info records @%u:%u differ%s\n", + colout->COL_DIFF, e1->rank,e2->rank, + colout->reset ); + print_stgi('<',&e1->data,&e2->data); + print_stgi('>',&e2->data,&e1->data); + diff_count++; + } + + if ( e1->rank != e2->rank ) + order_differ++; + + e1++; + e2++; + } + + if ( e1 < end1 ) + { + print_stgi_single('<',e1,end1); + diff_count++; + } + + if ( e2 < end2 ) + { + print_stgi_single('>',e2,end2); + diff_count++; + } + + if (order_differ) + { + if (verbose) + printf("%sSTGI: Order of stage info records differ%s\n", + colout->COL_DIFF, colout->reset ); + if ( verbose < 2 ) + return 1; + diff_count++; + } + + FREE(s1); + FREE(s2); + return diff_count; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// DiffKMP() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError DiffKMP +( + kmp_t * kmp1, // first kmp to compare + kmp_t * kmp2, // second kmp tp compare + uint verbose // 0:quiet, 1:summary only, 2:full report +) +{ + DASSERT(kmp1); + DASSERT(kmp2); + PRINT("DiffKMP( %s, %s, verbose=%d )\n",kmp1->fname,kmp2->fname,verbose); + + //--- compare sections + + enumError diff_count = 0; + + if ( KMP_DIFF_MODE & KDMD_AREA && ( verbose || !diff_count )) + diff_count += diff_KMP_AREA(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_CAME && ( verbose || !diff_count )) + diff_count += diff_KMP_CAME(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_CKPH && ( verbose || !diff_count )) + diff_count += diff_KMP_CKPH(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_CKPT && ( verbose || !diff_count )) + diff_count += diff_KMP_CKPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_CNPT && ( verbose || !diff_count )) + diff_count += diff_KMP_CNPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_ENPH && ( verbose || !diff_count )) + diff_count += diff_KMP_ENPH(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_ENPT && ( verbose || !diff_count )) + diff_count += diff_KMP_ENPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_GOBJ && ( verbose || !diff_count )) + diff_count += diff_KMP_GOBJ(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_ITPH && ( verbose || !diff_count )) + diff_count += diff_KMP_ITPH(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_ITPT && ( verbose || !diff_count )) + diff_count += diff_KMP_ITPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_JGPT && ( verbose || !diff_count )) + diff_count += diff_KMP_JGPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_KTPT && ( verbose || !diff_count )) + diff_count += diff_KMP_KTPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_MSPT && ( verbose || !diff_count )) + diff_count += diff_KMP_MSPT(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_POTI && ( verbose || !diff_count )) + diff_count += diff_KMP_POTI(kmp1,kmp2,verbose); + + if ( KMP_DIFF_MODE & KDMD_STGI && ( verbose || !diff_count )) + diff_count += diff_KMP_STGI(kmp1,kmp2,verbose); + + return diff_count ? ERR_DIFFER : ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// END /////////////// +/////////////////////////////////////////////////////////////////////////////// |