static char *
config_init(char *file_name, char *backup_file, char *resin_home)
{
FILE *is;
FILE *os;
char buf[4096];
is = fopen(file_name, "r");
if (! is)
return strdup(rsprintf(buf, "Can't find Netscape's %s", file_name));
os = fopen(backup_file, "w+");
if (! os) {
fclose(is);
return strdup(rsprintf(buf, "Can't write Netscape's %s", backup_file));
}
int lastInitModule = -1;
int hasCaucho = 0;
int line = 0;
while (fgets(buf, sizeof(buf), is)) {
fputs(buf, os);
line++;
char cmd[1024];
int args = sscanf(buf, "%s", cmd);
if (strstr(buf, "caucho_status")) {
hasCaucho = 1;
}
if (args >= 1 && ! strcmp(cmd, "Init"))
lastInitModule = line;
}
fclose(is);
fclose(os);
if (hasCaucho || lastInitModule < 0)
return 0;
is = fopen(backup_file, "r");
os = fopen(file_name, "w+");
line = 0;
int isFirst = 1;
while (fgets(buf, sizeof(buf), is)) {
fputs(buf, os);
line++;
if (line == lastInitModule) {
fprintf(os, "Init fn=\"load-modules\" shlib=\"%s/libexec/nsapi.dll\" "
"funcs=\"caucho_service,caucho_filter,caucho_status\"\n",
resin_home);
}
}
return 0;
}
void *append_WORD_no_NULL(void *p1, void *p2){
WORD *tw, *w1 = (WORD *)p1, *w2 = (WORD *)p2;
tw = get_WORD();
tw->use = 1;
tw->T1 = w1->T1;
tw->T2 = w2->T2;
tw->T_dur = tw->T2 - tw->T1;
tw->weight = w1->weight + w2->weight;
tw->conf = (w1->conf + w2->conf) / 2.0;
tw->frag_corr = (w1->frag_corr && w2->frag_corr);
if (w1->opt_del && w2->opt_del){
tw->intern_value =
TEXT_strdup((TEXT*)rsprintf("%s%s",
(! w1->opt_del) ? w1->value : w1->intern_value,
(! w2->opt_del) ? w2->value : w2->intern_value));
tw->value =
TEXT_strdup((TEXT*)rsprintf(WORD_OPT_DEL_PRE_STR "%s"
WORD_OPT_DEL_POST_STR, tw->intern_value));
tw->opt_del = TRUE;
} else {
if (TEXT_strcmp(w1->value, (TEXT *)"@") == 0)
tw->value = TEXT_strdup((! w2->opt_del) ? w2->value : w2->intern_value);
else if (TEXT_strcmp(w2->value,(TEXT *)"@") == 0)
tw->value = TEXT_strdup((! w1->opt_del) ? w1->value : w1->intern_value);
else
tw->value = TEXT_add((! w1->opt_del) ? w1->value : w1->intern_value,
(! w2->opt_del) ? w2->value : w2->intern_value);
}
return(tw);
}
int sp_compute_checksum(SP_FILE *sp, SP_CHECKSUM *comp_chksum){
char *proc = "sp_compute_checksum";
void *buff;
SP_INTEGER cur_pos;
if (sp == SPNULL)
return_err(proc,101,101,"Null SPFILE structure");
if (sp->open_mode != SP_mode_read)
return_err(proc,102,102,"File must be opened for read");
if (! sp->read_spifr->status->is_disk_file)
return_err(proc,103,103,"File must be a disk file");
if (sp_error(sp) != 0)
return_err(proc,104,104,"Sphere file already has an error");
/* save the current position so we can go back to it */
if ((cur_pos = sp_tell(sp)) < 0)
return_err(proc,110,110,
rsprintf("sp_tell() failed, returning: %s",
get_return_status_message()));
/* rewind the file */
if (sp_seek(sp,0,0) != 0)
return_err(proc,111,111,
rsprintf("sp_seek() to sample 0 failed, returning: %s",
get_return_status_message()));
/* allocate some memory */
if ((buff = (void *)sp_data_alloc(sp,4096)) == (void *)0)
return_err(proc,112,112,
rsprintf("can not alloc waveform buffer, returning: %s",
get_return_status_message()));
/* read in the data */
while (sp_read_data(buff,4096,sp) > 0)
;
/* dealloc memory */
sp_data_free(sp,buff);
if (sp_error(sp) != 0)
return_err(proc,120,120,
rsprintf("sp_error() indicates an error, returning: %s",
get_return_status_message()));
*comp_chksum = sp->read_spifr->waveform->checksum;
if (sp_seek(sp,cur_pos,0) != 0)
return_err(proc,130,130,
rsprintf("sp_seek() to return the file to it's initial"
"state failed, returning: %s",
get_return_status_message()));
return_success(proc,0,0,"ok");
}
int verify_file_checksum(char *filename)
{
char *proc="verify_file_checksum " SPHERE_VERSION_STR;
SP_FILE *sp;
char buf[1024];
if (sp_verbose > 10) fprintf(spfp,"Proc %s:\n",proc);
if (filename == CNULL) return_err(proc,100,100,"Null filename");
if ((sp = sp_open(filename,"rv")) == SPNULL)
return_err(proc,101,101,
rsprintf("Unable to open SPHERE file '%s'",filename));
if (sp->read_spifr->status->user_sample_count > 0){
if (sp_read_data(buf,1,sp) != 1){
sp_close(sp);
return_err(proc,200,200,"Verification of checksum failed");
}
} else {
sp_close(sp);
return_err(proc,300,300,"No data in file to check");
}
sp_close(sp);
if (sp_verbose > 11) fprintf(spfp,"Proc %s: Returning 0\n",proc);
return_success(proc,0,0,"Checksum verification passed");
}
int nz_instrument_sine_init(struct nz_node * node) {
int rc = nz_instr_init(node, sizeof(struct state), &sine_render);
if (rc != 0) return rc;
node->node_name = rsprintf("Sine Instrument");
return 0;
}
int parse_sample_byte_format(char *str, enum SP_sample_byte_fmt *sbf)
{
char *proc="parse_sample_byte_format " SPHERE_VERSION_STR;
if (sp_verbose > 10) fprintf(spfp,"Proc %s:\n",proc);
if (str == CNULL)
return_err(proc,100,100,"Null sample_byte_format_string");
if (sbf == (enum SP_sample_byte_fmt *)0)
return_err(proc,101,101,"Null sbf pointer");
if (strsame(str,"01")) *sbf = SP_sbf_01;
else if (strsame(str,"10")) *sbf = SP_sbf_10;
else if (strsame(str,"1")) *sbf = SP_sbf_1;
else if (strsame(str,"0123")) *sbf = SP_sbf_0123;
else if (strsame(str,"1032")) *sbf = SP_sbf_1032;
else if (strsame(str,"2301")) *sbf = SP_sbf_2301;
else if (strsame(str,"3210")) *sbf = SP_sbf_3210;
else if (strsame(str,"N")) *sbf = SP_sbf_N;
if (strstr(str,"shortpack") != CNULL) {
/* this return value must remain 1000, other functions depend on it*/
return_err(proc,1000,1000,
rsprintf("Unknown sample_byte_format value '%s' in header",str));
}
if (sp_verbose > 11) fprintf(spfp,"Proc %s: Returning 0\n",proc);
return_success(proc,0,0,"ok");
}
static int OnEditEaClick(HWND hDlg)
{
TFileTestData * pData = GetDialogData(hDlg);
TCHAR szEaInfo[128];
// Invoke the editor of the extended attributes
if(ExtendedAtributesEditorDialog(hDlg, pData) == IDOK)
{
// Update the info about extended attributes
rsprintf(szEaInfo, _maxchars(szEaInfo), IDS_EA_INFO, pData->pFileEa, pData->dwEaSize);
SetDlgItemText(hDlg, IDC_EXTENDED_ATTRIBUTES, szEaInfo);
}
return TRUE;
}
SP_INTEGER sp_header_size(struct header_t *h)
{
FILE *fp;
SP_INTEGER header_size, data_size;
if (h == HDRNULL)
return -1;
fp = fopen(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME),"w");
if (fp == FPNULL){
if (sp_verbose > 15)
fprintf(spfp,"Can't open file '%s'\n",
rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
return -1;
}
if (sp_write_header(fp,h,&header_size,&data_size) < 0){
fclose(fp);
unlink(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
return(-1);
}
fclose(fp);
unlink(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
return(header_size);
}
static void GetFileTestAppTitle(LPTSTR szTitle, int nMaxChars)
{
TCHAR szUserName[256] = _T("");
DWORD dwSize = _maxchars(szUserName);
UINT nIDTitle = IDS_APP_TITLE;
BOOL bElevated = FALSE;
// Get the elevation flags. Note that this returns FALSE on pre-Vista
if(GetTokenElevation(&bElevated))
{
nIDTitle = bElevated ? IDS_APP_TITLE_VISTA1 : IDS_APP_TITLE_VISTA2;
}
GetUserName(szUserName, &dwSize);
rsprintf(szTitle, nMaxChars, nIDTitle, szUserName);
}
static int OnRelativeFileHelp(HWND hDlg)
{
TFileTestData * pData = GetDialogData(hDlg);
TCHAR szMsgBuff[512];
LPTSTR szBuffer = szMsgBuff;
int nLength = 0;
// Load both parts of the message
nLength += LoadString(g_hInst, IDS_RELATIVE_FILE1, szBuffer + nLength, _tsize(szMsgBuff) - nLength);
nLength += LoadString(g_hInst, IDS_RELATIVE_FILE2, szBuffer + nLength, _tsize(szMsgBuff) - nLength);
nLength += rsprintf(szBuffer + nLength, IDS_RELATIVE_FILE3, pData->dwDesiredAccessRF,
pData->dwOpenOptionsRF,
pData->dwShareAccessRF);
// Show the message
MessageBoxRc(hDlg, IDS_RELATIVE_FILE_TITLE, (UINT_PTR)szMsgBuff);
return TRUE;
}
static int OnSetActive(HWND hDlg)
{
TFileTestData * pData = GetDialogData(hDlg);
TCHAR szEaInfo[128];
BOOL bEnabled = FALSE;
int nChecked;
// Set directory name and file name
SetDlgItemText(hDlg, IDC_DIRECTORY_NAME, pData->szDirName);
SetDlgItemText(hDlg, IDC_FILE_NAME, pData->szFileName1);
// Convert both to NT name.
if(GetWindowTextLength(GetDlgItem(hDlg, IDC_DIRECTORY_NAME)) == 0)
ConvertToNtName(hDlg, IDC_FILE_NAME);
ConvertToNtName(hDlg, IDC_DIRECTORY_NAME);
// Set the various create options
Hex2DlgText32(hDlg, IDC_OBJ_ATTR_FLAGS, pData->dwObjAttrFlags);
Hex2DlgText32(hDlg, IDC_DESIRED_ACCESS, pData->dwDesiredAccess);
Hex2DlgText64(hDlg, IDC_ALLOCATION_SIZE, pData->AllocationSize);
Hex2DlgText32(hDlg, IDC_FILE_ATTRIBUTES, pData->dwFileAttributes);
Hex2DlgText32(hDlg, IDC_SHARE_ACCESS, pData->dwShareAccess);
Hex2DlgText32(hDlg, IDC_CREATE_OPTIONS, pData->dwCreateOptions);
// Update the info about extended attributes
rsprintf(szEaInfo, IDS_EA_INFO, pData->pFileEa, pData->dwEaSize);
SetDlgItemText(hDlg, IDC_EXTENDED_ATTRIBUTES, szEaInfo);
// Enable/disable transaction
if(pfnRtlSetCurrentTransaction != NULL && IsHandleValid(pData->hTransaction))
bEnabled = TRUE;
EnableDlgItems(hDlg, bEnabled, IDC_TRANSACTED, 0);
if(bEnabled)
CheckDlgButton(hDlg, IDC_TRANSACTED, pData->bUseTransaction);
// Check/uncheck virtualization
nChecked = TokenVirtualization(TOKEN_VIRT_QUERY, 0);
CheckDlgButton(hDlg, IDC_VIRTUALIZATION, nChecked);
// Enable/disable "NtClose"
bEnabled = IsHandleValid(pData->hFile) ? TRUE : FALSE;
EnableDlgItems(hDlg, bEnabled, IDC_CLOSE_HANDLE, 0);
return TRUE;
}
char * sptemp_dirfile(void)
{
int max_attempt=999, attempt=0;
char * s, *n;
static int call=0;
struct stat fileinfo;
do {
s = rsprintf("%s/%s%d.sph",TEMP_DIR,TEMP_BASE_NAME,call++);
if (attempt++ >= max_attempt)
return(CNULL);
if (call > 9999)
call=0;
} while (stat(s,&fileinfo) == 0);
if ((n = mtrf_malloc(strlen(s) + 1)) == CNULL)
return(CNULL);
strcpy(n,s);
return(n);
}
nz_rc tee_block_create(const struct nz_context * context_p, const char * string, nz_block_state ** state_pp, struct nz_block_info * info_p) {
nz_arg * args[2];
nz_rc rc = arg_parse("required int n_outputs, required generic type", string, args);
if(rc != NZ_SUCCESS) return rc;
long n_outputs = *(long *)args[0];
char * type_str = (char *)args[1];
free(args[0]);
const struct nz_typeclass * typeclass_p;
nz_type * type_p;
if(n_outputs < 0) {
free(type_str);
NZ_RETURN_ERR_MSG(NZ_ARG_VALUE, rsprintf("%ld", n_outputs));
}
rc = nz_context_create_type(context_p, &typeclass_p, &type_p, type_str);
free(type_str);
if(rc != NZ_SUCCESS) return rc;
return tee_block_create_args(n_outputs, typeclass_p, type_p, state_pp, info_p);
}
static nz_rc tee_block_create_args(size_t n_outputs, const struct nz_typeclass * typeclass_p, nz_type * type_p, nz_block_state ** state_pp, struct nz_block_info * info_p) {
struct tee_block_state * state_p = calloc(1, sizeof(struct tee_block_state));
if(state_p == NULL) NZ_RETURN_ERR(NZ_NOT_ENOUGH_MEMORY);
if(n_outputs < 1) NZ_RETURN_ERR(NZ_ARG_VALUE);
// This function assumes ownership of typeclass_p and type_p
nz_rc rc;
nz_obj * obj_p;
rc = typeclass_p->type_create_obj(type_p, &obj_p);
if(rc != NZ_SUCCESS) {
typeclass_p->type_destroy(type_p);
free(state_p);
return rc;
}
state_p->typeclass_p = typeclass_p;
state_p->type_p = type_p;
state_p->obj_p = obj_p;
if((rc = nz_block_info_set_n_io(info_p, 1, n_outputs)) == NZ_SUCCESS &&
(rc = nz_block_info_set_input(info_p, 0, strdup("in"), typeclass_p, type_p)) == NZ_SUCCESS &&
(rc = nz_block_info_set_output(info_p, 0, strdup("main"), typeclass_p, type_p, tee_main_pull_fn)) == NZ_SUCCESS) {
for(size_t i = 1; i < n_outputs; i++) {
if((rc = nz_block_info_set_output(info_p, i, rsprintf("aux %lu", i), typeclass_p, type_p, tee_aux_pull_fn)) != NZ_SUCCESS) break;
}
}
if(rc != NZ_SUCCESS) {
typeclass_p->type_destroy_obj(type_p, obj_p);
typeclass_p->type_destroy(type_p);
free(state_p);
return rc;
}
*(struct tee_block_state **)(state_pp) = state_p;
return NZ_SUCCESS;
}
int sp_close(SP_FILE *sp)
{
char *proc="sp_close " SPHERE_VERSION_STR;
char *write_name;
char *read_name;
SP_INTEGER lint=0, header_size=0, data_size=0;
int header_changed=FALSE;
SPIFR *spifr;
SPSTATUS *w_spstat, *r_spstat;
int ret, verify_checksum=FALSE;
if (sp_verbose > 10) fprintf(spfp,"Proc %s:\n",proc);
if (sp == SPNULL)
return_err(proc,100,100,"Null SPFILE pointer");
w_spstat = sp->write_spifr->status;
r_spstat = sp->read_spifr->status;
write_name = (w_spstat->external_filename == CNULL) ? CNULL :
mtrf_strdup(sp->write_spifr->status->external_filename);
read_name = (r_spstat->external_filename == CNULL) ? CNULL :
mtrf_strdup(r_spstat->external_filename);
if (sp->open_mode == SP_mode_update) {
if (sp_verbose > 10) fprintf(spfp,"Proc %s: Mode SP_update\n",proc);
if (w_spstat->write_occured_flag) {
/* if there has been a spwrite, then the waveform is written */
/* as if it were a file opened for write */
/* Step 1: recursively call sp_close, changing the mode to write */
/* Step 2: delete the previous file */
/* Step 3: rename the temporary file */
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Overwriting the original waveform\n",
proc);
sp->open_mode = SP_mode_write;
if ((ret=sp_close(sp)) != 0){
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_child(proc,int,ret);
}
unlink(read_name);
rename(write_name,read_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_success(proc,0,0,"ok");
} else {
/* the header has been changed and the data mode of the waveform */
/* COULD BE CHANGED the waveform has not been modified in any */
/* way, only the header has changed */
/* Step 1: write the header into the temporary file */
/* Step 2: If the header changed in size OR the waveform */
/* format has changed */
/* A: copy the waveform into the temp file */
/* B: close the files */
/* C: delete the old file in favor of the new file */
/* Else the header has not changed in size. */
/* A: write the header into the original file */
/* B: Close both files */
/* C: delete the temporary file */
FILE *fp;
int samples_read, samples_written;
/* Step 1: */
spifr = sp->write_spifr;
fp = ((spifr->waveform->sp_fp != FPNULL) ?
(spifr->waveform->sp_fp) :
((spifr->waveform->sp_fob->fp != FPNULL) ?
(spifr->waveform->sp_fob->fp) : FPNULL));
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Writing header to temp file. position %d\n",
proc,ftell(fp));
if (fp == FPNULL){
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3000,3000,"Internal Error");
}
/* Write the header into the temporary file to compute the size */
/* of the header and then rewind back over the just written header*/
rewind(fp);
if (sp_write_header(fp,spifr->status->file_header,
&header_size,&data_size) < 0){
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3001,3001,
"Unable to update header in file");
}
rewind(fp);
/* Step 2 - - if the header size or waveform has changed */
if ((sp->read_spifr->waveform->header_data_size != header_size) ||
(w_spstat->file_encoding != r_spstat->file_encoding) ||
(w_spstat->file_compress != r_spstat->file_compress) ||
(w_spstat->file_sbf != r_spstat->file_sbf) ||
(w_spstat->channels != CHANNELSNULL)){
char *buff;
int ns, nc, in_nspb, out_nspb;
if (sp_verbose > 15) {
fprintf(spfp,"Proc %s: output header and/or",proc);
fprintf(spfp,"data has changed, copying file.\n");
fprintf(spfp,"Proc %s: from %d to %d\n",proc,
sp->read_spifr->waveform->header_data_size,
header_size);
}
ns = r_spstat->user_sample_count;
nc = r_spstat->user_channel_count;
in_nspb = r_spstat->user_sample_n_bytes *
r_spstat->user_channel_count;
out_nspb = w_spstat->user_sample_n_bytes *
w_spstat->user_channel_count;
if ((buff=mtrf_malloc(nc * in_nspb * 4096)) == CNULL) {
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3010,3010,
"Unable to malloc transfer buffer space");
}
/* A: */
do {
sp->open_mode = SP_mode_read;
samples_read = sp_read_data(buff,4096,sp);
if (samples_read > 0) {
sp->open_mode = SP_mode_write;
samples_written = sp_write_data(buff,samples_read,sp);
if (samples_written != samples_read){
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3012,3012,
"Copy of waveform data failed");
}
} else {
if (sp_eof(sp) == 0) {
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3013,3013,
"Error: Zero samples read while not at EOF");
}
if (sp_error(sp) >= 100) {
/* a checksum error occured, close the sp and */
/* delete the temp file */
sp->open_mode = SP_mode_update;
sp_print_return_status(spfp);
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
mtrf_free(buff);
return_err(proc,3011,3011,
"Error copying waveform data");
}
}
sp->open_mode = SP_mode_update;
} while (samples_read > 0);
mtrf_free(buff);
/* make sure the file is at eof (as if it were opened for */
/* read) */
sp->open_mode = SP_mode_read;
if (! sp_eof(sp)){
sp->open_mode = SP_mode_update;
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3012,3012,"Error copying waveform data");
}
sp->open_mode = SP_mode_write;
if ((ret=sp_close(sp)) != 0){
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_child(proc,int,ret);
}
/* C: */
unlink(read_name);
rename(write_name,read_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_success(proc,0,0,"ok");
} else {
/* A: */
spifr = sp->read_spifr;
fp = ((spifr->waveform->sp_fp != FPNULL) ?
(spifr->waveform->sp_fp) :
((spifr->waveform->sp_fob->fp != FPNULL) ?
(spifr->waveform->sp_fob->fp) : FPNULL));
if (fp == FPNULL)
return_err(proc,3002,3002,"Internal Error");
rewind(fp);
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: header size not changed. position %d\n",
proc,ftell(fp));
if (sp_write_header(fp,w_spstat->file_header,
&header_size,&data_size) < 0){
free_sphere_t(sp);
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,3003,3003,
"Unable to update header in file");
}
/* B: */
free_sphere_t(sp);
/* C: */
unlink(write_name);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_success(proc,0,0,"ok");
}
}
}
/* END of update mode file */
if (sp->open_mode == SP_mode_write) {
if (sp_verbose > 10) fprintf(spfp,
"Proc %s: Mode SP_mode_write\n",proc);
spifr = sp->write_spifr;
/* flush the data to the file */
if (spifr->status->is_disk_file)
fob_fflush(spifr->waveform->sp_fob);
/* if the mode is write, update the sample_count and checksum */
/* field if needed. If the checksum field exists, verify it, */
/* and warn if it's not the same */
/************ ONLY UPDATE FIELDS IF THE FILE IS NOT A STREAM *********/
if (spifr->status->is_disk_file){
h_get_field(w_spstat->file_header, SAMPLE_COUNT_FIELD,
T_INTEGER, (void *)&lint);
if (spifr->waveform->samples_written != lint) {
/* then update the field */
lint = (SP_INTEGER) spifr->waveform->samples_written;
spifr->status->file_sample_count = lint;
/* temporarily reset the write occured flag to allow header */
/* modifications */
w_spstat->write_occured_flag = FALSE;
if (sp_h_set_field(sp,SAMPLE_COUNT_FIELD,T_INTEGER,&lint) !=0){
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,200,200,"Unable to update sample_count");
}
/* Reset the write occured flag */
w_spstat->write_occured_flag = TRUE;
header_changed = TRUE;
}
if (h_get_field(spifr->status->file_header,SAMPLE_CHECKSUM_FIELD,
T_INTEGER,(void *)&lint) != 0){
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,201,201,
"Unable to get sample_checksum for file on disk");
}
if (lint != spifr->status->file_checksum) {
/* then the checksum was just computed, so install it */
lint = (SP_INTEGER)spifr->waveform->checksum;
/* temporarily reset the write occured flag to allow header */
/* modifications */
w_spstat->write_occured_flag = FALSE;
if (sp_h_set_field(sp,SAMPLE_CHECKSUM_FIELD,
T_INTEGER,&lint) >= 100){
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,202,202,"Unable to update checksum");
}
/* Reset the write occured flag */
w_spstat->write_occured_flag = TRUE;
header_changed = TRUE;
} else
if (lint != spifr->waveform->checksum) {
spifr->waveform->failed_checksum = TRUE;
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,203,203,
rsprintf("Write verification of checksum failed on file %s",
spifr->status->external_filename));
}
}
/* flush the updated header to the file */
if (header_changed) {
FILE *fp;
if (! spifr->status->is_disk_file) {
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,301,301,
"Internal Error, header changed size on write to stdout");
}
fp = ((spifr->waveform->sp_fp != FPNULL) ?
(spifr->waveform->sp_fp) :
((spifr->waveform->sp_fob->fp != FPNULL) ?
(spifr->waveform->sp_fob->fp) : FPNULL));
if (fp == FPNULL) {
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,300,300,"Internal Error");
}
rewind(fp);
if (sp_write_header(fp,spifr->status->file_header,
&header_size,&data_size) < 0) {
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,204,204,"Unable to update header in file");
}
}
if ((spifr->status->is_temp_file == FALSE) &&
fob_is_fp(spifr->waveform->sp_fob)) {
/* check to make sure the blocking has not changed */
if (header_changed)
if (((data_size + PAD_MULT) / PAD_MULT) !=
((spifr->waveform->header_data_size + PAD_MULT) /PAD_MULT)){
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,205,205,
"Header size has changed on update");
}
} else {
if (spifr->status->user_compress == spifr->status->file_compress){
if (fob_flush_to_fp(spifr->waveform->sp_fob,
spifr->waveform->sp_fp) != 0){
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,206,206,"Unable to flush data to disk");
}
} else { /* do some compression */
FOB *comp_fob;
/* 1. rewind the data */
/* 2. alloc FOB to compress into */
/* 3. compress the file */
/* 4. free the allocated FOB */
fob_rewind(spifr->waveform->sp_fob);
if ((comp_fob = fob_create(spifr->waveform->sp_fp)) ==
FOBPNULL) {
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,207,207,"Unable to setup for compression");
}
spifr->waveform->sp_fp = FPNULL;
switch (spifr->status->file_compress){
char message[70];
case SP_wc_shorten:
/* optimize the compression */
shorten_set_channel_count(spifr->status->file_channel_count);
if (spifr->status->file_encoding == SP_se_ulaw)
shorten_set_ftype("au");
else if (spifr->status->file_encoding == SP_se_pcm1)
shorten_set_ftype("s8");
else if (spifr->status->file_encoding == SP_se_pcm2)
if (spifr->status->file_sbf == SP_sbf_01)
shorten_set_ftype("s16lh");
else
shorten_set_ftype("s16hl");
if (sp_verbose > 15) shorten_dump_flags(spfp);
if(setjmp(exitenv) == 0){
if (shorten_compress(spifr->waveform->sp_fob,
comp_fob, message) < 0){
fob_destroy(comp_fob);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,208,208,
rsprintf("Shorten Compression Failed - %s",
message));
}
} else
return_err(proc,213,0,"Shorten Compression Aborted");
fob_fflush(comp_fob);
break;
case SP_wc_wavpack:
if(setjmp(exitenv) == 0){
/* optimize the compression */
wavpack_set_progname( "wavpack" );
if (spifr->status->file_channel_count == 1)
wavpack_set_monoflg(TRUE);
else
wavpack_set_monoflg(FALSE);
wavpack_set_byteflg(spifr->status->file_sbf ==SP_sbf_1);
if (sp_verbose > 15) wavpack_dump_interface(spfp);
if (wavpack_pack(spifr->waveform->sp_fob, comp_fob)<0){
fob_destroy(comp_fob);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,209,209,
"Wavpack Compression Failed");
}
wavpack_free_progname();
fob_fflush(comp_fob);
} else {
return_err(proc,212,0,"Wavpack Compression Aborted");
}
break;
case SP_wc_shortpack:
return_err(proc,211,211,
"Unable to Compress using shortpack\n");
default:
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
free_sphere_t(sp);
return_err(proc,210,210,
"Unable to Compress the requested format\n");
}
spifr->waveform->sp_fp = comp_fob->fp;
fob_destroy(comp_fob);
}
}
if ((sp->open_mode == SP_mode_write) ||
(sp->open_mode == SP_mode_update))
if (w_spstat->extra_checksum_verify)
verify_checksum = TRUE;
}
free_sphere_t(sp);
/*************************************************/
/* The file is now completely written and closed */
/*************************************************/
/**************************************************/
/* If the write verification is requested, do it */
if (verify_checksum) {
if (strsame(write_name,"-")) {
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_warn(proc,1,1,
"Unable to verify checksum, file went to STDOUT");
}
if (verify_file_checksum(write_name) != 0){
sp_print_return_status(spfp);
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_err(proc,1000,1000,
"Read Verification of written file failed");
}
}
if (write_name != CNULL) mtrf_free(write_name);
if (read_name != CNULL) mtrf_free(read_name);
return_success(proc,0,0,"ok");
}
static int decompress_waveform(SP_FILE *sp)
{
int decomp_into_memory=TRUE;
int wav_bytes=0;
SPIFR *spifr = sp->read_spifr;
FOB *fob_in, *fob_out;
char *buff;
int blen;
char *proc="decompress_waveform " SPHERE_VERSION_STR;
wav_bytes = spifr->status->user_sample_count *
spifr->status->user_channel_count *
spifr->status->user_sample_n_bytes;
/* the file must be decompressed, Question: Should it be done in memory? */
if (wav_bytes > MAX_INTERNAL_WAVFORM)
decomp_into_memory = FALSE;
/* The file needs to be de_compressed into memory !!!! */
/* 1. make an FOB struct for the uncompressed waveform to be read into d */
/* and the original file */
/* 2. allocate memory for the entire waveform */
/* 3. decompress the file */
/* 4. Clean up the FOB struct for the file, moving the fp from the FOB */
/* 5. reset the uncompressed FOB struct to the beginning of the memory */
if (decomp_into_memory) {
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Pre-buffering compressed data into memory\n",
proc);
if (fob_create2(spifr->waveform->sp_fp, FPNULL, &fob_in, &fob_out) < 0)
return_err(proc,200,0,"Unable to setup for decompression");
blen = spifr->status->file_channel_count *
spifr->status->file_sample_count *
spifr->status->file_sample_n_bytes;
if ((buff=mtrf_malloc(blen)) == CNULL){
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,201,0,"Unable to malloc memory to decompress into");
}
fob_bufinit(fob_out, buff, blen);
} else { /* decompress into a disk file */
FILE *temp_fp;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Pre-buffering compressed data %s\n",
proc,"into a temporary file");
spifr->status->temp_filename = sptemp_dirfile();
if (spifr->status->temp_filename == CNULL)
return_err(proc,400,0,"Unable to create usable temporary file");
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: %s%d bytes long, using temp file %s\n",
proc, "Attempting to read a big file ",wav_bytes,
spifr->status->temp_filename);
if ((temp_fp=fopen(spifr->status->temp_filename,TRUNCATE_UPDATEMODE))
== FPNULL)
return_err(proc,401,0,
rsprintf("Unable to open temporary file %s",
spifr->status->temp_filename));
if (fob_create2(spifr->waveform->sp_fp, temp_fp, &fob_in, &fob_out) <0)
return_err(proc,402,0,"Unable to setup for decompression");
/* the FILE pointer will be closed after completion of the */
/* decompression directly from the fob_in FOB pointer. this is the */
/* bug which Francis caught. */
/* Note: Do NOT set the waveform file to FPNULL here (see bugfix */
/* below.) ***PSI*** 24-Sep-1993 */
/* spifr->waveform->sp_fp = FPNULL; */
spifr->status->is_temp_file = TRUE;
}
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: before decompression, input file at position %d\n",
proc,fob_ftell(fob_in));
switch (spifr->status->file_compress){
char message[80];
case SP_wc_shorten:
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Executing Shorten Decompression\n",proc);
if (setjmp(exitenv) == 0){
if (shorten_uncompress(fob_in, fob_out, message) < 0){
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,202,0,
rsprintf("Shorten Decompression Failed",message));
}
} else {
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,207,0,"Shorten Decompression aborted");
}
break;
case SP_wc_wavpack:
if(setjmp(exitenv) == 0){
if (sp_verbose > 15) fprintf(spfp,"before set progname\n");
wavpack_set_progname( "wavpack" );
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Executing Wavpack Decompression\n",proc);
if (sp_verbose > 15)
wavpack_dump_interface(spfp);
if (wavpack_unpack(fob_in, fob_out) < 0){
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,203,0,"Wavpack Decompression Failed");
}
wavpack_free_progname();
} else {
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,206,0,"Wavpack Decompression aborted");
}
break;
case SP_wc_shortpack:
if(setjmp(exitenv) == 0){
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Executing Shortpack Decompression\n",proc);
if (shortpack_uncompress(fob_in, fob_out,
spifr->status->file_header) < 0){
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,203,0,"Shortpack Decompression Failed");
}
} else {
fob_destroy(fob_in);
fob_destroy(fob_out);
return_err(proc,208,0,"Shortpack Decompression aborted");
}
break;
default:
return_err(proc,209,0,"Unable to decompress the requested format\n");
}
fob_rewind(fob_out);
/**** Begin SRI bugfix. ****/
/* If a temporary file is being used, close the waveform file BEFORE */
/* setting it to FPNULL. ***PSI*** 24-Sep-1993 */
if (spifr->status->is_temp_file) {
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Closing waveform file \"%s\" (%d)\n",
proc, spifr->status->external_filename,
fileno(spifr->waveform->sp_fp));
if (fclose(spifr->waveform->sp_fp))
return_err(proc, 403, 0,
rsprintf("Unable to close waveform file \"%s\" (%d)",
spifr->status->external_filename,
fileno(spifr->waveform->sp_fp)));
spifr->waveform->sp_fp = FPNULL;
}
/**** End SRI bugfix. ****/
if (! decomp_into_memory) {
/* Close the original file pointer to the SPHERE file */
fclose(fob_in->fp);
}
fob_destroy(fob_in);
spifr->waveform->sp_fob = fob_out;
return_success(proc,0,0,"ok");
}
/*
*
* sp_read_data()
*
*/
int sp_mc_read_data(void *buffer, size_t num_sample, SP_FILE *sp)
{
char *proc="sp_read_data " SPHERE_VERSION_STR;
SPIFR *spifr;
int ret;
int do_conversions, do_channel_selections;
if (buffer == (void *)0)
return_err(proc,100,0,"Null memory buffer");
if (sp == SPNULL)
return_err(proc,101,0,"Null SPFILE structure");
if (sp->open_mode != SP_mode_read)
return_err(proc,104,104,"Read on a file not opened for read");
#ifdef isnotansi
if (num_sample < 0)
return_err(proc,103,0,
rsprintf("Negative sample count %d",num_sample));
#endif
spifr = sp->read_spifr;
if (sp_verbose > 10)
fprintf(spfp,
"Proc %s: file %s, %d bytes/sample, %d channels, %d samples\n",
proc,spifr->status->external_filename,
spifr->status->user_sample_n_bytes,
spifr->status->user_channel_count,
num_sample);
if (spifr->waveform->failed_checksum)
return_err(proc,1001,0,"Pre-Read Checksum Test Failed");
/***********************************************************************/
/* Perform all initializations to the sphere file to begin reading */
if (spifr->status->read_occured_flag == FALSE) {
spifr->status->read_occured_flag = TRUE;
if (sp_verbose > 15) fprintf(spfp,
"Proc %s: Initializing read of data\n",
proc);
if ((spifr->status->user_compress == SP_wc_none) &&
(spifr->status->file_compress != SP_wc_none)){
decompress_waveform(sp) ;
if ((ret = sp_get_return_status()) != 0)
return_err(proc,ret,0,
rsprintf("decompress_waveform failed, %s",
get_return_status_message()));
}
else {
/* The following code assumes that no pre-reading of the */
/* waveform is needed */
if ((spifr->waveform->sp_fob =
fob_create(spifr->waveform->sp_fp)) == FOBPNULL)
return_err(proc,300,0,
"Unable to allocate a FOB 'File or Buffer' struct.");
spifr->waveform->sp_fp = FPNULL;
}
/****************************************************/
/** INVARIANT ASSERTION: **/
/** The data is now in it's natural (decomp) form **/
/****************************************************/
/************ Set up the file conversions ***********/
/****************************************************/
/* Set up byte format the conversions */
if (spifr->status->user_sbf != spifr->status->file_sbf)
if (((spifr->status->user_sbf == SP_sbf_01) &&
(spifr->status->file_sbf == SP_sbf_10)) ||
((spifr->status->user_sbf == SP_sbf_10) &&
(spifr->status->file_sbf == SP_sbf_01)))
fob_read_byte_swap(spifr->waveform->sp_fob);
/********************************************************/
/* set up a translation buffer, for sample conversions */
/* and channel selections */
/* are sample encodings necessary ????? */
do_conversions = FALSE;
if (spifr->status->user_encoding != spifr->status->file_encoding) {
if (((spifr->status->file_encoding == SP_se_ulaw) &&
(spifr->status->user_encoding == SP_se_pcm2)) ||
((spifr->status->file_encoding == SP_se_pcm2) &&
(spifr->status->user_encoding == SP_se_ulaw)))
do_conversions = TRUE;
else
return_err(proc,400,0,
"Unable to convert sample types ... for now\n");
}
/* are channel selection requested ????? */
do_channel_selections = FALSE;
if (spifr->status->channels != CHANNELSNULL)
do_channel_selections = TRUE;
if (do_conversions || do_channel_selections ||
(spifr->status->user_data_fmt == SP_df_array)){
/* allocate the memory for the file data buffer */
/* IF it's a legal transformation */
spifr->waveform->file_data_buffer_len = TRANSLATION_LEN *
spifr->status->file_sample_n_bytes *
spifr->status->file_channel_count;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Alloc %d (%d*%d*%d) bytes%s\n",
proc,
spifr->waveform->file_data_buffer_len,TRANSLATION_LEN,
spifr->status->file_sample_n_bytes,
spifr->status->file_channel_count,
" for file data buffer");
if ((spifr->waveform->file_data_buffer =
(void *)
mtrf_malloc(spifr->waveform->file_data_buffer_len)) ==
(void *)0)
return_err(proc,500,0,
"Unable to alloc memory for the translation buffer");
}
if (do_conversions &&
(do_channel_selections ||
(spifr->status->user_data_fmt == SP_df_array))){
spifr->waveform->converted_buffer_len = TRANSLATION_LEN *
spifr->status->user_sample_n_bytes *
spifr->status->file_channel_count;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Alloc %d (%d*%d*%d) bytes %s\n",
proc,
spifr->waveform->converted_buffer_len,TRANSLATION_LEN,
spifr->status->user_sample_n_bytes,
spifr->status->file_channel_count,
"for converted data buffer");
if ((spifr->waveform->converted_buffer =
(void *)
mtrf_malloc(spifr->waveform->converted_buffer_len)) ==
(void *)0)
return_err(proc,550,0,
"Unable to alloc memory for the translation buffer");
}
if (spifr->status->user_data_fmt == SP_df_array){
spifr->waveform->interleave_buffer_len = TRANSLATION_LEN *
spifr->status->user_sample_n_bytes *
spifr->status->user_channel_count;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Alloc %d (%d*%d*%d) bytes %s\n",
proc,
spifr->waveform->interleave_buffer_len,TRANSLATION_LEN,
spifr->status->user_sample_n_bytes,
spifr->status->user_channel_count,
"for interleave data buffer");
if ((spifr->waveform->interleave_buffer =
(void *)
mtrf_malloc(spifr->waveform->interleave_buffer_len)) ==
(void *)0)
return_err(proc,600,0,
"Unable to alloc memory for the interleave buffer");
}
/* pre-verify the waveform data */
if (spifr->status->extra_checksum_verify){
pre_verify_checksum(sp);
if ((ret = sp_get_return_status()) != 0)
return_err(proc,ret,0,
rsprintf("pre_verify_checksum failed, %s",
get_return_status_message()));
}
}
if (sp_verbose > 15) fprintf(spfp,
"Proc %s: current file position %d\n",proc,
fob_ftell(spifr->waveform->sp_fob));
ret = read_data_in(buffer, num_sample, sp);
if (sp_get_return_type() == RETURN_TYPE_ERROR)
return_err(proc,sp_get_return_status(),0,
rsprintf("read_data_in failed, %s",
get_return_status_message()));
return_success(proc,0,ret,"ok");
}
static int read_data_in(void *buffer, size_t num_sample, SP_FILE *sp){
SPIFR *spifr;
char *proc=" read_data_in " SPHERE_VERSION_STR;
int samples_read = 0;
int in_samples=0, o, oc, s, c, ret;
int block=0;
char *in_block=(char *)0, *out_block=(char *)0;
char *current_data_location = (char *)0;
char *out_conversion_block=(char *)0,*in_conversion_block=(char *)0;
char *next_out_block=(char *)0;
short *sh_data=(short *)0;
unsigned char *ulaw_data = (unsigned char *)0;
SP_CHECKSUM checksum=0, block_checksum=0;
int file_record_size;
char **arr_buff = (char **)0, *arr;
spifr = sp->read_spifr;
file_record_size = spifr->status->file_sample_n_bytes *
spifr->status->file_channel_count;
while ((samples_read < num_sample) &&
(! fob_feof(spifr->waveform->sp_fob))){
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Beginning block %d\n",proc,block);
/* read in either a block or the whole chunk if data */
if (spifr->waveform->file_data_buffer != CNULL) {
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: reading a block into temporary storage\n",
proc);
in_block = (void *)spifr->waveform->file_data_buffer;
current_data_location = in_block;
if ((in_samples = (num_sample - samples_read))>
TRANSLATION_LEN)
in_samples = TRANSLATION_LEN;
ret = fob_fread(in_block, file_record_size,
in_samples, spifr->waveform->sp_fob);
if (ret < 0)
return_err(proc,105,0,"Unable to read data");
} else {
/* there was no change in the sample coding so just read */
/* in the data */
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: read a block WITHOUT coding conversions\n",
proc);
ret = fob_fread(buffer, file_record_size,
num_sample, spifr->waveform->sp_fob);
if (ret < 0)
return_err(proc,107,0,"Unable to read data");
in_block = (void *)buffer;
current_data_location = in_block;
}
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: block read of %d Samples, expected %d\n",
proc,ret,num_sample);
in_samples = ret;
/**** ret is the number of samples per time period read in from */
/**** the file */
/**** Do the checksum computation before format changes occur ***/
switch (spifr->status->file_encoding){
case SP_se_pcm2:
/* DON'T SWAP if the coding type hasn't changed, and the */
/* output SBF == natural_sbf */
/* OR if the coding changed and the file SBF */
/* is == natural SBF */
if (((spifr->status->user_encoding == SP_se_pcm2) &&
(spifr->status->natural_sbf == spifr->status->user_sbf))
||
((spifr->status->user_encoding != SP_se_pcm2) &&
(spifr->status->natural_sbf == spifr->status->file_sbf))){
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: Not Swapping for checksum\n",proc);
checksum =
sp_compute_short_checksum((void *)in_block,in_samples*
spifr->status->file_channel_count,
FALSE);
} else {
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Swapping for checksum\n",proc);
checksum =
sp_compute_short_checksum((void *)in_block,
in_samples*spifr->status->file_channel_count, TRUE);
}
break;
default: {
int n;
n = in_samples * spifr->status->file_channel_count *
spifr->status->file_sample_n_bytes;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Computing char checksum %d bytes\n",
proc,n);
checksum = sp_compute_char_checksum(in_block, n);
break;
}
}
spifr->waveform->checksum =
sp_add_checksum(spifr->waveform->checksum,checksum);
block_checksum = checksum;
/*** FINISHED WITH THE CHECKSUMS ***/
samples_read += in_samples;
spifr->waveform->samples_read += in_samples;
if (sp_eof(sp))
/* only check this if the user_sample count is real */
/* Added June 22, 1994 by JGF */
if (spifr->status->user_sample_count != 999999999){
if (spifr->waveform->samples_read !=
spifr->status->user_sample_count){
spifr->waveform->read_premature_eof = TRUE;
return_err(proc,500,0,
rsprintf("Premature End-of-File %d read != %d",
spifr->waveform->samples_read,
spifr->status->user_sample_count));
}
}
if (spifr->waveform->samples_read ==
spifr->status->user_sample_count){
if ((! spifr->status->ignore_checksum) &&
(spifr->waveform->checksum !=
spifr->status->file_checksum)){
spifr->waveform->failed_checksum = TRUE;
return_err(proc,1000,0,
rsprintf("%sComputed %d != Expected %d",
"Checksum Test Failed ",
spifr->waveform->checksum,
spifr->status->file_checksum));
}
}
/**** Do the sample coding conversions ****/
if (((spifr->status->file_encoding == SP_se_ulaw) &&
(spifr->status->user_encoding == SP_se_pcm2)) ||
((spifr->status->file_encoding == SP_se_pcm2) &&
(spifr->status->user_encoding == SP_se_ulaw))) {
int samples_to_change =
in_samples*spifr->status->file_channel_count;
if ((spifr->status->channels != CHANNELSNULL) ||
(spifr->status->user_data_fmt == SP_df_array)){
out_conversion_block = next_out_block =
(char *)spifr->waveform->converted_buffer;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: using converted buffer output\n",
proc);
}
else {
out_conversion_block = (char *)buffer;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: using buffer output argument\n",
proc);
if (next_out_block == (char *)0)
next_out_block = out_conversion_block;
}
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: converting %d (%d*%d) samples\n",proc,
samples_to_change,in_samples,
spifr->status->file_channel_count);
if ((spifr->status->file_encoding == SP_se_ulaw) &&
(spifr->status->user_encoding == SP_se_pcm2)) {
/* now convert the block into the buffer */
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Converting ULAW to PCM", proc);
/* set up some pointers */
ulaw_data =
(unsigned char *)spifr->waveform->file_data_buffer;
sh_data = (short *)next_out_block ;
/*** This was a bug, it used to compare to sp_sbf_10 ***/
if (spifr->status->user_sbf != get_natural_sbf(2)){
if (sp_verbose > 16)
fprintf(spfp," outputting 01 format bytes\n");
for (o=0; o < samples_to_change; o++) {
*sh_data = ulaw2linear_01_sbf_lut[*ulaw_data];
sh_data ++; ulaw_data ++;
}
} else {
if (sp_verbose > 16)
fprintf(spfp," outputting 10 format bytes\n");
for (o=0; o < samples_to_change; o++) {
*sh_data = ulaw2linear_10_sbf_lut[*ulaw_data];
sh_data ++; ulaw_data ++;
}
}
next_out_block = (char *)sh_data;
} else if ((spifr->status->file_encoding == SP_se_pcm2) &&
(spifr->status->user_encoding == SP_se_ulaw)) {
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Performing read translation%s\n",
proc," from PCM2 to ULAW");
/* set up some pointers */
sh_data = (short *)spifr->waveform->file_data_buffer;
ulaw_data = (unsigned char *)next_out_block;
if (spifr->status->file_sbf != spifr->status->natural_sbf){
char *p , temp; short odata;
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: Swapping input shorts\n", proc);
for (o=0; o < samples_to_change; o++) {
/* Pre swap the bytes */
odata = *sh_data;
p = (char *) &odata;
temp = *p;
*p = *(p + 1);
*(p + 1) = temp;
/* fprintf(spfp,
" %d -> %x -> %x\n",o,*sh_data,odata); */
*ulaw_data = linear2ulaw(odata);
sh_data ++; ulaw_data ++;
}
}else
for (o=0; o < samples_to_change; o++) {
*ulaw_data =linear2ulaw(*sh_data);
sh_data ++; ulaw_data ++;
}
next_out_block = (char *)ulaw_data;
} else
return_err(proc,109,0,"Internal Error");
current_data_location = out_conversion_block;
}
/* Do the channel conversions */
if (spifr->status->channels != CHANNELSNULL){
int in_recsize, out_recsize, in_chancnt, out_chancnt;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Converting channels\n",proc);
if (spifr->status->user_data_fmt == SP_df_array)
out_block = spifr->waveform->interleave_buffer;
else
if (out_block == (void *)0)
out_block = (void *)buffer;
current_data_location = out_block;
if (spifr->status->file_encoding != spifr->status->user_encoding)
in_conversion_block =
(void *)spifr->waveform->converted_buffer;
else
if (in_conversion_block == (void *)0)
in_conversion_block =
(void *)spifr->waveform->file_data_buffer;
in_chancnt = spifr->status->file_channel_count;
in_recsize = spifr->status->user_sample_n_bytes * in_chancnt;
out_chancnt = spifr->status->user_channel_count;
out_recsize = spifr->status->user_sample_n_bytes * out_chancnt;
for (oc=0; oc<spifr->status->channels->num_chan; oc++)
if (spifr->status->channels->ochan[oc].num_origin == 1){
char *in_ptr, *out_ptr;
in_ptr = in_conversion_block +
((spifr->status->channels->ochan[oc].orig_channel[0]-1)
* spifr->status->user_sample_n_bytes);
out_ptr = out_block +
(oc * spifr->status->user_sample_n_bytes);
for (s=0; s<in_samples; s++){
memcpy(out_ptr,in_ptr,
spifr->status->user_sample_n_bytes);
in_ptr += in_recsize;
out_ptr += out_recsize;
}
} else {
if (spifr->status->user_encoding == SP_se_pcm2) {
/* do a straight add */
ORIGINATION_CHAN *ochn;
short *in_ptr, *out_ptr;
int sum, ch;
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Adding PCM data %s %d\n",
proc, "channel",oc);
in_ptr = (short *)in_conversion_block;
out_ptr = (short *)out_block;
ochn = &(spifr->status->channels->ochan[oc]);
if (spifr->status->user_sbf== get_natural_sbf(2)){
for (s=0; s<in_samples; s++){
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
sum +=*(in_ptr+ochn->orig_channel[ch]-1);
}
if (sum > 32767) sum = 32767;
else if (sum < -32768) sum = -32768;
*(out_ptr + oc) = (short)sum;
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
} else {
short x;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: %s %d\n", proc,
"Adding Swapped PCM data channel",oc);
for (s=0; s<in_samples; s++){
/* fprintf(spfp,"sample %d\n",s); */
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
x = *(in_ptr+ochn->orig_channel[ch]-1);
swap_bytes(x);
sum += x;
/* fprintf(spfp," %d = %d\n",x,sum); */
}
if (sum > 32767) x = 32767;
else if (sum < -32768) x = -32768;
else x = sum;
swap_bytes(x);
*(out_ptr + oc) = (short)x;
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
}
} else if (spifr->status->user_encoding == SP_se_ulaw){
/* do an add on ulaw data */
ORIGINATION_CHAN *ochn;
unsigned char *in_ptr, *out_ptr;
int sum, ch;
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Adding ULAW data %s %d\n",
proc, "channel",oc);
in_ptr = (unsigned char *)in_conversion_block;
out_ptr = (unsigned char *)out_block;
ochn = &(spifr->status->channels->ochan[oc]);
for (s=0; s<in_samples; s++){
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
sum +=
ulaw2linear_10_sbf_lut[
*(in_ptr+ochn->orig_channel[ch]-1)];
}
if (sum > 32767) sum = 32767;
else if (sum < -32768) sum = -32768;
*(out_ptr + oc) = linear2ulaw(sum);
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
}
}
out_block += out_recsize * in_samples;
}
if (spifr->status->user_data_fmt == SP_df_array){
/* convert the data from it's interleaved form */
/* to an array format */
int snb = spifr->status->user_sample_n_bytes;
int chcnt = spifr->status->user_channel_count;
int recsize = snb * chcnt;
char *in_dat;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Converting data to an array\n",
proc);
if (arr_buff == (char **)0)
arr_buff = (char **)buffer;
for (c=0; c<chcnt; c++){
in_dat = current_data_location + (snb * c) ;
arr = arr_buff[c] + ((samples_read-in_samples) * snb);
for (s=0; s<in_samples; s++,arr+=snb,in_dat+=recsize)
memcpy(arr,in_dat,snb);
}
}
if (sp_verbose > 11){
fprintf(spfp,"Proc %s: Block %d: Requested %d samples",
proc,block++,num_sample);
fprintf(spfp," read %d total %d, Checksum %d (BC %d)\n",
ret,spifr->waveform->samples_read,
block_checksum,
spifr->waveform->checksum);
}
}
return_success(proc,0,samples_read,"ok");
}
void find_minimal_paths(NET_ALIGN *net_ali, int a, int b, int *rlev,float wwd(void *, void *, int (*cmp)(void *, void *)),NETWORK *net_a, PATH *path,int *count)
{
ARC_LIST_ATOM *oarc_a, *oarc_b;
ARC *arc_a, *arc_b;
int la, lb, cost;
int arc_a_id, arc_b_id,d;
int db = 0;
char buf[100];
sprintf(buf,rsprintf("%%0%ds",*rlev),"");
if (a == 0 && b == 0){
if (db > 5) printf("END recursion\n");
if (db > 2) {
printf("Count = %d\n",*count);
PATH_print(path,stdout,100);
}
(*count)++;
return;
}
arc_a = net_ali->arcset_a.arcs[a];
arc_b = net_ali->arcset_b.arcs[b];
cost = net_ali->cell[a][b].min_d;
if (db > 5){
printf("%sCurrent position: D(%d,%d) = %d\n",buf,a,b,cost);
printf("%s ",buf); print_arc(arc_a,0);
printf("%s ",buf); print_arc(arc_b,0);
}
/* loop through the net A in_arcs, seaching for possible paths */
for (oarc_a = arc_a->from_node->in_arcs; oarc_a != NULL;
oarc_a=oarc_a->next){
if ((arc_a_id = find_arcset_id(&(net_ali->arcset_a),oarc_a->arc,
a)) <0){
fprintf(stderr,"Error: find_arcset_id for Net A failed\n");
exit(1);
}
if (db > 5) {
printf("%s Checking deletion arcs:\n",buf);
printf("%s A:",buf); print_arc(oarc_a->arc,0);
}
if (net_ali->cell[arc_a_id][b].min_d <= cost &&
(wwd(arc_a->data,NULL_WORD,net_a->arc_func.equal) +
net_ali->cell[arc_a_id][b].min_d) <= cost){
if (db > 5) printf("%s Possible PATH\n",buf);
if (db > 5) printf("%s ***** Delete %s\n",buf,
((WORD*)(arc_b->data))->value);
*rlev += 2;
PATH_append(path,arc_a->data,0,P_DEL);
find_minimal_paths(net_ali,arc_a_id,b,rlev,wwd,net_a,path,count);
PATH_remove(path);
*rlev -= 2;
}
}
for (oarc_b = arc_b->from_node->in_arcs; oarc_b != NULL;
oarc_b = oarc_b->next){
if ((arc_b_id = find_arcset_id(&(net_ali->arcset_b),oarc_b->arc,
b)) < 0){
fprintf(stderr,"Error: find_arcset_id for Net B failed\n");
exit(1);
}
if (db > 5) {
printf("%s Checking insertion arcs:\n",buf);
printf("%s B:",buf); print_arc(oarc_b->arc,0);
}
if (net_ali->cell[a][arc_b_id].min_d <= cost &&
(wwd(NULL_WORD,arc_b->data,net_a->arc_func.equal) +
net_ali->cell[a][arc_b_id].min_d) <= cost){
if (db > 5) printf("%s Possible PATH\n",buf);
if (db > 5) printf("%s ***** Insert %s\n",buf,
((WORD*)(arc_b->data))->value);
*rlev += 2;
PATH_append(path,0,arc_b->data,P_INS);
find_minimal_paths(net_ali,a,arc_b_id,rlev,wwd,net_a,path,count);
PATH_remove(path);
*rlev -= 2;
}
}
for (oarc_a = arc_a->from_node->in_arcs; oarc_a != NULL;
oarc_a=oarc_a->next){
if ((arc_a_id = find_arcset_id(&(net_ali->arcset_a),oarc_a->arc,
a)) <0){
fprintf(stderr,"Error: find_arcset_id for Net A failed\n");
exit(1);
}
for (oarc_b = arc_b->from_node->in_arcs; oarc_b != NULL;
oarc_b = oarc_b->next){
if ((arc_b_id = find_arcset_id(&(net_ali->arcset_b),oarc_b->arc,
b)) < 0){
fprintf(stderr,"Error: find_arcset_id for Net B failed\n");
exit(1);
}
if (db > 5) {
printf("%s Checking substitution arcs: (%d,%d)\n",buf,
arc_a_id,arc_b_id);
printf("%s A:",buf); print_arc(oarc_a->arc,0);
printf("%s B:",buf); print_arc(oarc_b->arc,0);
}
if (net_ali->cell[arc_a_id][arc_b_id].min_d <= cost &&
((d=wwd(arc_a->data,arc_b->data,net_a->arc_func.equal)) +
net_ali->cell[arc_a_id][arc_b_id].min_d) <= cost){
if (db > 5){
printf("%s Possible PATH\n",buf);
printf("%s ***** Substitute %s and %s\n",buf,
((WORD*)(arc_a->data))->value,
((WORD*)(arc_b->data))->value);
}
*rlev += 2;
PATH_append(path,arc_a->data,arc_b->data,(d==0)?P_CORR:P_SUB);
find_minimal_paths(net_ali,arc_a_id,arc_b_id,rlev,wwd,net_a,path,count);
PATH_remove(path);
*rlev -= 2;
}
}
}
la = a; lb = b;
a = net_ali->cell[la][lb].back_a;
b = net_ali->cell[la][lb].back_b;
}
int sp_copy_header(SP_FILE *spin, SP_FILE *spout)
{
char *proc_name="sp_copy_header " SPHERE_VERSION_STR;
struct header_t *h;
int i;
SP_INTEGER l_int;
SP_REAL real;
if (spin->open_mode == SP_mode_read)
h = spin->read_spifr->header;
else if (spin->open_mode == SP_mode_write)
h = spin->write_spifr->header;
else
return_err(proc_name,100,100,"Unable to dup header opened for update");
/* just loop through all the names, adding each field */
for (i=0; i < h->fc ; i++){
switch (h->fv[i]->type){
case T_STRING:
if (sp_h_set_field(spout,h->fv[i]->name,
h->fv[i]->type,h->fv[i]->data) != 0){
sp_print_return_status(spfp);
return_err(proc_name,200,200,
rsprintf("Unable to copy STRING field '%s'",
h->fv[i]->name));
}
break;
case T_INTEGER:
l_int=atol(h->fv[i]->data);
if (sp_h_set_field(spout,h->fv[i]->name,
h->fv[i]->type,&l_int) != 0){
sp_print_return_status(spfp);
return_err(proc_name,200,200,
rsprintf("Unable to copy INTEGER field '%s'",
h->fv[i]->name));
}
break;
case T_REAL:
real=atof(h->fv[i]->data);
if (sp_h_set_field(spout,h->fv[i]->name,h->fv[i]->type,&real) != 0){
sp_print_return_status(spfp);
return_err(proc_name,200,200,
rsprintf("Unable to copy REAL field '%s'",
h->fv[i]->name));
}
break;
}
}
/* Special Check, if the input file is a pipe and the sample_count */
/* field is missing, (this is legal), AND the output is a disk file */
/* add a dummy sample_count field to the output header */
/* Added June 22, 1994 */
{ int type, size, is_disk_file, out_is_disk_file;
is_disk_file = (spin->open_mode == SP_mode_read) ?
spin->read_spifr->status->is_disk_file :
spin->write_spifr->status->is_disk_file;
out_is_disk_file = (spout->open_mode == SP_mode_read) ?
spout->read_spifr->status->is_disk_file :
spout->write_spifr->status->is_disk_file;
if (! is_disk_file)
if (sp_get_field(h,SAMPLE_COUNT_FIELD,&type,&size) < 0){
/* add the field to the header */
l_int = 999999999;
if (sp_h_set_field(spout,SAMPLE_COUNT_FIELD,
T_INTEGER,&l_int) != 0){
sp_print_return_status(spfp);
return_err(proc_name,400,400,
rsprintf("Unable to copy INTEGER field '%s'",
h->fv[i]->name));
}
}
}
if (sp_set_default_operations(spout) != 0)
return_err(proc_name,300,300,
"Unable to set default operations duplicated file");
return_success(proc_name,0,0,"ok");
}
int sp_set_default_operations(SP_FILE *sp)
{
SP_INTEGER l_int;
char *str, *proc="sp_set_default_operations " SPHERE_VERSION_STR;
SPIFR *spifr;
int ret;
if (sp_verbose > 10) fprintf(spfp,"Proc %s:\n",proc);
if (sp == SPNULL) return_err(proc,100,100,"Null SPFILE pointer");
if ((sp->open_mode == SP_mode_read) || (sp->open_mode == SP_mode_update))
spifr = sp->read_spifr;
else if (sp->open_mode == SP_mode_write)
spifr = sp->write_spifr;
else
return_err(proc,100,100,"Unknown File Mode");
/**********************************************************************/
/* The following fields are REQUIRED for Read operations, */
/* NO Exceptions */
if (sp_h_get_field(sp,SAMPLE_COUNT_FIELD,T_INTEGER,(void *)&l_int) != 0){
/* ---------- OLD CODE ---------------------
return_err(proc,101,101,rsprintf("Missing '%s' header field",
SAMPLE_COUNT_FIELD));
spifr->status->user_sample_count =
spifr->status->file_sample_count = (int)l_int;*/
/* added a condition to permit a pipe to NOT have a sample_count */
/* field. ADDED June 22, 1993 */
if (spifr->status->is_disk_file){
return_err(proc,101,101,rsprintf("Missing '%s' header field",
SAMPLE_COUNT_FIELD));
} else { /* Sample counts may be missing from piped files */
spifr->status->user_sample_count =
spifr->status->file_sample_count = 999999999;
}
} else
spifr->status->user_sample_count =
spifr->status->file_sample_count = (int)l_int;
if (l_int <= 0)
return_err(proc,108,108,
rsprintf("Field '%s' value out of range, %d <= 0",
SAMPLE_COUNT_FIELD,l_int));
if (sp_h_get_field(sp,SAMPLE_N_BYTES_FIELD,
T_INTEGER,(void *)&l_int) != 0)
return_err(proc,104,104,
rsprintf("Missing '%s' header field",
SAMPLE_N_BYTES_FIELD));
spifr->status->user_sample_n_bytes =
spifr->status->file_sample_n_bytes = (int)l_int;
if (l_int <= 0)
return_err(proc,108,108,
rsprintf("Field '%s' value out of range, %d <= 0",
SAMPLE_N_BYTES_FIELD,l_int));
if (sp_h_get_field(sp,CHANNEL_COUNT_FIELD,T_INTEGER,(void *)&l_int) != 0)
return_err(proc,105,105,
rsprintf("Missing '%s' header field",
CHANNEL_COUNT_FIELD));
spifr->status->user_channel_count = spifr->status->file_channel_count =
(int)l_int;
if (l_int <= 0)
return_err(proc,108,108,
rsprintf("Field '%s' value out of range, > 0",
CHANNEL_COUNT_FIELD,l_int));
/**********************************************************************/
/* The following fields may exist, if they do not, there is a default */
/***** NOTE: only set the file_sbf, Sp_set_data_mode is called to */
/***** set the user_sbf */
if ((ret=sp_h_get_field(sp,SAMPLE_BF_FIELD,T_STRING,(void *)&str)) != 0){
if ((spifr->status->file_sbf =
get_natural_sbf(spifr->status->user_sample_n_bytes)) ==
SP_sbf_null)
return_err(proc,107,107,
rsprintf("Unable to read sample sizes of %d bytes",
spifr->status->user_sample_n_bytes));
} else { /* str holds the sample_byte_format_value */
ret = parse_sample_byte_format(str,&(spifr->status->file_sbf));
if (ret == 1000) {
/* then the file was compressed using change_wav_format */
spifr->status->file_sbf =
get_natural_sbf(spifr->status->user_sample_n_bytes);
spifr->status->file_compress = SP_wc_shortpack;
if ((h_set_field(spifr->header,SAMPLE_BF_FIELD,
T_STRING,get_natural_byte_order(2)) != 0) ||
(h_set_field(spifr->status->file_header,SAMPLE_BF_FIELD,
T_STRING,get_natural_byte_order(2)) != 0)){
sp_print_return_status(spfp);
mtrf_free(str);
return_err(proc,110,110,
rsprintf("Unable to re-set sample byte format%s",
"field for a shortpacked file"));
}
if ((h_set_field(spifr->header,SAMPLE_CODING_FIELD,T_STRING,
rsprintf("pcm,embedded-%s",str)) != 0) ||
(h_set_field(spifr->status->file_header,SAMPLE_CODING_FIELD,
T_STRING,rsprintf("pcm,embedded-%s",str)) !=0)){
sp_print_return_status(spfp);
mtrf_free(str);
return_err(proc,111,111,
rsprintf("Unable to re-set sample coding field%s",
"for a shortpacked file"));
}
} else if (ret != 0) { /* there really was an error */
mtrf_free(str);
return_err(proc,106,106,
"Unable to parse the 'sample_byte_format' field");
}
mtrf_free(str);
}
/***** field break *****/
if (sp_h_get_field(sp,SAMPLE_CODING_FIELD,T_STRING,(void *)&str) != 0)
if (spifr->status->user_sample_n_bytes == 1)
str = mtrf_strdup("ulaw");
else
/* the default, since old Corpora are missing this field */
str = mtrf_strdup("pcm");
if (parse_sample_coding(str,spifr->status->file_sample_n_bytes,
&(spifr->status->file_encoding),
&(spifr->status->file_compress)) != 0){
mtrf_free(str);
print_return_status(spfp);
return_err(proc,107,107,
rsprintf("Unable to parse sample_coding value '%s' header field",
str));
}
mtrf_free(str);
/*********************************************************************/
/* The following fields are conditionally required. */
ret = sp_h_get_field(sp,SAMPLE_RATE_FIELD,T_INTEGER,(void *)&l_int);
switch (spifr->status->file_encoding) {
case SP_se_pcm1:
case SP_se_pcm2:
case SP_se_ulaw:
if (ret != 0)
return_err(proc,102,102,
rsprintf("Header field '%s' missing, but required%s",
SAMPLE_RATE_FIELD," for waveform data"));
spifr->status->user_sample_rate = spifr->status->file_sample_rate =
(int)l_int;
break;
case SP_se_raw:
default:
spifr->status->user_sample_rate = spifr->status->file_sample_rate =0;
}
/***********************************************************************/
/* The following fields are OPTIONAL, but if they exist, there is a */
/* special purpose for them */
if (sp_h_get_field(sp,SAMPLE_CHECKSUM_FIELD,T_INTEGER,(void *)&l_int)==0)
spifr->status->file_checksum = l_int;
else {
spifr->status->ignore_checksum = TRUE;
}
/*********************/
/* Consitency checks */
/*********************/
if (spifr->status->file_encoding == SP_se_ulaw &&
spifr->status->file_sample_n_bytes != 1)
return_err(proc,120,120,
rsprintf("Ulaw encoding requires a 1 byte sample,%s %d",
" however the header value is",
spifr->status->file_sample_n_bytes));
if (spifr->status->file_encoding == SP_se_pcm1 &&
spifr->status->file_sample_n_bytes != 1)
return_err(proc,120,120,
rsprintf("PCM1 encoding requires a 1 byte sample, %s %d",
"however the header value is",
spifr->status->file_sample_n_bytes));
if (spifr->status->file_encoding == SP_se_pcm1 &&
spifr->status->file_sample_n_bytes != 2)
return_err(proc,120,120,
rsprintf("PCM2 encoding requires a 2 byte sample, %s %d",
"however the header value is",
spifr->status->file_sample_n_bytes));
/********************************/
/* set up the default decodings */
if (sp->open_mode == SP_mode_read)
if (sp_set_data_mode(sp,"") != 0){
print_return_status(spfp);
return_err(proc,110,110,
rsprintf("Unable to set up default encodings %s",
"on file opened for read"));
}
else if (sp->open_mode == SP_mode_update)
if (sp_set_data_mode(sp,"SE_ORIG:SBF_ORIG") != 0){
print_return_status(spfp);
return_err(proc,111,111,
"Unable to set up default encodings on file opened for update");
}
if (sp_verbose > 11) fprintf(spfp,"Proc %s: Returning 0\n",proc);
return_success(proc,0,0,"ok");
}
/*
* sp_open
*
*/
SP_FILE *sp_open(char *filename, char *mode)
{
SP_FILE *tsp;
char *errmsg, *proc="sp_open " SPHERE_VERSION_STR, *fopen_mode;
enum SP_file_open_mode current_mode;
if (sp_verbose > 10) fprintf(spfp,"Proc %s:\n",proc);
if (filename == CNULL)
return_err(proc,101,SPNULL,"Null filename string");
if (mode == CNULL)
return_err(proc,101,SPNULL,"Null file mode string");
if (sp_verbose > 10) fprintf(spfp,"Proc %s: file '%s' mode '%s'\n",
proc,filename,mode);
if ((tsp=sp_alloc_and_init_sphere_t()) == SPNULL)
return_err(proc,102,SPNULL,"Unable to malloc SPFILE memory");
/* set the file open mode in the status structure */
if (strsame(mode,"r"))
current_mode = tsp->open_mode = SP_mode_read;
else if (strsame(mode,"w"))
current_mode = tsp->open_mode = SP_mode_write;
else if (strsame(mode,"rv")){
current_mode = tsp->open_mode = SP_mode_read;
tsp->read_spifr->status->extra_checksum_verify = TRUE;
}
else if (strsame(mode,"wv")) {
current_mode = tsp->open_mode = SP_mode_write;
tsp->write_spifr->status->extra_checksum_verify = TRUE;
}
else if (strsame(mode,"u")) {
tsp->open_mode = SP_mode_read;
current_mode = SP_mode_update;
}
else {
free_sphere_t(tsp);
return_err(proc,103,SPNULL,
rsprintf("Illegal SPFILE open mode '%s'",mode));
}
/* just open the file, either for reading or writing. If the */
/* mode was SP_mode_writing, and the file exists, change the mode */
/* to SP_mode_update. */
switch (tsp->open_mode) {
case (SP_mode_read): {
if (! strsame(filename,"-")) {
fopen_mode = (current_mode == SP_mode_read) ? READMODE :
UPDATEMODE;
if ((tsp->read_spifr->waveform->sp_fp =
fopen(filename,fopen_mode)) == (FILE *)0){
free_sphere_t(tsp);
return_err(proc,111,SPNULL,
rsprintf("%s'%s' for reading fopen mode %s",
"Unable to open SPHERE file ",
filename,fopen_mode));
}
tsp->read_spifr->status->is_disk_file = TRUE;
} else {
tsp->read_spifr->waveform->sp_fp = stdin;
tsp->read_spifr->status->is_disk_file = FALSE;
}
tsp->read_spifr->status->external_filename =
mtrf_strdup(filename);
break;
}
case (SP_mode_write):{
if (! strsame(filename,"-")) {
/* open the file, truncating if the file exists */
fopen_mode = (current_mode == SP_mode_write) ? WRITEMODE :
UPDATEMODE;
if ((tsp->write_spifr->waveform->sp_fp =
fopen(filename,fopen_mode)) == (FILE *)0){
free_sphere_t(tsp);
return_err(proc,105,SPNULL,
rsprintf("Unable to open SPHERE file '%s' for %s %s",
filename,"writing, fopen mode",fopen_mode));
}
tsp->write_spifr->status->is_disk_file = TRUE;
} else {
tsp->write_spifr->waveform->sp_fp = stdout;
tsp->write_spifr->status->is_disk_file = FALSE;
}
tsp->write_spifr->status->external_filename =
mtrf_strdup(filename);
break;
}
default: {
return_err(proc,200,SPNULL,"Internal error");
}
}
/* now that the file is opened, load the header if it exist, */
/* otherwise alloc an empty header for the user */
switch (tsp->open_mode) {
case (SP_mode_read): {
/* read the header */
tsp->read_spifr->header =
sp_open_header(tsp->read_spifr->waveform->sp_fp,TRUE,&errmsg);
if ( tsp->read_spifr->header == HDRNULL ) {
free_sphere_t(tsp);
return_err(proc,104,SPNULL,
rsprintf("Unable to open SPHERE header of file '%s', %s",
filename,errmsg));
}
/* get the size of the header */
if (! strsame(filename,"-")) {
if ((tsp->read_spifr->waveform->header_data_size =
sp_file_header_size(filename)) < 0){
free_sphere_t(tsp);
return_err(proc,110,SPNULL,
rsprintf("Unable to get SPHERE header size of file '%s'",
filename));
}
} else {
if ((tsp->read_spifr->waveform->header_data_size =
sp_header_size(tsp->read_spifr->header)) < 0){
free_sphere_t(tsp);
return_err(proc,111,SPNULL,
rsprintf("Unable to get SPHERE header size of file '%s'",
filename));
}
}
/****** Remove the sample_count field if it's ******/
/****** value is 999999999 and the file is a stream ******/
/****** Added by JGF June 22, 1994 ******/
if (! tsp->read_spifr->status->is_disk_file){
int type, size;
SP_INTEGER l_int;
if (sp_get_field(tsp->read_spifr->header,
SAMPLE_COUNT_FIELD,&type,&size) == 0){
if (sp_get_data(tsp->read_spifr->header,SAMPLE_COUNT_FIELD,
(char *)&l_int,&size) == 0){
if (l_int == 999999999){
if (sp_verbose > 10)
fprintf(spfp,
"Proc %s: file '%s' deleting %s field\n",
proc,filename,SAMPLE_COUNT_FIELD);
if (sp_delete_field(tsp->read_spifr->header,
SAMPLE_COUNT_FIELD) < 0)
return_err(proc,112,SPNULL,
rsprintf("Unable to delete fake '%s' field",
SAMPLE_COUNT_FIELD));
}
}
}
}
/****** Correct any out-of-date headers right NOW ******/
if (correct_out_of_date_headers(tsp) != 0){
fprintf(spfp,"Warning: correction of ");
fprintf(spfp,"out-of-date headers failed\n");
sp_print_return_status(spfp);
}
/* duplicate the header for the file interface */
if ((tsp->read_spifr->status->file_header =
sp_dup_header(tsp->read_spifr->header)) == HDRNULL){
fprintf(spfp,"Error: sp_open_header unable ");
fprintf(spfp,"to dup header for file '%s'\n",filename);
free_sphere_t(tsp);
return_err(proc,106,SPNULL,
rsprintf("Unable to duplicate the SPHERE header of file",
filename));
}
/* set the default operation settings */
if (sp_set_default_operations(tsp) != 0){
print_return_status(spfp);
return_err(proc,107,SPNULL,
rsprintf("Unable to interpret the SPHERE header of file '%s'",
filename));
}
break;
}
case (SP_mode_write):{
tsp->write_spifr->header = sp_create_header();
if ( tsp->write_spifr->header == HDRNULL ) {
free_sphere_t(tsp);
return_err(proc,108,SPNULL,
rsprintf("Unable to allocate SPHERE header for file '%s'",
filename));
}
tsp->write_spifr->status->file_header = sp_create_header();
if ( tsp->write_spifr->status->file_header == HDRNULL ) {
free_sphere_t(tsp);
return_err(proc,109,SPNULL,
rsprintf("Unable to allocate hidden SPHE. header for file '%s'",
filename));
}
}
default:
;
}
/* the file was actually opened for update, so make a temp file, and */
/* duplicate the read in file. */
if (current_mode == SP_mode_update){
SP_FILE *tsp2;
SPIFR *tspifr;
char *temp_file;
char data_mode[100];
temp_file = sptemp(tsp->read_spifr->status->external_filename);
if (temp_file == CNULL)
return_err(proc,300,SPNULL,"Unable to create temporary filename");
if ((tsp2 = sp_open(temp_file,WRITEMODE)) == SPNULL) {
free_sphere_t(tsp);
mtrf_free(temp_file);
return_err(proc,301,SPNULL,
rsprintf("Unable to open temporary file",temp_file));
}
sp_set_data_mode(tsp,"SE-ORIG:SBF-ORIG");
/* now copy the header into the update file */
if (sp_copy_header(tsp,tsp2) != 0){
free_sphere_t(tsp);
free_sphere_t(tsp2);
unlink(temp_file);
mtrf_free(temp_file);
return_err(proc,302,SPNULL,"Unable to duplicate output header");
}
*data_mode = '\0';
/*now set the data mode to match the output format of the read file*/
switch (tsp->read_spifr->status->file_compress){
case SP_wc_shorten: strcat(data_mode,"SE-SHORTEN:"); break;
case SP_wc_wavpack: strcat(data_mode,"SE-WAVPACK:"); break;
case SP_wc_shortpack: strcat(data_mode,"SE-SHORTPACK:"); break;
default: ;
}
switch (tsp->read_spifr->status->file_sbf){
case SP_sbf_01: strcat(data_mode,"SBF-01"); break;
case SP_sbf_10: strcat(data_mode,"SBF-10"); break;
case SP_sbf_1: strcat(data_mode,"SBF-1"); break;
case SP_sbf_N: strcat(data_mode,"SBF-N"); break;
default: ;
}
if (sp_set_data_mode(tsp2,data_mode) >= 100){
free_sphere_t(tsp);
free_sphere_t(tsp2);
unlink(temp_file);
mtrf_free(temp_file);
return_err(proc,303,SPNULL,
rsprintf("Unable to set_data_mode '%s' for update file",
data_mode));
}
/* now merge the two SPFILE pointers into a single structure */
/* and free the residual */
tspifr = tsp->write_spifr;
tsp->write_spifr = tsp2->write_spifr;
tsp2->write_spifr = tspifr;
free_sphere_t(tsp2);
mtrf_free(temp_file);
tsp->open_mode = current_mode;
}
/* sp_file_dump(tsp,spfp);*/
if (sp_verbose > 17) sp_file_dump(tsp,spfp);
if (sp_verbose > 11)
fprintf(spfp,"Proc %s: Returning Sphere-file pointer\n",proc);
return_success(proc,0,tsp,"ok");
}
char *
configure_apache(HWND hDlg, char *resin_home, char *apache_home)
{
char buf[1024];
char esc_resin_home[1024];
FILE *is;
FILE *os;
int i, j;
int isApache2 = 0;
char *apache_version = "apache-2.0";
isApache2 = (strstr(apache_home, "Apache2") != 0);
if (isApache2)
apache_version = "apache-2.0";
else
apache_version = "apache-1.3";
j = 0;
for (i = 0; resin_home[i]; i++) {
if (resin_home[i] == '\\')
esc_resin_home[j++] = '/';
else
esc_resin_home[j++] = resin_home[i];
}
esc_resin_home[j] = 0;
int isEtc = 0;
is = fopen(rsprintf(buf, "%s/etc/httpd.conf", apache_home), "r");
if (is) {
isEtc = 1;
os = fopen(rsprintf(buf, "%s/etc/httpd.conf.bak", apache_home), "w+");
}
else {
is = fopen(rsprintf(buf, "%s/conf/httpd.conf", apache_home), "r");
if (is)
os = fopen(rsprintf(buf, "%s/conf/httpd.conf.bak", apache_home), "w+");
}
if (! is)
return "Can't find Apache httpd.conf";
if (! os) {
fclose(os);
return "Can't write Apache httpd.conf.bak";
}
int lastAddModule = 0;
int lastLoadModule = 0;
int hasCaucho = 0;
int line = 0;
while (fgets(buf, sizeof(buf), is)) {
fputs(buf, os);
line++;
char cmd[1024];
char module[1024];
char file[1024];
int args = sscanf(buf, "%s%s%s", cmd, module, file);
if (args >= 2 && ! strcmp(cmd, "LoadModule") && ! strcmp(module, "caucho_module"))
hasCaucho = 1;
if (args >= 3 && (! strcmp(cmd, "LoadModule") || ! strcmp(cmd, "#LoadModule")))
lastLoadModule = line;
if (args >= 2 && (! strcmp(cmd, "AddModule") || ! strcmp(cmd, "#AddModule")))
lastAddModule = line;
}
if (lastAddModule < lastLoadModule)
lastAddModule = lastLoadModule;
fclose(is);
fclose(os);
if (hasCaucho)
return 0;
if (isEtc) {
is = fopen(rsprintf(buf, "%s/etc/httpd.conf.bak", apache_home), "r");
os = fopen(rsprintf(buf, "%s/etc/httpd.conf", apache_home), "w+");
}
else {
is = fopen(rsprintf(buf, "%s/conf/httpd.conf.bak", apache_home), "r");
os = fopen(rsprintf(buf, "%s/conf/httpd.conf", apache_home), "w+");
}
line = 0;
while (fgets(buf, sizeof(buf), is)) {
fputs(buf, os);
line++;
if (line == lastLoadModule)
fprintf(os, "LoadModule caucho_module \"%s/win32/%s/mod_caucho.dll\"\n",
esc_resin_home, apache_version);
if (line == lastAddModule && ! isApache2)
fprintf(os, "AddModule mod_caucho.c\n");
}
if (! lastLoadModule)
fprintf(os, "LoadModule caucho_module \"%s/win32/%s/mod_caucho.dll\"\n",
esc_resin_home, apache_version);
/*
if (! lastAddModule && ! isApache2)
fprintf(os, "AddModule mod_caucho.c\n");
*/
fprintf(os, "<IfModule mod_caucho.c>\n");
/*
fprintf(os, " CauchoConfigFile \"%s/conf/resin.conf\"\n", esc_resin_home);
*/
fprintf(os, " ResinConfigServer localhost 6800\n");
fprintf(os, " CauchoStatus yes\n");
fprintf(os, "</IfModule>\n");
fclose(is);
fclose(os);
return 0;
}
static void print_gnu_range_graph(RANK *rank, char *percent_desc, char *testname, char *base, int for_blks, int feedback)
{
int b,t;
FILE *fp_dat, *fp_mean, *fp_plt, *fp_median;
double sum;
TEXT *mean_name = (TEXT *)0, *dat_name = (TEXT *)0;
TEXT *plt_name = (TEXT *)0, *basename = (TEXT *)0;
TEXT *median_name = (TEXT *)0;
double *pctt, *rnkk;
int *ind;
alloc_singarr(pctt,MAX( rank->n_blk , rank->n_trt ),double);
alloc_singarr(rnkk,MAX( rank->n_blk , rank->n_trt ),double);
alloc_singarr(ind,MAX( rank->n_blk , rank->n_trt ),int);
basename = TEXT_strdup((TEXT *)rsprintf("%s%s",(strcmp(base,"-")==0) ? "STATS" : base,
(for_blks) ? ".spk" : ".sys"));
dat_name = TEXT_strdup((TEXT *)rsprintf("%s%s",basename,".dat"));
/* make the datafiles for the treatements */
if ((fp_dat = fopen(dat_name,"w")) == (FILE *)0){
fprintf(stderr,"Error: unable to open GNUPLOT data file %s\n",
dat_name);
exit(1);
} else
if (feedback >= 1) printf(" Output written to '%s.*'\n",basename);
mean_name = TEXT_strdup((TEXT *)rsprintf("%s%s",basename,".mean"));
if ((fp_mean = fopen(mean_name,"w")) == (FILE *)0){
fprintf(stderr,"Error: unable to open GNUPLOT data file %s\n",
mean_name);
exit(1);
}
median_name = TEXT_strdup((TEXT *)rsprintf("%s%s",basename,".median"));
if ((fp_median = fopen(median_name,"w")) == (FILE *)0){
fprintf(stderr,"Error: unable to open GNUPLOT data file %s\n",
median_name);
exit(1);
}
plt_name = TEXT_strdup((TEXT *)rsprintf("%s%s",basename,".plt"));
if ((fp_plt = fopen(plt_name,"w")) == (FILE *)0){
fprintf(stderr,"Error: unable to open GNUPLOT file %s\n",
plt_name);
exit(1);
}
fprintf(fp_plt,"set yrange [%d:0]\n",
1 + ((for_blks) ?rank->n_blk :rank->n_trt ));
fprintf(fp_plt,"set xrange [0:100]\n");
fprintf(fp_plt,"set title \"%s\"\n",testname);
fprintf(fp_plt,"set key\n");
fprintf(fp_plt,"set ylabel \"%s\"\n",(for_blks) ? "Speaker ID" :"Systems");
fprintf(fp_plt,"set xlabel \"%s\"\n",percent_desc);
fprintf(fp_plt,"set ytics (");
if (for_blks){
for (b=0;b< rank->n_blk ;b++){
double medianval=0.0;
sum = 0.0;
for (t=0;t< rank->n_trt ;t++){
fprintf(fp_dat,"%d %f\n",
b+1,rank->pcts [ rank->trt_srt_ind [ b ] ][ t ] );
pctt[t] = rank->pcts [ rank->trt_srt_ind [ b ] ][ t ] ;
sum += rank->pcts [ rank->trt_srt_ind [ b ] ][ t ] ;
}
rank_double_arr(pctt, rank->n_trt ,ind,rnkk,INCREASING);
if ( rank->n_trt % 2 == 0) { /* handle the even arr len */
medianval = (pctt[ind[ rank->n_trt / 2]] +
pctt[ind[( rank->n_trt / 2) - 1]]) / 2.0;
} else { /* handle the odd arr len */
medianval = pctt[ind[ rank->n_trt / 2]];
}
fprintf(fp_mean,"%d %f\n",b+1,sum / (double)( rank->n_trt ));
fprintf(fp_median,"%d %f\n",b+1,medianval);
fprintf(fp_plt,"\"%s\" %d",rank->blk_name[rank->trt_srt_ind[b]],
b+1);
if (b !=rank->n_blk -1)
fprintf(fp_plt,",");
}
fprintf(fp_plt,")\n");
} else {
for (t=0;t< rank->n_trt ;t++){
double medianval=0.0;
sum = 0.0;
for (b=0;b< rank->n_blk ;b++){
fprintf(fp_dat,"%d %f\n",
t+1,rank->pcts [ b ][ rank->blk_srt_ind [ t ] ] );
pctt[b] = rank->pcts [ b ][ rank->blk_srt_ind [ t ] ] ;
sum += rank->pcts [ b ][ rank->blk_srt_ind [ t ] ] ;
}
rank_double_arr(pctt, rank->n_blk ,ind,rnkk,INCREASING);
if ( rank->n_blk % 2 == 0) { /* handle the even arr len */
medianval = (pctt[ind[ rank->n_blk / 2]] +
pctt[ind[( rank->n_blk / 2) - 1]]) / 2.0;
} else { /* handle the odd arr len */
medianval = pctt[ind[ rank->n_blk / 2]];
}
fprintf(fp_mean,"%d %f\n",t+1,sum / (double)(rank->n_blk ));
fprintf(fp_median,"%d %f\n",t+1,medianval);
fprintf(fp_plt,"\"%s\" %d",rank->trt_name[rank->blk_srt_ind[t]],
t+1);
if (t !=rank->n_trt -1)
fprintf(fp_plt,",");
}
fprintf(fp_plt,")\n");
}
fprintf(fp_plt,"plot \"%s\" using 2:1 title \"Mean %s\" with lines,",
mean_name, percent_desc);
fprintf(fp_plt,"\"%s\" using 2:1 title \"Median %s\" with lines,",
median_name, percent_desc);
fprintf(fp_plt,"\"%s\" using 2:1 title \"Individual %s\"\n",dat_name,
percent_desc);
fclose(fp_dat);
fclose(fp_mean);
fclose(fp_median);
fclose(fp_plt);
free_singarr(mean_name , TEXT);
free_singarr(dat_name , TEXT);
free_singarr(plt_name , TEXT);
free_singarr(basename , TEXT);
free_singarr(median_name, TEXT);
free_singarr(pctt,double);
free_singarr(rnkk,double);
free_singarr(ind,int);
}
void run_multi_sys(SCORES *scor[],int nscor,char *out_dir,int stats,int stats_verbose,int stats_unified, int stats_graphs, char *stats_out_name, char *stats_formula, char *stats_test_name, int reports, int feedback, int linewidth)
{
RANK rank;
int nwin=0, **winner[15];
double **confidence[15];
char *win_desc[15], *win_id[15], *stat_form_str=formula_str(stats_formula);
char outroot[200], *sign_str=(char *)0, *wilc_str=(char *)0;
char outname[200];
if (feedback >= 1)
printf("Beginning Multi-System comparisons and reports\n");
if (strcmp(stats_out_name,"-") == 0)
strcpy(outroot,stats_out_name);
else
sprintf(outroot,"%s%s%s",
((out_dir != (char *)0) ? out_dir : ""),
((out_dir != (char *)0) ? "/" : ""),
stats_out_name);
/* printf("Out Root = %s\n",outroot); */
if (strcmp("-",outroot) == 0)
strcpy(outname,outroot);
else
sprintf(outname,"%s.%s",outroot,"stats");
if (stats > 0 || stats_graphs > 0)
init_RANK_struct_from_SCORES(&rank, scor, nscor, stats_formula);
/* dump_full_RANK_struct(&rank, "Systems", "Speakers", "", "",stats_formula,
"test name", "Speaker ranks for the system",
"System ranks for the speaker"); */
if ((stats & STAT_MAPSSWE) > 0){
win_desc[nwin] = "Matched Pair Sentence Segment (Word Error)";
win_id[nwin] = "MP";
if (feedback >= 1)
printf(" Performing the %s Test\n",win_desc[nwin]);
do_mtch_pairs(scor, nscor, "2", stats_test_name,
!stats_unified, stats_verbose, &winner[nwin],
outname, feedback, &confidence[nwin]);
nwin++;
}
if ((stats & STAT_MAPSSWE_SEG) > 0){
do_mtch_pairs_seg_analysis(scor, nscor, stats_test_name, 1, 1);
}
if ((stats & STAT_SIGN) > 0){
win_desc[nwin] = (char *)TEXT_strdup((TEXT*)rsprintf("%s (%s)",
"Signed Paired Comparison",
stat_form_str));
sign_str = win_desc[nwin];
win_id[nwin] = "SI";
if (feedback >= 1)
printf(" Performing the %s Test\n",win_desc[nwin]);
perform_signtest(&rank, stats_verbose, !stats_unified,
stat_form_str, *stats_formula, &winner[nwin],
outname, feedback, &confidence[nwin]);
nwin++;
}
if ((stats & STAT_WILC) > 0){
win_desc[nwin] = (char*)TEXT_strdup((TEXT *)rsprintf("%s (%s)",
"Wilcoxon Signed Rank",
stat_form_str));
wilc_str = win_desc[nwin];
win_id[nwin] = "WI";
if (feedback >= 1)
printf(" Performing the %s Test\n",win_desc[nwin]);
perform_wilcoxon(&rank, stats_verbose, !stats_unified,
stat_form_str, *stats_formula, &winner[nwin],
outname, feedback, &confidence[nwin]);
nwin++;
}
if ((stats & STAT_MCN) > 0){
win_desc[nwin] = "McNemar (Sentence Error)"; win_id[nwin] = "MN";
if (feedback >= 1)
printf(" Performing the %s Test\n",win_desc[nwin]);
McNemar_sent(scor, nscor, &winner[nwin], stats_test_name,
!stats_unified, stats_verbose,outname,
feedback, &confidence[nwin]);
nwin++;
}
if ((stats & STAT_ANOVAR) > 0){
win_desc[nwin] = "Analysis of Variance by Ranks";
win_id[nwin] = "AN";
if (feedback >= 1)
printf(" Performing the %s Test\n",win_desc[nwin]);
compute_anovar(&rank, stats_verbose, !stats_unified,
&winner[nwin],outname,feedback,&confidence[nwin]);
nwin++;
}
if (stats_unified){
if (feedback >= 1)
printf(" Printing Unified Statistical Test Reports\n");
#define new
#ifdef new
print_composite_significance2(&rank, 80, nwin, winner, confidence,
win_desc, win_id,
1 /*matrix*/, 1 /*int report*/,
stats_test_name,outname, feedback,
(out_dir != (char *)0) ? out_dir : "");
#endif
#ifdef old
print_composite_significance(&rank, 80, nwin, winner,
win_desc, win_id,
1 /*matrix*/, 1 /*int report*/,
stats_test_name,outname,feedback,
(out_dir != (char *)0) ? out_dir : "");
#endif
}
if ((stats_graphs & GRAPH_RANGE) > 0){
if (strcmp("-",outroot) == 0)
strcpy(outname,outroot);
else
sprintf(outname,"%s.%s",outroot,"range");
if (feedback >= 1) printf(" Printing Range Graphs\n");
print_rank_ranges(&rank, stat_form_str,stats_test_name, outname, feedback);
}
if ((stats_graphs & GRAPH_GRANGE) > 0){
if (strcmp("-",outroot) == 0)
strcpy(outname,outroot);
else
sprintf(outname,"%s.%s",outroot,"grange");
if (feedback >= 1) printf(" Printing GNUPLOT Range Graphs\n");
print_gnu_rank_ranges(&rank, stat_form_str,stats_test_name, outname, feedback);
}
if ((stats_graphs & GRAPH_GRANGE2) > 0){
if (strcmp("-",outroot) == 0)
strcpy(outname,outroot);
else
sprintf(outname,"%s.%s",outroot,"grange2");
if (feedback >= 1) printf(" Printing GNUPLOT Range Graphs V2\n");
print_gnu_rank_ranges2(&rank, stat_form_str,stats_test_name, outname, feedback);
}
if ((stats_graphs & GRAPH_DET) > 0){
if (strcmp("-",outroot) != 0){
if (make_SCORES_DET_curve(scor, nscor,outroot,feedback,stats_test_name)
!= 0)
exit(1);
} else {
fprintf(scfp,"Warning: DET plot can not go to STDOUT\n");
}
}
strcpy(outname,outroot);
if ((reports & REPORT_SUM) > 0)
print_N_system_summary(scor, nscor, outname, stats_test_name, 0, feedback);
if ((reports & REPORT_RSUM) > 0)
print_N_system_summary(scor, nscor, outname, stats_test_name, 1,
feedback);
if ((reports & REPORT_ESUM) > 0)
print_N_system_executive_summary(scor, nscor, outname,
stats_test_name, 0, feedback);
if ((reports & REPORT_RESUM) > 0)
print_N_system_executive_summary(scor, nscor, outname,
stats_test_name, 1, feedback);
if ((reports & REPORT_PRN) > 0)
print_N_SCORE(scor, nscor, outname, linewidth, feedback, 0);
if ((reports & REPORT_LUR) > 0)
print_N_lur(scor, nscor, outname, stats_test_name, feedback);
if (stats > 0 || stats_graphs > 0){
int i;
for (i=0; i<nwin; i++)
free_2dimarr(winner[i],rank.n_trt,int);
free_RANK(&rank);
}
int pattern_init(struct pattern * pattern, const char * prefix) {
GLenum e;
memset(pattern, 0, sizeof *pattern);
pattern->intensity = 0;
pattern->intensity_integral = 0;
pattern->name = strdup(prefix);
if(pattern->name == NULL) ERROR("Could not allocate memory");
int n = 0;
for(;;) {
char * filename;
struct stat statbuf;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, n);
if(filename == NULL) MEMFAIL();
int rc = stat(filename, &statbuf);
free(filename);
if (rc != 0 || S_ISDIR(statbuf.st_mode)) {
break;
}
n++;
}
if(n == 0) {
ERROR("Could not find any shaders for %s", prefix);
return 1;
}
pattern->n_shaders = n;
pattern->shader = calloc(pattern->n_shaders, sizeof *pattern->shader);
if(pattern->shader == NULL) MEMFAIL();
pattern->tex = calloc(pattern->n_shaders, sizeof *pattern->tex);
if(pattern->tex == NULL) MEMFAIL();
bool success = true;
for(int i = 0; i < pattern->n_shaders; i++) {
char * filename;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, i);
if(filename == NULL) MEMFAIL();
GLhandleARB h = load_shader(filename);
if (h == 0) {
fprintf(stderr, "%s", load_shader_error);
WARN("Unable to load shader %s", filename);
success = false;
} else {
pattern->shader[i] = h;
DEBUG("Loaded shader #%d", i);
}
free(filename);
}
if(!success) {
ERROR("Failed to load some shaders.");
return 2;
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Render targets
glGenFramebuffersEXT(1, &pattern->fb);
glGenTextures(pattern->n_shaders + 1, pattern->tex);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glBindTexture(GL_TEXTURE_2D, pattern->tex[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.pattern.master_width, config.pattern.master_height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
glBindTexture(GL_TEXTURE_2D, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pattern->fb);
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pattern->tex[i], 0);
glClear(GL_COLOR_BUFFER_BIT);
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Some OpenGL API garbage
pattern->uni_tex = calloc(pattern->n_shaders, sizeof *pattern->uni_tex);
if(pattern->uni_tex == NULL) MEMFAIL();
for(int i = 0; i < pattern->n_shaders; i++) {
pattern->uni_tex[i] = i + 1;
}
return 0;
}
char *
configure_netscape(HWND hDlg, char *resin_home_raw, char *netscape_home)
{
char obj_name[1024];
char bak_name[1024];
char resin_home[1024];
char buf[1024];
char *status;
FILE *is;
FILE *os;
int i;
// netscape needs forward slashes
for (i = 0; resin_home_raw[i]; i++) {
if (resin_home_raw[i] == '\\')
resin_home[i] = '/';
else
resin_home[i] = resin_home_raw[i];
}
resin_home[i] = 0;
int isEtc = 0;
wsprintf(obj_name, "%s/config/magnus.conf", netscape_home);
wsprintf(bak_name, "%s/config/magnus.conf.bak", netscape_home);
status = config_init(obj_name, bak_name, resin_home);
if (status)
return status;
wsprintf(obj_name, "%s/config/obj.conf", netscape_home);
wsprintf(bak_name, "%s/config/obj.conf.bak", netscape_home);
status = config_init(obj_name, bak_name, resin_home);
if (status)
return status;
is = fopen(obj_name, "r");
if (! is)
return strdup(rsprintf(buf, "Can't find Netscape's %s", obj_name));
os = fopen(bak_name, "w+");
if (! os) {
fclose(is);
return "Can't write Netscape obj.conf.bak";
}
int hasCaucho = 0;
int line = 0;
while (fgets(buf, sizeof(buf), is)) {
fputs(buf, os);
line++;
char cmd[1024];
int args = sscanf(buf, "%s", cmd);
if (strstr(buf, "caucho-status")) {
hasCaucho = 1;
}
}
fclose(is);
fclose(os);
if (hasCaucho)
return 0;
is = fopen(bak_name, "r");
os = fopen(obj_name, "w+");
line = 0;
int isFirst = 1;
while (fgets(buf, sizeof(buf), is)) {
char cmd[1024];
int args = sscanf(buf, "%s", cmd);
if (isFirst && args > 0 && ! strcmp(cmd, "NameTrans")) {
isFirst = 0;
fprintf(os, "NameTrans fn=\"caucho_filter\" conf=\"%s/conf/resin.conf\" name=\"resin\"\n",
resin_home);
fprintf(os, "NameTrans fn=\"assign-name\" from=\"/caucho-status\" name=\"caucho-status\"\n");
}
fputs(buf, os);
line++;
}
fprintf(os, "\n");
fprintf(os, "<Object name=\"resin\">\n");
fprintf(os, "Service fn=\"caucho_service\"\n");
fprintf(os, "</Object>\n\n");
fprintf(os, "<Object name=\"caucho-status\">\n");
fprintf(os, "Service fn=\"caucho_status\"\n");
fprintf(os, "</Object>\n");
fclose(is);
fclose(os);
return 0;
}
