spclose.c

speech signal process tools

		    if (read_name != CNULL) mtrf_free(read_name);
		    free_sphere_t(sp);
		    return_err(proc_name,200,200,"Unable to update sample_count");
		}
		/* Reset the write occured flag */
		sp->write_spifr->status->write_occured_flag = TRUE;
		header_changed = TRUE;
	    }
	    if (h_get_field(spifr->status->file_header,SAMPLE_CHECKSUM_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_name,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 = (long)spifr->waveform->checksum;
		/* temporarily reset the write occured flag to allow header modifications */
		sp->write_spifr->status->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_name,202,202,"Unable to update checksum");
		}
		/* Reset the write occured flag */
		sp->write_spifr->status->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_name,203,203,"Write verification of checksum failed");
		}
	}

	/* 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_name,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_name,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_name,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_name,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_name,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_name,207,207,"Unable to setup for compression");
		}
		spifr->waveform->sp_fp = FPNULL;
		switch (spifr->status->file_compress){
		  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(stdout);

		    if (shorten_compress(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_name,208,208,"Shorten Compression Failed");
		    }
		    fob_fflush(comp_fob);
		    break;
		  case SP_wc_wavpack:
		    /* optimize the compression */
		    if (spifr->status->file_channel_count == 1)
			wavpack_set_monoflg();
		    if (spifr->status->file_sbf == SP_sbf_1)
			wavpack_set_byteflg();

		    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_name,209,209,"Wavpack Compression Failed");
		    }
		    fob_fflush(comp_fob);
		    break;
		  case SP_wc_shortpack:
		    return_err(proc_name,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_name,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 (sp->write_spifr->status->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_name,1,1,"Unable to verify checksum, file went to STDOUT");
	}
	if (verify_file_checksum(write_name) != 0){
	    sp_print_return_status(stdout);
	    if (write_name != CNULL) mtrf_free(write_name);
	    if (read_name != CNULL) mtrf_free(read_name);
	    return_err(proc_name,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_name,0,0,"ok");
}

verify_file_checksum(filename)
char *filename;
{
    char *proc_name="verify_file_checksum";
    SP_FILE *sp;
    char buf[1024];

    if (sp_verbose > 10) printf("Proc %s:\n",proc_name);
    if (filename == CNULL) return_err(proc_name,100,100,"Null filename");
    
    if ((sp = sp_open(filename,"rv")) == SPNULL)
        return_err(proc_name,101,101,rsprintf("Unable to open SPHERE file '%s'",filename));
    if (sp->read_spifr->status->user_sample_count > 0){
	if (sp_read_data(buf,sp->read_spifr->status->user_sample_n_bytes,1,sp) != 1){
	    sp_close(sp);
	    return_err(proc_name,200,200,"Verification of checksum failed");
	}
    } else {
	sp_close(sp);
	return_err(proc_name,300,300,"No data in file to check");
    }
	
    sp_close(sp);
    if (sp_verbose > 11) printf("Proc %s: Returning 0\n",proc_name);
    return_success(proc_name,0,0,"Checksum verification passed");
}