/*
NAME
HDflush -- flush the HDF file
USAGE
intn HDflush(fid)
int32 fid; IN: file ID
RETURNS
SUCCEED / FAIL
DESCRIPTION
Force the system to flush the HDF file stream
This should be primarily used for debugging
The MAC does not really support fflush() so this r
outine just returns SUCCEED always on a MAC w/o
really doing anything.
---------------------------------------------------------------------------*/
intn
HDflush(int32 file_id)
{
CONSTR(FUNC, "HDflush"); /* for HERROR */
filerec_t *file_rec;
file_rec = HAatom_object(file_id);
if (BADFREC(file_rec))
HRETURN_ERROR(DFE_ARGS, FAIL);
HI_FLUSH(file_rec->file);
return SUCCEED;
} /* HDflush */
/*--------------------------------------------------------------------------
NAME
HCIcszip_decode -- Decode SZIP compressed data into a buffer.
USAGE
int32 HCIcszip_decode(info,length,buf)
compinfo_t *info; IN: the info about the compressed element
int32 length; IN: number of bytes to read into the buffer
uint8 *buf; OUT: buffer to store the bytes read
RETURNS
Returns SUCCEED or FAIL
DESCRIPTION
Common code called to decode SZIP data from the file.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
PRIVATE int32
HCIcszip_decode(compinfo_t * info, int32 length, uint8 *buf)
{
CONSTR(FUNC, "HCIcszip_decode");
#ifdef H4_HAVE_LIBSZ
accrec_t *access_rec;
comp_coder_szip_info_t *szip_info; /* ptr to SZIP info */
uint8 *in_buffer;
uint8 *out_buffer;
int32 in_length;
int32 out_length;
int bytes_per_pixel;
int32 rbytes;
uint16 tag,ref;
int32 len1;
int32 aid;
int32 status;
size_t size_out;
uint8 *cp;
int32 good_bytes;
int32 old_way;
SZ_com_t sz_param;
#endif
#ifdef H4_HAVE_LIBSZ
szip_info = &(info->cinfo.coder_info.szip_info);
if (szip_info->szip_state == SZIP_INIT) {
/* Load from disk, decode the data */
if ((access_rec = HAatom_object(info->aid)) == NULL) /* get the access_rec pointer */
HRETURN_ERROR(DFE_ARGS, FAIL);
/* Discover how much data must be read */
if(HTPinquire(access_rec->ddid,&tag,&ref,NULL,&in_length)==FAIL)
HRETURN_ERROR(DFE_INTERNAL, FAIL);
if (in_length == -1)
HRETURN_ERROR(DFE_INTERNAL, FAIL);
if (tag & 0x4000) {
/* this is linked list -- get the length of the data */
aid = Hstartread(access_rec->file_id, tag, ref);
if (HDinqblockinfo(aid, &len1, NULL, NULL, NULL) == FAIL) {
Hendaccess(aid);
HRETURN_ERROR(DFE_INTERNAL, FAIL);
}
in_length = len1;
Hendaccess(aid);
}
old_way = (int)(szip_info->options_mask & SZ_H4_REV_2);
if (old_way == 0) {
/* special case: read data encoded in V4.2r0 */
old_way = 1;
good_bytes = in_length;
in_length = in_length+5;
if ((in_buffer = (uint8 *) HDmalloc(in_length)) == NULL)
HRETURN_ERROR(DFE_NOSPACE, FAIL);
cp = in_buffer;
*cp = 0;
cp++;
INT32ENCODE(cp, good_bytes);
} else {
/* V4.2r1: in_length is correct */
old_way = 0;
if ((in_buffer = (uint8 *) HDmalloc(in_length)) == NULL)
HRETURN_ERROR(DFE_NOSPACE, FAIL);
}
/* Allocate memory for the uncompressed data */
bytes_per_pixel = (szip_info->bits_per_pixel + 7) >> 3;
if (bytes_per_pixel == 3)
bytes_per_pixel++;
out_length = szip_info->pixels * bytes_per_pixel;
if ((out_buffer = (uint8 *) HDmalloc(out_length)) == NULL)
HRETURN_ERROR(DFE_NOSPACE, FAIL);
/* Read the unompressed data */
if (old_way == 1) {
/* this is encoded in V4.2r0 */
/* the preamble isn't in the file, so read only the data */
if ((rbytes = Hread(info->aid, in_length-5, in_buffer+5)) == FAIL)
{
HDfree(out_buffer);
HDfree(in_buffer);
HRETURN_ERROR(DFE_READERROR, FAIL);
}
if (rbytes == 0 || rbytes != (in_length - 5)) {
/* is this possible? */
HDfree(out_buffer);
HDfree(in_buffer);
HRETURN_ERROR(DFE_READERROR, FAIL);
}
} else {
/* HDF4.2R1: read the data plus preamble */
if ((rbytes = Hread(info->aid, in_length, in_buffer)) == FAIL)
{
HDfree(out_buffer);
HDfree(in_buffer);
HRETURN_ERROR(DFE_READERROR, FAIL);
}
if (rbytes == 0 || rbytes != in_length) {
/* is this possible? */
HDfree(out_buffer);
HDfree(in_buffer);
HRETURN_ERROR(DFE_READERROR, FAIL);
}
}
cp = in_buffer;
cp++;
INT32DECODE(cp, good_bytes);
if (in_buffer[0] == 1) {
/* This byte means the data was not compressed -- just copy out */
szip_info->szip_state = SZIP_RUN;
HDmemcpy(out_buffer, in_buffer+5, good_bytes);
szip_info->buffer = out_buffer;
szip_info->buffer_pos = 0;
szip_info->buffer_size = good_bytes;
szip_info->offset = 0;
if (good_bytes > length) {
/* partial read */
HDmemcpy(buf, in_buffer+5, length);
szip_info->buffer_pos += length;
szip_info->buffer_size -= length;
} else {
/* read the whole data block to the user buffer */
HDmemcpy(buf, in_buffer+5, good_bytes);
szip_info->buffer_pos += good_bytes;
szip_info->buffer_size -= good_bytes;
}
szip_info->offset = szip_info->buffer_pos;
HDfree(in_buffer);
if (szip_info->buffer_size == 0) {
if (szip_info->buffer != NULL) {
HDfree(szip_info->buffer);
szip_info->buffer = NULL;
}
}
return (SUCCEED);
}
/* Decompress the data */
/* set up the parameters */
sz_param.options_mask = (szip_info->options_mask & ~SZ_H4_REV_2);
sz_param.bits_per_pixel = szip_info->bits_per_pixel;
sz_param.pixels_per_block = szip_info->pixels_per_block;
sz_param.pixels_per_scanline = szip_info->pixels_per_scanline;
size_out = out_length;
if(SZ_OK!= (status = SZ_BufftoBuffDecompress(out_buffer, &size_out, (in_buffer+5), good_bytes, &sz_param)))
{
HDfree(out_buffer);
HDfree(in_buffer);
HRETURN_ERROR(DFE_CDECODE, FAIL);
}
if ((int32)size_out != out_length) {
/* This should never happen?? */
printf("status: %d ??bytes != out_length %d != %d\n",status,size_out,out_length);
}
/* The data is successfully decompressed. Put into the szip struct */
HDfree(in_buffer);
szip_info->szip_state = SZIP_RUN;
szip_info->buffer = out_buffer;
szip_info->buffer_pos = 0;
szip_info->buffer_size = out_length;
szip_info->offset = 0;
}
/* copy the data into the return buffer */
if (length > szip_info->buffer_size)
{
/* can't happen?? panic?? */
if (szip_info->buffer != NULL) {
HDfree(szip_info->buffer);
szip_info->buffer = NULL;
}
return (FAIL);
}
HDmemcpy(buf, szip_info->buffer + szip_info->buffer_pos, length);
szip_info->buffer_pos += length;
szip_info->buffer_size -= length;
szip_info->offset = szip_info->buffer_pos;
if (szip_info->buffer_size == 0) {
if (szip_info->buffer != NULL) {
HDfree(szip_info->buffer);
szip_info->buffer = NULL;
}
}
return (SUCCEED);
#else /* ifdef H4_HAVE_LIBSZ */
HRETURN_ERROR(DFE_CANTCOMP, FAIL);
#endif /* H4_HAVE_LIBSZ */
} /* end HCIcszip_decode() */
