/** * R T _ B I N U N I F _ F R E E * * Free the storage associated with a binunif_internal object */ void rt_binunif_free( struct rt_binunif_internal *bip) { RT_CK_BINUNIF(bip); bu_free( (genptr_t) bip->u.uint8, "binunif free uint8" ); bu_free( bip, "binunif free"); bip = GENPTR_NULL; /* sanity */ }
/** * R T _ B I N U N I F _ D U M P * * Diagnostic routine */ void rt_binunif_dump( struct rt_binunif_internal *bip) { RT_CK_BINUNIF(bip); bu_log("rt_bin_unif_internal <%x>...\n", bip); bu_log(" type = x%x = %d", bip -> type, bip -> type); bu_log(" count = %ld first = 0x%02x", bip -> count, bip->u.uint8[0] & 0x0ff); bu_log("- - - - -\n"); }
/** * R T _ B I N U N I F _ I F R E E * * Free the storage associated with the rt_db_internal version of this * thing. */ void rt_binunif_ifree( struct rt_db_internal *ip ) { struct rt_binunif_internal *bip; RT_CK_DB_INTERNAL(ip); bip = (struct rt_binunif_internal *)ip->idb_ptr; RT_CK_BINUNIF(bip); bu_free( (genptr_t) bip->u.uint8, "binunif ifree" ); bu_free( ip->idb_ptr, "binunif ifree" ); ip->idb_ptr = GENPTR_NULL; }
/** * R T _ B I N U N I F _ D E S C R I B E * * Make human-readable formatted presentation of this object. First * line describes type of object. Additional lines are indented one * tab, and give parameter values. */ int rt_binunif_describe( struct bu_vls *str, const struct rt_db_internal *ip, int verbose, double mm2local ) { register struct rt_binunif_internal *bip; char buf[256]; unsigned short wid; bip = (struct rt_binunif_internal *) ip->idb_ptr; RT_CK_BINUNIF(bip); bu_vls_strcat( str, "uniform-array binary object (BINUNIF)\n"); wid = (bip->type & DB5_MINORTYPE_BINU_WID_MASK) >> 4; switch (wid) { case 0: sprintf( buf, "%ld ", bip->count ); break; case 1: sprintf( buf, "%ld pairs of ", bip->count / 2 ); break; case 2: sprintf( buf, "%ld triples of ", bip->count / 3 ); break; case 3: sprintf( buf, "%ld quadruples of ", bip->count / 4 ); break; } bu_vls_strcat( str, buf ); switch (bip->type & DB5_MINORTYPE_BINU_ATM_MASK) { case DB5_MINORTYPE_BINU_FLOAT: bu_vls_strcat( str, "floats\n"); break; case DB5_MINORTYPE_BINU_DOUBLE: bu_vls_strcat( str, "doubles\n"); break; case DB5_MINORTYPE_BINU_8BITINT: bu_vls_strcat( str, "8-bit ints\n"); break; case DB5_MINORTYPE_BINU_16BITINT: bu_vls_strcat( str, "16-bit ints\n"); break; case DB5_MINORTYPE_BINU_32BITINT: bu_vls_strcat( str, "32-bit ints\n"); break; case DB5_MINORTYPE_BINU_64BITINT: bu_vls_strcat( str, "64-bit ints\n"); break; case DB5_MINORTYPE_BINU_8BITINT_U: bu_vls_strcat( str, "unsigned 8-bit ints\n"); break; case DB5_MINORTYPE_BINU_16BITINT_U: bu_vls_strcat( str, "unsigned 16-bit ints\n"); break; case DB5_MINORTYPE_BINU_32BITINT_U: bu_vls_strcat( str, "unsigned 32-bit ints\n"); break; case DB5_MINORTYPE_BINU_64BITINT_U: bu_vls_strcat( str, "unsigned 64-bit ints\n"); break; default: bu_log("%s:%d: This shouldn't happen", __FILE__, __LINE__); return(1); } return(0); }
/* * This is a helper routine used in txt_setup() to load a texture either from * a file or from a db object. The resources are released in txt_free() * (there is no specific unload_datasource function). */ HIDDEN int txt_load_datasource(struct txt_specific *texture, struct db_i *dbInstance, const unsigned long int size) { struct directory *dirEntry; RT_CK_DBI(dbInstance); if (texture == (struct txt_specific *)NULL) { bu_bomb("ERROR: txt_load_datasource() received NULL arg (struct txt_specific *)\n"); } bu_log("Loading texture %s [%s]...", texture->tx_datasrc==TXT_SRC_AUTO?"from auto-determined datasource":texture->tx_datasrc==TXT_SRC_OBJECT?"from a database object":texture->tx_datasrc==TXT_SRC_FILE?"from a file":"from an unknown source (ERROR)", bu_vls_addr(&texture->tx_name)); /* if the source is auto or object, we try to load the object */ if ((texture->tx_datasrc==TXT_SRC_AUTO) || (texture->tx_datasrc==TXT_SRC_OBJECT)) { /* see if the object exists */ if ((dirEntry=db_lookup(dbInstance, bu_vls_addr(&texture->tx_name), LOOKUP_QUIET)) == RT_DIR_NULL) { /* unable to find the texture object */ if (texture->tx_datasrc!=TXT_SRC_AUTO) { return -1; } } else { struct rt_db_internal *dbip; BU_ALLOC(dbip, struct rt_db_internal); RT_DB_INTERNAL_INIT(dbip); RT_CK_DB_INTERNAL(dbip); RT_CK_DIR(dirEntry); /* the object was in the directory, so go get it */ if (rt_db_get_internal(dbip, dirEntry, dbInstance, NULL, NULL) <= 0) { /* unable to load/create the texture database record object */ return -1; } RT_CK_DB_INTERNAL(dbip); RT_CK_BINUNIF(dbip->idb_ptr); /* keep the binary object pointer */ texture->tx_binunifp=(struct rt_binunif_internal *)dbip->idb_ptr; /* make it so */ /* release the database instance pointer struct we created */ RT_DB_INTERNAL_INIT(dbip); bu_free(dbip, "txt_load_datasource"); /* check size of object */ if (texture->tx_binunifp->count < size) { bu_log("\nWARNING: %s needs %d bytes, binary object only has %lu\n", bu_vls_addr(&texture->tx_name), size, texture->tx_binunifp->count); } else if (texture->tx_binunifp->count > size) { bu_log("\nWARNING: Binary object is larger than specified texture size\n\tBinary Object: %zu pixels\n\tSpecified Texture Size: %zu pixels\n...continuing to load using image subsection...", texture->tx_binunifp->count); } } } /* if we are auto and we couldn't find a database object match, or if source * is explicitly a file then we load the file. */ if (((texture->tx_datasrc==TXT_SRC_AUTO) && (texture->tx_binunifp==NULL)) || (texture->tx_datasrc==TXT_SRC_FILE)) { texture->tx_mp = bu_open_mapped_file_with_path(dbInstance->dbi_filepath, bu_vls_addr(&texture->tx_name), NULL); if (texture->tx_mp==NULL) return -1; /* FAIL */ if (texture->tx_mp->buflen < size) { bu_log("\nWARNING: %s needs %d bytes, file only has %lu\n", bu_vls_addr(&texture->tx_name), size, texture->tx_mp->buflen); } else if (texture->tx_mp->buflen > size) { bu_log("\nWARNING: Texture file size is larger than specified texture size\n\tInput File: %zu pixels\n\tSpecified Texture Size: %lu pixels\n...continuing to load using image subsection...", texture->tx_mp->buflen, size); } } bu_log("done.\n"); return 0; }
int rt_retrieve_binunif(struct rt_db_internal *intern, struct db_i *dbip, char *name) { register struct directory *dp; struct rt_binunif_internal *bip; struct bu_external ext; struct db5_raw_internal raw; char *tmp; /* *Find the guy we're told to write */ if ( (dp = db_lookup( dbip, name, LOOKUP_NOISY)) == DIR_NULL ) return -1; RT_INIT_DB_INTERNAL(intern); if ( rt_db_get_internal5( intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) return -1; if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); return -1; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("get_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); if (raw.major_type != DB5_MAJORTYPE_BINARY_UNIF) return -1; bip = intern->idb_ptr; RT_CK_BINUNIF(bip); if (RT_G_DEBUG & DEBUG_HF) rt_binunif_dump(bip); if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); break; case DB5_MINORTYPE_BINU_8BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); break; case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bituint"); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } bu_free_external( &ext ); return 0; }
/** * R T _ B I N U N I F _ E X P O R T 5 * * Create the "body" portion of external form */ int rt_binunif_export5( struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, /* we ignore */ const struct db_i *dbip, struct resource *resp, const int minor_type ) { struct rt_binunif_internal *bip; int i; unsigned char *destp; unsigned long *lsrcp; int in_cookie, out_cookie; int gotten; RT_CK_DB_INTERNAL(ip); if ( ip->idb_minor_type != minor_type ) { bu_log("ip->idb_minor_type(%d) != minor_type(%d)\n", ip->idb_minor_type, minor_type ); return -1; } bip = (struct rt_binunif_internal *)ip->idb_ptr; RT_CK_BINUNIF(bip); if ( bip->type != minor_type ) { bu_log("bip->type(%d) != minor_type(%d)\n", bip->type, minor_type ); return -1; } BU_INIT_EXTERNAL(ep); /* * Convert from internal (host) to database (network) format */ switch (bip->type) { case DB5_MINORTYPE_BINU_FLOAT: ep->ext_nbytes = bip->count * SIZEOF_NETWORK_FLOAT; ep->ext_buf = (genptr_t)bu_malloc( ep->ext_nbytes, "binunif external"); htonf( ep->ext_buf, (unsigned char *) bip->u.uint8, bip->count ); break; case DB5_MINORTYPE_BINU_DOUBLE: ep->ext_nbytes = bip->count * SIZEOF_NETWORK_DOUBLE; ep->ext_buf = (genptr_t)bu_malloc( ep->ext_nbytes, "binunif external"); htond( ep->ext_buf, (unsigned char *) bip->u.uint8, bip->count ); break; case DB5_MINORTYPE_BINU_8BITINT: case DB5_MINORTYPE_BINU_8BITINT_U: ep->ext_nbytes = bip->count; ep->ext_buf = (genptr_t)bu_malloc( ep->ext_nbytes, "binunif external"); memcpy((char *) ep->ext_buf, (char *) bip->u.uint8, bip->count); break; case DB5_MINORTYPE_BINU_16BITINT: case DB5_MINORTYPE_BINU_16BITINT_U: ep->ext_nbytes = bip->count * 2; ep->ext_buf = (genptr_t)bu_malloc( ep->ext_nbytes, "binunif external"); in_cookie = bu_cv_cookie("hus"); out_cookie = bu_cv_cookie("nus"); if (bu_cv_optimize(in_cookie) != bu_cv_optimize(out_cookie)) { gotten = bu_cv_w_cookie(ep->ext_buf, out_cookie, ep->ext_nbytes, (genptr_t) bip->u.uint8, in_cookie, bip->count); if (gotten != bip->count) { bu_log("%s:%d: Tried to convert %d, did %d", __FILE__, __LINE__, bip->count, gotten); bu_bomb("\n"); } } else { memcpy((char *) ep->ext_buf, (char *) bip->u.uint8, ep->ext_nbytes ); } break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: ep->ext_nbytes = bip->count * 4; ep->ext_buf = (genptr_t)bu_malloc( ep->ext_nbytes, "binunif external"); lsrcp = (unsigned long *) bip->u.uint8; destp = (unsigned char *) ep->ext_buf; for (i = 0; i < bip->count; ++i, ++destp, ++lsrcp) { (void) bu_plong( destp, *lsrcp ); } break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: bu_log("rt_binunif_export5() Can't handle 64-bit integers yet\n"); return -1; } return 0; }
/* * C M D _ E X P O R T _ B O D Y ( ) * * Write an object's body to disk file * */ int cmd_export_body(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { register struct directory *dp; int fd; void *bufp; size_t nbytes = 0; long int written; struct bu_external ext; struct db5_raw_internal raw; struct rt_db_internal intern; struct rt_binunif_internal *bip; struct bu_vls vls; #if 0 int status; #endif char *tmp; CHECK_DBI_NULL; if (argc != 3) { bu_vls_init(&vls); bu_vls_printf(&vls, "help %s", argv[0]); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } /* * Find the guy we're told to write */ if ( (dp = db_lookup( dbip, argv[2], LOOKUP_NOISY)) == DIR_NULL ) { bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot find object %s for writing\n", argv[2] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } RT_INIT_DB_INTERNAL(&intern); if ( rt_db_get_internal5( &intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_free_external( &ext ); (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } /* * Do the writing */ #ifndef _WIN32 if ( (fd = creat( argv[1], S_IRWXU | S_IRGRP | S_IROTH )) == -1 ) { #else if ( (fd = creat( argv[1], _S_IREAD | _S_IWRITE )) == -1 ) { #endif bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot open file %s for writing\n", argv[1] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); switch (raw.major_type) { case DB5_MAJORTYPE_BINARY_UNIF: #if 0 if ( rt_binunif_import5( &intern, &ext, 0, dbip, &rt_uniresource, raw.minor_type ) ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } #endif bip = (struct rt_binunif_internal *) intern.idb_ptr; RT_CK_BINUNIF(bip); rt_binunif_dump(bip); bufp = (void *) bip->u.uint8; bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); nbytes = (size_t) (bip->count * sizeof(float)); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); nbytes = (size_t) (bip->count * sizeof(double)); break; case DB5_MINORTYPE_BINU_8BITINT: case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); nbytes = (size_t) (bip->count); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); nbytes = (size_t) (bip->count * 4); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); nbytes = (size_t) (bip->count * 8); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } break; default: if (RT_G_DEBUG & DEBUG_VOL) bu_log("I'm in the default\n"); bufp = (void *) ext.ext_buf; nbytes = (size_t) ext.ext_nbytes; break; } if (RT_G_DEBUG & DEBUG_VOL) bu_log("going to write %ld bytes\n", nbytes); if ( (written = write(fd, bufp, nbytes) ) != nbytes ) { perror(argv[1]); bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Incomplete write of object %s to file %s, got %ld, s/b=%ld\n", argv[2], argv[1], written, nbytes ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } bu_free_external( &ext ); return TCL_OK; }