spopen.c

speech signal process tools

#include <stdio.h>
#define SPHERE_LIBRARY_CODE
#include <sp/sphere.h>
#include <string.h>

#define READMODE "r"
#define UPDATEMODE "r+"
#define WRITEMODE "w"


/*
 *  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");
}

/**** This function is exempt from the requirement of using spfp ****/
void sp_file_dump(SP_FILE *sp, FILE *fp)
{
    fprintf(fp,"|==========================================");
    fprintf(fp,"========================\n");
    fprintf(fp,"File open mode:      %s\n",
	    enum_str_SP_file_open_mode(sp->open_mode));
    if ((sp->open_mode == SP_mode_read) || 
	(sp->open_mode == SP_mode_update)){
	fprintf(fp,"Read SPIFR:\n");
	spifr_dump(sp->read_spifr,fp);
    }
    if ((sp->open_mode == SP_mode_write) ||
	(sp->open_mode == SP_mode_update)){
	fprintf(fp,"Write SPIFR:\n");
	spifr_dump(sp->write_spifr,fp);
    }
    fprintf(fp,"|==========================================");
    fprintf(fp,"========================\n");
}

/**** This function is exempt from the requirement of using spfp ****/
void spifr_dump(SPIFR *spifr, FILE *fp)
{
    fprintf(fp,"|------------------------------------------");
    fprintf(fp,"-----------------------------\n|\n");
    fprintf(fp,"Dump of an SP_FILE structure\n");
    fprintf(fp,"Users file header\n");
    sp_print_lines(spifr->header,fp);
    fprintf(fp,"\n");
    fprintf(fp,"Wave Sructure\n");
    fprintf(fp,"File pointer:     %x\n",spifr->waveform->sp_fp);
    fprintf(fp,"FOB pointer:      %x\n",spifr->waveform->sp_fob);
    fprintf(fp,"Samples Read:     %d\n",spifr->waveform->samples_read);
    fprintf(fp,"Samples written:  %d\n",spifr->waveform->samples_written);
    fprintf(fp,"Checksum:         %d\n",spifr->waveform->checksum);
    fprintf(fp,"Header Data Size: %d\n",spifr->waveform->header_data_size);
    fprintf(fp,"Read Pre-Mat. EOF %d\n",spifr->waveform->read_premature_eof);
    fprintf(fp,"Failed Checksum   %d\n",spifr->waveform->failed_checksum);
    fprintf(fp,"File Tran. Len    %d\n",
	    spifr->waveform->file_data_buffer_len);
    fprintf(fp,"File Tran. Buf.   %d\n",spifr->waveform->file_data_buffer);
    fprintf(fp,"Code Tran. Len    %d\n",
	    spifr->waveform->converted_buffer_len);
    fprintf(fp,"Code Tran. Buf.   %d\n",spifr->waveform->converted_buffer);
    fprintf(fp,"Interkleave Len   %d\n",
	    spifr->waveform->interleave_buffer_len);
    fprintf(fp,"Interleave Buf.   %d\n",spifr->waveform->interleave_buffer);
    
    fprintf(fp,"\n");

    fprintf(fp,"Status Structure\n");
    fprintf(fp,"External file name:  %s\n",
	    spifr->status->external_filename);
    fprintf(fp,"The File header\n");
    sp_print_lines(spifr->status->file_header,fp);
    fprintf(fp,"Write Occured Flag:  %d\n",
	    spifr->status->write_occured_flag);
    fprintf(fp,"Read Occured Flag:   %d\n",
	    spifr->status->read_occured_flag);
    fprintf(fp,"Field Set Occ. Flag: %d\n",
	    spifr->status->field_set_occured_flag);
    fprintf(fp,"S_D_MODE Occ. Flg:   %d\n",
	    spifr->status->set_data_mode_occured_flag);
    fprintf(fp,"File checksum:       %d\n",
	    spifr->status->file_checksum);   
    fprintf(fp,"Ignore checksum:     %d\n",
	    spifr->status->ignore_checksum);   
    fprintf(fp,"Nat Sample Byte Fmt: %s\n",
	    enum_str_SP_sample_byte_fmt(spifr->status->natural_sbf));
    fprintf(fp,"Extra Checksum Check %d\n",
	    spifr->status->extra_checksum_verify);
    fprintf(fp,"Is Disk File         %d\n",spifr->status->is_disk_file);
    fprintf(fp,"Is Temp File         %d\n",spifr->status->is_temp_file);
    fprintf(fp,"Temp File Name       %s\n",spifr->status->temp_filename);

    if (spifr->status->channels != CHANNELSNULL) {
	int outc, orgc;
	CHANNELS *Channels=spifr->status->channels;
	fprintf(spfp,"Channel Structure:\n");
	for (outc=0; outc<Channels->num_chan; outc++){
	    fprintf(fp,"     Channel %d: #sources=%d ",
		    outc,Channels->ochan[outc].num_origin);
	    for (orgc=0; orgc < Channels->ochan[outc].num_origin; orgc++)
		fprintf(fp," %s%d",(orgc >= 1) ? "+ " : "",
		       Channels->ochan[outc].orig_channel[orgc]);
	    fprintf(fp,"\n");
	}
	fprintf(fp,"\n");
    }

    fprintf(fp,"                                   USER");
    fprintf(fp,"                    FILE\n");
    fprintf(fp,"Channel count:    %22d  %22d\n",
	    spifr->status->user_channel_count,
	    spifr->status->file_channel_count);
    fprintf(fp,"Sample Count:     %22d  %22d\n",
	    spifr->status->user_sample_count,
	    spifr->status->file_sample_count);
    fprintf(fp,"Sample Rate:      %22d  %22d\n",
	    spifr->status->user_sample_rate, 
	    spifr->status->file_sample_rate); 
    fprintf(fp,"Sample N bytes:   %22d  %22d\n",
           spifr->status->user_sample_n_bytes,
	    spifr->status->file_sample_n_bytes);
    fprintf(fp,"Sample Byte Fmt:  %22s  %22s\n",
	    enum_str_SP_sample_byte_fmt(spifr->status->user_sbf),
	    enum_str_SP_sample_byte_fmt(spifr->status->file_sbf));
    fprintf(fp,"File Coding:      %22s  %22s\n",
	    enum_str_SP_sample_encoding(spifr->status->user_encoding),
	    enum_str_SP_sample_encoding(spifr->status->file_encoding));
    fprintf(fp,"File Compress:    %22s  %22s\n",
	    enum_str_SP_waveform_comp(spifr->status->user_compress),
	    enum_str_SP_waveform_comp(spifr->status->file_compress));
    fprintf(fp,"Data Format:      %22s\n",
	    enum_str_SP_data_format(spifr->status->user_data_fmt));
    fprintf(fp,"|\n|--------------------------------------");
    fprintf(fp,"---------------------------------\n");

}

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 =