47#include "EST_wave_aux.h"
48#include "EST_wave_utils.h"
49#include "EST_strcasecmp.h"
51#include "EST_FileType.h"
53static int def_load_sample_rate = 16000;
65static const char *NIST_SIG =
"NIST_1A\n 1024\n";
66static const char *NIST_END_SIG =
"end_head\n";
67#define NIST_HDR_SIZE 1024
69int nist_get_param_int(
const char *
hdr,
const char *field,
int def_val)
85char *nist_get_param_str(
const char *
hdr,
const char *field,
const char *def_val)
95 val = walloc(
char,size+1);
101 return wstrdup(def_val);
106const char *sample_type_to_nist(
enum EST_sample_type_t sample_type)
109 switch (sample_type) {
133enum EST_sample_type_t nist_to_sample_type(
char *type)
135 if ((streq(type,
"pcm")) ||
136 (streq(type,
"PCM")) ||
137 (streq(type,
"pcm-2")))
139 if (
strcmp(type,
"pcm,embedded-shorten-v1.1") == 0)
141 else if ((EST_strcasecmp(type,
"ULAW",NULL) == 0) ||
142 (EST_strcasecmp(type,
"U-LAW",NULL) == 0) ||
143 (EST_strcasecmp(type,
"mu-law",NULL) == 0) ||
144 (EST_strcasecmp(type,
"mulaw",NULL) == 0))
146 else if ((EST_strcasecmp(type,
"ALAW",NULL) == 0) ||
147 (EST_strcasecmp(type,
"A-LAW",NULL) == 0))
149 else if (
strcmp(type,
"alaw") == 0)
151 else if (
strcmp(type,
"PCM-1") == 0)
153 else if (
strcmp(type,
"PCM-4") == 0)
155 else if (
strcmp(type,
"REAL") == 0)
166 *num_samples,
int *num_channels,
int
168 EST_sample_type_t *sample_type,
int *
bo ,
int
172 char header[NIST_HDR_SIZE];
181 if (
ts.fread(
header,NIST_HDR_SIZE,1) != 1)
187 samps = nist_get_param_int(
header,
"sample_count",-1);
188 *num_channels = nist_get_param_int(
header,
"channel_count",1);
191 nist_get_param_int(
header,
"sample_rate",def_load_sample_rate);
193 (EST_BIG_ENDIAN ?
"10" :
"01"));
197 byte_order = wstrdup((EST_BIG_ENDIAN ?
"10" :
"01"));
202 byte_order = wstrdup((EST_BIG_ENDIAN ?
"10" :
"01"));
218 enum EST_read_status
rval;
222 fprintf(
stderr,
"WAVE read: no support for shorten -- you need to use some external program to unshorten the data\n");
223 return misc_read_error;
226 tmpfile = cmake_tmp_filename();
237 rval = load_wave_nist(
tt, data, num_samples,
239 sample_type,
bo, offset, length);
264 return misc_read_error;
268 fprintf(
stderr,
"WAVE read: nist header is (probably) non-standard\n");
269 fprintf(
stderr,
"WAVE read: assuming different num_channel interpretation\n");
275 (
const char *)
ts.filename());
276 fprintf(
stderr,
"WAVE read: at %d got %d instead of %d samples\n",
288 *sample_type = st_short;
297enum EST_write_status save_wave_nist_header(
FILE *fp,
298 int num_samples,
int num_channels,
300 enum EST_sample_type_t sample_type,
int bo)
302 char h[1024], p[1024];
308 sprintf(p,
"channel_count -i %d\n", num_channels);
310 sprintf(p,
"sample_count -i %d\n", num_samples);
312 sprintf(p,
"sample_rate -i %d\n", sample_rate);
315 t = sample_type_to_nist(sample_type);
320 sprintf(p,
"sample_n_bytes -i %d\n", get_word_size(sample_type));
324 if (get_word_size(sample_type) > 1)
326 sprintf(p,
"sample_byte_format -s%d %s\n", 2,
327 ((
bo == bo_big) ?
"10" :
"01"));
333 strcat(h,
"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
335 if (
fwrite(&h, 1024, 1, fp) != 1)
336 return misc_write_error;
342enum EST_write_status save_wave_nist_data(
FILE *fp,
const short *data,
int offset,
343 int num_samples,
int num_channels,
345 enum EST_sample_type_t sample_type,
int bo)
350 return save_raw_data(fp,data,offset,num_samples,num_channels,
355enum EST_write_status save_wave_nist(
FILE *fp,
const short *data,
int offset,
356 int num_samples,
int num_channels,
358 enum EST_sample_type_t sample_type,
int bo)
360 save_wave_nist_header(fp, num_samples, num_channels,
361 sample_rate, sample_type,
bo);
362 return save_wave_nist_data(fp, data, offset,
363 num_samples, num_channels,
364 sample_rate, sample_type,
bo);
372 *num_samples,
int *num_channels,
int
374 EST_sample_type_t *sample_type,
int *
bo,
375 int offset,
int length)
389 if ((r = read_est_header(
ts,
hinfo,
ascii, t)) != format_ok)
391 if (t != est_file_wave)
392 return misc_read_error;
394 *num_samples =
hinfo.ival(
"NumSamples");
395 *num_channels =
hinfo.ival(
"NumChannels");
396 *sample_rate =
hinfo.ival(
"SampleRate");
410 cerr <<
"EST wave load: " <<
ts.pos_description() <<
endl;
411 cerr <<
"failed to read file\n";
413 return misc_read_error;
417 cerr <<
"Wrong number of samples/channels in EST wave file\n";
418 cerr <<
ts.pos_description() <<
" ";
424 if (
hinfo.present(
"SampleType"))
429 *data = convert_raw_data((
unsigned char *)
file_data,
432 *sample_type = st_short;
439enum EST_write_status save_wave_est_header(
FILE *fp,
440 int num_samples,
int num_channels,
442 enum EST_sample_type_t sample_type,
int bo)
444 fprintf(fp,
"EST_File wave\n");
445 fprintf(fp,
"DataType binary\n");
446 fprintf(fp,
"SampleRate %d\n", sample_rate);
447 fprintf(fp,
"NumSamples %d\n", num_samples);
448 fprintf(fp,
"NumChannels %d\n", num_channels);
449 fprintf(fp,
"SampleType %s\n", sample_type_to_str(sample_type));
450 if (get_word_size(sample_type) > 1)
451 fprintf(fp,
"ByteOrder %s\n", ((
bo == bo_big) ?
"10" :
"01"));
453 fprintf(fp,
"EST_Header_End\n");
457enum EST_write_status save_wave_est_data(
FILE *fp,
const short *data,
int offset,
458 int num_samples,
int num_channels,
460 enum EST_sample_type_t sample_type,
int bo)
465 return save_raw_data(fp, data, offset, num_samples, num_channels,
469enum EST_write_status save_wave_est(
FILE *fp,
const short *data,
int offset,
470 int num_samples,
int num_channels,
472 enum EST_sample_type_t sample_type,
int bo)
474 save_wave_est_header(fp, num_samples, num_channels,
475 sample_rate, sample_type,
bo);
477 return save_wave_est_data(fp, data, offset,
478 num_samples, num_channels,
479 sample_rate, sample_type,
bo);
493#define WAVE_FORMAT_PCM 0x0001
494#define WAVE_FORMAT_ADPCM 0x0002
495#define WAVE_FORMAT_ALAW 0x0006
496#define WAVE_FORMAT_MULAW 0x0007
499 *num_samples,
int *num_channels,
int
501 EST_sample_type_t *sample_type,
int *
bo ,
int
511 if (
ts.fread(info,
sizeof(
char),4) != 4)
513 if (
strncmp(info,
"RIFF",4) != 0)
518 if(
ts.fread(&
dsize,4,1) != 1)
return misc_read_error;
521 if ((
ts.fread(info,
sizeof(
char),4) != 4) ||
525 return misc_read_error;
527 if ((
ts.fread(info,
sizeof(
char),4) != 4) ||
529 return misc_read_error;
531 if (
ts.fread(&
dsize,4,1) != 1)
return misc_read_error;
533 if (
ts.fread(&
shortdata,2,1) != 1)
return misc_read_error;
539 case WAVE_FORMAT_PCM:
542 case WAVE_FORMAT_MULAW:
544 case WAVE_FORMAT_ALAW:
546 case WAVE_FORMAT_ADPCM:
547 fprintf(
stderr,
"RIFF file: unsupported proprietary sample format ADPCM\n");
556 if (
ts.fread(&
shortdata,2,1) != 1)
return misc_read_error;
559 if (
ts.fread(sample_rate,4,1) != 1)
return misc_read_error;
560 if (EST_BIG_ENDIAN) *sample_rate = SWAPINT(*sample_rate);
561 if (
ts.fread(&
intdata,4,1) != 1)
return misc_read_error;
563 if (
ts.fread(&
shortdata,2,1) != 1)
return misc_read_error;
565 if (
ts.fread(&
shortdata,2,1) != 1)
return misc_read_error;
575 if (
ts.fread(info,
sizeof(
char),4) != 4)
578 return misc_read_error;
580 if (
strncmp(info,
"data",4) == 0)
582 if (
ts.fread(&
samps,4,1) != 1)
return misc_read_error;
587 else if (
strncmp(info,
"fact",4) == 0)
589 if (
ts.fread(&
samps,4,1) != 1)
return misc_read_error;
599 if(
ts.fread(&
dsize,4,1) != 1)
return misc_read_error;
622 return misc_read_error;
629 *num_samples =
dsize / (*num_channels);
630 *sample_type = st_short;
637enum EST_write_status save_wave_riff_header(
FILE *fp,
int num_samples,
638 int num_channels,
int sample_rate,
639 enum EST_sample_type_t sample_type,
int bo)
646 if (sample_type == st_schar)
648 EST_warning(
"RIFF format: Signed 8-bit not allowed by this file format");
649 sample_type=st_uchar;
652 info =
"RIFF";
fwrite(info,4,1,fp);
653 data_size = num_channels*num_samples*get_word_size(sample_type)+ 8+16+12;
655 if (EST_BIG_ENDIAN) data_size = SWAPINT(data_size);
656 fwrite(&data_size,1,4,fp);
657 info =
"WAVE";
fwrite(info,4,1,fp);
658 info =
"fmt ";
fwrite(info,4,1,fp);
660 if (EST_BIG_ENDIAN) data_size = SWAPINT(data_size);
661 fwrite(&data_size,1,4,fp);
664 case st_short:
data_short = WAVE_FORMAT_PCM;
break;
665 case st_uchar:
data_short = WAVE_FORMAT_PCM;
break;
666 case st_mulaw:
data_short = WAVE_FORMAT_MULAW;
break;
667 case st_alaw:
data_short = WAVE_FORMAT_ALAW;
break;
668 case st_adpcm:
data_short = WAVE_FORMAT_ADPCM;
break;
672 return misc_write_error;
682 data_int = sample_rate * num_channels * get_word_size(sample_type);
685 data_short = num_channels * get_word_size(sample_type);
691 info =
"data";
fwrite(info,4,1,fp);
692 data_size = num_channels*num_samples*get_word_size(sample_type);
693 if (EST_BIG_ENDIAN) data_size = SWAPINT(data_size);
694 fwrite(&data_size,1,4,fp);
699enum EST_write_status save_wave_riff_data(
FILE *fp,
const short *data,
700 int offset,
int num_samples,
int num_channels,
702 enum EST_sample_type_t sample_type,
int bo)
707 return save_raw_data(fp,data,offset,num_samples,num_channels,
708 sample_type,bo_little);
712enum EST_write_status save_wave_riff(
FILE *fp,
const short *data,
int offset,
713 int num_samples,
int num_channels,
715 enum EST_sample_type_t sample_type,
int bo)
717 save_wave_riff_header(fp, num_samples, num_channels, sample_rate,
720 return save_wave_riff_data(fp, data, offset, num_samples,
721 num_channels, sample_rate, sample_type,
bo);
743 *num_samples,
int *num_channels,
int
745 EST_sample_type_t *sample_type,
int *
bo ,
int
749 struct AIFFchunk
chunk;
759 if (
ts.fread(info,
sizeof(
char),4) != 4)
761 if (
strncmp(info,
"FORM",4) != 0)
765 if (
ts.fread(&
dsize,4,1) != 1)
return misc_read_error;
766 if (EST_LITTLE_ENDIAN)
768 if ((
ts.fread(info,
sizeof(
char),4) != 4) ||
772 return misc_read_error;
777 if (EST_LITTLE_ENDIAN)
781 if (
chunk.size != 18)
784 return misc_read_error;
787 return misc_read_error;
789 return misc_read_error;
791 return misc_read_error;
795 return misc_read_error;
797 if (EST_LITTLE_ENDIAN)
810 return misc_read_error;
812 if (EST_LITTLE_ENDIAN)
826 return misc_read_error;
841 (
const char *)
ts.filename());
842 fprintf(
stderr,
"AIFF read: at %d got %d instead of %d samples\n",
850 *sample_type = st_short;
865enum EST_write_status save_wave_aiff_header(
FILE *fp,
866 int num_samples,
int num_channels,
868 enum EST_sample_type_t sample_type,
int bo)
879 data_size = 54+(num_samples*num_channels*get_word_size(sample_type));
880 if (EST_LITTLE_ENDIAN)
881 data_size = SWAPINT(data_size);
882 fwrite(&data_size,1,4,fp);
888 if (EST_LITTLE_ENDIAN)
892 if (EST_LITTLE_ENDIAN)
896 if (EST_LITTLE_ENDIAN)
900 if (EST_LITTLE_ENDIAN)
903 ConvertToIeeeExtended((
double)sample_rate,
ieee_ext_buf);
907 data_int = 8 + (num_samples*num_channels*get_word_size(sample_type));
908 if (EST_LITTLE_ENDIAN)
912 if (EST_LITTLE_ENDIAN)
915 if (EST_LITTLE_ENDIAN)
923enum EST_write_status save_wave_aiff_data(
FILE *fp,
const short *data,
int offset,
924 int num_samples,
int num_channels,
926 enum EST_sample_type_t sample_type,
int bo)
931 if ((sample_type == st_short) || (sample_type == st_uchar))
932 return save_raw_data(fp,data, offset, num_samples, num_channels,
933 sample_type, bo_big);
936 fprintf(
stderr,
"AIFF: requested data type not uchar or short\n");
937 return misc_write_error;
942enum EST_write_status save_wave_aiff(
FILE *fp,
const short *data,
int offset,
943 int num_samples,
int num_channels,
945 enum EST_sample_type_t sample_type,
int bo)
947 save_wave_aiff_header(fp, num_samples, num_channels,
948 sample_rate, sample_type,
bo);
950 return save_wave_aiff_data(fp, data, offset,
951 num_samples, num_channels,
952 sample_rate, sample_type,
bo);
960 *num_samples,
int *num_channels,
int *
word_size,
int
961 *sample_rate,
enum EST_sample_type_t *sample_type,
int *
bo,
962 int offset,
int length)
981 return misc_read_error;
991 *sample_type = st_short;
998enum EST_write_status save_wave_ulaw_header(
FILE *fp,
999 int num_samples,
int num_channels,
1001 enum EST_sample_type_t sample_type,
int bo)
1007 (
void) num_channels;
1012enum EST_write_status save_wave_ulaw_data(
FILE *fp,
const short *data,
int offset,
1013 int num_samples,
int num_channels,
1015 enum EST_sample_type_t sample_type,
int bo)
1020 return save_wave_raw(fp,data,offset,num_samples,num_channels,
1024enum EST_write_status save_wave_ulaw(
FILE *fp,
const short *data,
int offset,
1025 int num_samples,
int num_channels,
1027 enum EST_sample_type_t sample_type,
int bo)
1029 save_wave_ulaw_header(fp, num_samples, num_channels,
1030 sample_rate, sample_type,
bo);
1032 return save_wave_ulaw_data(fp, data, offset,
1033 num_samples, num_channels,
1034 sample_rate, sample_type,
bo);
1040 *num_samples,
int *num_channels,
int *
word_size,
int
1041 *sample_rate,
enum EST_sample_type_t *sample_type,
int *
bo,
1042 int offset,
int length)
1045 unsigned char *
alaw;
1061 return misc_read_error;
1069 *sample_rate = 8000;
1071 *sample_type = st_short;
1073 *
bo = EST_NATIVE_BO;
1078enum EST_write_status save_wave_alaw_header(
FILE *fp,
1079 int num_samples,
int num_channels,
1081 enum EST_sample_type_t sample_type,
int bo)
1087 (
void) num_channels;
1092enum EST_write_status save_wave_alaw_data(
FILE *fp,
const short *data,
int offset,
1093 int num_samples,
int num_channels,
1095 enum EST_sample_type_t sample_type,
int bo)
1101 return save_wave_raw(fp,data,offset,num_samples,num_channels,
1105enum EST_write_status save_wave_alaw(
FILE *fp,
const short *data,
int offset,
1106 int num_samples,
int num_channels,
1108 enum EST_sample_type_t sample_type,
int bo)
1110 save_wave_alaw_header(fp, num_samples, num_channels,
1111 sample_rate, sample_type,
bo);
1113 return save_wave_alaw_data(fp, data, offset,
1114 num_samples, num_channels,
1115 sample_rate, sample_type,
bo);
1125 unsigned int hdr_size;
1127 unsigned int encoding;
1128 unsigned int sample_rate;
1129 unsigned int channels;
1133 *num_samples,
int *num_channels,
int *
word_size,
int
1134 *sample_rate,
enum EST_sample_type_t *sample_type,
int *
bo ,
1135 int offset,
int length)
1145 if (
ts.fread(&
header,
sizeof(Sun_au_header), 1) != 1)
1146 return misc_read_error;
1149 if ((EST_LITTLE_ENDIAN) &&
1150 ((
unsigned int)0x2e736e64 == SWAPINT(
header.magic)))
1158 else if ((
unsigned int)0x2e736e64 !=
header.magic)
1159 return wrong_format;
1174 return misc_read_error;
1177 *num_channels =
header.channels;
1179 *sample_rate =
header.sample_rate;
1181 if ((
header.data_size == 0) ||
1182 (
header.data_size == -1))
1201 (
const char *)
ts.filename());
1202 fprintf(
stderr,
"WAVE read: at %d got %d instead of %d samples\n",
1213 *sample_type = st_short;
1214 *
bo = EST_NATIVE_BO;
1219enum EST_write_status save_wave_snd_header(
FILE *fp,
1220 int num_samples,
int num_channels,
1222 enum EST_sample_type_t sample_type,
int bo)
1229 header.magic = (
unsigned int)0x2e736e64;
1231 header.data_size = get_word_size(sample_type) * num_channels * num_samples;
1233 switch (sample_type) {
1246 "Unsupported sample type cannot be saved in SND format\n");
1247 return misc_write_error;
1253 header.sample_rate = sample_rate;
1255 header.channels = num_channels;
1257 if (EST_LITTLE_ENDIAN)
1270 return misc_write_error;
1275enum EST_write_status save_wave_snd_data(
FILE *fp,
const short *data,
int offset,
1276 int num_samples,
int num_channels,
1278 enum EST_sample_type_t sample_type,
int bo)
1284 return save_raw_data(fp,data,offset,num_samples,num_channels,
1285 sample_type,bo_big);
1289enum EST_write_status save_wave_snd(
FILE *fp,
const short *data,
int offset,
1290 int num_samples,
int num_channels,
1292 enum EST_sample_type_t sample_type,
int bo)
1294 save_wave_snd_header(fp, num_samples, num_channels, sample_rate,
1296 return save_wave_snd_data(fp, data, offset, num_samples,
1297 num_channels, sample_rate, sample_type,
bo);
1352 *num_samples,
int *num_channels,
int *
word_size,
int
1353 *sample_rate,
enum EST_sample_type_t *sample_type,
int *
bo,
int
1367 if (
ts.fread(&
fh,
sizeof(
struct audlabfh), 1) != 1)
1368 return misc_read_error;
1369 if (
strcmp(
fh.file_type,
"Sample") != 0)
1370 return wrong_format;
1372 if (
ts.fread(&
sh,
sizeof(
struct audlabsh), 1) != 1)
1373 return misc_read_error;
1374 if (
ts.fread(&
sd,
sizeof(
struct audlabsd), 1) != 1)
1375 return misc_read_error;
1382 *num_channels =
sh.channel_count;
1383 *sample_rate =
sh.sample_rate;
1384 sample_count =
sd.sample_count;
1388 *num_channels = SWAPINT(
sh.channel_count);
1389 *sample_rate = SWAPINT(
sh.sample_rate);
1390 sample_count = SWAPINT(
sd.sample_count);
1393 data_length = (sample_count - offset) * (*num_channels);
1397 *data = walloc(
short,
sizeof(
short) *
data_length);
1403 return misc_read_error;
1405 if (EST_LITTLE_ENDIAN)
1409 *sample_type = st_short;
1411 *
bo = EST_NATIVE_BO;
1416enum EST_write_status save_wave_audlab_header(
FILE *fp,
1417 int num_samples,
int num_channels,
1419 enum EST_sample_type_t sample_type,
int bo)
1428 fh.start =
sizeof (
struct audlabfh) +
1433 if (EST_LITTLE_ENDIAN)
1435 sh.channel_count = SWAPINT(num_channels);
1437 sh.sample_rate = SWAPINT(sample_rate);
1439 sd.sample_count = SWAPINT(num_samples);
1440 sd.nbits = SWAPINT(16);
1444 sh.channel_count = num_channels;
1446 sh.sample_rate = sample_rate;
1448 sd.sample_count = num_samples;
1460enum EST_write_status save_wave_audlab_data(
FILE *fp,
const short *data,
int offset,
1461 int num_samples,
int num_channels,
1463 enum EST_sample_type_t sample_type,
int bo)
1469 return save_raw_data(fp,data,offset,num_samples,num_channels,
1473enum EST_write_status save_wave_audlab(
FILE *fp,
const short *data,
int offset,
1474 int num_samples,
int num_channels,
1476 enum EST_sample_type_t sample_type,
int bo)
1478 save_wave_audlab_header(fp, num_samples, num_channels,
1479 sample_rate, sample_type,
bo);
1480 return save_wave_audlab_data(fp, data, offset,
1481 num_samples, num_channels,
1482 sample_rate, sample_type,
bo);
1496#include "esps_utils.h"
1498 *num_samples,
int *num_channels,
int
1500 EST_sample_type_t *sample_type,
int *
bo ,
int
1507 enum EST_read_status
rv;
1513 if ((fd =
ts.filedescriptor()) == NULL)
1516 (
const char *)
ts.filename());
1517 return misc_read_error;
1520 if ((
rv=read_esps_hdr(&
hdr,fd)) != format_ok)
1523 if (
hdr->file_type != ESPS_SD)
1526 delete_esps_hdr(
hdr);
1527 return misc_read_error;
1530 if (fea_value_d(
"record_freq",0,
hdr,&d) != 0)
1532 fprintf(
stderr,
"ESPS file: can't find sample_rate in header assuming 16000\n");
1533 *sample_rate = 16000;
1536 *sample_rate = (int)d;
1539 *num_channels =
hdr->field_dimension[0];
1541 actual_bo = (EST_BIG_ENDIAN ? bo_little : bo_big);
1543 actual_bo = (EST_BIG_ENDIAN ? bo_big : bo_little);
1556 (
const char *)
ts.filename());
1557 fprintf(
stderr,
"WAVE read: at %d got %d instead of %d samples\n",
1567 *sample_type = st_short;
1568 *
bo = EST_NATIVE_BO;
1570 delete_esps_hdr(
hdr);
1576enum EST_write_status save_wave_sd_header(
FILE *fp,
1577 int num_samples,
int num_channels,
1579 enum EST_sample_type_t sample_type,
int bo)
1584 enum EST_write_status
rv;
1587 hdr->num_records = num_samples;
1588 switch (sample_type)
1590 case st_short:
esps_type = ESPS_SHORT;
break;
1591 case st_schar:
esps_type = ESPS_CHAR;
break;
1592 case st_int:
esps_type = ESPS_INT;
break;
1593 case st_float:
esps_type = ESPS_FLOAT;
break;
1594 case st_double:
esps_type = ESPS_DOUBLE;
break;
1596 fprintf(
stderr,
"ESPS file: no support for sample_type %s\n",
1597 sample_type_to_str(sample_type));
1598 return misc_write_error;
1603 add_fea_special(
hdr,ESPS_FEA_DIRECTORY,
"margo:/disk/disk10/home/awb/projects/speech_tools/main");
1604 add_fea_special(
hdr,ESPS_FEA_COMMAND,
1605 "EDST waveform written as ESPS FEA_SD.\n\
1607 add_fea_d(
hdr,
"start_time",0,(
double)0);
1608 add_fea_d(
hdr,
"record_freq",0,(
double)sample_rate);
1609 add_fea_d(
hdr,
"max_value",0,(
double)27355);
1611 if ((
rv=write_esps_hdr(
hdr,fp)) != write_ok)
1613 delete_esps_hdr(
hdr);
1617 delete_esps_hdr(
hdr);
1622enum EST_write_status save_wave_sd_data(
FILE *fp,
const short *data,
1624 int num_samples,
int num_channels,
1626 enum EST_sample_type_t sample_type,
int bo)
1632 return save_raw_data(fp,data,offset,num_samples,num_channels,
1633 sample_type,EST_NATIVE_BO);
1636enum EST_write_status save_wave_sd(
FILE *fp,
const short *data,
int offset,
1637 int num_samples,
int num_channels,
1639 enum EST_sample_type_t sample_type,
int bo)
1642 save_wave_sd_header(fp, num_samples, num_channels, sample_rate,
1644 return save_wave_sd_data(fp, data, offset, num_samples,
1645 num_channels, sample_rate, sample_type,
bo);
1657 *num_samples,
int *num_channels,
1660 enum EST_sample_type_t *sample_type,
1661 int *
bo,
int offset,
int length,
1674 if ((offset != 0) || (length != 0))
1676 fprintf(
stderr,
"Load ascii wave: doesn't support offsets and lengths\n");
1677 return misc_read_error;
1681 guess = (int)(1.2*
ts.tell()/7)+10;
1683 *data = walloc(
short,
guess);
1687 samp =
atoi(
ts.get().string());
1698 fprintf(
stderr,
"Load ascii wave: sample %d underflow clipping\n",
1700 (*data)[i] = -32768;
1702 else if (samp > 32767)
1704 fprintf(
stderr,
"Load ascii wave: sample %d overflow clipping\n",
1709 (*data)[i] = (
short)samp;
1728 return misc_read_error;
1735 *num_channels =
inc;
1736 *sample_type = st_short;
1738 *
bo = EST_NATIVE_BO;
1743enum EST_write_status save_wave_raw_header(
FILE *fp,
1744 int num_samples,
int num_channels,
1746 enum EST_sample_type_t sample_type,
int bo)
1751enum EST_write_status save_wave_raw_data(
FILE *fp,
const short *data,
1753 int num_samples,
int num_channels,
1755 enum EST_sample_type_t sample_type,
int bo)
1760 return save_raw_data(fp,data,offset,num_samples,num_channels,
1764enum EST_write_status save_wave_raw(
FILE *fp,
const short *data,
1766 int num_samples,
int num_channels,
1768 enum EST_sample_type_t sample_type,
int bo)
1772 return save_wave_raw_data(fp, data, offset, num_samples,
1773 num_channels, sample_rate, sample_type,
bo);
1782enum EST_write_status wave_io_save_header(
FILE *fp,
1783 const int num_samples,
const int num_channels,
1784 const int sample_rate,
1788 EST_WaveFileType t = EST_WaveFile::map.token(ftype);
1789 EST_sample_type_t sample_type = EST_sample_type_map.token(
stype);
1793 return save_wave_nist_header(fp, num_samples, num_channels,
1794 sample_rate, sample_type,
bo);
1797 return save_wave_sd_header(fp, num_samples, num_channels,
1798 sample_rate, sample_type,
bo);
1801 return save_wave_est_header(fp, num_samples, num_channels,
1802 sample_rate, sample_type,
bo);
1805 return save_wave_audlab_header(fp, num_samples, num_channels,
1806 sample_rate, sample_type,
bo);
1809 return save_wave_snd_header(fp, num_samples, num_channels,
1810 sample_rate, sample_type,
bo);
1813 return save_wave_aiff_header(fp, num_samples, num_channels,
1814 sample_rate, sample_type,
bo);
1817 return save_wave_riff_header(fp, num_samples, num_channels,
1818 sample_rate, sample_type,
bo);
1821 return save_wave_raw_header(fp, num_samples, num_channels,
1822 sample_rate, sample_type,
bo);
1825 return save_wave_ulaw_header(fp, num_samples, num_channels,
1826 sample_rate, sample_type,
bo);
1830 cerr <<
"Can't save wave header to files type " << ftype <<
endl;
1837enum EST_write_status wave_io_save_data(
FILE *fp,
const short * data,
1839 const int num_samples,
const int num_channels,
1840 const int sample_rate,
1844 EST_WaveFileType t = EST_WaveFile::map.token(ftype);
1845 EST_sample_type_t sample_type = EST_sample_type_map.token(
stype);
1849 return save_wave_nist_data(fp, data, offset, num_samples, num_channels,
1850 sample_rate, sample_type,
bo);
1853 return save_wave_sd_data(fp, data, offset, num_samples, num_channels,
1854 sample_rate, sample_type,
bo);
1857 return save_wave_est_data(fp, data, offset, num_samples, num_channels,
1858 sample_rate, sample_type,
bo);
1861 return save_wave_audlab_data(fp, data, offset, num_samples, num_channels,
1862 sample_rate, sample_type,
bo);
1865 return save_wave_snd_data(fp, data, offset, num_samples, num_channels,
1866 sample_rate, sample_type,
bo);
1869 return save_wave_aiff_data(fp, data, offset, num_samples, num_channels,
1870 sample_rate, sample_type,
bo);
1873 return save_wave_riff_data(fp, data, offset, num_samples, num_channels,
1874 sample_rate, sample_type,
bo);
1877 return save_wave_raw_data(fp, data, offset, num_samples, num_channels,
1878 sample_rate, sample_type,
bo);
1881 return save_wave_ulaw_data(fp, data, offset, num_samples, num_channels,
1882 sample_rate, sample_type,
bo);
1886 cerr <<
"Can't save wave data to files type " << ftype <<
endl;