/*-------------------------------------------------------------------------
* Function: h5repack_addfilter
*
* Purpose: add a compression -f option to table
* Example: -f dset:GZIP=6
*
* Return: 0, ok, -1, fail
*
*-------------------------------------------------------------------------
*/
int h5repack_addfilter(const char* str,
pack_opt_t *options)
{
obj_list_t *obj_list=NULL; /* one object list for the -f and -l option entry */
filter_info_t filter; /* filter info for the current -f option entry */
int n_objs; /* number of objects in the current -f or -l option entry */
int is_glb; /* is the filter global */
/* parse the -f option */
if(NULL == (obj_list = parse_filter(str, &n_objs, &filter, options, &is_glb)))
return -1;
/* if it applies to all objects */
if(is_glb)
{
int n;
n = options->n_filter_g++; /* increase # of global filters */
if(options->n_filter_g > H5_REPACK_MAX_NFILTERS)
{
error_msg(h5tools_getprogname(), "maximum number of filters exceeded for <%s>\n", str);
free(obj_list);
return -1;
}
options->filter_g[n] = filter;
}
else
options_add_filter(obj_list, n_objs, filter, options->op_tbl);
free(obj_list);
return 0;
}
void parse_command_line(int argc,
const char* argv[],
const char** fname1,
const char** fname2,
const char** objname1,
const char** objname2,
diff_opt_t* options)
{
int i;
int opt;
struct exclude_path_list *exclude_head, *exclude_prev, *exclude_node;
/* process the command-line */
memset(options, 0, sizeof (diff_opt_t));
/* assume equal contents initially */
options->contents = 1;
/* NaNs are handled by default */
options->do_nans = 1;
/* init for exclude-path option */
exclude_head = NULL;
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF)
{
switch ((char)opt)
{
default:
usage();
h5diff_exit(EXIT_FAILURE);
case 'h':
usage();
h5diff_exit(EXIT_SUCCESS);
case 'V':
print_version(h5tools_getprogname());
h5diff_exit(EXIT_SUCCESS);
case 'v':
options->m_verbose = 1;
/* This for loop is for handling style like
* -v, -v1, --verbose, --verbose=1.
*/
for (i = 1; i < argc; i++)
{
/*
* short opt
*/
if (!strcmp (argv[i], "-v")) /* no arg */
{
opt_ind--;
options->m_verbose_level = 0;
break;
}
else if (!strncmp (argv[i], "-v", (size_t)2))
{
options->m_verbose_level = atoi(&argv[i][2]);
break;
}
/*
* long opt
*/
if (!strcmp (argv[i], "--verbose")) /* no arg */
{
options->m_verbose_level = 0;
break;
}
else if ( !strncmp (argv[i], "--verbose", (size_t)9) && argv[i][9]=='=')
{
options->m_verbose_level = atoi(&argv[i][10]);
break;
}
}
break;
case 'q':
/* use quiet mode; supress the message "0 differences found" */
options->m_quiet = 1;
break;
case 'r':
options->m_report = 1;
break;
case 'l':
options->follow_links = TRUE;
break;
case 'x':
options->no_dangle_links = 1;
break;
case 'E':
options->exclude_path = 1;
/* create linked list of excluding objects */
if( (exclude_node = (struct exclude_path_list*) HDmalloc(sizeof(struct exclude_path_list))) == NULL)
{
printf("Error: lack of memory!\n");
h5diff_exit(EXIT_FAILURE);
}
/* init */
exclude_node->obj_path = (char*)opt_arg;
exclude_node->obj_type = H5TRAV_TYPE_UNKNOWN;
exclude_prev = exclude_head;
if (NULL == exclude_head)
{
exclude_head = exclude_node;
exclude_head->next = NULL;
}
else
{
while(NULL != exclude_prev->next)
exclude_prev=exclude_prev->next;
exclude_node->next = NULL;
exclude_prev->next = exclude_node;
}
break;
case 'd':
options->d=1;
if ( check_d_input( opt_arg )==-1)
{
printf("<-d %s> is not a valid option\n", opt_arg );
usage();
h5diff_exit(EXIT_FAILURE);
}
options->delta = atof( opt_arg );
/* -d 0 is the same as default */
if (options->delta == 0)
options->d=0;
break;
case 'p':
options->p=1;
if ( check_p_input( opt_arg )==-1)
{
printf("<-p %s> is not a valid option\n", opt_arg );
usage();
h5diff_exit(EXIT_FAILURE);
}
options->percent = atof( opt_arg );
/* -p 0 is the same as default */
if (options->percent == 0)
options->p = 0;
break;
case 'n':
options->n=1;
if ( check_n_input( opt_arg )==-1)
{
printf("<-n %s> is not a valid option\n", opt_arg );
usage();
h5diff_exit(EXIT_FAILURE);
}
options->count = atol( opt_arg );
break;
case 'N':
options->do_nans = 0;
break;
case 'c':
options->m_list_not_cmp = 1;
break;
case 'e':
options->use_system_epsilon = 1;
break;
}
}
/* check options */
check_options(options);
/* if exclude-path option is used, keep the exclude path list */
if (options->exclude_path)
options->exclude = exclude_head;
/* check for file names to be processed */
if (argc <= opt_ind || argv[ opt_ind + 1 ] == NULL)
{
error_msg("missing file names\n");
usage();
h5diff_exit(EXIT_FAILURE);
}
*fname1 = argv[ opt_ind ];
*fname2 = argv[ opt_ind + 1 ];
*objname1 = argv[ opt_ind + 2 ];
if ( *objname1 == NULL )
{
*objname2 = NULL;
return;
}
if ( argv[ opt_ind + 3 ] != NULL)
{
*objname2 = argv[ opt_ind + 3 ];
}
else
{
*objname2 = *objname1;
}
}
/*-------------------------------------------------------------------------
* Function: parse_command_line
*
* Purpose: Parse the command line for the h5dumper.
*
* Return: Success: EXIT_SUCCESS;
*
* Failure: Exits function with EXIT_FAILURE value.
*
*-------------------------------------------------------------------------
*/
static int
parse_command_line(int argc, const char *argv[])
{
int opt = FALSE;
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
switch((char)opt) {
case 'o':
output_file = HDstrdup(opt_arg);
if (output_file)
h5tools_set_data_output_file(output_file, 1);
break;
case 'i':
input_file = HDstrdup(opt_arg);
if (input_file)
h5tools_set_input_file(input_file, 1);
break;;
case 'u':
ub_file = HDstrdup(opt_arg);
if (ub_file)
h5tools_set_output_file(ub_file, 1);
else
rawoutstream = stdout;
break;
case 'd':
do_delete = TRUE;
break;
case 'h':
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
goto done;
case 'V':
print_version (h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
goto done;
case '?':
default:
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
}
return EXIT_SUCCESS;
done:
if(input_file)
HDfree(input_file);
if(output_file)
HDfree(output_file);
if(ub_file)
HDfree(ub_file);
return EXIT_FAILURE;
}
int
main (int argc, const char *argv[])
{
int fd;
unsigned int size;
char *filename;
long res;
char *buf;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
parse_command_line (argc, argv);
if (nbytes == NULL)
{
/* missing arg */
error_msg("missing size\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
if (argc <= (opt_ind))
{
error_msg("missing file name\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
filename = HDstrdup (argv[opt_ind]);
size = 0;
res = sscanf (nbytes, "%u", &size);
if (res == EOF)
{
/* fail */
error_msg("missing file name\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
fd = HDopen (filename, O_RDONLY, 0);
if (fd < 0)
{
error_msg("can't open file %s\n", filename);
exit (EXIT_FAILURE);
}
buf = (char *)HDmalloc ((unsigned)(size + 1));
if (buf == NULL)
{
HDclose (fd);
exit (EXIT_FAILURE);
}
res = HDread (fd, buf, (unsigned)size);
if (res < (long)size)
{
if (buf)
HDfree (buf);
HDclose (fd);
exit (EXIT_FAILURE);
}
HDwrite (1, buf, (unsigned)size);
if (buf)
HDfree (buf);
HDclose (fd);
return (EXIT_SUCCESS);
}
static
int parse_command_line(int argc, const char **argv, pack_opt_t* options) {
int opt;
int ret_value = 0;
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
switch ((char) opt) {
/* -i for backward compability */
case 'i':
infile = opt_arg;
has_i_o = 1;
break;
/* -o for backward compability */
case 'o':
outfile = opt_arg;
has_i_o = 1;
break;
case 'h':
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
ret_value = -1;
goto done;
case 'V':
print_version(h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
ret_value = -1;
goto done;
case 'v':
options->verbose = 1;
break;
case 'f':
/* parse the -f filter option */
if (h5repack_addfilter(opt_arg, options) < 0) {
error_msg("in parsing filter\n");
h5tools_setstatus(EXIT_FAILURE);
ret_value = -1;
goto done;
}
break;
case 'l':
/* parse the -l layout option */
if (h5repack_addlayout(opt_arg, options) < 0) {
error_msg("in parsing layout\n");
h5tools_setstatus(EXIT_FAILURE);
ret_value = -1;
goto done;
}
break;
case 'm':
options->min_comp = HDatoi( opt_arg );
if ((int) options->min_comp <= 0) {
error_msg("invalid minimum compress size <%s>\n", opt_arg);
h5tools_setstatus(EXIT_FAILURE);
ret_value = -1;
goto done;
}
break;
case 'e':
ret_value = read_info(opt_arg, options);
if (ret_value < 0)
goto done;
break;
case 'n':
options->use_native = 1;
break;
case 'L':
options->latest = 1;
break;
case 'c':
options->grp_compact = HDatoi( opt_arg );
if (options->grp_compact > 0)
options->latest = 1; /* must use latest format */
break;
case 'd':
options->grp_indexed = HDatoi( opt_arg );
if (options->grp_indexed > 0)
options->latest = 1; /* must use latest format */
break;
case 's':
{
int idx = 0;
int ssize = 0;
char *msgPtr = HDstrchr( opt_arg, ':');
options->latest = 1; /* must use latest format */
if (msgPtr == NULL) {
ssize = HDatoi( opt_arg );
for (idx = 0; idx < 5; idx++)
options->msg_size[idx] = ssize;
}
else {
char msgType[10];
HDstrcpy(msgType, msgPtr + 1);
msgPtr[0] = '\0';
ssize = HDatoi( opt_arg );
if (HDstrncmp(msgType, "dspace",6) == 0) {
options->msg_size[0] = ssize;
}
else if (HDstrncmp(msgType, "dtype", 5) == 0) {
options->msg_size[1] = ssize;
}
else if (HDstrncmp(msgType, "fill", 4) == 0) {
options->msg_size[2] = ssize;
}
else if (HDstrncmp(msgType, "pline", 5) == 0) {
options->msg_size[3] = ssize;
}
else if (HDstrncmp(msgType, "attr", 4) == 0) {
options->msg_size[4] = ssize;
}
}
}
break;
case 'u':
options->ublock_filename = opt_arg;
break;
case 'b':
options->ublock_size = (hsize_t) HDatol( opt_arg );
break;
case 'M':
options->meta_block_size = (hsize_t) HDatol( opt_arg );
break;
case 't':
options->threshold = (hsize_t) HDatol( opt_arg );
break;
case 'a':
options->alignment = HDatol( opt_arg );
if (options->alignment < 1) {
error_msg("invalid alignment size\n", opt_arg);
h5tools_setstatus(EXIT_FAILURE);
ret_value = -1;
goto done;
}
break;
default:
break;
} /* switch */
} /* while */
if (has_i_o == 0) {
/* check for file names to be processed */
if (argc <= opt_ind || argv[opt_ind + 1] == NULL) {
error_msg("missing file names\n");
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_FAILURE);
ret_value = -1;
}
}
done:
return ret_value;
}
int
main (int argc, const char *argv[])
{
hid_t fid_src = -1;
hid_t fid_dst = -1;
unsigned flag = 0;
unsigned verbose = 0;
unsigned parents = 0;
hid_t ocpl_id = (-1); /* Object copy property list */
hid_t lcpl_id = (-1); /* Link creation property list */
int opt;
int li_ret;
h5tool_link_info_t linkinfo;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* initialize h5tools lib */
h5tools_init();
/* init linkinfo struct */
HDmemset(&linkinfo, 0, sizeof(h5tool_link_info_t));
/* Check for no command line parameters */
if(argc == 1)
{
usage();
leave(EXIT_FAILURE);
} /* end if */
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF)
{
switch ((char)opt)
{
case 'd':
oname_dst = HDstrdup(opt_arg);
break;
case 'f':
/* validate flag */
if (parse_flag(opt_arg,&flag)<0)
{
usage();
leave(EXIT_FAILURE);
}
str_flag = HDstrdup(opt_arg);
break;
case 'h':
usage();
leave(EXIT_SUCCESS);
break;
case 'i':
fname_src = HDstrdup(opt_arg);
break;
case 'o':
fname_dst = HDstrdup(opt_arg);
break;
case 'p':
parents = 1;
break;
case 's':
oname_src = HDstrdup(opt_arg);
break;
case 'V':
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
break;
case 'v':
verbose = 1;
break;
default:
usage();
leave(EXIT_FAILURE);
}
} /* end of while */
/*-------------------------------------------------------------------------
* check for missing file/object names
*-------------------------------------------------------------------------*/
if (fname_src==NULL)
{
error_msg("Input file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (fname_dst==NULL)
{
error_msg("Output file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_src==NULL)
{
error_msg("Source object name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_dst==NULL)
{
error_msg("Destination object name missing\n");
usage();
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* open output file
*-------------------------------------------------------------------------*/
/* Attempt to open an existing HDF5 file first. Need to open the dst file
before the src file just in case that the dst and src are the same file
*/
fid_dst = h5tools_fopen(fname_dst, H5F_ACC_RDWR, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* open input file
*-------------------------------------------------------------------------*/
fid_src = h5tools_fopen(fname_src, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* test for error in opening input file
*-------------------------------------------------------------------------*/
if (fid_src==-1)
{
error_msg("Could not open input file <%s>...Exiting\n", fname_src);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* create an output file when failed to open it
*-------------------------------------------------------------------------*/
/* If we couldn't open an existing file, try creating file */
/* (use "EXCL" instead of "TRUNC", so we don't blow away existing non-HDF5 file) */
if(fid_dst < 0)
fid_dst = H5Fcreate(fname_dst, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
/*-------------------------------------------------------------------------
* test for error in opening output file
*-------------------------------------------------------------------------*/
if (fid_dst==-1)
{
error_msg("Could not open output file <%s>...Exiting\n", fname_dst);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* print some info
*-------------------------------------------------------------------------*/
if (verbose)
{
printf("Copying file <%s> and object <%s> to file <%s> and object <%s>\n",
fname_src, oname_src, fname_dst, oname_dst);
if (flag) {
HDassert(str_flag);
printf("Using %s flag\n", str_flag);
}
}
/*-------------------------------------------------------------------------
* create property lists for copy
*-------------------------------------------------------------------------*/
/* create property to pass copy options */
if ( (ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
goto error;
/* set options for object copy */
if (flag)
{
if ( H5Pset_copy_object(ocpl_id, flag) < 0)
goto error;
}
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
goto error;
} /* end if */
/* Check for creating intermediate groups */
if(parents) {
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, 1) < 0) {
error_msg("Could not set property for creating parent groups\n");
goto error;
} /* end if */
/* Display some output if requested */
if(verbose)
printf("%s: Creating parent groups\n", h5tools_getprogname());
} /* end if */
else /* error, if parent groups doesn't already exist in destination file */
{
size_t i, len;
len = HDstrlen(oname_dst);
/* check if all the parents groups exist. skip root group */
for (i = 1; i < len; i++)
{
if ('/'==oname_dst[i])
{
char *str_ptr;
str_ptr = (char *)HDcalloc(i + 1, sizeof(char));
HDstrncpy(str_ptr, oname_dst, i);
str_ptr[i]='\0';
if (H5Lexists(fid_dst, str_ptr, H5P_DEFAULT) <= 0)
{
error_msg("group <%s> doesn't exist. Use -p to create parent groups.\n", str_ptr);
HDfree(str_ptr);
goto error;
}
HDfree(str_ptr);
}
}
}
/*-------------------------------------------------------------------------
* do the copy
*-------------------------------------------------------------------------*/
if(verbose)
linkinfo.opt.msg_mode = 1;
li_ret = H5tools_get_symlink_info(fid_src, oname_src, &linkinfo, 1);
if (li_ret == 0) /* dangling link */
{
if(H5Lcopy(fid_src, oname_src,
fid_dst, oname_dst,
H5P_DEFAULT, H5P_DEFAULT) < 0)
goto error;
}
else /* valid link */
{
if (H5Ocopy(fid_src, /* Source file or group identifier */
oname_src, /* Name of the source object to be copied */
fid_dst, /* Destination file or group identifier */
oname_dst, /* Name of the destination object */
ocpl_id, /* Object copy property list */
lcpl_id)<0) /* Link creation property list */
goto error;
}
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
/* close propertis */
if(H5Pclose(ocpl_id)<0)
goto error;
if(H5Pclose(lcpl_id)<0)
goto error;
/* close files */
if (H5Fclose(fid_src)<0)
goto error;
if (H5Fclose(fid_dst)<0)
goto error;
leave(EXIT_SUCCESS);
error:
printf("Error in copy...Exiting\n");
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
H5E_BEGIN_TRY {
H5Pclose(ocpl_id);
H5Pclose(lcpl_id);
H5Fclose(fid_src);
H5Fclose(fid_dst);
} H5E_END_TRY;
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* Function: parse_command_line
*
* Purpose: Parses command line and sets up global variable to control output
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Elena Pourmal
* Saturday, August 12, 2006
*
*-------------------------------------------------------------------------
*/
static struct handler_t *
parse_command_line(int argc, const char *argv[])
{
int opt, i;
struct handler_t *hand = NULL;
/* Allocate space to hold the command line info */
if((hand = (struct handler_t *)HDcalloc((size_t)argc, sizeof(struct handler_t)))==NULL) {
error_msg("unable to parse command line arguments \n");
goto error;
}
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
switch ((char)opt) {
case 'h':
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
if (hand) {
for (i = 0; i < argc; i++)
if(hand[i].obj) {
free(hand[i].obj);
hand[i].obj=NULL;
}
free(hand);
hand = NULL;
}
goto done;
break;
case 'V':
print_version(h5tools_getprogname());
h5tools_setstatus(EXIT_SUCCESS);
if (hand) {
for (i = 0; i < argc; i++)
if(hand[i].obj) {
free(hand[i].obj);
hand[i].obj=NULL;
}
free(hand);
hand = NULL;
}
goto done;
break;
case 'F':
display_all = FALSE;
display_file_metadata = TRUE;
break;
case 'f':
display_all = FALSE;
display_file = TRUE;
break;
case 'G':
display_all = FALSE;
display_group_metadata = TRUE;
break;
case 'g':
display_all = FALSE;
display_group = TRUE;
break;
case 'D':
display_all = FALSE;
display_dset_metadata = TRUE;
break;
case 'd':
display_all = FALSE;
display_dset = TRUE;
break;
case 'T':
display_all = FALSE;
display_dset_dtype_meta = TRUE;
break;
case 'A':
display_all = FALSE;
display_attr = TRUE;
break;
case 'S':
display_all = FALSE;
display_summary = TRUE;
break;
case 'O':
display_all = FALSE;
display_object = TRUE;
for(i = 0; i < argc; i++)
if(!hand[i].obj) {
hand[i].obj = HDstrdup(opt_arg);
break;
} /* end if */
break;
default:
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_FAILURE);
goto error;
} /* end switch */
} /* end while */
/* check for file name to be processed */
if (argc <= opt_ind) {
error_msg("missing file name\n");
usage(h5tools_getprogname());
h5tools_setstatus(EXIT_FAILURE);
goto error;
} /* end if */
done:
return hand;
error:
if (hand) {
for (i = 0; i < argc; i++)
if(hand[i].obj) {
free(hand[i].obj);
hand[i].obj=NULL;
}
free(hand);
hand = NULL;
}
h5tools_setstatus(EXIT_FAILURE);
return hand;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: h5watch
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Vailin Choi; August 2010
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
char drivername[50];
char *fname = NULL;
char *dname = NULL;
void *edata;
H5E_auto2_t func;
char *x;
hid_t fid = -1;
hid_t fapl = -1;
/* Set up tool name and exit status */
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
/* parse command line options */
parse_command_line(argc, argv);
if(argc <= opt_ind) {
error_msg("missing dataset name\n");
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
/* Mostly copied from tools/h5ls coding & modified accordingly */
/*
* [OBJECT] is specified as
* [<filename>/<path_to_dataset>/<dsetname>]
*
* Example: ../dir1/foo/bar/dset
* \_________/\______/
* file obj
*
* The dichotomy is determined by calling H5Fopen() repeatedly until it
* succeeds. The first call uses the entire name and each subsequent call
* chops off the last component. If we reach the beginning of the name
* then there must have been something wrong with the file (perhaps it
* doesn't exist).
*/
if((fname = HDstrdup(argv[opt_ind])) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
h5tools_setstatus(EXIT_FAILURE);
}
/* Create a copy of file access property list */
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
return -1;
/* Set to use the latest library format */
if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
return -1;
do {
while(fname && *fname) {
fid = h5tools_fopen(fname, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl, NULL, drivername, sizeof drivername);
if(fid >= 0) {
HDfprintf(stdout, "Opened \"%s\" with %s driver.\n", fname, drivername);
break; /*success*/
} /* end if */
/* Shorten the file name; lengthen the object name */
x = dname;
dname = HDstrrchr(fname, '/');
if(x)
*x = '/';
if(!dname)
break;
*dname = '\0';
} /* end while */
/* Try opening the file again if somehow unstable */
} while(g_retry-- > 0 && fid == FAIL);
if(fid < 0) {
error_msg("unable to open file \"%s\"\n", fname);
if(fname) HDfree(fname);
if(fapl >= 0) H5Pclose(fapl);
leave(EXIT_FAILURE);
}
if(!dname) {
error_msg("no dataset specified\n");
h5tools_setstatus(EXIT_FAILURE);
} else {
*dname = '/';
x = dname;
if((dname = HDstrdup(dname)) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
h5tools_setstatus(EXIT_FAILURE);
} else {
*x = '\0';
/* Validate dataset */
if(check_dataset(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
/* Validate input "fields" */
else if(g_list_of_fields && *g_list_of_fields)
if(process_cmpd_fields(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
}
}
/* If everything is fine, start monitoring the datset */
if(h5tools_getstatus() != EXIT_FAILURE)
if(monitor_dataset(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
/* Free spaces */
if(fname) HDfree(fname);
if(dname) HDfree(dname);
if(g_list_of_fields) HDfree(g_list_of_fields);
if(g_listv) {
H5LD_clean_vector(g_listv);
HDfree(g_listv);
}
if(g_dup_fields) HDfree(g_dup_fields);
/* Close the file access property list */
if(fapl >= 0 && H5Pclose(fapl) < 0) {
error_msg("unable to close file access property list\n");
h5tools_setstatus(EXIT_FAILURE);
}
/* Close the file */
if(H5Fclose(fid) < 0) {
error_msg("unable to close file\n");
h5tools_setstatus(EXIT_FAILURE);
}
H5Eset_auto2(H5E_DEFAULT, func, edata);
/* exit */
leave(h5tools_getstatus());
} /* main() */
/*-------------------------------------------------------------------------
* Function: parse_command_line
*
* Purpose: Parse the command line for h5watch (take only long options)
*
* Return: Success: Set the corresponding command flags and return void
* Failure: Exits program with EXIT_FAILURE value.
*
* Programmer: Vailin Choi; August 2010
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
parse_command_line(int argc, const char *argv[])
{
int opt; /* Command line option */
int tmp;
/* no arguments */
if (argc == 1) {
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
switch ((char)opt) {
case '?':
case 'h': /* --help */
usage(h5tools_getprogname());
leave(EXIT_SUCCESS);
case 'V': /* --version */
print_version(progname);
leave(EXIT_SUCCESS);
break;
case 'w': /* --width=N */
g_display_width = (int)HDstrtol(opt_arg, NULL, 0);
if(g_display_width < 0) {
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
break;
case 'd': /* --dim */
g_monitor_size_only = TRUE;
break;
case 'S': /* --simple */
g_simple_output = TRUE;
break;
case 'l': /* --label */
g_label = TRUE;
break;
case 'p': /* --polling=N */
/* g_polling_interval = HDstrtod(opt_arg, NULL); */
if((tmp = (int)HDstrtol(opt_arg, NULL, 10)) <= 0) {
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
g_polling_interval = (unsigned)tmp;
break;
case 'f': /* --fields=<list_of_fields> */
if(g_list_of_fields == NULL) {
if((g_list_of_fields = HDstrdup(opt_arg)) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
leave(EXIT_FAILURE);
}
} else {
char *str;
if((str = HDstrdup(opt_arg)) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
leave(EXIT_FAILURE);
}
if((g_list_of_fields = (char *)HDrealloc(g_list_of_fields, HDstrlen(g_list_of_fields) + HDstrlen(str) + 2)) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
leave(EXIT_FAILURE);
}
HDstrcat(g_list_of_fields, FIELD_SEP);
HDstrcat(g_list_of_fields, str);
}
break;
default:
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
}
/* check for object to be processed */
if (argc <= opt_ind) {
error_msg("missing dataset name\n");
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
} /* parse_command_line() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Create group(s) in an HDF5 file
*
* Programmer: Quincey Koziol, 2/13/2007
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
hid_t fid; /* HDF5 file ID */
hid_t fapl_id; /* File access property list ID */
hid_t lcpl_id; /* Link creation property list ID */
size_t curr_group; /* Current group to create */
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable the HDF5 library's error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
/* Parse command line */
HDmemset(¶ms, 0, sizeof(params));
if(parse_command_line(argc, argv, ¶ms) < 0) {
error_msg("unable to parse command line arguments\n");
leave(EXIT_FAILURE);
} /* end if */
/* Create file access property list */
if((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
error_msg("Could not create file access property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Check for creating groups with new format version */
if(params.latest) {
/* Set the "use the latest version of the format" bounds */
if(H5Pset_libver_bounds(fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) {
error_msg("Could not set property for using latest version of the format\n");
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: Creating groups with latest version of the format\n", h5tools_getprogname());
} /* end if */
/* Attempt to open an existing HDF5 file first */
fid = h5tools_fopen(params.fname, H5F_ACC_RDWR, fapl_id, NULL, NULL, 0);
/* If we couldn't open an existing file, try creating file */
/* (use "EXCL" instead of "TRUNC", so we don't blow away existing non-HDF5 file) */
if(fid < 0)
fid = H5Fcreate(params.fname, H5F_ACC_EXCL, H5P_DEFAULT, fapl_id);
/* Test for error in opening file */
if(fid < 0) {
error_msg("Could not open output file '%s'\n", params.fname);
leave(EXIT_FAILURE);
} /* end if */
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Check for creating intermediate groups */
if(params.parents) {
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, TRUE) < 0) {
error_msg("Could not set property for creating parent groups\n");
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: Creating parent groups\n", h5tools_getprogname());
} /* end if */
/* Loop over creating requested groups */
for(curr_group = 0; curr_group < params.ngroups; curr_group++) {
hid_t gid; /* Group ID */
/* Attempt to create a group */
if((gid = H5Gcreate2(fid, params.groups[curr_group], lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
error_msg("Could not create group '%s'\n", params.groups[curr_group]);
leave(EXIT_FAILURE);
} /* end if */
/* Close the group */
if(H5Gclose(gid) < 0) {
error_msg("Could not close group '%s'??\n", params.groups[curr_group]);
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: created group '%s'\n", h5tools_getprogname(), params.groups[curr_group]);
} /* end for */
/* Close link creation property list */
if(H5Pclose(lcpl_id) < 0) {
error_msg("Could not close link creation property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Close file */
if(H5Fclose(fid) < 0) {
error_msg("Could not close output file '%s'??\n", params.fname);
leave(EXIT_FAILURE);
} /* end if */
/* Close file access property list */
if(H5Pclose(fapl_id) < 0) {
error_msg("Could not close file access property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Shut down h5tools lib */
h5tools_close();
leave(EXIT_SUCCESS);
} /* end main() */
/*-------------------------------------------------------------------------
* Function: parse_command_line
*
* Purpose: Parses command line and sets up global variable to control output
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol, 2/13/2007
*
*-------------------------------------------------------------------------
*/
static int
parse_command_line(int argc, const char *argv[], param_t *parms)
{
int opt; /* Option from command line */
size_t curr_group; /* Current group name to copy */
/* Check for empty command line */
if(argc == 1) {
usage();
leave(EXIT_SUCCESS);
} /* end if */
/* Parse command line options */
while((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
switch((char)opt) {
/* Display 'help' */
case 'h':
usage();
leave(EXIT_SUCCESS);
/* Create objects with the latest version of the format */
case 'l':
parms->latest = TRUE;
break;
/* Create parent groups */
case 'p':
parms->parents = TRUE;
break;
/* Verbose output */
case 'v':
parms->verbose = TRUE;
break;
/* Display version */
case 'V':
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
/* Bad command line argument */
default:
usage();
leave(EXIT_FAILURE);
} /* end switch */
} /* end while */
/* Check for file name to be processed */
if(argc <= opt_ind) {
error_msg("missing file name\n");
usage();
leave(EXIT_FAILURE);
} /* end if */
/* Retrieve file name */
parms->fname = HDstrdup(argv[opt_ind]);
opt_ind++;
/* Check for group(s) to be created */
if(argc <= opt_ind) {
error_msg("missing group name(s)\n");
usage();
leave(EXIT_FAILURE);
} /* end if */
/* Allocate space for the group name pointers */
parms->ngroups = (size_t)(argc - opt_ind);
parms->groups = (char **)HDmalloc(parms->ngroups * sizeof(char *));
/* Retrieve the group names */
curr_group = 0;
while(opt_ind < argc) {
parms->groups[curr_group] = HDstrdup(argv[opt_ind]);
curr_group++;
opt_ind++;
} /* end while */
#ifdef QAK
HDfprintf(stderr, "parms->parents = %t\n", parms->parents);
HDfprintf(stderr, "parms->verbose = %t\n", parms->verbose);
HDfprintf(stderr, "parms->fname = '%s'\n", parms->fname);
HDfprintf(stderr, "parms->ngroups = %Zu\n", parms->ngroups);
for(curr_group = 0; curr_group < parms->ngroups; curr_group++)
HDfprintf(stderr, "parms->group[%Zu] = '%s'\n", curr_group, parms->groups[curr_group]);
#endif /* QAK */
return(0);
} /* parse_command_line() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block jammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
int ufid;
int h5fid;
int ofid;
void *edata;
H5E_auto2_t func;
hid_t ifile;
hid_t plist;
herr_t status;
htri_t testval;
hsize_t usize;
hsize_t h5fsize;
hsize_t startub;
hsize_t where;
hsize_t newubsize;
off_t fsize;
struct stat sbuf;
struct stat sbuf2;
int res;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
parse_command_line (argc, argv);
if (ub_file == NULL)
{
/* no user block */
error_msg("no user block file name\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
if (input_file == NULL)
{
/* no user block */
error_msg("no HDF5 file\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (input_file);
if (testval <= 0)
{
error_msg("Input HDF5 file is not HDF \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0)
{
error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0)
{
error_msg("Can't get file creation plist for file \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0)
{
error_msg("Can't get user block for file \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
H5Pclose (plist);
H5Fclose (ifile);
ufid = HDopen (ub_file, O_RDONLY, 0);
if (ufid < 0)
{
error_msg("unable to open user block file \"%s\"\n",
ub_file);
exit (EXIT_FAILURE);
}
res = stat (ub_file, &sbuf);
if (res < 0)
{
error_msg("Can't stat file \"%s\"\n", ub_file);
exit (EXIT_FAILURE);
}
fsize = sbuf.st_size;
h5fid = HDopen (input_file, O_RDONLY, 0);
if (h5fid < 0)
{
error_msg("unable to open HDF5 file for read \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
res = stat (input_file, &sbuf2);
if (res < 0)
{
error_msg("Can't stat file \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
h5fsize = sbuf2.st_size;
if (output_file == NULL)
{
ofid = HDopen (input_file, O_WRONLY, 0);
if (ofid < 0)
{
error_msg("unable to open output file \"%s\"\n",
output_file);
exit (EXIT_FAILURE);
}
}
else
{
ofid = HDopen (output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (ofid < 0)
{
error_msg("unable to create output file \"%s\"\n",
output_file);
exit (EXIT_FAILURE);
}
}
newubsize = compute_user_block_size ((hsize_t) fsize);
startub = usize;
if (usize > 0)
{
if (do_clobber == TRUE)
{
/* where is max of the current size or the new UB */
if (usize > newubsize)
{
newubsize = usize;
}
startub = 0; /*blast the old */
}
else
{
/* add new ub to current ublock, pad to new offset */
newubsize += usize;
newubsize = compute_user_block_size ((hsize_t) newubsize);
}
}
/* copy the HDF5 from starting at usize to starting at newubsize:
* makes room at 'from' for new ub */
/* if no current ub, usize is 0 */
copy_some_to_file (h5fid, ofid, usize, newubsize,
(ssize_t) (h5fsize - usize));
/* copy the old ub to the beginning of the new file */
if (!do_clobber)
{
where =
copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0,
(ssize_t) usize);
}
/* copy the new ub to the end of the ub */
where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
/* pad the ub */
where = write_pad (ofid, where);
HDclose (ufid);
HDclose (h5fid);
HDclose (ofid);
return h5tools_getstatus();
}
obj_list_t* parse_filter(const char *str,
int *n_objs,
filter_info_t *filt,
pack_opt_t *options,
int *is_glb)
{
unsigned i, u;
char c;
size_t len=strlen(str);
int j, m, n, k, l, end_obj=-1, no_param=0;
char sobj[MAX_NC_NAME];
char scomp[10];
char stype[5];
char smask[3];
obj_list_t* obj_list=NULL;
unsigned pixels_per_block;
/* initialize compression info */
memset(filt,0,sizeof(filter_info_t));
*is_glb = 0;
/* check for the end of object list and number of objects */
for ( i = 0, n = 0; i < len; i++)
{
c = str[i];
if ( c==':' )
{
end_obj=i;
}
if ( c==',' )
{
n++;
}
}
if (end_obj==-1) /* missing : */
{
/* apply to all objects */
options->all_filter=1;
*is_glb = 1;
}
n++;
obj_list = (obj_list_t*) malloc(n*sizeof(obj_list_t));
if (obj_list==NULL)
{
error_msg(h5tools_getprogname(), "could not allocate object list\n");
return NULL;
}
*n_objs=n;
/* get object list */
for ( j = 0, k = 0, n = 0; j < end_obj; j++, k++)
{
c = str[j];
sobj[k] = c;
if ( c==',' || j==end_obj-1)
{
if ( c==',') sobj[k]='\0'; else sobj[k+1]='\0';
strcpy(obj_list[n].obj,sobj);
memset(sobj,0,sizeof(sobj));
n++;
k=-1;
}
}
/* nothing after : */
if (end_obj+1==(int)len)
{
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "input Error: Invalid compression type in <%s>\n",str);
exit(EXIT_FAILURE);
}
/* get filter additional parameters */
m=0;
for ( i=end_obj+1, k=0, j=0; i<len; i++,k++)
{
c = str[i];
scomp[k]=c;
if ( c=='=' || i==len-1)
{
if ( c=='=') /*one more parameter */
{
scomp[k]='\0'; /*cut space */
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
* szip has the format SZIP=<pixels per block,coding>
* pixels per block is a even number in 2-32 and coding method is 'EC' or 'NN'
* example SZIP=8,NN
*-------------------------------------------------------------------------
*/
if (strcmp(scomp,"SZIP")==0)
{
l=-1; /* mask index check */
for ( m=0,u=i+1; u<len; u++,m++)
{
if (str[u]==',')
{
stype[m]='\0'; /* end digit of szip */
l=0; /* start EC or NN search */
u++; /* skip ',' */
}
c = str[u];
if (!isdigit(c) && l==-1){
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "compression parameter not digit in <%s>\n",str);
exit(EXIT_FAILURE);
}
if (l==-1)
stype[m]=c;
else
{
smask[l]=c;
l++;
if (l==2)
{
smask[l]='\0';
i=len-1; /* end */
(*n_objs)--; /* we counted an extra ',' */
if (strcmp(smask,"NN")==0)
filt->cd_values[j++]=H5_SZIP_NN_OPTION_MASK;
else if (strcmp(smask,"EC")==0)
filt->cd_values[j++]=H5_SZIP_EC_OPTION_MASK;
else
{
error_msg(h5tools_getprogname(), "szip mask must be 'NN' or 'EC' \n");
exit(EXIT_FAILURE);
}
}
}
} /* u */
} /*if */
/*-------------------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET
* scaleoffset has the format SOFF=<scale_factor,scale_type>
* scale_type can be
* integer datatype, H5Z_SO_INT (IN)
* float datatype using D-scaling method, H5Z_SO_FLOAT_DSCALE (DS)
* float datatype using E-scaling method, H5Z_SO_FLOAT_ESCALE (ES) , not yet implemented
* for integer datatypes, scale_factor denotes Minimum Bits
* for float datatypes, scale_factor denotes decimal scale factor
* examples
* SOFF=31,IN
* SOFF=3,DF
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"SOFF")==0)
{
l=-1; /* mask index check */
for ( m=0,u=i+1; u<len; u++,m++)
{
if (str[u]==',')
{
stype[m]='\0'; /* end digit */
l=0; /* start 'IN' , 'DS', or 'ES' search */
u++; /* skip ',' */
}
c = str[u];
if (!isdigit(c) && l==-1){
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "compression parameter is not a digit in <%s>\n",str);
exit(EXIT_FAILURE);
}
if (l==-1)
stype[m]=c;
else
{
smask[l]=c;
l++;
if (l==2)
{
smask[l]='\0';
i=len-1; /* end */
(*n_objs)--; /* we counted an extra ',' */
if (strcmp(smask,"IN")==0)
filt->cd_values[j++]=H5Z_SO_INT;
else if (strcmp(smask,"DS")==H5Z_SO_FLOAT_DSCALE)
filt->cd_values[j++]=H5Z_SO_FLOAT_DSCALE;
else
{
error_msg(h5tools_getprogname(), "scale type must be 'IN' or 'DS' \n");
exit(EXIT_FAILURE);
}
}
}
} /* u */
} /*if */
/*-------------------------------------------------------------------------
* all other filters
*-------------------------------------------------------------------------
*/
else
{
/* here we could have 1 or 2 digits */
for ( m=0,u=i+1; u<len; u++,m++)
{
c = str[u];
if (!isdigit(c)){
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "compression parameter is not a digit in <%s>\n",str);
exit(EXIT_FAILURE);
}
stype[m]=c;
} /* u */
stype[m]='\0';
} /*if */
filt->cd_values[j++]=atoi(stype);
i+=m; /* jump */
}
else if (i==len-1)
{ /*no more parameters */
scomp[k+1]='\0';
no_param=1;
}
/*-------------------------------------------------------------------------
* translate from string to filter symbol
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* H5Z_FILTER_NONE
*-------------------------------------------------------------------------
*/
if (strcmp(scomp,"NONE")==0)
{
filt->filtn=H5Z_FILTER_NONE;
filt->cd_nelmts = 0;
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"GZIP")==0)
{
filt->filtn=H5Z_FILTER_DEFLATE;
filt->cd_nelmts = 1;
if (no_param)
{ /*no more parameters, GZIP must have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "missing compression parameter in <%s>\n",str);
exit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"SZIP")==0)
{
filt->filtn=H5Z_FILTER_SZIP;
filt->cd_nelmts = 2;
if (no_param)
{ /*no more parameters, SZIP must have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "missing compression parameter in <%s>\n",str);
exit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SHUFFLE
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"SHUF")==0)
{
filt->filtn=H5Z_FILTER_SHUFFLE;
filt->cd_nelmts = 0;
if (m>0)
{ /*shuffle does not have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "extra parameter in SHUF <%s>\n",str);
exit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_FLETCHER32
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"FLET")==0)
{
filt->filtn=H5Z_FILTER_FLETCHER32;
filt->cd_nelmts = 0;
if (m>0)
{ /*shuffle does not have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "extra parameter in FLET <%s>\n",str);
exit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_NBIT
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"NBIT")==0)
{
filt->filtn=H5Z_FILTER_NBIT;
filt->cd_nelmts = 0;
if (m>0)
{ /*nbit does not have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "extra parameter in NBIT <%s>\n",str);
exit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET
*-------------------------------------------------------------------------
*/
else if (strcmp(scomp,"SOFF")==0)
{
filt->filtn=H5Z_FILTER_SCALEOFFSET;
filt->cd_nelmts = 2;
if (no_param)
{ /*no more parameters, SOFF must have parameter */
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "missing compression parameter in <%s>\n",str);
exit(EXIT_FAILURE);
}
}
else {
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "invalid filter type in <%s>\n",str);
exit(EXIT_FAILURE);
}
}
} /*i*/
/*-------------------------------------------------------------------------
* check valid parameters
*-------------------------------------------------------------------------
*/
switch (filt->filtn)
{
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_DEFLATE:
if (filt->cd_values[0]>9 )
{
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "invalid compression parameter in <%s>\n",str);
exit(EXIT_FAILURE);
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SZIP:
pixels_per_block=filt->cd_values[0];
if ((pixels_per_block%2)==1)
{
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "pixels_per_block is not even in <%s>\n",str);
exit(EXIT_FAILURE);
}
if (pixels_per_block>H5_SZIP_MAX_PIXELS_PER_BLOCK)
{
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "pixels_per_block is too large in <%s>\n",str);
exit(EXIT_FAILURE);
}
if ( (strcmp(smask,"NN")!=0) && (strcmp(smask,"EC")!=0) )
{
if (obj_list) free(obj_list);
error_msg(h5tools_getprogname(), "szip mask must be 'NN' or 'EC' \n");
exit(EXIT_FAILURE);
}
break;
default:
break;
};
return obj_list;
}
/*------------------------------------------------------------------------- * Function: parse_layout * * Purpose: read layout info * * Return: a list of names, the number of names and its chunking info for * chunked. NULL, on error * the layout type can be: * CHUNK, to apply chunking layout * CONTI, to apply continuous layout * COMPA, to apply compact layout * * Example: * "AA,B,CDE:CHUNK=10X10" * * Programmer: Pedro Vicente, [email protected] * * Date: December 30, 2003 * *------------------------------------------------------------------------- */ obj_list_t* parse_layout(const char *str, int *n_objs, pack_info_t *pack, /* info about layout needed */ pack_opt_t *options) { obj_list_t* obj_list=NULL; unsigned i; char c; size_t len=strlen(str); int j, n, k, end_obj=-1, c_index; char sobj[MAX_NC_NAME]; char sdim[10]; char slayout[10]; memset(sdim, '\0', sizeof(sdim)); memset(sobj, '\0', sizeof(sobj)); memset(slayout, '\0', sizeof(slayout)); /* check for the end of object list and number of objects */ for ( i=0, n=0; i<len; i++) { c = str[i]; if ( c==':' ) { end_obj=i; } if ( c==',' ) { n++; } } if (end_obj==-1) { /* missing : chunk all */ options->all_layout=1; } n++; obj_list = (obj_list_t*) malloc(n*sizeof(obj_list_t)); if (obj_list==NULL) { error_msg(h5tools_getprogname(), "could not allocate object list\n"); return NULL; } *n_objs=n; /* get object list */ for ( j=0, k=0, n=0; j<end_obj; j++,k++) { c = str[j]; sobj[k]=c; if ( c==',' || j==end_obj-1) { if ( c==',') sobj[k]='\0'; else sobj[k+1]='\0'; strcpy(obj_list[n].obj,sobj); memset(sobj,0,sizeof(sobj)); n++; k=-1; } } /* nothing after : */ if (end_obj+1==(int)len) { if (obj_list) free(obj_list); error_msg(h5tools_getprogname(), "in parse layout, no characters after : in <%s>\n",str); exit(EXIT_FAILURE); } /* get layout info */ for ( j=end_obj+1, n=0; n<=5; j++,n++) { if (n==5) { slayout[n]='\0'; /*cut string */ if (strcmp(slayout,"COMPA")==0) pack->layout=H5D_COMPACT; else if (strcmp(slayout,"CONTI")==0) pack->layout=H5D_CONTIGUOUS; else if (strcmp(slayout,"CHUNK")==0) pack->layout=H5D_CHUNKED; else { error_msg(h5tools_getprogname(), "in parse layout, not a valid layout in <%s>\n",str); exit(EXIT_FAILURE); } } else { c = str[j]; slayout[n]=c; } } /* j */ if ( pack->layout==H5D_CHUNKED ) { /*------------------------------------------------------------------------- * get chunk info *------------------------------------------------------------------------- */ k=0; if (j>(int)len) { if (obj_list) free(obj_list); error_msg(h5tools_getprogname(), "in parse layout, <%s> Chunk dimensions missing\n",str); exit(EXIT_FAILURE); } for ( i=j, c_index=0; i<len; i++) { c = str[i]; sdim[k]=c; k++; /*increment sdim index */ if (!isdigit(c) && c!='x' && c!='N' && c!='O' && c!='N' && c!='E' ){ if (obj_list) free(obj_list); error_msg(h5tools_getprogname(), "in parse layout, <%s> Not a valid character in <%s>\n", sdim,str); exit(EXIT_FAILURE); } if ( c=='x' || i==len-1) { if ( c=='x') { sdim[k-1]='\0'; k=0; pack->chunk.chunk_lengths[c_index]=atoi(sdim); if (pack->chunk.chunk_lengths[c_index]==0) { if (obj_list) free(obj_list); error_msg(h5tools_getprogname(), "in parse layout, <%s> conversion to number in <%s>\n", sdim,str); exit(EXIT_FAILURE); } c_index++; } else if (i==len-1) { /*no more parameters */ sdim[k]='\0'; k=0; if (strcmp(sdim,"NONE")==0) { pack->chunk.rank=-2; } else { pack->chunk.chunk_lengths[c_index]=atoi(sdim); if (pack->chunk.chunk_lengths[c_index]==0){ if (obj_list) free(obj_list); error_msg(h5tools_getprogname(), "in parse layout, <%s> conversion to number in <%s>\n", sdim,str); exit(EXIT_FAILURE); } pack->chunk.rank=c_index+1; } } /*if */ } /*if c=='x' || i==len-1 */ } /*i*/ } /*H5D_CHUNKED*/ return obj_list; }
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block unjammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
char *ifname;
void *edata;
H5E_auto2_t func;
hid_t ifile;
hsize_t usize;
htri_t testval;
herr_t status;
hid_t plist;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
parse_command_line (argc, argv);
if (argc <= (opt_ind))
{
error_msg("missing file name\n");
usage (h5tools_getprogname());
return (EXIT_FAILURE);
}
ifname = HDstrdup (argv[opt_ind]);
testval = H5Fis_hdf5 (ifname);
if (testval <= 0)
{
error_msg("Input HDF5 file is not HDF \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
ifile = H5Fopen (ifname, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0)
{
error_msg("Can't open input HDF5 file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0)
{
error_msg("Can't get file creation plist for file \"%s\"\n",
ifname);
return (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0)
{
error_msg("Can't get user block for file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
printf ("%ld\n", (long) usize);
H5Pclose (plist);
H5Fclose (ifile);
return (EXIT_SUCCESS);
}
/*-------------------------------------------------------------------------
* Function: help_ref_msg
*
* Purpose: Print a message to refer help page
*
* Return: Nothing
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
help_ref_msg(FILE *output)
{
HDfprintf(output, "Try '-h' or '--help' for more information or ");
HDfprintf(output, "see the <%s> entry in the 'HDF5 Reference Manual'.\n",h5tools_getprogname());
}
