spopen.c

speech signal process tools

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

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

/*
 *  sp_open
 *
 */
SP_FILE *sp_open(filename, mode)
char *filename;
char *mode;
{
    SP_FILE *tsp;
    char *errmsg, *proc_name="sp_open", *fopen_mode;
    enum SP_file_open_mode current_mode;

    if (sp_verbose > 10) printf("Proc %s:\n",proc_name);
    if (filename == CNULL) 
	return_err(proc_name,101,SPNULL,"Null filename string");
    if (mode == CNULL) 
	return_err(proc_name,101,SPNULL,"Null file mode string");

    if ((tsp=sp_alloc_and_init_sphere_t()) == SPNULL)
        return_err(proc_name,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_name,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_name,111,SPNULL,
			       rsprintf("Unable to open SPHERE file '%s' for reading fopen mode %s",
				    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_name,105,SPNULL,
			       rsprintf("Unable to open SPHERE file '%s' for writing, fopen mode %s",
					filename,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_name,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_name,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_name,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_name,111,SPNULL,
			       rsprintf("Unable to get SPHERE header size of file '%s'",filename));
		}
	    }

            /* duplicate the header for the file interface */
            if ((tsp->read_spifr->status->file_header = sp_dup_header(tsp->read_spifr->header)) == HDRNULL){
		fprintf(stderr,"Error: sp_open_header unable to dup header for ");
		fprintf(stderr,"file '%s'\n",filename);
		free_sphere_t(tsp);		
		return_err(proc_name,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(stderr);
		return_err(proc_name,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_name,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_name,109,SPNULL,
			   rsprintf("Unable to allocate hidden SPHERE header for file '%s'",
				    filename));
	    }
	}
    }

    /* 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_name,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_name,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_dup(tsp,tsp2) != 0){
	    free_sphere_t(tsp);		
	    free_sphere_t(tsp2);		
	    unlink(temp_file);
	    mtrf_free(temp_file);
	    return_err(proc_name,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;
	}
	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;
	}
	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_name,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,stdout);*/
    if (sp_verbose > 17) sp_file_dump(tsp,stdout);
    if (sp_verbose > 11) printf("Proc %s: Returning Sphere-file pointer\n",proc_name);
    return_success(proc_name,0,tsp,"ok");
}


sp_file_dump(sp,fp)
SP_FILE *sp;
FILE *fp;
{
    char *enum_str_SP_file_open_mode();

    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,"|==================================================================\n");
}

spifr_dump(spifr,fp)
SPIFR *spifr;
FILE *fp;
{
    char *enum_str_SP_sample_byte_fmt();
    char *enum_str_SP_sample_encoding();
    char *enum_str_SP_waveform_comp();

    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,"\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);

    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,"|\n|-----------------------------------------------------------------------\n");

}

char *enum_str_SP_file_open_mode(id)
enum SP_file_open_mode id;
{
    switch (id){
	  case SP_mode_read : return("SP_mode_read");
	  case SP_mode_write : return("SP_mode_write");
	  case SP_mode_update : return("SP_mode_update");
	  case SP_mode_null : return("SP_mode_null");
	  default: return("UNKNOWN");
    }
}

char *enum_str_SP_sample_encoding(id)
enum SP_sample_encoding id;