void printTree(int individual_count, int family_count, Individual *individuals,
Family *families, char *INDI)
{
int i;
Family family, *family_ptr;
Individual key, *individual_ptr;
find_children(individual_count, family_count, individuals, families, INDI);
key.INDI = INDI;
individual_ptr = bsearch(&key, individuals, individual_count,
sizeof(Individual), individual_cmp);
if (individual_ptr == NULL)
return;
family.FAM = individual_ptr ->FAMS;
if (family.FAM)// if FAM in family isn't empty
{
family_ptr = bsearch(&family, families, family_count, sizeof(Family),
family_cmp);
if (family_ptr) // if family_ptr is found
for (i = 0; i < family_ptr->chil_count; i++)
printTree(individual_count, family_count, individuals, families, family_ptr -> CHILs[i]);
// call printTree and print out their children for their children
}// if
}//printTree()
/* entry point of the program */
int main(int argc, char *argv[]) {
struct Individual *individuals = NULL;
struct Family *families = NULL;
/* two ints to hold the sizes of the two sets of parallel arrays */
int indi_count = 0;
int fam_count = 0;
/* and a FILE */
FILE *fp = NULL;
/* there should only be 2 arguments */
if(argc != 2) {
printf("Usage: family.out <ged_filename>\n");
return 1;
}
fp = count_records(argv[1], &indi_count, &fam_count);
initialize(indi_count, fam_count, &individuals, &families);
read_file(fp, individuals, families);
/* sort individuals and families qsort functions */
qsort(individuals, indi_count, sizeof(struct Individual), individual_cmp);
qsort(families, fam_count, sizeof(struct Family), family_cmp);
find_children(indi_count, fam_count, individuals, families);
deallocate(indi_count, fam_count, individuals, families);
return 0;
}
int main(int argc, char **argv)
{
Individual *individuals;
Family *families;
int individual_count, family_count;
FILE *fp;
if(argc != 2)
{
printf("Usage: family.out <ged_filename>\n");
return 1;
} // if the number of arguments is wrong
fp = count_records(argv[1], &individual_count, &family_count);
initialize(&individuals, &families, individual_count, family_count);
read_file(individuals, families, fp);
qsort(individuals, 4, sizeof(Individual), individual_cmp);
qsort(families, 4, sizeof(Family), family_cmp);
find_children(individuals, families, individual_count, family_count);
deallocate(individuals, families, individual_count, family_count);
return 0;
} // main()
void BvcEncoder::encode_sbc(const u_int8_t* p)
{
#ifdef notyet
u_int bb = bb_;
int nbb = nbb_;
#endif
u_char stack[3*64];
u_char* sp = stack;
u_char children[64];
u_char grandchildren[64];
smquant((u_int8_t*)p, qs_);
find_children(p, children);
find_grandchildren(children, grandchildren);
/*XXX dpcm & entropy */
PUT_BITS(p[0], 8, nbb_, bb_, bs_);
b.dc += 8;
int active = prune_layers(0x7f, children[0]);
if (active == 0)
return;
int ga = prune_layers(active, grandchildren[0]);
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = 9;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = 8;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = 1;
do {
int k = *--sp;
int active = *--sp;
encode_coef(p[k], active & 0x7f);
if (active & 0x80) {
active = *--sp;
if (active & 0x80)
abort();
if (active == 0)
continue;
active = prune_layers(active, children[k]);
if (active == 0)
continue;
k = child[k];
if (k < 64) {
*sp++ = active;
*sp++ = k + 9;
*sp++ = active;
*sp++ = k + 8;
*sp++ = active;
*sp++ = k + 1;
*sp++ = active;
*sp++ = k;
} else {
#ifndef HAVE_HH
if (k >= 192)
k -= 156;
#endif
encode_coef(p[k], active);
encode_coef(p[k + 1], active);
encode_coef(p[k + 8], active);
encode_coef(p[k + 9], active);
}
} else {
active = prune_layers(active, children[k]);
if (active == 0)
continue;
int c = child[k];
if (c < 64) {
int ga = prune_layers(active, grandchildren[k]);
k = c;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = k + 9;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = k + 8;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = k + 1;
*sp++ = ga;
*sp++ = active|0x80;
*sp++ = k;
} else {
k = c;
#ifndef HAVE_HH
if (k >= 192)
k -= 156;
#endif
encode_coef(p[k], active);
encode_coef(p[k + 1], active);
encode_coef(p[k + 8], active);
encode_coef(p[k + 9], active);
}
}
} while (sp > stack);
#ifdef notyet
bb_ = bb;
nbb_ = nbb;
#endif
}
