Attachment #454952 for bug #601408

View | Details | Raw Unified | Return to bug 601408
Collapse All | Expand All




                       unsigned char *buffer, size_t *j, int *buf_len, unsigned size);
static void H5Z_nbit_decompress_one_atomic(unsigned char *data, size_t data_offset,
                    unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p);
static herr_t H5Z__nbit_decompress_one_array(unsigned char *data, size_t data_offset,
           unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
static herr_t H5Z__nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
              unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
static herr_t H5Z__nbit_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
                                const unsigned parms[]);
static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,
                     unsigned char *buffer, size_t *j, int *buf_len, unsigned size);

            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed for nbit decompression")

        /* decompress the buffer */
        if(H5Z__nbit_decompress(outbuf, d_nelmts, (unsigned char *)*buf, cd_values) < 0)
            HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, 0, "can't decompress buffer")
    } /* end if */
    /* output; compress */
    else {

   }
}

static herr_t
H5Z__nbit_decompress_one_array(unsigned char *data, size_t data_offset,
           unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[])
{
   unsigned i, total_size, base_class, base_size, n, begin_index;
   parms_atomic p;
   herr_t ret_value = SUCCEED; /* Return value */

   FUNC_ENTER_STATIC

   total_size = parms[parms_index++];
   base_class = parms[parms_index++];

           p.order = parms[parms_index++];
           p.precision = parms[parms_index++];
           p.offset = parms[parms_index++];

           /* Check values of precision and offset */
           if(p.precision > p.size * 8 || (p.precision + p.offset) > p.size * 8)
              HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")

           n = total_size / p.size;
           for(i = 0; i < n; i++)
              H5Z_nbit_decompress_one_atomic(data, data_offset + i*p.size,
                                             buffer, j, buf_len, p);

           n = total_size/base_size; /* number of base_type elements inside the array datatype */
           begin_index = parms_index;
           for(i = 0; i < n; i++) {
              if(H5Z__nbit_decompress_one_array(data, data_offset + i * base_size,
                                            buffer, j, buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
              parms_index = begin_index;
           }
           break;

           n = total_size/base_size; /* number of base_type elements inside the array datatype */
           begin_index = parms_index;
           for(i = 0; i < n; i++) {
              if(H5Z__nbit_decompress_one_compound(data, data_offset + i * base_size,
                                               buffer, j, buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
              parms_index = begin_index;
           }
           break;

      default:
          HDassert(0 && "This Should never be executed!");
   } /* end switch */

done:
    FUNC_LEAVE_NOAPI(ret_value)
}

static herr_t
H5Z__nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
              unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[])
{
   unsigned i, nmembers, member_offset, member_class, member_size, used_size = 0, size;
   parms_atomic p;
   herr_t ret_value = SUCCEED; /* Return value */

   FUNC_ENTER_STATIC

   size = parms[parms_index++];
   nmembers = parms[parms_index++];

   for(i = 0; i < nmembers; i++) {
      member_offset = parms[parms_index++];
      member_class = parms[parms_index++];

      /* Check for overflow */
      member_size = parms[parms_index];
      used_size += member_size;
      if(used_size > size)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "compound member offset overflowed compound size")
      switch(member_class) {
         case H5Z_NBIT_ATOMIC:
              p.size = member_size;
              /* Advance past member size */
              parms_index++;
              p.order = parms[parms_index++];
              p.precision = parms[parms_index++];
              p.offset = parms[parms_index++];

              /* Check values of precision and offset */
              if(p.precision > p.size * 8 || (p.precision + p.offset) > p.size * 8)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")

              H5Z_nbit_decompress_one_atomic(data, data_offset + member_offset,
                                             buffer, j, buf_len, p);
              break;
         case H5Z_NBIT_ARRAY:
              if(H5Z__nbit_decompress_one_array(data, data_offset + member_offset,
                                            buffer, j, buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
              break;
         case H5Z_NBIT_COMPOUND:
              if(H5Z__nbit_decompress_one_compound(data, data_offset+member_offset,
                                            buffer, j, buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
              break;
         case H5Z_NBIT_NOOPTYPE:
              /* Advance past member size */
              parms_index++;
              H5Z_nbit_decompress_one_nooptype(data, data_offset+member_offset,
                                               buffer, j, buf_len, member_size);
              break;
          default:
              HDassert(0 && "This Should never be executed!");
      } /* end switch */
   }

done:
    FUNC_LEAVE_NOAPI(ret_value)
}

static herr_t
H5Z__nbit_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
                                const unsigned parms[])
{
   /* i: index of data, j: index of buffer,

   size_t i, j, size;
   int buf_len;
   parms_atomic p;
   herr_t ret_value = SUCCEED; /* Return value */

   FUNC_ENTER_STATIC

   /* may not have to initialize to zeros */
   for(i = 0; i < d_nelmts*parms[4]; i++) data[i] = 0;

           p.order = parms[5];
           p.precision = parms[6];
           p.offset = parms[7];

           /* Check values of precision and offset */
           if(p.precision > p.size * 8 || (p.precision + p.offset) > p.size * 8)
              HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")

           for(i = 0; i < d_nelmts; i++) {
              H5Z_nbit_decompress_one_atomic(data, i*p.size, buffer, &j, &buf_len, p);
           }

           size = parms[4];
           parms_index = 4;
           for(i = 0; i < d_nelmts; i++) {
              if(H5Z__nbit_decompress_one_array(data, i*size, buffer, &j, &buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
              parms_index = 4;
           }
           break;

           size = parms[4];
           parms_index = 4;
           for(i = 0; i < d_nelmts; i++) {
              if(H5Z__nbit_decompress_one_compound(data, i*size, buffer, &j, &buf_len, parms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
              parms_index = 4;
           }
           break;
      default:
          HDassert(0 && "This Should never be executed!");
   } /* end switch */

done:
    FUNC_LEAVE_NOAPI(ret_value)
}

static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,

Return to bug 601408

Lines 60-70 Link Here

(-)hdf5-1.8.17/src/H5Znbit.c (-26 / +75 lines)
60	unsigned char buffer, size_t j, int *buf_len, unsigned size);	60	unsigned char buffer, size_t j, int *buf_len, unsigned size);
61	static void H5Z_nbit_decompress_one_atomic(unsigned char *data, size_t data_offset,	61	static void H5Z_nbit_decompress_one_atomic(unsigned char *data, size_t data_offset,
62	unsigned char buffer, size_t j, int *buf_len, parms_atomic p);	62	unsigned char buffer, size_t j, int *buf_len, parms_atomic p);
63	static void H5Z_nbit_decompress_one_array(unsigned char *data, size_t data_offset,	63	static herr_t H5Z__nbit_decompress_one_array(unsigned char *data, size_t data_offset,
64	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[]);	64	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[]);
65	static void H5Z_nbit_decompress_one_compound(unsigned char *data, size_t data_offset,	65	static herr_t H5Z__nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
66	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[]);	66	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[]);
67	static void H5Z_nbit_decompress(unsigned char data, unsigned d_nelmts, unsigned char buffer,	67	static herr_t H5Z__nbit_decompress(unsigned char data, unsigned d_nelmts, unsigned char buffer,
68	const unsigned parms[]);	68	const unsigned parms[]);
69	static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,	69	static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,
70	unsigned char buffer, size_t j, int *buf_len, unsigned size);	70	unsigned char buffer, size_t j, int *buf_len, unsigned size);
Lines 897-903 Link Here
897	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed for nbit decompression")	897	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed for nbit decompression")
898		898
899	/* decompress the buffer */	899	/* decompress the buffer */
900	H5Z_nbit_decompress(outbuf, d_nelmts, (unsigned char )buf, cd_values);	900	if(H5Z__nbit_decompress(outbuf, d_nelmts, (unsigned char )buf, cd_values) < 0)
		901	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, 0, "can't decompress buffer")
901	} /* end if */	902	} /* end if */
902	/* output; compress */	903	/* output; compress */
903	else {	904	else {
Lines 1046-1057 Link Here
1046	}	1047	}
1047	}	1048	}
1048		1049
1049	static void	1050	static herr_t
1050	H5Z_nbit_decompress_one_array(unsigned char *data, size_t data_offset,	1051	H5Z__nbit_decompress_one_array(unsigned char *data, size_t data_offset,
1051	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[])	1052	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[])
1052	{	1053	{
1053	unsigned i, total_size, base_class, base_size, n, begin_index;	1054	unsigned i, total_size, base_class, base_size, n, begin_index;
1054	parms_atomic p;	1055	parms_atomic p;
		1056	herr_t ret_value = SUCCEED; /* Return value */
		1057
		1058	FUNC_ENTER_STATIC
1055		1059
1056	total_size = parms[parms_index++];	1060	total_size = parms[parms_index++];
1057	base_class = parms[parms_index++];	1061	base_class = parms[parms_index++];
Lines 1062-1068 Link Here
1062	p.order = parms[parms_index++];	1066	p.order = parms[parms_index++];
1063	p.precision = parms[parms_index++];	1067	p.precision = parms[parms_index++];
1064	p.offset = parms[parms_index++];	1068	p.offset = parms[parms_index++];
1065	n = total_size/p.size;	1069
		1070	/* Check values of precision and offset */
		1071	if(p.precision > p.size * 8 \|\| (p.precision + p.offset) > p.size * 8)
		1072	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")
		1073
		1074	n = total_size / p.size;
1066	for(i = 0; i < n; i++)	1075	for(i = 0; i < n; i++)
1067	H5Z_nbit_decompress_one_atomic(data, data_offset + i*p.size,	1076	H5Z_nbit_decompress_one_atomic(data, data_offset + i*p.size,
1068	buffer, j, buf_len, p);	1077	buffer, j, buf_len, p);
Lines 1072-1079 Link Here
1072	n = total_size/base_size; /* number of base_type elements inside the array datatype */	1081	n = total_size/base_size; /* number of base_type elements inside the array datatype */
1073	begin_index = parms_index;	1082	begin_index = parms_index;
1074	for(i = 0; i < n; i++) {	1083	for(i = 0; i < n; i++) {
1075	H5Z_nbit_decompress_one_array(data, data_offset + i*base_size,	1084	if(H5Z__nbit_decompress_one_array(data, data_offset + i * base_size,
1076	buffer, j, buf_len, parms);	1085	buffer, j, buf_len, parms) < 0)
		1086	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
1077	parms_index = begin_index;	1087	parms_index = begin_index;
1078	}	1088	}
1079	break;	1089	break;
Lines 1082-1089 Link Here
1082	n = total_size/base_size; /* number of base_type elements inside the array datatype */	1092	n = total_size/base_size; /* number of base_type elements inside the array datatype */
1083	begin_index = parms_index;	1093	begin_index = parms_index;
1084	for(i = 0; i < n; i++) {	1094	for(i = 0; i < n; i++) {
1085	H5Z_nbit_decompress_one_compound(data, data_offset + i*base_size,	1095	if(H5Z__nbit_decompress_one_compound(data, data_offset + i * base_size,
1086	buffer, j, buf_len, parms);	1096	buffer, j, buf_len, parms) < 0)
		1097	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
1087	parms_index = begin_index;	1098	parms_index = begin_index;
1088	}	1099	}
1089	break;	1100	break;
Lines 1094-1144 Link Here
1094	default:	1105	default:
1095	HDassert(0 && "This Should never be executed!");	1106	HDassert(0 && "This Should never be executed!");
1096	} /* end switch */	1107	} /* end switch */
		1108
		1109	done:
		1110	FUNC_LEAVE_NOAPI(ret_value)
1097	}	1111	}
1098		1112
1099	static void	1113	static herr_t
1100	H5Z_nbit_decompress_one_compound(unsigned char *data, size_t data_offset,	1114	H5Z__nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
1101	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[])	1115	unsigned char buffer, size_t j, int *buf_len, const unsigned parms[])
1102	{	1116	{
1103	unsigned i, nmembers, member_offset, member_class, size;	1117	unsigned i, nmembers, member_offset, member_class, member_size, used_size = 0, size;
1104	parms_atomic p;	1118	parms_atomic p;
		1119	herr_t ret_value = SUCCEED; /* Return value */
1105		1120
1106	parms_index++; /* skip total size of compound datatype */	1121	FUNC_ENTER_STATIC
		1122
		1123	size = parms[parms_index++];
1107	nmembers = parms[parms_index++];	1124	nmembers = parms[parms_index++];
1108		1125
1109	for(i = 0; i < nmembers; i++) {	1126	for(i = 0; i < nmembers; i++) {
1110	member_offset = parms[parms_index++];	1127	member_offset = parms[parms_index++];
1111	member_class = parms[parms_index++];	1128	member_class = parms[parms_index++];
		1129
		1130	/* Check for overflow */
		1131	member_size = parms[parms_index];
		1132	used_size += member_size;
		1133	if(used_size > size)
		1134	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "compound member offset overflowed compound size")
1112	switch(member_class) {	1135	switch(member_class) {
1113	case H5Z_NBIT_ATOMIC:	1136	case H5Z_NBIT_ATOMIC:
1114	p.size = parms[parms_index++];	1137	p.size = member_size;
		1138	/* Advance past member size */
		1139	parms_index++;
1115	p.order = parms[parms_index++];	1140	p.order = parms[parms_index++];
1116	p.precision = parms[parms_index++];	1141	p.precision = parms[parms_index++];
1117	p.offset = parms[parms_index++];	1142	p.offset = parms[parms_index++];
		1143
		1144	/* Check values of precision and offset */
		1145	if(p.precision > p.size * 8 \|\| (p.precision + p.offset) > p.size * 8)
		1146	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")
		1147
1118	H5Z_nbit_decompress_one_atomic(data, data_offset + member_offset,	1148	H5Z_nbit_decompress_one_atomic(data, data_offset + member_offset,
1119	buffer, j, buf_len, p);	1149	buffer, j, buf_len, p);
1120	break;	1150	break;
1121	case H5Z_NBIT_ARRAY:	1151	case H5Z_NBIT_ARRAY:
1122	H5Z_nbit_decompress_one_array(data, data_offset + member_offset,	1152	if(H5Z__nbit_decompress_one_array(data, data_offset + member_offset,
1123	buffer, j, buf_len, parms);	1153	buffer, j, buf_len, parms) < 0)
		1154	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
1124	break;	1155	break;
1125	case H5Z_NBIT_COMPOUND:	1156	case H5Z_NBIT_COMPOUND:
1126	H5Z_nbit_decompress_one_compound(data, data_offset+member_offset,	1157	if(H5Z__nbit_decompress_one_compound(data, data_offset+member_offset,
1127	buffer, j, buf_len, parms);	1158	buffer, j, buf_len, parms) < 0)
		1159	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
1128	break;	1160	break;
1129	case H5Z_NBIT_NOOPTYPE:	1161	case H5Z_NBIT_NOOPTYPE:
1130	size = parms[parms_index++];	1162	/* Advance past member size */
		1163	parms_index++;
1131	H5Z_nbit_decompress_one_nooptype(data, data_offset+member_offset,	1164	H5Z_nbit_decompress_one_nooptype(data, data_offset+member_offset,
1132	buffer, j, buf_len, size);	1165	buffer, j, buf_len, member_size);
1133	break;	1166	break;
1134	default:	1167	default:
1135	HDassert(0 && "This Should never be executed!");	1168	HDassert(0 && "This Should never be executed!");
1136	} /* end switch */	1169	} /* end switch */
1137	}	1170	}
		1171
		1172	done:
		1173	FUNC_LEAVE_NOAPI(ret_value)
1138	}	1174	}
1139		1175
1140	static void	1176	static herr_t
1141	H5Z_nbit_decompress(unsigned char data, unsigned d_nelmts, unsigned char buffer,	1177	H5Z__nbit_decompress(unsigned char data, unsigned d_nelmts, unsigned char buffer,
1142	const unsigned parms[])	1178	const unsigned parms[])
1143	{	1179	{
1144	/* i: index of data, j: index of buffer,	1180	/* i: index of data, j: index of buffer,
Lines 1146-1151 Link Here
1146	size_t i, j, size;	1182	size_t i, j, size;
1147	int buf_len;	1183	int buf_len;
1148	parms_atomic p;	1184	parms_atomic p;
		1185	herr_t ret_value = SUCCEED; /* Return value */
		1186
		1187	FUNC_ENTER_STATIC
1149		1188
1150	/* may not have to initialize to zeros */	1189	/* may not have to initialize to zeros */
1151	for(i = 0; i < d_nelmts*parms[4]; i++) data[i] = 0;	1190	for(i = 0; i < d_nelmts*parms[4]; i++) data[i] = 0;
Lines 1161-1166 Link Here
1161	p.order = parms[5];	1200	p.order = parms[5];
1162	p.precision = parms[6];	1201	p.precision = parms[6];
1163	p.offset = parms[7];	1202	p.offset = parms[7];
		1203
		1204	/* Check values of precision and offset */
		1205	if(p.precision > p.size * 8 \|\| (p.precision + p.offset) > p.size * 8)
		1206	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")
		1207
1164	for(i = 0; i < d_nelmts; i++) {	1208	for(i = 0; i < d_nelmts; i++) {
1165	H5Z_nbit_decompress_one_atomic(data, i*p.size, buffer, &j, &buf_len, p);	1209	H5Z_nbit_decompress_one_atomic(data, i*p.size, buffer, &j, &buf_len, p);
1166	}	1210	}
Lines 1169-1175 Link Here
1169	size = parms[4];	1213	size = parms[4];
1170	parms_index = 4;	1214	parms_index = 4;
1171	for(i = 0; i < d_nelmts; i++) {	1215	for(i = 0; i < d_nelmts; i++) {
1172	H5Z_nbit_decompress_one_array(data, i*size, buffer, &j, &buf_len, parms);	1216	if(H5Z__nbit_decompress_one_array(data, i*size, buffer, &j, &buf_len, parms) < 0)
		1217	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress array")
1173	parms_index = 4;	1218	parms_index = 4;
1174	}	1219	}
1175	break;	1220	break;
Lines 1177-1189 Link Here
1177	size = parms[4];	1222	size = parms[4];
1178	parms_index = 4;	1223	parms_index = 4;
1179	for(i = 0; i < d_nelmts; i++) {	1224	for(i = 0; i < d_nelmts; i++) {
1180	H5Z_nbit_decompress_one_compound(data, i*size, buffer, &j, &buf_len, parms);	1225	if(H5Z__nbit_decompress_one_compound(data, i*size, buffer, &j, &buf_len, parms) < 0)
		1226	HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "can't decompress compound")
1181	parms_index = 4;	1227	parms_index = 4;
1182	}	1228	}
1183	break;	1229	break;
1184	default:	1230	default:
1185	HDassert(0 && "This Should never be executed!");	1231	HDassert(0 && "This Should never be executed!");
1186	} /* end switch */	1232	} /* end switch */
		1233
		1234	done:
		1235	FUNC_LEAVE_NOAPI(ret_value)
1187	}	1236	}
1188		1237
1189	static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,	1238	static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,