summaryrefslogtreecommitdiffstats
path: root/src/H5Zscaleoffset.c
diff options
context:
space:
mode:
authorAllen Byrne <byrn@hdfgroup.org>2020-09-30 14:27:10 (GMT)
committerAllen Byrne <byrn@hdfgroup.org>2020-09-30 14:27:10 (GMT)
commitb2d661b508a7fc7a2592c13bc6bdc175551f075d (patch)
tree13baeb0d83a7c2a4c6299993c182b1227c2f6114 /src/H5Zscaleoffset.c
parent29ab58b58dce556639ea3154e262895773a8a8df (diff)
downloadhdf5-b2d661b508a7fc7a2592c13bc6bdc175551f075d.zip
hdf5-b2d661b508a7fc7a2592c13bc6bdc175551f075d.tar.gz
hdf5-b2d661b508a7fc7a2592c13bc6bdc175551f075d.tar.bz2
Clang-format of source files
Diffstat (limited to 'src/H5Zscaleoffset.c')
-rw-r--r--src/H5Zscaleoffset.c2190
1 files changed, 1139 insertions, 1051 deletions
diff --git a/src/H5Zscaleoffset.c b/src/H5Zscaleoffset.c
index 83f170e..96360eb 100644
--- a/src/H5Zscaleoffset.c
+++ b/src/H5Zscaleoffset.c
@@ -11,69 +11,83 @@
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#include "H5Zmodule.h" /* This source code file is part of the H5Z module */
-
-#include "H5private.h" /* Generic Functions */
-#include "H5ACprivate.h" /* Metadata cache */
-#include "H5Eprivate.h" /* Error handling */
-#include "H5Iprivate.h" /* IDs */
-#include "H5MMprivate.h" /* Memory management */
-#include "H5Pprivate.h" /* Property lists */
-#include "H5Oprivate.h" /* Object headers */
-#include "H5Sprivate.h" /* Dataspaces */
-#include "H5Tprivate.h" /* Datatypes */
-#include "H5Zpkg.h" /* Data filters */
+#include "H5Zmodule.h" /* This source code file is part of the H5Z module */
+
+#include "H5private.h" /* Generic Functions */
+#include "H5ACprivate.h" /* Metadata cache */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Iprivate.h" /* IDs */
+#include "H5MMprivate.h" /* Memory management */
+#include "H5Pprivate.h" /* Property lists */
+#include "H5Oprivate.h" /* Object headers */
+#include "H5Sprivate.h" /* Dataspaces */
+#include "H5Tprivate.h" /* Datatypes */
+#include "H5Zpkg.h" /* Data filters */
/* Struct of parameters needed for compressing/decompressing one atomic datatype */
typedef struct {
- unsigned size; /* datatype size */
- uint32_t minbits; /* minimum bits to compress one value of such datatype */
- unsigned mem_order; /* current memory endianness order */
+ unsigned size; /* datatype size */
+ uint32_t minbits; /* minimum bits to compress one value of such datatype */
+ unsigned mem_order; /* current memory endianness order */
} parms_atomic;
-enum H5Z_scaleoffset_t {t_bad=0, t_uchar=1, t_ushort, t_uint, t_ulong, t_ulong_long,
- t_schar, t_short, t_int, t_long, t_long_long,
- t_float, t_double};
+enum H5Z_scaleoffset_t {
+ t_bad = 0,
+ t_uchar = 1,
+ t_ushort,
+ t_uint,
+ t_ulong,
+ t_ulong_long,
+ t_schar,
+ t_short,
+ t_int,
+ t_long,
+ t_long_long,
+ t_float,
+ t_double
+};
/* Local function prototypes */
-static htri_t H5Z__can_apply_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id);
-static enum H5Z_scaleoffset_t H5Z__scaleoffset_get_type(unsigned dtype_class,
- unsigned dtype_size, unsigned dtype_sign);
-static herr_t H5Z__scaleoffset_set_parms_fillval(H5P_genplist_t *dcpl_plist,
- H5T_t *type, enum H5Z_scaleoffset_t scale_type, unsigned cd_values[],
- int need_convert);
-static herr_t H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id);
-static size_t H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts,
- const unsigned cd_values[], size_t nbytes, size_t *buf_size, void **buf);
-static void H5Z__scaleoffset_convert(void *buf, unsigned d_nelmts, unsigned dtype_size);
+static htri_t H5Z__can_apply_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id);
+static enum H5Z_scaleoffset_t H5Z__scaleoffset_get_type(unsigned dtype_class, unsigned dtype_size,
+ unsigned dtype_sign);
+static herr_t H5Z__scaleoffset_set_parms_fillval(H5P_genplist_t *dcpl_plist, H5T_t *type,
+ enum H5Z_scaleoffset_t scale_type, unsigned cd_values[],
+ int need_convert);
+static herr_t H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id);
+static size_t H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
+ size_t nbytes, size_t *buf_size, void **buf);
+static void H5Z__scaleoffset_convert(void *buf, unsigned d_nelmts, unsigned dtype_size);
static H5_ATTR_CONST unsigned H5Z__scaleoffset_log2(unsigned long long num);
-static void H5Z__scaleoffset_precompress_i(void *data, unsigned d_nelmts,
- enum H5Z_scaleoffset_t type, unsigned filavail, const unsigned cd_values[],
- uint32_t *minbits, unsigned long long *minval);
-static void H5Z__scaleoffset_postdecompress_i(void *data, unsigned d_nelmts,
- enum H5Z_scaleoffset_t type, unsigned filavail, const unsigned cd_values[],
- uint32_t minbits, unsigned long long minval);
-static herr_t H5Z__scaleoffset_precompress_fd(void *data, unsigned d_nelmts,
- enum H5Z_scaleoffset_t type, unsigned filavail, const unsigned cd_values[],
- uint32_t *minbits, unsigned long long *minval, double D_val);
-static herr_t H5Z__scaleoffset_postdecompress_fd(void *data, unsigned d_nelmts,
- enum H5Z_scaleoffset_t type, unsigned filavail, const unsigned cd_values[],
- uint32_t minbits, unsigned long long minval, double D_val);
-static void H5Z__scaleoffset_next_byte(size_t *j, unsigned *buf_len);
-static void H5Z__scaleoffset_decompress_one_byte(unsigned char *data, size_t data_offset,
- unsigned k, unsigned begin_i, unsigned char *buffer, size_t *j, unsigned *buf_len,
- parms_atomic p, unsigned dtype_len);
-static void H5Z__scaleoffset_compress_one_byte(unsigned char *data, size_t data_offset,
- unsigned k, unsigned begin_i, unsigned char *buffer, size_t *j, unsigned *buf_len,
- parms_atomic p, unsigned dtype_len);
-static void H5Z__scaleoffset_decompress_one_atomic(unsigned char *data, size_t data_offset,
- unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p);
-static void H5Z__scaleoffset_compress_one_atomic(unsigned char *data, size_t data_offset,
- unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p);
-static void H5Z__scaleoffset_decompress(unsigned char *data, unsigned d_nelmts,
- unsigned char *buffer, parms_atomic p);
-static void H5Z__scaleoffset_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
- size_t buffer_size, parms_atomic p);
+static void H5Z__scaleoffset_precompress_i(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
+ unsigned filavail, const unsigned cd_values[], uint32_t *minbits,
+ unsigned long long *minval);
+static void H5Z__scaleoffset_postdecompress_i(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
+ unsigned filavail, const unsigned cd_values[], uint32_t minbits,
+ unsigned long long minval);
+static herr_t H5Z__scaleoffset_precompress_fd(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
+ unsigned filavail, const unsigned cd_values[],
+ uint32_t *minbits, unsigned long long *minval, double D_val);
+static herr_t H5Z__scaleoffset_postdecompress_fd(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
+ unsigned filavail, const unsigned cd_values[],
+ uint32_t minbits, unsigned long long minval, double D_val);
+static void H5Z__scaleoffset_next_byte(size_t *j, unsigned *buf_len);
+static void H5Z__scaleoffset_decompress_one_byte(unsigned char *data, size_t data_offset, unsigned k,
+ unsigned begin_i, unsigned char *buffer, size_t *j,
+ unsigned *buf_len, parms_atomic p, unsigned dtype_len);
+static void H5Z__scaleoffset_compress_one_byte(unsigned char *data, size_t data_offset, unsigned k,
+ unsigned begin_i, unsigned char *buffer, size_t *j,
+ unsigned *buf_len, parms_atomic p, unsigned dtype_len);
+static void H5Z__scaleoffset_decompress_one_atomic(unsigned char *data, size_t data_offset,
+ unsigned char *buffer, size_t *j, unsigned *buf_len,
+ parms_atomic p);
+static void H5Z__scaleoffset_compress_one_atomic(unsigned char *data, size_t data_offset,
+ unsigned char *buffer, size_t *j, unsigned *buf_len,
+ parms_atomic p);
+static void H5Z__scaleoffset_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
+ parms_atomic p);
+static void H5Z__scaleoffset_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
+ size_t buffer_size, parms_atomic p);
/* This message derives from H5Z */
H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
@@ -88,583 +102,639 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
}};
/* Local macros */
-#define H5Z_SCALEOFFSET_TOTAL_NPARMS 20 /* Total number of parameters for filter */
-#define H5Z_SCALEOFFSET_PARM_SCALETYPE 0 /* "User" parameter for scale type */
-#define H5Z_SCALEOFFSET_PARM_SCALEFACTOR 1 /* "User" parameter for scale factor */
-#define H5Z_SCALEOFFSET_PARM_NELMTS 2 /* "Local" parameter for number of elements in the chunk */
-#define H5Z_SCALEOFFSET_PARM_CLASS 3 /* "Local" parameter for datatype class */
-#define H5Z_SCALEOFFSET_PARM_SIZE 4 /* "Local" parameter for datatype size */
-#define H5Z_SCALEOFFSET_PARM_SIGN 5 /* "Local" parameter for integer datatype sign */
-#define H5Z_SCALEOFFSET_PARM_ORDER 6 /* "Local" parameter for datatype byte order */
-#define H5Z_SCALEOFFSET_PARM_FILAVAIL 7 /* "Local" parameter for dataset fill value existence */
-#define H5Z_SCALEOFFSET_PARM_FILVAL 8 /* "Local" parameter for start location to store dataset fill value */
+#define H5Z_SCALEOFFSET_TOTAL_NPARMS 20 /* Total number of parameters for filter */
+#define H5Z_SCALEOFFSET_PARM_SCALETYPE 0 /* "User" parameter for scale type */
+#define H5Z_SCALEOFFSET_PARM_SCALEFACTOR 1 /* "User" parameter for scale factor */
+#define H5Z_SCALEOFFSET_PARM_NELMTS 2 /* "Local" parameter for number of elements in the chunk */
+#define H5Z_SCALEOFFSET_PARM_CLASS 3 /* "Local" parameter for datatype class */
+#define H5Z_SCALEOFFSET_PARM_SIZE 4 /* "Local" parameter for datatype size */
+#define H5Z_SCALEOFFSET_PARM_SIGN 5 /* "Local" parameter for integer datatype sign */
+#define H5Z_SCALEOFFSET_PARM_ORDER 6 /* "Local" parameter for datatype byte order */
+#define H5Z_SCALEOFFSET_PARM_FILAVAIL 7 /* "Local" parameter for dataset fill value existence */
+#define H5Z_SCALEOFFSET_PARM_FILVAL 8 /* "Local" parameter for start location to store dataset fill value */
-#define H5Z_SCALEOFFSET_CLS_INTEGER 0 /* Integer (datatype class) */
-#define H5Z_SCALEOFFSET_CLS_FLOAT 1 /* Floatig-point (datatype class) */
+#define H5Z_SCALEOFFSET_CLS_INTEGER 0 /* Integer (datatype class) */
+#define H5Z_SCALEOFFSET_CLS_FLOAT 1 /* Floatig-point (datatype class) */
-#define H5Z_SCALEOFFSET_SGN_NONE 0 /* Unsigned integer type */
-#define H5Z_SCALEOFFSET_SGN_2 1 /* Two's complement signed integer type */
+#define H5Z_SCALEOFFSET_SGN_NONE 0 /* Unsigned integer type */
+#define H5Z_SCALEOFFSET_SGN_2 1 /* Two's complement signed integer type */
-#define H5Z_SCALEOFFSET_ORDER_LE 0 /* Little endian (datatype byte order) */
-#define H5Z_SCALEOFFSET_ORDER_BE 1 /* Big endian (datatype byte order) */
+#define H5Z_SCALEOFFSET_ORDER_LE 0 /* Little endian (datatype byte order) */
+#define H5Z_SCALEOFFSET_ORDER_BE 1 /* Big endian (datatype byte order) */
-#define H5Z_SCALEOFFSET_FILL_UNDEFINED 0 /* Fill value is not defined */
-#define H5Z_SCALEOFFSET_FILL_DEFINED 1 /* Fill value is defined */
+#define H5Z_SCALEOFFSET_FILL_UNDEFINED 0 /* Fill value is not defined */
+#define H5Z_SCALEOFFSET_FILL_DEFINED 1 /* Fill value is defined */
/* Store fill value in cd_values[] */
-#define H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
-{ \
- unsigned _i = H5Z_SCALEOFFSET_PARM_FILVAL; /* index into cd_values */ \
- uint32_t _cd_value; /* Current cd_value */ \
- char *_fv_p; /* Pointer to current byte in fill_val */ \
- size_t _copy_size = 4; /* # of bytes to copy this iteration */ \
- size_t _size_rem = sizeof(type); /* # of bytes left to copy to cd_values */ \
- \
- /* Store the fill value as the last entry in cd_values[] \
- * Store byte by byte from least significant byte to most significant byte \
- * Plenty of space left for the fill value (from index 8 to 19) \
- * H5O_pline_encode will byte-swap each individual cd value, but we still \
- * need to swap the cd values as a whole if we are on a BE machine. Note \
- * that we need to make sure to put the data only in the lowest 4 bytes of \
- * each, if sizeof(unsigned) > 4. \
- */ \
- if(H5T_native_order_g == H5T_ORDER_LE) { \
- _fv_p = (char *)&(fill_val); \
- /* Copy 4 bytes at a time to each cd value */ \
- do { \
- if(_size_rem < 4) { \
- /* Amount left to copy is smaller than a cd_value, adjust copy \
- * size and initialize cd_value as it will not be fully \
- * overwritten */ \
- _copy_size = _size_rem; \
- _cd_value = (uint32_t)0; \
- } /* end if */ \
- \
- /* Copy the value */ \
- H5MM_memcpy(&_cd_value, _fv_p, _copy_size); \
- (cd_values)[_i] = (unsigned)_cd_value; \
- \
- /* Next field */ \
- _i++; \
- _fv_p += _copy_size; \
- _size_rem -= _copy_size; \
- } while(_size_rem); \
- } /* end if */ \
- else { \
- HDassert(H5T_native_order_g == H5T_ORDER_BE); \
- \
- /* Copy 4 bytes at a time to each cd value, but start at the end \
- * (highest address) of fill_val */ \
- _fv_p = ((char *)&(fill_val)) + sizeof(type) - MIN(4, _size_rem); \
- while(_size_rem >= 4) { \
- /* Copy the value */ \
- H5MM_memcpy(&_cd_value, _fv_p, _copy_size); \
- (cd_values)[_i] = (unsigned)_cd_value; \
- \
- /* Next field */ \
- _i++; \
- _size_rem -= 4; \
- if(_size_rem >= 4) \
- _fv_p -= 4; \
- else \
- _fv_p -= _size_rem; \
- } /* end while */ \
- \
- HDassert(_fv_p == (char *)&(fill_val)); \
- if(_size_rem) { \
- /* Amount left to copy is smaller than a cd_value, initialize \
- * _cd_value as it will not be fully overwritten and copy to the end \
- * of _cd value as it is BE. */ \
- _cd_value = (uint32_t)0; \
- H5MM_memcpy((char *)&_cd_value + 4 - _size_rem, _fv_p, _size_rem); \
- (cd_values)[_i] = (unsigned)_cd_value; \
- } /* end if */ \
- } /* end else */ \
-}
+#define H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
+ { \
+ unsigned _i = H5Z_SCALEOFFSET_PARM_FILVAL; /* index into cd_values */ \
+ uint32_t _cd_value; /* Current cd_value */ \
+ char * _fv_p; /* Pointer to current byte in fill_val */ \
+ size_t _copy_size = 4; /* # of bytes to copy this iteration */ \
+ size_t _size_rem = sizeof(type); /* # of bytes left to copy to cd_values */ \
+ \
+ /* Store the fill value as the last entry in cd_values[] \
+ * Store byte by byte from least significant byte to most significant byte \
+ * Plenty of space left for the fill value (from index 8 to 19) \
+ * H5O_pline_encode will byte-swap each individual cd value, but we still \
+ * need to swap the cd values as a whole if we are on a BE machine. Note \
+ * that we need to make sure to put the data only in the lowest 4 bytes of \
+ * each, if sizeof(unsigned) > 4. \
+ */ \
+ if (H5T_native_order_g == H5T_ORDER_LE) { \
+ _fv_p = (char *)&(fill_val); \
+ /* Copy 4 bytes at a time to each cd value */ \
+ do { \
+ if (_size_rem < 4) { \
+ /* Amount left to copy is smaller than a cd_value, adjust copy \
+ * size and initialize cd_value as it will not be fully \
+ * overwritten */ \
+ _copy_size = _size_rem; \
+ _cd_value = (uint32_t)0; \
+ } /* end if */ \
+ \
+ /* Copy the value */ \
+ H5MM_memcpy(&_cd_value, _fv_p, _copy_size); \
+ (cd_values)[_i] = (unsigned)_cd_value; \
+ \
+ /* Next field */ \
+ _i++; \
+ _fv_p += _copy_size; \
+ _size_rem -= _copy_size; \
+ } while (_size_rem); \
+ } /* end if */ \
+ else { \
+ HDassert(H5T_native_order_g == H5T_ORDER_BE); \
+ \
+ /* Copy 4 bytes at a time to each cd value, but start at the end \
+ * (highest address) of fill_val */ \
+ _fv_p = ((char *)&(fill_val)) + sizeof(type) - MIN(4, _size_rem); \
+ while (_size_rem >= 4) { \
+ /* Copy the value */ \
+ H5MM_memcpy(&_cd_value, _fv_p, _copy_size); \
+ (cd_values)[_i] = (unsigned)_cd_value; \
+ \
+ /* Next field */ \
+ _i++; \
+ _size_rem -= 4; \
+ if (_size_rem >= 4) \
+ _fv_p -= 4; \
+ else \
+ _fv_p -= _size_rem; \
+ } /* end while */ \
+ \
+ HDassert(_fv_p == (char *)&(fill_val)); \
+ if (_size_rem) { \
+ /* Amount left to copy is smaller than a cd_value, initialize \
+ * _cd_value as it will not be fully overwritten and copy to the end \
+ * of _cd value as it is BE. */ \
+ _cd_value = (uint32_t)0; \
+ H5MM_memcpy((char *)&_cd_value + 4 - _size_rem, _fv_p, _size_rem); \
+ (cd_values)[_i] = (unsigned)_cd_value; \
+ } /* end if */ \
+ } /* end else */ \
+ }
/* Set the fill value parameter in cd_values[] for unsigned integer type */
-#define H5Z_scaleoffset_set_filval_1(type, dcpl_plist, dt, cd_values, need_convert) \
-{ \
- type fill_val; \
- \
- /* Get dataset fill value */ \
- if(H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
- HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
- \
- if(need_convert) \
- H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
- \
- H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
-}
+#define H5Z_scaleoffset_set_filval_1(type, dcpl_plist, dt, cd_values, need_convert) \
+ { \
+ type fill_val; \
+ \
+ /* Get dataset fill value */ \
+ if (H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
+ HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
+ \
+ if (need_convert) \
+ H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
+ \
+ H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
+ }
/* Set the fill value parameter in cd_values[] for signed integer type */
-#define H5Z_scaleoffset_set_filval_2(type, dcpl_plist, dt, cd_values, need_convert) \
-{ \
- type fill_val; \
- \
- /* Get dataset fill value */ \
- if(H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
- HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
- \
- if(need_convert) \
- H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
- \
- H5Z_scaleoffset_save_filval(unsigned type, cd_values, fill_val) \
-}
+#define H5Z_scaleoffset_set_filval_2(type, dcpl_plist, dt, cd_values, need_convert) \
+ { \
+ type fill_val; \
+ \
+ /* Get dataset fill value */ \
+ if (H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
+ HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
+ \
+ if (need_convert) \
+ H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
+ \
+ H5Z_scaleoffset_save_filval(unsigned type, cd_values, fill_val) \
+ }
/* Set the fill value parameter in cd_values[] for character integer type */
-#define H5Z_scaleoffset_set_filval_3(type, dcpl_plist, dt, cd_values, need_convert) \
-{ \
- type fill_val; \
- \
- /* Get dataset fill value */ \
- if(H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
- HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
- \
- /* Store the fill value as the last entry in cd_values[] */ \
- (cd_values)[H5Z_SCALEOFFSET_PARM_FILVAL] = (unsigned)((unsigned char)fill_val); \
-}
+#define H5Z_scaleoffset_set_filval_3(type, dcpl_plist, dt, cd_values, need_convert) \
+ { \
+ type fill_val; \
+ \
+ /* Get dataset fill value */ \
+ if (H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
+ HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
+ \
+ /* Store the fill value as the last entry in cd_values[] */ \
+ (cd_values)[H5Z_SCALEOFFSET_PARM_FILVAL] = (unsigned)((unsigned char)fill_val); \
+ }
/* Set the fill value parameter in cd_values[] for floating-point type */
-#define H5Z_scaleoffset_set_filval_4(type, dcpl_plist, dt, cd_values, need_convert) \
-{ \
- type fill_val; \
- \
- /* Get dataset fill value */ \
- if(H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
- HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
- \
- if(need_convert) \
- H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
- \
- H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
-}
+#define H5Z_scaleoffset_set_filval_4(type, dcpl_plist, dt, cd_values, need_convert) \
+ { \
+ type fill_val; \
+ \
+ /* Get dataset fill value */ \
+ if (H5P_get_fill_value(dcpl_plist, dt, &fill_val) < 0) \
+ HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get fill value") \
+ \
+ if (need_convert) \
+ H5Z__scaleoffset_convert(&fill_val, 1, sizeof(type)); \
+ \
+ H5Z_scaleoffset_save_filval(type, cd_values, fill_val) \
+ }
/* Get the fill value for integer type */
-#define H5Z_scaleoffset_get_filval_1(type, cd_values, fill_val) \
-{ \
- unsigned _i = H5Z_SCALEOFFSET_PARM_FILVAL; /* index into cd_values */ \
- uint32_t _cd_value; /* Current cd_value */ \
- char *_fv_p; /* Pointer to current byte in fill_val */ \
- size_t _copy_size = 4; /* # of bytes to copy this iteration */ \
- size_t _size_rem = sizeof(type); /* # of bytes left to copy to filval */ \
- \
- /* Retrieve the fill value from the last entry in cd_values[] \
- * Store byte by byte from least significant byte to most significant byte \
- * Plenty of space left for the fill value (from index 8 to 19) \
- * H5O_pline_encode will byte-swap each individual cd value, but we still \
- * need to swap the cd values as a whole if we are on a BE machine. Note \
- * that we need to make sure to put the data only in the lowest 4 bytes of \
- * each, if sizeof(unsigned) > 4. \
- */ \
- if(H5T_native_order_g == H5T_ORDER_LE) { \
- _fv_p = (char *)&(fill_val); \
- /* Copy 4 bytes at a time to each cd value */ \
- do { \
- if(_size_rem < 4) \
- /* Amount left to copy is smaller than a cd_value, adjust copy \
- * size and initialize cd_value as it will not be fully \
- * overwritten */ \
- _copy_size = _size_rem; \
- \
- /* Copy the value */ \
- _cd_value = (uint32_t)(cd_values)[_i]; \
- H5MM_memcpy(_fv_p, &_cd_value, _copy_size); \
- \
- /* Next field */ \
- _i++; \
- _fv_p += _copy_size; \
- _size_rem -= _copy_size; \
- } while(_size_rem); \
- } /* end if */ \
- else { \
- HDassert(H5T_native_order_g == H5T_ORDER_BE); \
- \
- /* Copy 4 bytes at a time to each cd value, but start at the end \
- * (highest address) of fill_val */ \
- _fv_p = ((char *)&(fill_val)) + sizeof(type) - MIN(4, _size_rem); \
- while(_size_rem >= 4) { \
- /* Copy the value */ \
- _cd_value = (uint32_t)(cd_values)[_i]; \
- H5MM_memcpy(_fv_p, &_cd_value, _copy_size); \
- \
- /* Next field */ \
- _i++; \
- _size_rem -= 4; \
- if(_size_rem >=4) \
- _fv_p -= 4; \
- else \
- _fv_p -= _size_rem; \
- } /* end while */ \
- \
- HDassert(_fv_p == (char *)&(fill_val)); \
- if(_size_rem) { \
- /* Amount left to copy is smaller than a cd_value, initialize \
- * _cd_value as it will not be fully overwritten and copy to the end \
- * of _cd value as it is BE. */ \
- _cd_value = (uint32_t)(cd_values)[_i]; \
- H5MM_memcpy(_fv_p, (char *)&_cd_value + 4 - _size_rem, _size_rem); \
- } /* end if */ \
- } /* end else */ \
-}
+#define H5Z_scaleoffset_get_filval_1(type, cd_values, fill_val) \
+ { \
+ unsigned _i = H5Z_SCALEOFFSET_PARM_FILVAL; /* index into cd_values */ \
+ uint32_t _cd_value; /* Current cd_value */ \
+ char * _fv_p; /* Pointer to current byte in fill_val */ \
+ size_t _copy_size = 4; /* # of bytes to copy this iteration */ \
+ size_t _size_rem = sizeof(type); /* # of bytes left to copy to filval */ \
+ \
+ /* Retrieve the fill value from the last entry in cd_values[] \
+ * Store byte by byte from least significant byte to most significant byte \
+ * Plenty of space left for the fill value (from index 8 to 19) \
+ * H5O_pline_encode will byte-swap each individual cd value, but we still \
+ * need to swap the cd values as a whole if we are on a BE machine. Note \
+ * that we need to make sure to put the data only in the lowest 4 bytes of \
+ * each, if sizeof(unsigned) > 4. \
+ */ \
+ if (H5T_native_order_g == H5T_ORDER_LE) { \
+ _fv_p = (char *)&(fill_val); \
+ /* Copy 4 bytes at a time to each cd value */ \
+ do { \
+ if (_size_rem < 4) \
+ /* Amount left to copy is smaller than a cd_value, adjust copy \
+ * size and initialize cd_value as it will not be fully \
+ * overwritten */ \
+ _copy_size = _size_rem; \
+ \
+ /* Copy the value */ \
+ _cd_value = (uint32_t)(cd_values)[_i]; \
+ H5MM_memcpy(_fv_p, &_cd_value, _copy_size); \
+ \
+ /* Next field */ \
+ _i++; \
+ _fv_p += _copy_size; \
+ _size_rem -= _copy_size; \
+ } while (_size_rem); \
+ } /* end if */ \
+ else { \
+ HDassert(H5T_native_order_g == H5T_ORDER_BE); \
+ \
+ /* Copy 4 bytes at a time to each cd value, but start at the end \
+ * (highest address) of fill_val */ \
+ _fv_p = ((char *)&(fill_val)) + sizeof(type) - MIN(4, _size_rem); \
+ while (_size_rem >= 4) { \
+ /* Copy the value */ \
+ _cd_value = (uint32_t)(cd_values)[_i]; \
+ H5MM_memcpy(_fv_p, &_cd_value, _copy_size); \
+ \
+ /* Next field */ \
+ _i++; \
+ _size_rem -= 4; \
+ if (_size_rem >= 4) \
+ _fv_p -= 4; \
+ else \
+ _fv_p -= _size_rem; \
+ } /* end while */ \
+ \
+ HDassert(_fv_p == (char *)&(fill_val)); \
+ if (_size_rem) { \
+ /* Amount left to copy is smaller than a cd_value, initialize \
+ * _cd_value as it will not be fully overwritten and copy to the end \
+ * of _cd value as it is BE. */ \
+ _cd_value = (uint32_t)(cd_values)[_i]; \
+ H5MM_memcpy(_fv_p, (char *)&_cd_value + 4 - _size_rem, _size_rem); \
+ } /* end if */ \
+ } /* end else */ \
+ }
/* Get the fill value for floating-point type */
-#define H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
-{ \
- if(sizeof(type) <= sizeof(long long)) \
- H5Z_scaleoffset_get_filval_1(type, cd_values, filval) \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
+ { \
+ if (sizeof(type) <= sizeof(long long)) \
+ H5Z_scaleoffset_get_filval_1(type, cd_values, filval) else HGOTO_ERROR( \
+ H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Find maximum and minimum values of a buffer with fill value defined for integer type */
-#define H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min)\
-{ \
- i = 0; while(i < d_nelmts && buf[i]== filval) i++; \
- if(i < d_nelmts) min = max = buf[i]; \
- for(; i < d_nelmts; i++) { \
- if(buf[i] == filval) continue; /* ignore fill value */ \
- if(buf[i] > max) max = buf[i]; \
- if(buf[i] < min) min = buf[i]; \
- } \
-}
+#define H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min) \
+ { \
+ i = 0; \
+ while (i < d_nelmts && buf[i] == filval) \
+ i++; \
+ if (i < d_nelmts) \
+ min = max = buf[i]; \
+ for (; i < d_nelmts; i++) { \
+ if (buf[i] == filval) \
+ continue; /* ignore fill value */ \
+ if (buf[i] > max) \
+ max = buf[i]; \
+ if (buf[i] < min) \
+ min = buf[i]; \
+ } \
+ }
/* Find maximum and minimum values of a buffer with fill value undefined */
-#define H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min)\
-{ \
- min = max = buf[0]; \
- for(i = 0; i < d_nelmts; i++) { \
- if(buf[i] > max) max = buf[i]; \
- if(buf[i] < min) min = buf[i]; \
- } \
-}
+#define H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
+ { \
+ min = max = buf[0]; \
+ for (i = 0; i < d_nelmts; i++) { \
+ if (buf[i] > max) \
+ max = buf[i]; \
+ if (buf[i] < min) \
+ min = buf[i]; \
+ } \
+ }
/* Find maximum and minimum values of a buffer with fill value defined for floating-point type */
-#define H5Z_scaleoffset_max_min_3(i, d_nelmts, buf, filval, max, min, D_val) \
-{ \
- i = 0; while(i < d_nelmts && HDfabs(buf[i] - filval) < HDpow(10.0f, -D_val)) i++; \
- if(i < d_nelmts) min = max = buf[i]; \
- for(; i < d_nelmts; i++) { \
- if(HDfabs(buf[i] - filval) < HDpow(10.0f, -D_val)) \
- continue; /* ignore fill value */ \
- if(buf[i] > max) max = buf[i]; \
- if(buf[i] < min) min = buf[i]; \
- } \
-}
+#define H5Z_scaleoffset_max_min_3(i, d_nelmts, buf, filval, max, min, D_val) \
+ { \
+ i = 0; \
+ while (i < d_nelmts && HDfabs(buf[i] - filval) < HDpow(10.0f, -D_val)) \
+ i++; \
+ if (i < d_nelmts) \
+ min = max = buf[i]; \
+ for (; i < d_nelmts; i++) { \
+ if (HDfabs(buf[i] - filval) < HDpow(10.0f, -D_val)) \
+ continue; /* ignore fill value */ \
+ if (buf[i] > max) \
+ max = buf[i]; \
+ if (buf[i] < min) \
+ min = buf[i]; \
+ } \
+ }
/* Find minimum value of a buffer with fill value defined for integer type */
-#define H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval, min) \
-{ \
- i = 0; while(i < d_nelmts && buf[i]== filval) i++; \
- if(i < d_nelmts) min = buf[i]; \
- for(; i < d_nelmts; i++) { \
- if(buf[i] == filval) continue; /* ignore fill value */ \
- if(buf[i] < min) min = buf[i]; \
- } \
-}
+#define H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval, min) \
+ { \
+ i = 0; \
+ while (i < d_nelmts && buf[i] == filval) \
+ i++; \
+ if (i < d_nelmts) \
+ min = buf[i]; \
+ for (; i < d_nelmts; i++) { \
+ if (buf[i] == filval) \
+ continue; /* ignore fill value */ \
+ if (buf[i] < min) \
+ min = buf[i]; \
+ } \
+ }
/* Find minimum value of a buffer with fill value undefined */
-#define H5Z_scaleoffset_min_2(i, d_nelmts, buf, min)\
-{ \
- min = buf[0]; \
- for(i = 0; i < d_nelmts; i++) \
- if(buf[i] < min) min = buf[i]; \
-}
+#define H5Z_scaleoffset_min_2(i, d_nelmts, buf, min) \
+ { \
+ min = buf[0]; \
+ for (i = 0; i < d_nelmts; i++) \
+ if (buf[i] < min) \
+ min = buf[i]; \
+ }
/* Check and handle special situation for unsigned integer type */
-#define H5Z_scaleoffset_check_1(type, max, min, minbits) \
-{ \
- if(max - min > (type)(~(type)0 - 2)) \
- { *minbits = sizeof(type)*8; return; } \
-}
+#define H5Z_scaleoffset_check_1(type, max, min, minbits) \
+ { \
+ if (max - min > (type)(~(type)0 - 2)) { \
+ *minbits = sizeof(type) * 8; \
+ return; \
+ } \
+ }
/* Check and handle special situation for signed integer type */
-#define H5Z_scaleoffset_check_2(type, max, min, minbits) \
-{ \
- if((unsigned type)(max - min) > (unsigned type)(~(unsigned type)0 - 2)) \
- { *minbits = sizeof(type)*8; return; } \
-}
+#define H5Z_scaleoffset_check_2(type, max, min, minbits) \
+ { \
+ if ((unsigned type)(max - min) > (unsigned type)(~(unsigned type)0 - 2)) { \
+ *minbits = sizeof(type) * 8; \
+ return; \
+ } \
+ }
/* Check and handle special situation for floating-point type */
-#define H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) \
-{ \
- if(sizeof(type) == sizeof(int)) { \
- if(round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) \
- > pow_fun(2.0f, (type)(sizeof(int) * 8 - 1))) { \
- *minbits = sizeof(int) * 8; \
- goto done; \
- } \
- } else if(sizeof(type) == sizeof(long)) { \
- if(round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) \
- > pow_fun(2.0f, (type)(sizeof(long) * 8 - 1))) { \
- *minbits = sizeof(long) * 8; \
- goto done; \
- } \
- } else if(sizeof(type) == sizeof(long long)) { \
- if(round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) \
- > pow_fun(2.0f, (type)(sizeof(long long) * 8 - 1))) { \
- *minbits = sizeof(long long) * 8; \
- goto done; \
- } \
- } else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) \
+ { \
+ if (sizeof(type) == sizeof(int)) { \
+ if (round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) > \
+ pow_fun(2.0f, (type)(sizeof(int) * 8 - 1))) { \
+ *minbits = sizeof(int) * 8; \
+ goto done; \
+ } \
+ } \
+ else if (sizeof(type) == sizeof(long)) { \
+ if (round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) > \
+ pow_fun(2.0f, (type)(sizeof(long) * 8 - 1))) { \
+ *minbits = sizeof(long) * 8; \
+ goto done; \
+ } \
+ } \
+ else if (sizeof(type) == sizeof(long long)) { \
+ if (round_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) > \
+ pow_fun(2.0f, (type)(sizeof(long long) * 8 - 1))) { \
+ *minbits = sizeof(long long) * 8; \
+ goto done; \
+ } \
+ } \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Precompress for unsigned integer type */
-#define H5Z_scaleoffset_precompress_1(type, data, d_nelmts, filavail, cd_values, minbits, minval)\
-{ \
- type *buf = (type *)data, min = 0, max = 0, span, filval = 0; \
- unsigned i; \
- \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_1(type, cd_values, filval) \
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */ \
- H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min) \
- H5Z_scaleoffset_check_1(type, max, min, minbits) \
- span = (type)(max - min + 1); \
- *minbits = H5Z__scaleoffset_log2((unsigned long long)(span+1)); \
- } else /* minbits already set, only calculate min */ \
- H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval, min) \
- if(*minbits != sizeof(type)*8) /* change values if minbits != full precision */ \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((buf[i] == filval) ? (((type)1 << *minbits) - 1) : (buf[i] - min)); \
- } else { /* fill value undefined */ \
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT ) { /* minbits not set yet, calculate max, min, and minbits */ \
- H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
- H5Z_scaleoffset_check_1(type, max, min, minbits) \
- span = (type)(max - min + 1); \
- *minbits = H5Z__scaleoffset_log2((unsigned long long)span); \
- } else /* minbits already set, only calculate min */ \
- H5Z_scaleoffset_min_2(i, d_nelmts, buf, min) \
- if(*minbits != sizeof(type)*8) /* change values if minbits != full precision */ \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)(buf[i] - min); \
- } \
- *minval = min; \
-}
+#define H5Z_scaleoffset_precompress_1(type, data, d_nelmts, filavail, cd_values, minbits, minval) \
+ { \
+ type * buf = (type *)data, min = 0, max = 0, span, filval = 0; \
+ unsigned i; \
+ \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_1(type, cd_values, \
+ filval) if (*minbits == H5Z_SO_INT_MINBITS_DEFAULT) \
+ { /* minbits not set yet, calculate max, min, and minbits */ \
+ H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min) \
+ H5Z_scaleoffset_check_1(type, max, min, minbits) span = (type)(max - min + 1); \
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)(span + 1)); \
+ } \
+ else /* minbits already set, only calculate min */ \
+ H5Z_scaleoffset_min_1( \
+ i, d_nelmts, buf, filval, \
+ min) if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ for (i = 0; i < d_nelmts; i++) buf[i] = \
+ (type)((buf[i] == filval) ? (((type)1 << *minbits) - 1) : (buf[i] - min)); \
+ } \
+ else { /* fill value undefined */ \
+ if (*minbits == \
+ H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */ \
+ H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
+ H5Z_scaleoffset_check_1(type, max, min, minbits) span = (type)(max - min + 1); \
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)span); \
+ } \
+ else /* minbits already set, only calculate min */ \
+ H5Z_scaleoffset_min_2( \
+ i, d_nelmts, buf, \
+ min) if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ for (i = 0; i < d_nelmts; i++) buf[i] = (type)(buf[i] - min); \
+ } \
+ *minval = min; \
+ }
/* Precompress for signed integer type */
-#define H5Z_scaleoffset_precompress_2(type, data, d_nelmts, filavail, cd_values, minbits, minval)\
-{ \
- type *buf = (type *)data, min = 0, max = 0, filval = 0; \
- unsigned type span; unsigned i; \
- \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_1(type, cd_values, filval) \
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */ \
- H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min) \
- H5Z_scaleoffset_check_2(type, max, min, minbits) \
- span = (unsigned type)(max - min + 1); \
- *minbits = H5Z__scaleoffset_log2((unsigned long long)(span + 1)); \
- } else /* minbits already set, only calculate min */ \
- H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval, min) \
- if(*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((buf[i] == filval) ? (type)(((unsigned type)1 << *minbits) - 1) : (buf[i] - min)); \
- } else { /* fill value undefined */ \
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT ) { /* minbits not set yet, calculate max, min, and minbits */\
- H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
- H5Z_scaleoffset_check_2(type, max, min, minbits) \
- span = (unsigned type)(max - min + 1); \
- *minbits = H5Z__scaleoffset_log2((unsigned long long)span); \
- } else /* minbits already set, only calculate min */ \
- H5Z_scaleoffset_min_2(i, d_nelmts, buf, min) \
- if(*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)(buf[i] - min); \
- } \
- *minval = (unsigned long long)min; \
-}
+#define H5Z_scaleoffset_precompress_2(type, data, d_nelmts, filavail, cd_values, minbits, minval) \
+ { \
+ type * buf = (type *)data, min = 0, max = 0, filval = 0; \
+ unsigned type span; \
+ unsigned i; \
+ \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_1(type, cd_values, \
+ filval) if (*minbits == H5Z_SO_INT_MINBITS_DEFAULT) \
+ { /* minbits not set yet, calculate max, min, and minbits */ \
+ H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min) \
+ H5Z_scaleoffset_check_2(type, max, min, minbits) span = (unsigned type)(max - min + 1); \
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)(span + 1)); \
+ } \
+ else /* minbits already set, only calculate min */ \
+ H5Z_scaleoffset_min_1( \
+ i, d_nelmts, buf, filval, \
+ min) if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ for (i = 0; i < d_nelmts; i++) buf[i] = (type)( \
+ (buf[i] == filval) ? (type)(((unsigned type)1 << *minbits) - 1) : (buf[i] - min)); \
+ } \
+ else { /* fill value undefined */ \
+ if (*minbits == \
+ H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */ \
+ H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
+ H5Z_scaleoffset_check_2(type, max, min, minbits) span = (unsigned type)(max - min + 1); \
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)span); \
+ } \
+ else /* minbits already set, only calculate min */ \
+ H5Z_scaleoffset_min_2( \
+ i, d_nelmts, buf, \
+ min) if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ for (i = 0; i < d_nelmts; i++) buf[i] = (type)(buf[i] - min); \
+ } \
+ *minval = (unsigned long long)min; \
+ }
/* Modify values of data in precompression if fill value defined for floating-point type */
-#define H5Z_scaleoffset_modify_1(i, type, pow_fun, abs_fun, lround_fun, llround_fun, buf, d_nelmts, filval, minbits, min, D_val) \
-{ \
- if(sizeof(type) == sizeof(int)) \
- for(i = 0; i < d_nelmts; i++) { \
- if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
- *(int *)((void *)&buf[i]) = (int)(((unsigned int)1 << *minbits) - 1); \
- else \
- *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- } \
- else if(sizeof(type) == sizeof(long)) \
- for(i = 0; i < d_nelmts; i++) { \
- if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
- *(long *)((void *)&buf[i]) = (long)(((unsigned long)1 << *minbits) - 1); \
- else \
- *(long *)((void *)&buf[i]) = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- } \
- else if(sizeof(type) == sizeof(long long)) \
- for(i = 0; i < d_nelmts; i++) { \
- if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
- *(long long *)((void *)&buf[i]) = (long long)(((unsigned long long)1 << *minbits) - 1); \
- else \
- *(long long *)((void *)&buf[i]) = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- } \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_modify_1(i, type, pow_fun, abs_fun, lround_fun, llround_fun, buf, d_nelmts, filval, \
+ minbits, min, D_val) \
+ { \
+ if (sizeof(type) == sizeof(int)) \
+ for (i = 0; i < d_nelmts; i++) { \
+ if (abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
+ *(int *)((void *)&buf[i]) = (int)(((unsigned int)1 << *minbits) - 1); \
+ else \
+ *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)); \
+ } \
+ else if (sizeof(type) == sizeof(long)) \
+ for (i = 0; i < d_nelmts; i++) { \
+ if (abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
+ *(long *)((void *)&buf[i]) = (long)(((unsigned long)1 << *minbits) - 1); \
+ else \
+ *(long *)((void *)&buf[i]) = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)); \
+ } \
+ else if (sizeof(type) == sizeof(long long)) \
+ for (i = 0; i < d_nelmts; i++) { \
+ if (abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val)) \
+ *(long long *)((void *)&buf[i]) = (long long)(((unsigned long long)1 << *minbits) - 1); \
+ else \
+ *(long long *)((void *)&buf[i]) = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)); \
+ } \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Modify values of data in precompression if fill value undefined for floating-point type */
-#define H5Z_scaleoffset_modify_2(i, type, pow_fun, lround_fun, llround_fun, buf, d_nelmts, min, D_val) \
-{ \
- if(sizeof(type) == sizeof(int)) \
- for(i = 0; i < d_nelmts; i++) \
- *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- else if(sizeof(type) == sizeof(long)) \
- for(i = 0; i < d_nelmts; i++) \
- *(long *)((void *)&buf[i]) = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- else if(sizeof(type) == sizeof(long long)) \
- for(i = 0; i < d_nelmts; i++) \
- *(long long *)((void *)&buf[i]) = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_modify_2(i, type, pow_fun, lround_fun, llround_fun, buf, d_nelmts, min, D_val) \
+ { \
+ if (sizeof(type) == sizeof(int)) \
+ for (i = 0; i < d_nelmts; i++) \
+ *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)); \
+ else if (sizeof(type) == sizeof(long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ *(long *)((void *)&buf[i]) = \
+ lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
+ else if (sizeof(type) == sizeof(long long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ *(long long *)((void *)&buf[i]) = \
+ llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Save the minimum value for floating-point type */
-#define H5Z_scaleoffset_save_min(i, type, minval, min) \
-{ \
- if(sizeof(type) <= sizeof(long long)) \
- /* Save min value to corresponding position \
- * byte-order will be swapped as appropriate, but be sure to \
- * account for offset in BE if sizes differ \
- */ \
- if(H5T_native_order_g == H5T_ORDER_LE) \
- H5MM_memcpy(minval, &min, sizeof(type)); \
- else { \
- HDassert(H5T_native_order_g == H5T_ORDER_BE); \
- H5MM_memcpy(((char *)minval) + (sizeof(long long) - sizeof(type)), \
- &min, sizeof(type)); \
- } /* end else */ \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_save_min(i, type, minval, min) \
+ { \
+ if (sizeof(type) <= sizeof(long long)) \
+ /* Save min value to corresponding position \
+ * byte-order will be swapped as appropriate, but be sure to \
+ * account for offset in BE if sizes differ \
+ */ \
+ if (H5T_native_order_g == H5T_ORDER_LE) \
+ H5MM_memcpy(minval, &min, sizeof(type)); \
+ else { \
+ HDassert(H5T_native_order_g == H5T_ORDER_BE); \
+ H5MM_memcpy(((char *)minval) + (sizeof(long long) - sizeof(type)), &min, sizeof(type)); \
+ } /* end else */ \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Precompress for floating-point type using variable-minimum-bits method */
-#define H5Z_scaleoffset_precompress_3(type, pow_fun, abs_fun, round_fun, lround_fun, llround_fun, data, d_nelmts, filavail, cd_values, \
- minbits, minval, D_val) \
-{ \
- type *buf = (type *)data, min = 0, max = 0, filval = 0; \
- unsigned long long span; \
- unsigned i; \
- \
- *minval = 0; \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
- H5Z_scaleoffset_max_min_3(i, d_nelmts, buf, filval, max, min, D_val) \
- H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) \
- span = (unsigned long long)(llround_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) + 1); \
- *minbits = H5Z__scaleoffset_log2(span + 1); \
- if(*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
- H5Z_scaleoffset_modify_1(i, type, pow_fun, abs_fun, lround_fun, llround_fun, buf, d_nelmts, filval, minbits, min, D_val) \
- } else { /* fill value undefined */ \
- H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
- H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) \
- span = (unsigned long long)(llround_fun(max * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)) + 1); \
- *minbits = H5Z__scaleoffset_log2(span); \
- if(*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
- H5Z_scaleoffset_modify_2(i, type, pow_fun, lround_fun, llround_fun, buf, d_nelmts, min, D_val) \
- } \
- H5Z_scaleoffset_save_min(i, type, minval, min) \
-}
+#define H5Z_scaleoffset_precompress_3(type, pow_fun, abs_fun, round_fun, lround_fun, llround_fun, data, \
+ d_nelmts, filavail, cd_values, minbits, minval, D_val) \
+ { \
+ type * buf = (type *)data, min = 0, max = 0, filval = 0; \
+ unsigned long long span; \
+ unsigned i; \
+ \
+ *minval = 0; \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
+ H5Z_scaleoffset_max_min_3(i, d_nelmts, buf, filval, max, min, D_val) \
+ H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) span = \
+ (unsigned long long)(llround_fun(max * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)) + \
+ 1); \
+ *minbits = H5Z__scaleoffset_log2(span + 1); \
+ if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ H5Z_scaleoffset_modify_1(i, type, pow_fun, abs_fun, lround_fun, llround_fun, buf, d_nelmts, \
+ filval, minbits, min, D_val) \
+ } \
+ else { /* fill value undefined */ \
+ H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min) \
+ H5Z_scaleoffset_check_3(i, type, pow_fun, round_fun, max, min, minbits, D_val) span = \
+ (unsigned long long)(llround_fun(max * pow_fun(10.0f, (type)D_val) - \
+ min * pow_fun(10.0f, (type)D_val)) + \
+ 1); \
+ *minbits = H5Z__scaleoffset_log2(span); \
+ if (*minbits != sizeof(type) * 8) /* change values if minbits != full precision */ \
+ H5Z_scaleoffset_modify_2(i, type, pow_fun, lround_fun, llround_fun, buf, d_nelmts, min, \
+ D_val) \
+ } \
+ H5Z_scaleoffset_save_min(i, type, minval, min) \
+ }
/* Postdecompress for unsigned integer type */
-#define H5Z_scaleoffset_postdecompress_1(type, data, d_nelmts, filavail, cd_values, minbits, minval)\
-{ \
- type *buf = (type *)data, filval = 0; unsigned i; \
- \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_1(type, cd_values, filval) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((buf[i] == (((type)1 << minbits) - 1)) ? filval : (buf[i] + minval)); \
- } else /* fill value undefined */ \
- for(i = 0; i < d_nelmts; i++) buf[i] = (type)(buf[i] + (type)(minval)); \
-}
+#define H5Z_scaleoffset_postdecompress_1(type, data, d_nelmts, filavail, cd_values, minbits, minval) \
+ { \
+ type * buf = (type *)data, filval = 0; \
+ unsigned i; \
+ \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_1(type, cd_values, filval) for (i = 0; i < d_nelmts; i++) buf[i] = \
+ (type)((buf[i] == (((type)1 << minbits) - 1)) ? filval : (buf[i] + minval)); \
+ } \
+ else /* fill value undefined */ \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = (type)(buf[i] + (type)(minval)); \
+ }
/* Postdecompress for signed integer type */
-#define H5Z_scaleoffset_postdecompress_2(type, data, d_nelmts, filavail, cd_values, minbits, minval)\
-{ \
- type *buf = (type *)data, filval = 0; \
- unsigned i; \
- \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_1(type, cd_values, filval) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)(((unsigned type)buf[i] == (((unsigned type)1 << minbits) - 1)) ? filval : (buf[i] + minval));\
- } else /* fill value undefined */ \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)(buf[i] + (type)(minval)); \
-}
+#define H5Z_scaleoffset_postdecompress_2(type, data, d_nelmts, filavail, cd_values, minbits, minval) \
+ { \
+ type * buf = (type *)data, filval = 0; \
+ unsigned i; \
+ \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_1(type, cd_values, filval) for (i = 0; i < d_nelmts; i++) buf[i] = \
+ (type)(((unsigned type)buf[i] == (((unsigned type)1 << minbits) - 1)) ? filval \
+ : (buf[i] + minval)); \
+ } \
+ else /* fill value undefined */ \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = (type)(buf[i] + (type)(minval)); \
+ }
/* Retrive minimum value of floating-point type */
-#define H5Z_scaleoffset_get_min(type, minval, min) \
-{ \
- if(sizeof(type) <= sizeof(long long)) \
- /* retrieve min value from corresponding position \
- * byte-order has already been swapped as appropriate, but be sure to \
- * account for offset in BE if sizes differ \
- */ \
- if(H5T_native_order_g == H5T_ORDER_LE) \
- H5MM_memcpy(&min, &minval, sizeof(type)); \
- else { \
- HDassert(H5T_native_order_g == H5T_ORDER_BE); \
- H5MM_memcpy(&min, ((char *)&minval) + (sizeof(long long) \
- - sizeof(type)), sizeof(type)); \
- } /* end else */ \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_get_min(type, minval, min) \
+ { \
+ if (sizeof(type) <= sizeof(long long)) \
+ /* retrieve min value from corresponding position \
+ * byte-order has already been swapped as appropriate, but be sure to \
+ * account for offset in BE if sizes differ \
+ */ \
+ if (H5T_native_order_g == H5T_ORDER_LE) \
+ H5MM_memcpy(&min, &minval, sizeof(type)); \
+ else { \
+ HDassert(H5T_native_order_g == H5T_ORDER_BE); \
+ H5MM_memcpy(&min, ((char *)&minval) + (sizeof(long long) - sizeof(type)), sizeof(type)); \
+ } /* end else */ \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Modify values of data in postdecompression if fill value defined for floating-point type */
-#define H5Z_scaleoffset_modify_3(i, type, pow_fun, buf, d_nelmts, filval, minbits, min, D_val) \
-{ \
- if(sizeof(type) == sizeof(int)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((*(int *)((void *)&buf[i]) == (int)(((unsigned int)1 << minbits) - 1)) ? \
- filval : (type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else if(sizeof(type) == sizeof(long)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((*(long *)((void *)&buf[i]) == (long)(((unsigned long)1 << minbits) - 1)) ? \
- filval : (type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else if(sizeof(type) == sizeof(long long)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = (type)((*(long long *)((void *)&buf[i]) == (long long)(((unsigned long long)1 << minbits) - 1)) ? \
- filval : (type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_modify_3(i, type, pow_fun, buf, d_nelmts, filval, minbits, min, D_val) \
+ { \
+ if (sizeof(type) == sizeof(int)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = \
+ (type)((*(int *)((void *)&buf[i]) == (int)(((unsigned int)1 << minbits) - 1)) \
+ ? filval \
+ : (type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else if (sizeof(type) == sizeof(long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = \
+ (type)((*(long *)((void *)&buf[i]) == (long)(((unsigned long)1 << minbits) - 1)) \
+ ? filval \
+ : (type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else if (sizeof(type) == sizeof(long long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = (type)( \
+ (*(long long *)((void *)&buf[i]) == (long long)(((unsigned long long)1 << minbits) - 1)) \
+ ? filval \
+ : (type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Modify values of data in postdecompression if fill value undefined for floating-point type */
-#define H5Z_scaleoffset_modify_4(i, type, pow_fun, buf, d_nelmts, min, D_val) \
-{ \
- if(sizeof(type)==sizeof(int)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = ((type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else if(sizeof(type)==sizeof(long)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = ((type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else if(sizeof(type)==sizeof(long long)) \
- for(i = 0; i < d_nelmts; i++) \
- buf[i] = ((type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
- else \
- HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
-}
+#define H5Z_scaleoffset_modify_4(i, type, pow_fun, buf, d_nelmts, min, D_val) \
+ { \
+ if (sizeof(type) == sizeof(int)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = ((type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else if (sizeof(type) == sizeof(long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = ((type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else if (sizeof(type) == sizeof(long long)) \
+ for (i = 0; i < d_nelmts; i++) \
+ buf[i] = ((type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
+ else \
+ HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
+ }
/* Postdecompress for floating-point type using variable-minimum-bits method */
-#define H5Z_scaleoffset_postdecompress_3(type, pow_fun, data, d_nelmts, filavail, cd_values, \
- minbits, minval, D_val) \
-{ \
- type *buf = (type *)data, filval = 0, min = 0; \
- unsigned i; \
- \
- H5Z_scaleoffset_get_min(type, minval, min) \
- \
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */ \
- H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
- H5Z_scaleoffset_modify_3(i, type, pow_fun, buf, d_nelmts, filval, minbits, min, D_val) \
- } else /* fill value undefined */ \
- H5Z_scaleoffset_modify_4(i, type, pow_fun, buf, d_nelmts, min, D_val) \
-}
-
+#define H5Z_scaleoffset_postdecompress_3(type, pow_fun, data, d_nelmts, filavail, cd_values, minbits, \
+ minval, D_val) \
+ { \
+ type * buf = (type *)data, filval = 0, min = 0; \
+ unsigned i; \
+ \
+ H5Z_scaleoffset_get_min(type, minval, min) \
+ \
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) \
+ { /* fill value defined */ \
+ H5Z_scaleoffset_get_filval_2(type, cd_values, filval) \
+ H5Z_scaleoffset_modify_3(i, type, pow_fun, buf, d_nelmts, filval, minbits, min, D_val) \
+ } \
+ else /* fill value undefined */ \
+ H5Z_scaleoffset_modify_4(i, type, pow_fun, buf, d_nelmts, min, D_val) \
+ }
/*-------------------------------------------------------------------------
* Function: H5Z__can_apply_scaleoffset
@@ -683,41 +753,41 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
static htri_t
H5Z__can_apply_scaleoffset(hid_t H5_ATTR_UNUSED dcpl_id, hid_t type_id, hid_t H5_ATTR_UNUSED space_id)
{
- const H5T_t *type; /* Datatype */
- H5T_class_t dtype_class; /* Datatype's class */
- H5T_order_t dtype_order; /* Datatype's endianness order */
- htri_t ret_value = TRUE; /* Return value */
+ const H5T_t *type; /* Datatype */
+ H5T_class_t dtype_class; /* Datatype's class */
+ H5T_order_t dtype_order; /* Datatype's endianness order */
+ htri_t ret_value = TRUE; /* Return value */
FUNC_ENTER_STATIC
/* Get datatype */
- if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
+ if (NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
/* Get datatype's class, for checking the "datatype class" */
- if((dtype_class = H5T_get_class(type, TRUE)) == H5T_NO_CLASS)
+ if ((dtype_class = H5T_get_class(type, TRUE)) == H5T_NO_CLASS)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype class")
/* Get datatype's size, for checking the "datatype size" */
- if(H5T_get_size(type) == 0)
+ if (H5T_get_size(type) == 0)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
- if(dtype_class == H5T_INTEGER || dtype_class == H5T_FLOAT) {
+ if (dtype_class == H5T_INTEGER || dtype_class == H5T_FLOAT) {
/* Get datatype's endianness order */
- if((dtype_order = H5T_get_order(type)) == H5T_ORDER_ERROR)
+ if ((dtype_order = H5T_get_order(type)) == H5T_ORDER_ERROR)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "can't retrieve datatype endianness order")
/* Range check datatype's endianness order */
- if(dtype_order != H5T_ORDER_LE && dtype_order != H5T_ORDER_BE)
+ if (dtype_order != H5T_ORDER_LE && dtype_order != H5T_ORDER_BE)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FALSE, "bad datatype endianness order")
- } else
+ }
+ else
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FALSE, "datatype class not supported by scaleoffset")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5Z__can_apply_scaleoffset() */
-
/*-------------------------------------------------------------------------
* Function: H5Z__scaleoffset_get_type
*
@@ -735,40 +805,52 @@ done:
static enum H5Z_scaleoffset_t
H5Z__scaleoffset_get_type(unsigned dtype_class, unsigned dtype_size, unsigned dtype_sign)
{
- enum H5Z_scaleoffset_t type = t_bad; /* integer type */
- enum H5Z_scaleoffset_t ret_value = t_bad; /* Return value */
+ enum H5Z_scaleoffset_t type = t_bad; /* integer type */
+ enum H5Z_scaleoffset_t ret_value = t_bad; /* Return value */
FUNC_ENTER_STATIC
- if(dtype_class==H5Z_SCALEOFFSET_CLS_INTEGER) {
- if(dtype_sign==H5Z_SCALEOFFSET_SGN_NONE) { /* unsigned integer */
- if (dtype_size == sizeof(unsigned char)) type = t_uchar;
- else if(dtype_size == sizeof(unsigned short)) type = t_ushort;
- else if(dtype_size == sizeof(unsigned int)) type = t_uint;
- else if(dtype_size == sizeof(unsigned long)) type = t_ulong;
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_INTEGER) {
+ if (dtype_sign == H5Z_SCALEOFFSET_SGN_NONE) { /* unsigned integer */
+ if (dtype_size == sizeof(unsigned char))
+ type = t_uchar;
+ else if (dtype_size == sizeof(unsigned short))
+ type = t_ushort;
+ else if (dtype_size == sizeof(unsigned int))
+ type = t_uint;
+ else if (dtype_size == sizeof(unsigned long))
+ type = t_ulong;
#if H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG
- else if(dtype_size == sizeof(unsigned long long)) type = t_ulong_long;
+ else if (dtype_size == sizeof(unsigned long long))
+ type = t_ulong_long;
#endif /* H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG */
else
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, t_bad, "cannot find matched memory dataype")
}
- if(dtype_sign==H5Z_SCALEOFFSET_SGN_2) { /* signed integer */
- if (dtype_size == sizeof(signed char)) type = t_schar;
- else if(dtype_size == sizeof(short)) type = t_short;
- else if(dtype_size == sizeof(int)) type = t_int;
- else if(dtype_size == sizeof(long)) type = t_long;
+ if (dtype_sign == H5Z_SCALEOFFSET_SGN_2) { /* signed integer */
+ if (dtype_size == sizeof(signed char))
+ type = t_schar;
+ else if (dtype_size == sizeof(short))
+ type = t_short;
+ else if (dtype_size == sizeof(int))
+ type = t_int;
+ else if (dtype_size == sizeof(long))
+ type = t_long;
#if H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG
- else if(dtype_size == sizeof(long long)) type = t_long_long;
+ else if (dtype_size == sizeof(long long))
+ type = t_long_long;
#endif /* H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG */
else
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, t_bad, "cannot find matched memory dataype")
}
}
- if(dtype_class==H5Z_SCALEOFFSET_CLS_FLOAT) {
- if(dtype_size == sizeof(float)) type = t_float;
- else if(dtype_size == sizeof(double)) type = t_double;
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_FLOAT) {
+ if (dtype_size == sizeof(float))
+ type = t_float;
+ else if (dtype_size == sizeof(double))
+ type = t_double;
else
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, t_bad, "cannot find matched memory dataype")
}
@@ -780,7 +862,6 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
}
-
/*-------------------------------------------------------------------------
* Function: H5Z__scaleoffset_set_parms_fillval
*
@@ -795,44 +876,45 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5Z__scaleoffset_set_parms_fillval(H5P_genplist_t *dcpl_plist,
- H5T_t *type, enum H5Z_scaleoffset_t scale_type,
- unsigned cd_values[], int need_convert)
+H5Z__scaleoffset_set_parms_fillval(H5P_genplist_t *dcpl_plist, H5T_t *type, enum H5Z_scaleoffset_t scale_type,
+ unsigned cd_values[], int need_convert)
{
- herr_t ret_value = SUCCEED; /* Return value */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
- if(scale_type == t_uchar)
- H5Z_scaleoffset_set_filval_3(unsigned char, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_ushort)
- H5Z_scaleoffset_set_filval_1(unsigned short, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_uint)
- H5Z_scaleoffset_set_filval_1(unsigned int, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_ulong)
- H5Z_scaleoffset_set_filval_1(unsigned long, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_ulong_long)
- H5Z_scaleoffset_set_filval_1(unsigned long long, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_schar)
- H5Z_scaleoffset_set_filval_3(signed char, dcpl_plist, type, cd_values, need_convertd)
- else if(scale_type == t_short)
- H5Z_scaleoffset_set_filval_2(short, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_int)
- H5Z_scaleoffset_set_filval_2(int, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_long)
- H5Z_scaleoffset_set_filval_2(long, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_long_long)
- H5Z_scaleoffset_set_filval_2(long long, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_float)
- H5Z_scaleoffset_set_filval_4(float, dcpl_plist, type, cd_values, need_convert)
- else if(scale_type == t_double)
- H5Z_scaleoffset_set_filval_4(double, dcpl_plist, type, cd_values, need_convert)
-
-done:
- FUNC_LEAVE_NOAPI(ret_value)
+ if (scale_type == t_uchar)
+ H5Z_scaleoffset_set_filval_3(unsigned char, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_ushort)
+ H5Z_scaleoffset_set_filval_1(unsigned short, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_uint)
+ H5Z_scaleoffset_set_filval_1(unsigned int, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_ulong)
+ H5Z_scaleoffset_set_filval_1(unsigned long, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_ulong_long)
+ H5Z_scaleoffset_set_filval_1(unsigned long long, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_schar)
+ H5Z_scaleoffset_set_filval_3(signed char, dcpl_plist, type, cd_values,
+ need_convertd) else if (scale_type == t_short)
+ H5Z_scaleoffset_set_filval_2(short, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_int)
+ H5Z_scaleoffset_set_filval_2(int, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_long)
+ H5Z_scaleoffset_set_filval_2(long, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type ==
+ t_long_long)
+ H5Z_scaleoffset_set_filval_2(
+ long long, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_float)
+ H5Z_scaleoffset_set_filval_4(
+ float, dcpl_plist, type, cd_values,
+ need_convert) else if (scale_type == t_double)
+ H5Z_scaleoffset_set_filval_4(double, dcpl_plist, type,
+ cd_values, need_convert)
+
+ done : FUNC_LEAVE_NOAPI(ret_value)
} /* end H5Z__scaleoffset_set_parms_fillval() */
-
/*-------------------------------------------------------------------------
* Function: H5Z__set_local_scaleoffset
*
@@ -850,55 +932,56 @@ done:
static herr_t
H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id)
{
- H5P_genplist_t *dcpl_plist; /* Property list pointer */
- H5T_t *type; /* Datatype */
- const H5S_t *ds; /* Dataspace */
- unsigned flags; /* Filter flags */
- size_t cd_nelmts = H5Z_SCALEOFFSET_USER_NPARMS; /* Number of filter parameters */
- unsigned cd_values[H5Z_SCALEOFFSET_TOTAL_NPARMS]; /* Filter parameters */
- hssize_t npoints; /* Number of points in the dataspace */
- H5T_class_t dtype_class; /* Datatype's class */
- H5T_order_t dtype_order; /* Datatype's endianness order */
- size_t dtype_size; /* Datatype's size (in bytes) */
- H5T_sign_t dtype_sign; /* Datatype's sign */
- enum H5Z_scaleoffset_t scale_type; /* Specific datatype */
- H5D_fill_value_t status; /* Status of fill value in property list */
- herr_t ret_value = SUCCEED; /* Return value */
+ H5P_genplist_t * dcpl_plist; /* Property list pointer */
+ H5T_t * type; /* Datatype */
+ const H5S_t * ds; /* Dataspace */
+ unsigned flags; /* Filter flags */
+ size_t cd_nelmts = H5Z_SCALEOFFSET_USER_NPARMS; /* Number of filter parameters */
+ unsigned cd_values[H5Z_SCALEOFFSET_TOTAL_NPARMS]; /* Filter parameters */
+ hssize_t npoints; /* Number of points in the dataspace */
+ H5T_class_t dtype_class; /* Datatype's class */
+ H5T_order_t dtype_order; /* Datatype's endianness order */
+ size_t dtype_size; /* Datatype's size (in bytes) */
+ H5T_sign_t dtype_sign; /* Datatype's sign */
+ enum H5Z_scaleoffset_t scale_type; /* Specific datatype */
+ H5D_fill_value_t status; /* Status of fill value in property list */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
/* Get the plist structure */
- if(NULL == (dcpl_plist = H5P_object_verify(dcpl_id, H5P_DATASET_CREATE)))
+ if (NULL == (dcpl_plist = H5P_object_verify(dcpl_id, H5P_DATASET_CREATE)))
HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID")
/* Get datatype */
- if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
+ if (NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
/* Initialize the parameters to a known state */
HDmemset(cd_values, 0, sizeof(cd_values));
/* Get the filter's current parameters */
- if(H5P_get_filter_by_id(dcpl_plist, H5Z_FILTER_SCALEOFFSET, &flags, &cd_nelmts, cd_values, (size_t)0, NULL, NULL) < 0)
+ if (H5P_get_filter_by_id(dcpl_plist, H5Z_FILTER_SCALEOFFSET, &flags, &cd_nelmts, cd_values, (size_t)0,
+ NULL, NULL) < 0)
HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't get scaleoffset parameters")
/* Get dataspace */
- if(NULL == (ds = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+ if (NULL == (ds = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
/* Get total number of elements in the chunk */
- if((npoints = H5S_GET_EXTENT_NPOINTS(ds)) < 0)
+ if ((npoints = H5S_GET_EXTENT_NPOINTS(ds)) < 0)
HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to get number of points in the dataspace")
/* Set "local" parameter for this dataset's number of elements */
H5_CHECKED_ASSIGN(cd_values[H5Z_SCALEOFFSET_PARM_NELMTS], unsigned, npoints, hssize_t);
/* Get datatype's class */
- if((dtype_class = H5T_get_class(type, TRUE)) == H5T_NO_CLASS)
+ if ((dtype_class = H5T_get_class(type, TRUE)) == H5T_NO_CLASS)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype class")
/* Set "local" parameter for datatype's class */
- switch(dtype_class) {
+ switch (dtype_class) {
case H5T_INTEGER:
cd_values[H5Z_SCALEOFFSET_PARM_CLASS] = H5Z_SCALEOFFSET_CLS_INTEGER;
break;
@@ -923,20 +1006,20 @@ H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id)
} /* end switch */
/* Get datatype's size */
- if((dtype_size = H5T_get_size(type)) == 0)
+ if ((dtype_size = H5T_get_size(type)) == 0)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
/* Set "local" parameter for datatype size */
H5_CHECK_OVERFLOW(dtype_size, size_t, unsigned);
cd_values[H5Z_SCALEOFFSET_PARM_SIZE] = (unsigned)dtype_size;
- if(dtype_class == H5T_INTEGER) {
+ if (dtype_class == H5T_INTEGER) {
/* Get datatype's sign */
- if((dtype_sign = H5T_get_sign(type)) == H5T_SGN_ERROR)
+ if ((dtype_sign = H5T_get_sign(type)) == H5T_SGN_ERROR)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype sign")
/* Set "local" parameter for integer datatype sign */
- switch(dtype_sign) {
+ switch (dtype_sign) {
case H5T_SGN_NONE:
cd_values[H5Z_SCALEOFFSET_PARM_SIGN] = H5Z_SCALEOFFSET_SGN_NONE;
break;
@@ -950,19 +1033,19 @@ H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id)
default:
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad integer sign")
} /* end switch */
- } /* end if */
+ } /* end if */
/* Get datatype's endianness order */
- if((dtype_order = H5T_get_order(type)) == H5T_ORDER_ERROR)
+ if ((dtype_order = H5T_get_order(type)) == H5T_ORDER_ERROR)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype endianness order")
/* Set "local" parameter for datatype endianness */
- switch(dtype_order) {
- case H5T_ORDER_LE: /* Little-endian byte order */
+ switch (dtype_order) {
+ case H5T_ORDER_LE: /* Little-endian byte order */
cd_values[H5Z_SCALEOFFSET_PARM_ORDER] = H5Z_SCALEOFFSET_ORDER_LE;
break;
- case H5T_ORDER_BE: /* Big-endian byte order */
+ case H5T_ORDER_BE: /* Big-endian byte order */
cd_values[H5Z_SCALEOFFSET_PARM_ORDER] = H5Z_SCALEOFFSET_ORDER_BE;
break;
@@ -975,40 +1058,41 @@ H5Z__set_local_scaleoffset(hid_t dcpl_id, hid_t type_id, hid_t space_id)
} /* end switch */
/* Check whether fill value is defined for dataset */
- if(H5P_fill_value_defined(dcpl_plist, &status) < 0)
+ if (H5P_fill_value_defined(dcpl_plist, &status) < 0)
HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "unable to determine if fill value is defined")
/* Set local parameter for availability of fill value */
- if(status == H5D_FILL_VALUE_UNDEFINED)
+ if (status == H5D_FILL_VALUE_UNDEFINED)
cd_values[H5Z_SCALEOFFSET_PARM_FILAVAIL] = H5Z_SCALEOFFSET_FILL_UNDEFINED;
else {
- int need_convert = FALSE; /* Flag indicating conversion of byte order */
+ int need_convert = FALSE; /* Flag indicating conversion of byte order */
cd_values[H5Z_SCALEOFFSET_PARM_FILAVAIL] = H5Z_SCALEOFFSET_FILL_DEFINED;
/* Check if memory byte order matches dataset datatype byte order */
- if(H5T_native_order_g != dtype_order)
+ if (H5T_native_order_g != dtype_order)
need_convert = TRUE;
/* Before getting fill value, get its type */
- if((scale_type = H5Z__scaleoffset_get_type(cd_values[H5Z_SCALEOFFSET_PARM_CLASS],
- cd_values[H5Z_SCALEOFFSET_PARM_SIZE], cd_values[H5Z_SCALEOFFSET_PARM_SIGN])) == 0)
+ if ((scale_type = H5Z__scaleoffset_get_type(cd_values[H5Z_SCALEOFFSET_PARM_CLASS],
+ cd_values[H5Z_SCALEOFFSET_PARM_SIZE],
+ cd_values[H5Z_SCALEOFFSET_PARM_SIGN])) == 0)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot use C integer datatype for cast")
/* Get dataset fill value and store in cd_values[] */
- if(H5Z__scaleoffset_set_parms_fillval(dcpl_plist, type, scale_type, cd_values, need_convert) < 0)
+ if (H5Z__scaleoffset_set_parms_fillval(dcpl_plist, type, scale_type, cd_values, need_convert) < 0)
HGOTO_ERROR(H5E_PLINE, H5E_CANTSET, FAIL, "unable to set fill value")
} /* end else */
/* Modify the filter's parameters for this dataset */
- if(H5P_modify_filter(dcpl_plist, H5Z_FILTER_SCALEOFFSET, flags, (size_t)H5Z_SCALEOFFSET_TOTAL_NPARMS, cd_values) < 0)
+ if (H5P_modify_filter(dcpl_plist, H5Z_FILTER_SCALEOFFSET, flags, (size_t)H5Z_SCALEOFFSET_TOTAL_NPARMS,
+ cd_values) < 0)
HGOTO_ERROR(H5E_PLINE, H5E_CANTSET, FAIL, "can't set local scaleoffset parameters")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5Z__set_local_scaleoffset() */
-
/*-------------------------------------------------------------------------
* Function: H5Z__filter_scaleoffset
*
@@ -1024,42 +1108,42 @@ done:
*-------------------------------------------------------------------------
*/
static size_t
-H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
- size_t nbytes, size_t *buf_size, void **buf)
+H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_values[], size_t nbytes,
+ size_t *buf_size, void **buf)
{
- size_t ret_value = 0; /* return value */
- size_t size_out = 0; /* size of output buffer */
- unsigned d_nelmts = 0; /* number of data elements in the chunk */
- unsigned dtype_class; /* datatype class */
- unsigned dtype_sign; /* integer datatype sign */
- unsigned filavail; /* flag indicating if fill value is defined or not */
- H5Z_SO_scale_type_t scale_type = H5Z_SO_FLOAT_DSCALE;/* scale type */
- int scale_factor = 0; /* scale factor */
- double D_val = 0.0f; /* decimal scale factor */
- uint32_t minbits = 0; /* minimum number of bits to store values */
- unsigned long long minval= 0; /* minimum value of input buffer */
- enum H5Z_scaleoffset_t type; /* memory type corresponding to dataset datatype */
- int need_convert = FALSE; /* flag indicating conversion of byte order */
- unsigned char *outbuf = NULL; /* pointer to new output buffer */
- unsigned buf_offset = 21; /* buffer offset because of parameters stored in file */
- unsigned i; /* index */
- parms_atomic p; /* parameters needed for compress/decompress functions */
+ size_t ret_value = 0; /* return value */
+ size_t size_out = 0; /* size of output buffer */
+ unsigned d_nelmts = 0; /* number of data elements in the chunk */
+ unsigned dtype_class; /* datatype class */
+ unsigned dtype_sign; /* integer datatype sign */
+ unsigned filavail; /* flag indicating if fill value is defined or not */
+ H5Z_SO_scale_type_t scale_type = H5Z_SO_FLOAT_DSCALE; /* scale type */
+ int scale_factor = 0; /* scale factor */
+ double D_val = 0.0f; /* decimal scale factor */
+ uint32_t minbits = 0; /* minimum number of bits to store values */
+ unsigned long long minval = 0; /* minimum value of input buffer */
+ enum H5Z_scaleoffset_t type; /* memory type corresponding to dataset datatype */
+ int need_convert = FALSE; /* flag indicating conversion of byte order */
+ unsigned char * outbuf = NULL; /* pointer to new output buffer */
+ unsigned buf_offset = 21; /* buffer offset because of parameters stored in file */
+ unsigned i; /* index */
+ parms_atomic p; /* parameters needed for compress/decompress functions */
FUNC_ENTER_STATIC
/* check arguments */
- if(cd_nelmts != H5Z_SCALEOFFSET_TOTAL_NPARMS)
+ if (cd_nelmts != H5Z_SCALEOFFSET_TOTAL_NPARMS)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid scaleoffset number of parameters")
/* Check if memory byte order matches dataset datatype byte order */
- switch(H5T_native_order_g) {
- case H5T_ORDER_LE: /* memory is little-endian byte order */
- if(cd_values[H5Z_SCALEOFFSET_PARM_ORDER] == H5Z_SCALEOFFSET_ORDER_BE)
+ switch (H5T_native_order_g) {
+ case H5T_ORDER_LE: /* memory is little-endian byte order */
+ if (cd_values[H5Z_SCALEOFFSET_PARM_ORDER] == H5Z_SCALEOFFSET_ORDER_BE)
need_convert = TRUE;
break;
- case H5T_ORDER_BE: /* memory is big-endian byte order */
- if(cd_values[H5Z_SCALEOFFSET_PARM_ORDER] == H5Z_SCALEOFFSET_ORDER_LE)
+ case H5T_ORDER_BE: /* memory is big-endian byte order */
+ if (cd_values[H5Z_SCALEOFFSET_PARM_ORDER] == H5Z_SCALEOFFSET_ORDER_LE)
need_convert = TRUE;
break;
@@ -1087,33 +1171,35 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
* scale factor is the fixed minimum number of bits
* H5Z_SO_INT : integer type, scale_factor is minimum number of bits
*/
- if(dtype_class==H5Z_SCALEOFFSET_CLS_FLOAT) { /* floating-point type */
- if(scale_type!=H5Z_SO_FLOAT_DSCALE && scale_type!=H5Z_SO_FLOAT_ESCALE)
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_FLOAT) { /* floating-point type */
+ if (scale_type != H5Z_SO_FLOAT_DSCALE && scale_type != H5Z_SO_FLOAT_ESCALE)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid scale type")
}
- if(dtype_class==H5Z_SCALEOFFSET_CLS_INTEGER) { /* integer type */
- if(scale_type!=H5Z_SO_INT)
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_INTEGER) { /* integer type */
+ if (scale_type != H5Z_SO_INT)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid scale type")
/* if scale_factor is less than 0 for integer, library will reset it to 0
* in this case, library will calculate the minimum-bits
*/
- if(scale_factor < 0) scale_factor = 0;
+ if (scale_factor < 0)
+ scale_factor = 0;
}
/* fixed-minimum-bits method is not implemented and is forbidden */
- if(scale_type==H5Z_SO_FLOAT_ESCALE)
- HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "E-scaling method not supported")
+ if (scale_type == H5Z_SO_FLOAT_ESCALE)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "E-scaling method not supported")
- if(scale_type==H5Z_SO_FLOAT_DSCALE) { /* floating-point type, variable-minimum-bits */
+ if (scale_type == H5Z_SO_FLOAT_DSCALE) { /* floating-point type, variable-minimum-bits */
D_val = (double)scale_factor;
- } else { /* integer type, or floating-point type with fixed-minimum-bits method */
- if(scale_factor > (int)(cd_values[H5Z_SCALEOFFSET_PARM_SIZE] * 8))
+ }
+ else { /* integer type, or floating-point type with fixed-minimum-bits method */
+ if (scale_factor > (int)(cd_values[H5Z_SCALEOFFSET_PARM_SIZE] * 8))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "minimum number of bits exceeds maximum")
/* no need to process data */
- if(scale_factor == (int)(cd_values[H5Z_SCALEOFFSET_PARM_SIZE] * 8)) {
+ if (scale_factor == (int)(cd_values[H5Z_SCALEOFFSET_PARM_SIZE] * 8)) {
ret_value = *buf_size;
goto done;
}
@@ -1121,7 +1207,7 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
}
/* prepare parameters to pass to compress/decompress functions */
- p.size = cd_values[H5Z_SCALEOFFSET_PARM_SIZE];
+ p.size = cd_values[H5Z_SCALEOFFSET_PARM_SIZE];
p.mem_order = H5T_native_order_g;
/* input; decompress */
@@ -1129,14 +1215,14 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
/* retrieve values of minbits and minval from input compressed buffer
* retrieve them corresponding to how they are stored during compression
*/
- uint32_t minbits_mask = 0;
- unsigned long long minval_mask = 0;
- unsigned minval_size = 0;
+ uint32_t minbits_mask = 0;
+ unsigned long long minval_mask = 0;
+ unsigned minval_size = 0;
minbits = 0;
- for(i = 0; i < 4; i++) {
+ for (i = 0; i < 4; i++) {
minbits_mask = ((unsigned char *)*buf)[i];
- minbits_mask <<= i*8;
+ minbits_mask <<= i * 8;
minbits |= minbits_mask;
}
@@ -1144,12 +1230,12 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
* unsigned long long (datatype of minval) may change from compression
* to decompression, only smaller size is used
*/
- minval_size = sizeof(unsigned long long) <= ((unsigned char *)*buf)[4] ?
- sizeof(unsigned long long) : ((unsigned char *)*buf)[4];
+ minval_size = sizeof(unsigned long long) <= ((unsigned char *)*buf)[4] ? sizeof(unsigned long long)
+ : ((unsigned char *)*buf)[4];
minval = 0;
- for(i = 0; i < minval_size; i++) {
- minval_mask = ((unsigned char *)*buf)[5+i];
- minval_mask <<= i*8;
+ for (i = 0; i < minval_size; i++) {
+ minval_mask = ((unsigned char *)*buf)[5 + i];
+ minval_mask <<= i * 8;
minval |= minval_mask;
}
@@ -1160,52 +1246,53 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
size_out = d_nelmts * p.size;
/* allocate memory space for decompressed buffer */
- if(NULL == (outbuf = (unsigned char *)H5MM_malloc(size_out)))
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed for scaleoffset decompression")
+ if (NULL == (outbuf = (unsigned char *)H5MM_malloc(size_out)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0,
+ "memory allocation failed for scaleoffset decompression")
/* special case: minbits equal to full precision */
- if(minbits == p.size * 8) {
- H5MM_memcpy(outbuf, (unsigned char*)(*buf)+buf_offset, size_out);
+ if (minbits == p.size * 8) {
+ H5MM_memcpy(outbuf, (unsigned char *)(*buf) + buf_offset, size_out);
/* free the original buffer */
H5MM_xfree(*buf);
/* convert to dataset datatype endianness order if needed */
- if(need_convert)
+ if (need_convert)
H5Z__scaleoffset_convert(outbuf, d_nelmts, p.size);
- *buf = outbuf;
- outbuf = NULL;
+ *buf = outbuf;
+ outbuf = NULL;
*buf_size = size_out;
ret_value = size_out;
goto done;
}
/* decompress the buffer if minbits not equal to zero */
- if(minbits != 0)
- H5Z__scaleoffset_decompress(outbuf, d_nelmts, (unsigned char*)(*buf)+buf_offset, p);
+ if (minbits != 0)
+ H5Z__scaleoffset_decompress(outbuf, d_nelmts, (unsigned char *)(*buf) + buf_offset, p);
else {
/* fill value is not defined and all data elements have the same value */
- for(i = 0; i < size_out; i++) outbuf[i] = 0;
+ for (i = 0; i < size_out; i++)
+ outbuf[i] = 0;
}
/* before postprocess, get memory type */
- if((type = H5Z__scaleoffset_get_type(dtype_class, p.size, dtype_sign)) == 0)
+ if ((type = H5Z__scaleoffset_get_type(dtype_class, p.size, dtype_sign)) == 0)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, 0, "cannot use C integer datatype for cast")
/* postprocess after decompression */
- if(dtype_class==H5Z_SCALEOFFSET_CLS_INTEGER)
- H5Z__scaleoffset_postdecompress_i(outbuf, d_nelmts, type, filavail,
- cd_values, minbits, minval);
-
- if(dtype_class==H5Z_SCALEOFFSET_CLS_FLOAT)
- if(scale_type==0) { /* variable-minimum-bits method */
- if(H5Z__scaleoffset_postdecompress_fd(outbuf, d_nelmts, type, filavail,
- cd_values, minbits, minval, D_val)==FAIL)
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_INTEGER)
+ H5Z__scaleoffset_postdecompress_i(outbuf, d_nelmts, type, filavail, cd_values, minbits, minval);
+
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_FLOAT)
+ if (scale_type == 0) { /* variable-minimum-bits method */
+ if (H5Z__scaleoffset_postdecompress_fd(outbuf, d_nelmts, type, filavail, cd_values, minbits,
+ minval, D_val) == FAIL)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, 0, "post-decompression failed")
}
/* after postprocess, convert to dataset datatype endianness order if needed */
- if(need_convert)
+ if (need_convert)
H5Z__scaleoffset_convert(outbuf, d_nelmts, p.size);
}
/* output; compress */
@@ -1213,22 +1300,21 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
HDassert(nbytes == d_nelmts * p.size);
/* before preprocess, convert to memory endianness order if needed */
- if(need_convert)
+ if (need_convert)
H5Z__scaleoffset_convert(*buf, d_nelmts, p.size);
/* before preprocess, get memory type */
- if((type = H5Z__scaleoffset_get_type(dtype_class, p.size, dtype_sign))==0)
+ if ((type = H5Z__scaleoffset_get_type(dtype_class, p.size, dtype_sign)) == 0)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, 0, "cannot use C integer datatype for cast")
/* preprocess before compression */
- if(dtype_class==H5Z_SCALEOFFSET_CLS_INTEGER)
- H5Z__scaleoffset_precompress_i(*buf, d_nelmts, type, filavail,
- cd_values, &minbits, &minval);
-
- if(dtype_class==H5Z_SCALEOFFSET_CLS_FLOAT)
- if(scale_type==0) { /* variable-minimum-bits method */
- if(H5Z__scaleoffset_precompress_fd(*buf, d_nelmts, type, filavail,
- cd_values, &minbits, &minval, D_val)==FAIL)
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_INTEGER)
+ H5Z__scaleoffset_precompress_i(*buf, d_nelmts, type, filavail, cd_values, &minbits, &minval);
+
+ if (dtype_class == H5Z_SCALEOFFSET_CLS_FLOAT)
+ if (scale_type == 0) { /* variable-minimum-bits method */
+ if (H5Z__scaleoffset_precompress_fd(*buf, d_nelmts, type, filavail, cd_values, &minbits,
+ &minval, D_val) == FAIL)
HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, 0, "pre-compression failed")
}
@@ -1238,10 +1324,10 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
* minbits and minval are stored in the front of the compressed buffer
*/
p.minbits = minbits;
- size_out = buf_offset + nbytes * p.minbits / (p.size * 8) + 1; /* may be 1 larger */
+ size_out = buf_offset + nbytes * p.minbits / (p.size * 8) + 1; /* may be 1 larger */
/* allocate memory space for compressed buffer */
- if(NULL == (outbuf = (unsigned char *)H5MM_malloc(size_out)))
+ if (NULL == (outbuf = (unsigned char *)H5MM_malloc(size_out)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed for scaleoffset compression")
/* store minbits and minval in the front of output compressed buffer
@@ -1249,13 +1335,14 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
* constant buffer size (21 bytes) is left for these two parameters
* 4 bytes for minbits, 1 byte for size of minval, 16 bytes for minval
*/
- for(i = 0; i < 4; i++)
- ((unsigned char *)outbuf)[i] = (unsigned char)((minbits & ((uint32_t)0xff << i*8)) >> i*8);
+ for (i = 0; i < 4; i++)
+ ((unsigned char *)outbuf)[i] = (unsigned char)((minbits & ((uint32_t)0xff << i * 8)) >> i * 8);
((unsigned char *)outbuf)[4] = sizeof(unsigned long long);
- for(i = 0; i < sizeof(unsigned long long); i++)
- ((unsigned char *)outbuf)[5+i] = (unsigned char)((minval & ((unsigned long long)0xff << i*8)) >> i*8);
+ for (i = 0; i < sizeof(unsigned long long); i++)
+ ((unsigned char *)outbuf)[5 + i] =
+ (unsigned char)((minval & ((unsigned long long)0xff << i * 8)) >> i * 8);
/* Zero out remaining, unused bytes */
/* (Looks like an error in the original determination of how many
@@ -1264,13 +1351,13 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
HDmemset(outbuf + 13, 0, (size_t)8);
/* special case: minbits equal to full precision */
- if(minbits == p.size * 8) {
+ if (minbits == p.size * 8) {
H5MM_memcpy(outbuf + buf_offset, *buf, nbytes);
/* free the original buffer */
H5MM_xfree(*buf);
- *buf = outbuf;
- outbuf = NULL;
+ *buf = outbuf;
+ outbuf = NULL;
*buf_size = size_out;
ret_value = buf_offset + nbytes;
goto done;
@@ -1280,21 +1367,22 @@ H5Z__filter_scaleoffset(unsigned flags, size_t cd_nelmts, const unsigned cd_valu
* minbits equal to zero only when fill value is not defined and
* all data elements have the same value
*/
- if(minbits != 0)
- H5Z__scaleoffset_compress((unsigned char *)*buf, d_nelmts, outbuf + buf_offset, size_out - buf_offset, p);
+ if (minbits != 0)
+ H5Z__scaleoffset_compress((unsigned char *)*buf, d_nelmts, outbuf + buf_offset,
+ size_out - buf_offset, p);
}
/* free the input buffer */
H5MM_xfree(*buf);
/* set return values */
- *buf = outbuf;
- outbuf = NULL;
+ *buf = outbuf;
+ outbuf = NULL;
*buf_size = size_out;
ret_value = size_out;
done:
- if(outbuf)
+ if (outbuf)
H5MM_xfree(outbuf);
FUNC_LEAVE_NOAPI(ret_value)
}
@@ -1307,26 +1395,25 @@ done:
* atomic datatype is treated on byte basis
*/
-
/* change byte order of input buffer either from little-endian to big-endian
* or from big-endian to little-endian 2/21/2005
*/
static void
H5Z__scaleoffset_convert(void *buf, unsigned d_nelmts, unsigned dtype_size)
{
- if(dtype_size > 1) {
- size_t i, j;
- unsigned char *buffer, temp;
-
- buffer = (unsigned char *)buf;
- for(i = 0; i < d_nelmts * dtype_size; i += dtype_size)
- for(j = 0; j < dtype_size / 2; j++) {
- /* swap pair of bytes */
- temp = buffer[i + j];
- buffer[i + j] = buffer[i + dtype_size - 1 - j];
- buffer[i + dtype_size - 1 - j] = temp;
- } /* end for */
- } /* end if */
+ if (dtype_size > 1) {
+ size_t i, j;
+ unsigned char *buffer, temp;
+
+ buffer = (unsigned char *)buf;
+ for (i = 0; i < d_nelmts * dtype_size; i += dtype_size)
+ for (j = 0; j < dtype_size / 2; j++) {
+ /* swap pair of bytes */
+ temp = buffer[i + j];
+ buffer[i + j] = buffer[i + dtype_size - 1 - j];
+ buffer[i + dtype_size - 1 - j] = temp;
+ } /* end for */
+ } /* end if */
} /* end H5Z__scaleoffset_convert() */
/* return ceiling of floating-point log2 function
@@ -1335,357 +1422,358 @@ H5Z__scaleoffset_convert(void *buf, unsigned d_nelmts, unsigned dtype_size)
static unsigned
H5Z__scaleoffset_log2(unsigned long long num)
{
- unsigned v = 0;
- unsigned long long lower_bound = 1; /* is power of 2, largest value <= num */
- unsigned long long val = num;
-
- while(val >>= 1) {
- v++;
- lower_bound <<= 1;
- }
-
- if(num == lower_bound)
- return v;
- else
- return v + 1;
+ unsigned v = 0;
+ unsigned long long lower_bound = 1; /* is power of 2, largest value <= num */
+ unsigned long long val = num;
+
+ while (val >>= 1) {
+ v++;
+ lower_bound <<= 1;
+ }
+
+ if (num == lower_bound)
+ return v;
+ else
+ return v + 1;
}
/* precompress for integer type */
static void
-H5Z__scaleoffset_precompress_i(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
- unsigned filavail, const unsigned cd_values[], uint32_t *minbits, unsigned long long *minval)
+H5Z__scaleoffset_precompress_i(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type, unsigned filavail,
+ const unsigned cd_values[], uint32_t *minbits, unsigned long long *minval)
{
- if(type == t_uchar)
- H5Z_scaleoffset_precompress_1(unsigned char, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_ushort)
- H5Z_scaleoffset_precompress_1(unsigned short, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_uint)
- H5Z_scaleoffset_precompress_1(unsigned int, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_ulong)
- H5Z_scaleoffset_precompress_1(unsigned long, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_ulong_long)
- H5Z_scaleoffset_precompress_1(unsigned long long, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_schar) {
- signed char *buf = (signed char *)data, min = 0, max = 0, filval = 0;
- unsigned char span;
- unsigned i;
-
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */
- H5Z_scaleoffset_get_filval_1(signed char, cd_values, filval);
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */
- H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max, min)
- if((unsigned char)(max - min) > (unsigned char)(~(unsigned char)0 - 2)) {
- *minbits = sizeof(signed char)*8;
- return;
+ if (type == t_uchar)
+ H5Z_scaleoffset_precompress_1(unsigned char, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_ushort)
+ H5Z_scaleoffset_precompress_1(unsigned short, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_uint)
+ H5Z_scaleoffset_precompress_1(unsigned int, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_ulong)
+ H5Z_scaleoffset_precompress_1(unsigned long, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_ulong_long)
+ H5Z_scaleoffset_precompress_1(unsigned long long, data, d_nelmts, filavail, cd_values,
+ minbits, minval) else if (type == t_schar)
+ {
+ signed char * buf = (signed char *)data, min = 0, max = 0, filval = 0;
+ unsigned char span;
+ unsigned i;
+
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */
+ H5Z_scaleoffset_get_filval_1(signed char, cd_values, filval);
+ if (*minbits ==
+ H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */
+ H5Z_scaleoffset_max_min_1(i, d_nelmts, buf, filval, max,
+ min) if ((unsigned char)(max - min) >
+ (unsigned char)(~(unsigned char)0 - 2))
+ {
+ *minbits = sizeof(signed char) * 8;
+ return;
+ }
+ span = (unsigned char)(max - min + 1);
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)(span + 1));
}
- span = (unsigned char)(max - min + 1);
- *minbits = H5Z__scaleoffset_log2((unsigned long long)(span+1));
- } else /* minbits already set, only calculate min */
- H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval, min)
- if(*minbits != sizeof(signed char)*8) /* change values if minbits != full precision */
- for(i = 0; i < d_nelmts; i++)
- buf[i] = (signed char)((buf[i] == filval) ? (((unsigned char)1 << *minbits) - 1) : (buf[i] - min));
- } else { /* fill value undefined */
- if(*minbits == H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */
- H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max, min)
- if((unsigned char)(max - min) > (unsigned char)(~(unsigned char)0 - 2)) {
- *minbits = sizeof(signed char)*8;
- *minval = (unsigned long long)min;
- return;
+ else /* minbits already set, only calculate min */
+ H5Z_scaleoffset_min_1(i, d_nelmts, buf, filval,
+ min) if (*minbits !=
+ sizeof(signed char) *
+ 8) /* change values if minbits != full precision */
+ for (i = 0; i < d_nelmts; i++) buf[i] =
+ (signed char)((buf[i] == filval) ? (((unsigned char)1 << *minbits) - 1)
+ : (buf[i] - min));
+ }
+ else { /* fill value undefined */
+ if (*minbits ==
+ H5Z_SO_INT_MINBITS_DEFAULT) { /* minbits not set yet, calculate max, min, and minbits */
+ H5Z_scaleoffset_max_min_2(i, d_nelmts, buf, max,
+ min) if ((unsigned char)(max - min) >
+ (unsigned char)(~(unsigned char)0 - 2))
+ {
+ *minbits = sizeof(signed char) * 8;
+ *minval = (unsigned long long)min;
+ return;
+ }
+ span = (unsigned char)(max - min + 1);
+ *minbits = H5Z__scaleoffset_log2((unsigned long long)span);
}
- span = (unsigned char)(max - min + 1);
- *minbits = H5Z__scaleoffset_log2((unsigned long long)span);
- } else /* minbits already set, only calculate min */
- H5Z_scaleoffset_min_2(i, d_nelmts, buf, min)
- if(*minbits != sizeof(signed char) * 8) /* change values if minbits != full precision */
- for(i = 0; i < d_nelmts; i++)
- buf[i] = (signed char)(buf[i] - min);
+ else /* minbits already set, only calculate min */
+ H5Z_scaleoffset_min_2(i, d_nelmts, buf,
+ min) if (*minbits !=
+ sizeof(signed char) *
+ 8) /* change values if minbits != full precision */
+ for (i = 0; i < d_nelmts; i++) buf[i] = (signed char)(buf[i] - min);
+ }
+ *minval = (unsigned long long)min;
}
- *minval = (unsigned long long)min;
- }
- else if(type == t_short)
- H5Z_scaleoffset_precompress_2(short, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_int)
- H5Z_scaleoffset_precompress_2(int, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_long)
- H5Z_scaleoffset_precompress_2(long, data, d_nelmts,
- filavail, cd_values, minbits, minval)
- else if(type == t_long_long)
- H5Z_scaleoffset_precompress_2(long long, data, d_nelmts,
- filavail, cd_values, minbits, minval)
+ else if (type == t_short)
+ H5Z_scaleoffset_precompress_2(short, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_int)
+ H5Z_scaleoffset_precompress_2(int, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_long)
+ H5Z_scaleoffset_precompress_2(long, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_long_long)
+ H5Z_scaleoffset_precompress_2(long long, data, d_nelmts, filavail, cd_values, minbits,
+ minval)
}
/* postdecompress for integer type */
static void
H5Z__scaleoffset_postdecompress_i(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
- unsigned filavail, const unsigned cd_values[], uint32_t minbits, unsigned long long minval)
+ unsigned filavail, const unsigned cd_values[], uint32_t minbits,
+ unsigned long long minval)
{
- long long sminval = *(long long*)&minval; /* for signed integer types */
-
- if(type == t_uchar)
- H5Z_scaleoffset_postdecompress_1(unsigned char, data, d_nelmts, filavail,
- cd_values, minbits, minval)
- else if(type == t_ushort)
- H5Z_scaleoffset_postdecompress_1(unsigned short, data, d_nelmts, filavail,
- cd_values, minbits, minval)
- else if(type == t_uint)
- H5Z_scaleoffset_postdecompress_1(unsigned int, data, d_nelmts, filavail,
- cd_values, minbits, minval)
- else if(type == t_ulong)
- H5Z_scaleoffset_postdecompress_1(unsigned long, data, d_nelmts, filavail,
- cd_values, minbits, minval)
- else if(type == t_ulong_long)
- H5Z_scaleoffset_postdecompress_1(unsigned long long, data, d_nelmts, filavail,
- cd_values, minbits, minval)
- else if(type == t_schar) {
- signed char *buf = (signed char *)data, filval = 0;
- unsigned i;
-
- if(filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */
- H5Z_scaleoffset_get_filval_1(signed char, cd_values, filval)
- for(i = 0; i < d_nelmts; i++)
- buf[i] = (signed char)((buf[i] == (((unsigned char)1 << minbits) - 1)) ? filval : (buf[i] + sminval));
- } else /* fill value undefined */
- for(i = 0; i < d_nelmts; i++)
- buf[i] = (signed char)(buf[i] + sminval);
- }
- else if(type == t_short)
- H5Z_scaleoffset_postdecompress_2(short, data, d_nelmts, filavail,
- cd_values, minbits, sminval)
- else if(type == t_int)
- H5Z_scaleoffset_postdecompress_2(int, data, d_nelmts, filavail,
- cd_values, minbits, sminval)
- else if(type == t_long)
- H5Z_scaleoffset_postdecompress_2(long, data, d_nelmts, filavail,
- cd_values, minbits, sminval)
- else if(type == t_long_long)
- H5Z_scaleoffset_postdecompress_2(long long, data, d_nelmts, filavail,
- cd_values, minbits, sminval)
+ long long sminval = *(long long *)&minval; /* for signed integer types */
+
+ if (type == t_uchar)
+ H5Z_scaleoffset_postdecompress_1(unsigned char, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_ushort)
+ H5Z_scaleoffset_postdecompress_1(unsigned short, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_uint)
+ H5Z_scaleoffset_postdecompress_1(unsigned int, data, d_nelmts, filavail, cd_values, minbits,
+ minval) else if (type == t_ulong)
+ H5Z_scaleoffset_postdecompress_1(unsigned long, data, d_nelmts, filavail, cd_values,
+ minbits, minval) else if (type == t_ulong_long)
+ H5Z_scaleoffset_postdecompress_1(unsigned long long, data, d_nelmts, filavail,
+ cd_values, minbits, minval) else if (type == t_schar)
+ {
+ signed char *buf = (signed char *)data, filval = 0;
+ unsigned i;
+
+ if (filavail == H5Z_SCALEOFFSET_FILL_DEFINED) { /* fill value defined */
+ H5Z_scaleoffset_get_filval_1(signed char, cd_values, filval) for (i = 0; i < d_nelmts; i++)
+ buf[i] =
+ (signed char)((buf[i] == (((unsigned char)1 << minbits) - 1)) ? filval
+ : (buf[i] + sminval));
+ }
+ else /* fill value undefined */
+ for (i = 0; i < d_nelmts; i++)
+ buf[i] = (signed char)(buf[i] + sminval);
+ }
+ else if (type == t_short)
+ H5Z_scaleoffset_postdecompress_2(short, data, d_nelmts, filavail, cd_values, minbits,
+ sminval) else if (type == t_int)
+ H5Z_scaleoffset_postdecompress_2(int, data, d_nelmts, filavail, cd_values, minbits,
+ sminval) else if (type == t_long)
+ H5Z_scaleoffset_postdecompress_2(long, data, d_nelmts, filavail, cd_values, minbits,
+ sminval) else if (type == t_long_long)
+ H5Z_scaleoffset_postdecompress_2(long long, data, d_nelmts, filavail, cd_values, minbits,
+ sminval)
}
/* precompress for floating-point type, variable-minimum-bits method
success: non-negative, failure: negative 4/15/05 */
static herr_t
-H5Z__scaleoffset_precompress_fd(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
- unsigned filavail, const unsigned cd_values[], uint32_t *minbits,
- unsigned long long *minval, double D_val)
+H5Z__scaleoffset_precompress_fd(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type, unsigned filavail,
+ const unsigned cd_values[], uint32_t *minbits, unsigned long long *minval,
+ double D_val)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
- if(type == t_float)
+ if (type == t_float)
H5Z_scaleoffset_precompress_3(float, HDpowf, HDfabsf, HDroundf, HDlroundf, HDllroundf, data, d_nelmts,
- filavail, cd_values, minbits, minval, D_val)
- else if(type == t_double)
- H5Z_scaleoffset_precompress_3(double, HDpow, HDfabs, HDround, HDlround, HDllround, data, d_nelmts,
- filavail, cd_values, minbits, minval, D_val)
+ filavail, cd_values, minbits, minval, D_val) else if (type == t_double)
+ H5Z_scaleoffset_precompress_3(double, HDpow, HDfabs, HDround, HDlround, HDllround, data, d_nelmts,
+ filavail, cd_values, minbits, minval, D_val)
-done:
- FUNC_LEAVE_NOAPI(ret_value)
+ done : FUNC_LEAVE_NOAPI(ret_value)
}
/* postdecompress for floating-point type, variable-minimum-bits method
success: non-negative, failure: negative 4/15/05 */
static herr_t
H5Z__scaleoffset_postdecompress_fd(void *data, unsigned d_nelmts, enum H5Z_scaleoffset_t type,
- unsigned filavail, const unsigned cd_values[], uint32_t minbits,
- unsigned long long minval, double D_val)
+ unsigned filavail, const unsigned cd_values[], uint32_t minbits,
+ unsigned long long minval, double D_val)
{
- long long sminval = (long long)minval; /* for signed integer types */
- herr_t ret_value=SUCCEED; /* Return value */
+ long long sminval = (long long)minval; /* for signed integer types */
+ herr_t ret_value = SUCCEED; /* Return value */
- FUNC_ENTER_STATIC
+ FUNC_ENTER_STATIC
- if(type == t_float)
- H5Z_scaleoffset_postdecompress_3(float, HDpowf, data, d_nelmts, filavail,
- cd_values, minbits, sminval, D_val)
- else if(type == t_double)
- H5Z_scaleoffset_postdecompress_3(double, HDpow, data, d_nelmts, filavail,
- cd_values, minbits, sminval, D_val)
+ if (type == t_float)
+ H5Z_scaleoffset_postdecompress_3(float, HDpowf, data, d_nelmts, filavail, cd_values, minbits, sminval,
+ D_val) else if (type == t_double)
+ H5Z_scaleoffset_postdecompress_3(double, HDpow, data, d_nelmts, filavail, cd_values, minbits,
+ sminval, D_val)
-done:
- FUNC_LEAVE_NOAPI(ret_value)
+ done : FUNC_LEAVE_NOAPI(ret_value)
}
static void
H5Z__scaleoffset_next_byte(size_t *j, unsigned *buf_len)
{
- ++(*j);
- *buf_len = 8 * sizeof(unsigned char);
+ ++(*j);
+ *buf_len = 8 * sizeof(unsigned char);
}
static void
-H5Z__scaleoffset_decompress_one_byte(unsigned char *data, size_t data_offset,
- unsigned k, unsigned begin_i, unsigned char *buffer, size_t *j, unsigned *buf_len,
- parms_atomic p, unsigned dtype_len)
+H5Z__scaleoffset_decompress_one_byte(unsigned char *data, size_t data_offset, unsigned k, unsigned begin_i,
+ unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p,
+ unsigned dtype_len)
{
- unsigned dat_len; /* dat_len is the number of bits to be copied in each data byte */
- unsigned char val; /* value to be copied in each data byte */
-
- /* initialize value and bits of unsigned char to be copied */
- val = buffer[*j];
- if(k == begin_i)
- dat_len = 8 - (dtype_len - p.minbits) % 8;
- else
- dat_len = 8;
-
- if(*buf_len > dat_len) {
- data[data_offset + k] = (unsigned char)((unsigned)(val >> (*buf_len - dat_len)) & (unsigned)(~((unsigned)~0 << dat_len)));
- *buf_len -= dat_len;
- } /* end if */
- else {
- data[data_offset + k] = (unsigned char)((val & ~((unsigned)(~0) << *buf_len)) << (dat_len - *buf_len));
- dat_len -= *buf_len;
- H5Z__scaleoffset_next_byte(j, buf_len);
- if(dat_len == 0)
- return;
-
- val = buffer[*j];
- data[data_offset + k] |= (unsigned char)((unsigned)(val >> (*buf_len - dat_len)) & ~((unsigned)(~0) << dat_len));
- *buf_len -= dat_len;
- } /* end else */
+ unsigned dat_len; /* dat_len is the number of bits to be copied in each data byte */
+ unsigned char val; /* value to be copied in each data byte */
+
+ /* initialize value and bits of unsigned char to be copied */
+ val = buffer[*j];
+ if (k == begin_i)
+ dat_len = 8 - (dtype_len - p.minbits) % 8;
+ else
+ dat_len = 8;
+
+ if (*buf_len > dat_len) {
+ data[data_offset + k] =
+ (unsigned char)((unsigned)(val >> (*buf_len - dat_len)) & (unsigned)(~((unsigned)~0 << dat_len)));
+ *buf_len -= dat_len;
+ } /* end if */
+ else {
+ data[data_offset + k] =
+ (unsigned char)((val & ~((unsigned)(~0) << *buf_len)) << (dat_len - *buf_len));
+ dat_len -= *buf_len;
+ H5Z__scaleoffset_next_byte(j, buf_len);
+ if (dat_len == 0)
+ return;
+
+ val = buffer[*j];
+ data[data_offset + k] |=
+ (unsigned char)((unsigned)(val >> (*buf_len - dat_len)) & ~((unsigned)(~0) << dat_len));
+ *buf_len -= dat_len;
+ } /* end else */
}
static void
-H5Z__scaleoffset_decompress_one_atomic(unsigned char *data, size_t data_offset,
- unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p)
+H5Z__scaleoffset_decompress_one_atomic(unsigned char *data, size_t data_offset, unsigned char *buffer,
+ size_t *j, unsigned *buf_len, parms_atomic p)
{
- /* begin_i: the index of byte having first significant bit */
- unsigned begin_i;
- unsigned dtype_len;
- int k;
+ /* begin_i: the index of byte having first significant bit */
+ unsigned begin_i;
+ unsigned dtype_len;
+ int k;
- HDassert(p.minbits > 0);
+ HDassert(p.minbits > 0);
- dtype_len = p.size * 8;
+ dtype_len = p.size * 8;
- if(p.mem_order == H5Z_SCALEOFFSET_ORDER_LE) { /* little endian */
- begin_i = p.size - 1 - (dtype_len - p.minbits) / 8;
+ if (p.mem_order == H5Z_SCALEOFFSET_ORDER_LE) { /* little endian */
+ begin_i = p.size - 1 - (dtype_len - p.minbits) / 8;
- for(k = (int)begin_i; k >= 0; k--)
- H5Z__scaleoffset_decompress_one_byte(data, data_offset, (unsigned)k, begin_i,
- buffer, j, buf_len, p, dtype_len);
- }
- else { /* big endian */
- HDassert(p.mem_order == H5Z_SCALEOFFSET_ORDER_BE);
+ for (k = (int)begin_i; k >= 0; k--)
+ H5Z__scaleoffset_decompress_one_byte(data, data_offset, (unsigned)k, begin_i, buffer, j, buf_len,
+ p, dtype_len);
+ }
+ else { /* big endian */
+ HDassert(p.mem_order == H5Z_SCALEOFFSET_ORDER_BE);
- begin_i = (dtype_len - p.minbits) / 8;
+ begin_i = (dtype_len - p.minbits) / 8;
- for(k = (int)begin_i; k <= (int)(p.size - 1); k++)
- H5Z__scaleoffset_decompress_one_byte(data, data_offset, (unsigned)k, begin_i,
- buffer, j, buf_len, p, dtype_len);
- }
+ for (k = (int)begin_i; k <= (int)(p.size - 1); k++)
+ H5Z__scaleoffset_decompress_one_byte(data, data_offset, (unsigned)k, begin_i, buffer, j, buf_len,
+ p, dtype_len);
+ }
}
static void
-H5Z__scaleoffset_decompress(unsigned char *data, unsigned d_nelmts,
- unsigned char *buffer, parms_atomic p)
+H5Z__scaleoffset_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer, parms_atomic p)
{
/* i: index of data, j: index of buffer,
buf_len: number of bits to be filled in current byte */
- size_t i, j;
+ size_t i, j;
unsigned buf_len;
/* must initialize to zeros */
- for(i = 0; i < d_nelmts * p.size; i++)
+ for (i = 0; i < d_nelmts * p.size; i++)
data[i] = 0;
/* initialization before the loop */
- j = 0;
+ j = 0;
buf_len = sizeof(unsigned char) * 8;
/* decompress */
- for(i = 0; i < d_nelmts; i++)
+ for (i = 0; i < d_nelmts; i++)
H5Z__scaleoffset_decompress_one_atomic(data, i * p.size, buffer, &j, &buf_len, p);
}
static void
-H5Z__scaleoffset_compress_one_byte(unsigned char *data, size_t data_offset,
- unsigned k, unsigned begin_i, unsigned char *buffer, size_t *j, unsigned *buf_len,
- parms_atomic p, unsigned dtype_len)
+H5Z__scaleoffset_compress_one_byte(unsigned char *data, size_t data_offset, unsigned k, unsigned begin_i,
+ unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p,
+ unsigned dtype_len)
{
- unsigned dat_len; /* dat_len is the number of bits to be copied in each data byte */
- unsigned char val; /* value to be copied in each data byte */
-
- /* initialize value and bits of unsigned char to be copied */
- val = data[data_offset + k];
- if(k == begin_i)
- dat_len = 8 - (dtype_len - p.minbits) % 8;
- else
- dat_len = 8;
-
- if(*buf_len > dat_len) {
- buffer[*j] |= (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
- *buf_len -= dat_len;
- } else {
- buffer[*j] |= (unsigned char)((unsigned)(val >> (dat_len - *buf_len)) & ~((unsigned)(~0) << *buf_len));
- dat_len -= *buf_len;
- H5Z__scaleoffset_next_byte(j, buf_len);
- if(dat_len == 0)
- return;
-
- buffer[*j] = (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
- *buf_len -= dat_len;
- } /* end else */
+ unsigned dat_len; /* dat_len is the number of bits to be copied in each data byte */
+ unsigned char val; /* value to be copied in each data byte */
+
+ /* initialize value and bits of unsigned char to be copied */
+ val = data[data_offset + k];
+ if (k == begin_i)
+ dat_len = 8 - (dtype_len - p.minbits) % 8;
+ else
+ dat_len = 8;
+
+ if (*buf_len > dat_len) {
+ buffer[*j] |= (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
+ *buf_len -= dat_len;
+ }
+ else {
+ buffer[*j] |=
+ (unsigned char)((unsigned)(val >> (dat_len - *buf_len)) & ~((unsigned)(~0) << *buf_len));
+ dat_len -= *buf_len;
+ H5Z__scaleoffset_next_byte(j, buf_len);
+ if (dat_len == 0)
+ return;
+
+ buffer[*j] = (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
+ *buf_len -= dat_len;
+ } /* end else */
}
static void
-H5Z__scaleoffset_compress_one_atomic(unsigned char *data, size_t data_offset,
- unsigned char *buffer, size_t *j, unsigned *buf_len, parms_atomic p)
+H5Z__scaleoffset_compress_one_atomic(unsigned char *data, size_t data_offset, unsigned char *buffer,
+ size_t *j, unsigned *buf_len, parms_atomic p)
{
- /* begin_i: the index of byte having first significant bit */
- unsigned begin_i;
- unsigned dtype_len;
- int k;
-
- HDassert(p.minbits > 0);
-
- dtype_len = p.size * 8;
-
- if(p.mem_order == H5Z_SCALEOFFSET_ORDER_LE) { /* little endian */
- begin_i = p.size - 1 - (dtype_len - p.minbits) / 8;
-
- for(k = (int)begin_i; k >= 0; k--)
- H5Z__scaleoffset_compress_one_byte(data, data_offset, (unsigned)k, begin_i,
- buffer, j, buf_len, p, dtype_len);
- }
- else { /* big endian */
- HDassert(p.mem_order == H5Z_SCALEOFFSET_ORDER_BE);
- begin_i = (dtype_len - p.minbits) / 8;
-
- for(k = (int)begin_i; k <= (int)(p.size - 1); k++)
- H5Z__scaleoffset_compress_one_byte(data, data_offset, (unsigned)k, begin_i,
- buffer, j, buf_len, p, dtype_len);
- }
+ /* begin_i: the index of byte having first significant bit */
+ unsigned begin_i;
+ unsigned dtype_len;
+ int k;
+
+ HDassert(p.minbits > 0);
+
+ dtype_len = p.size * 8;
+
+ if (p.mem_order == H5Z_SCALEOFFSET_ORDER_LE) { /* little endian */
+ begin_i = p.size - 1 - (dtype_len - p.minbits) / 8;
+
+ for (k = (int)begin_i; k >= 0; k--)
+ H5Z__scaleoffset_compress_one_byte(data, data_offset, (unsigned)k, begin_i, buffer, j, buf_len, p,
+ dtype_len);
+ }
+ else { /* big endian */
+ HDassert(p.mem_order == H5Z_SCALEOFFSET_ORDER_BE);
+ begin_i = (dtype_len - p.minbits) / 8;
+
+ for (k = (int)begin_i; k <= (int)(p.size - 1); k++)
+ H5Z__scaleoffset_compress_one_byte(data, data_offset, (unsigned)k, begin_i, buffer, j, buf_len, p,
+ dtype_len);
+ }
}
static void
-H5Z__scaleoffset_compress(unsigned char *data, unsigned d_nelmts,
- unsigned char *buffer, size_t buffer_size, parms_atomic p)
+H5Z__scaleoffset_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer, size_t buffer_size,
+ parms_atomic p)
{
- /* i: index of data, j: index of buffer,
- buf_len: number of bits to be filled in current byte */
- size_t i, j;
- unsigned buf_len;
-
- /* must initialize buffer to be zeros */
- for(j = 0; j < buffer_size; j++)
- buffer[j] = 0;
-
- /* initialization before the loop */
- j = 0;
- buf_len = sizeof(unsigned char) * 8;
-
- /* compress */
- for(i = 0; i < d_nelmts; i++)
- H5Z__scaleoffset_compress_one_atomic(data, i * p.size, buffer, &j, &buf_len, p);
-}
+ /* i: index of data, j: index of buffer,
+ buf_len: number of bits to be filled in current byte */
+ size_t i, j;
+ unsigned buf_len;
+
+ /* must initialize buffer to be zeros */
+ for (j = 0; j < buffer_size; j++)
+ buffer[j] = 0;
+
+ /* initialization before the loop */
+ j = 0;
+ buf_len = sizeof(unsigned char) * 8;
+ /* compress */
+ for (i = 0; i < d_nelmts; i++)
+ H5Z__scaleoffset_compress_one_atomic(data, i * p.size, buffer, &j, &buf_len, p);
+}
generated by cgit v0.12 at 2024-11-04 21:54:08 (GMT)