huff_code_t *
huff_code_read(FILE *infh)
{
huff_code_t *hc;
uint32 i, j;
hc = (huff_code_t*)ckd_calloc(1, sizeof(*hc));
hc->refcount = 1;
hc->maxbits = fgetc(infh);
hc->type = fgetc(infh);
/* Two bytes of padding. */
fgetc(infh);
fgetc(infh);
/* Allocate stuff. */
hc->firstcode = (uint32*)ckd_calloc(hc->maxbits + 1, sizeof(*hc->firstcode));
hc->numl = (uint32*)ckd_calloc(hc->maxbits + 1, sizeof(*hc->numl));
hc->syms = (huff_codeword_t**)ckd_calloc(hc->maxbits + 1, sizeof(*hc->syms));
/* Read the symbol tables. */
hc->codewords = hash_table_new(hc->maxbits, HASH_CASE_YES);
for (i = 1; i <= hc->maxbits; ++i) {
if (fread(&hc->firstcode[i], 4, 1, infh) != 1)
goto error_out;
SWAP_BE_32(&hc->firstcode[i]);
if (fread(&hc->numl[i], 4, 1, infh) != 1)
goto error_out;
SWAP_BE_32(&hc->numl[i]);
hc->syms[i] =(huff_codeword_t*) ckd_calloc(hc->numl[i], sizeof(**hc->syms));
for (j = 0; j < hc->numl[i]; ++j) {
huff_codeword_t *cw = &hc->syms[i][j];
cw->nbits = i;
cw->codeword = hc->firstcode[i] + j;
if (hc->type == HUFF_CODE_INT) {
if (fread(&cw->r.ival, 4, 1, infh) != 1)
goto error_out;
SWAP_BE_32(&cw->r.ival);
hash_table_enter_bkey(hc->codewords,
(char const *)&cw->r.ival,
sizeof(cw->r.ival),
(void *)cw);
}
else {
size_t len;
cw->r.sval = fread_line(infh, &len);
cw->r.sval[len-1] = '\0';
hash_table_enter(hc->codewords, cw->r.sval, (void *)cw);
}
}
}
return hc;
error_out:
huff_code_free(hc);
return 0;
}
int
huff_code_write(huff_code_t *hc, FILE *outfh)
{
uint32 i, j;
/* Maximum codeword length */
fputc(hc->maxbits, outfh);
/* Symbol type */
fputc(hc->type, outfh);
/* Two extra bytes (for future use and alignment) */
fputc(0, outfh);
fputc(0, outfh);
/* For each codeword length: */
for (i = 1; i <= hc->maxbits; ++i) {
uint32 val;
/* Starting code, number of codes. */
val = hc->firstcode[i];
/* Canonically big-endian (like the data itself) */
SWAP_BE_32(&val);
fwrite(&val, 4, 1, outfh);
val = hc->numl[i];
SWAP_BE_32(&val);
fwrite(&val, 4, 1, outfh);
/* Symbols for each code (FIXME: Should compress these too) */
for (j = 0; j < hc->numl[i]; ++j) {
if (hc->type == HUFF_CODE_INT) {
int32 val = hc->syms[i][j].r.ival;
SWAP_BE_32(&val);
fwrite(&val, 4, 1, outfh);
}
else {
/* Write them all separated by newlines, so that
* fgets() will read them for us. */
#ifndef POCKETSPHINX_NET
fprintf(outfh, "%s\n", hc->syms[i][j].r.sval);
#else
net_fprintf(outfh,gcnew String("{0}\n"),gcnew String(hc->syms[i][j].r.sval));
#endif
}
}
}
return 0;
}
int
areaddouble (char *file, double **data_ref, int *length_ref)
{
int fd;
int length;
int size;
int offset;
char *data;
if ((fd = open (file, O_RDONLY, 0644)) < 0)
{
fprintf (stderr, "areaddouble: %s: can't open\n", file);
return -1;
}
if (read (fd, (char *) &length, 4) != 4)
{
fprintf (stderr, "areaddouble: %s: can't read length (empty file?)\n", file);
close (fd);
return -1;
}
SWAP_BE_32(&length);
size = length * sizeof (double);
if (!(data = malloc ((unsigned) size)))
{
fprintf (stderr, "areaddouble: %s: can't alloc data\n", file);
close (fd);
return -1;
}
if (read (fd, data, size) != size)
{
fprintf (stderr, "areaddouble: %s: can't read data\n", file);
close (fd);
free (data);
return -1;
}
close (fd);
*data_ref = (double *) data;
for(offset = 0; offset < length; offset++)
SWAP_BE_64(*data_ref + offset);
*length_ref = length;
return length;
}
