update_checksum_unless_its_already_there(short int *waveform, header_t *header)
{ int field_len;
int checksum;
int wav_len;
field_len = sizeof(int);
if(sp_get_data(header,"sample_checksum",(char *)&checksum,&field_len) < 0)
{ field_len = sizeof(int);
if(sp_get_data(header,"sample_count",(char *)&wav_len,&field_len) < 0)
{ fprintf(stderr,"HEY! couldn't read sample count from header!!\n");
longjmp(exitenv,-1);
/* exit(-1); */
}
checksum = compute_checksum(waveform, wav_len);
sp_add_field(header,"sample_checksum",T_INTEGER,(void *)&checksum);
}
}
static void
gst_shm_sink_free_buffer (gpointer data)
{
ShmPipe *pipe;
ShmBlock *block = data;
GstShmSink *self;
pipe = sp_writer_block_get_pipe (block);
self = sp_get_data (pipe);
GST_OBJECT_LOCK (self);
sp_writer_free_block (block);
GST_OBJECT_UNLOCK (self);
g_object_unref (self);
}
/*
* 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");
}
int diff_data(char *file1, char *file2, int verbose, FILE *fp)
{
FILE *fp1, *fp2;
struct header_t *h1, *h2;
char c1, c2, *errmsg;
int chr=0;
if (strsame(file1,"-") && strsame(file2,"-")) {
fprintf(spfp,"diff_data: Unable to compare Stdin to itself\n");
return(100);
}
if ((fp1 = (strsame(file1,"-") ? stdin : fopen(file1, "r"))) == FPNULL){
fprintf(spfp,"diff_data: Unable to open file '%s'\n",file1);
return(100);
}
if ((fp2 = (strsame(file2,"-") ? stdin : fopen(file2, "r"))) == FPNULL){
fprintf(spfp,"diff_data: Unable to open file '%s'\n",file2);
return(100);
}
if ((h1 = sp_open_header(fp1,TRUE,&errmsg)) == HDRNULL){
if (verbose)
fprintf(fp,"diff_data: Unable to open SPHERE header for file %s\n"
,file1);
return(100);
}
if ((h2 = sp_open_header(fp2,TRUE,&errmsg)) == HDRNULL){
if (verbose)
fprintf(fp,"diff_data: Unable to open SPHERE header for file %s\n"
,file2);
return(100);
}
/* make Sure the sample byte_formats are the same before proceeding */
{ char *h1_sbf, *h2_sbf;
int n, type, size;
n = sp_get_field( h1, "sample_byte_format", &type, &size );
if ( n < 0 ) {
fprintf(fp,"diff_data: Can't get sample_byte_format for file %s\n",
file1);
return(100);
}
if ((h1_sbf = (char *)mtrf_malloc( size + 1 )) == CNULL ){
fprintf(fp,"diff_data: malloc failed for sbf string\n");
return(100);
}
if ((n = sp_get_data( h1, "sample_byte_format", h1_sbf, &size )) != 0){
fprintf(fp,"diff_data: Can't Load sample_byte_format for file %s\n",
file1);
mtrf_free(h1_sbf);
return(100);
}
h1_sbf[size] = '\0';
n = sp_get_field( h2, "sample_byte_format", &type, &size );
if ( n < 0 ) {
fprintf(fp,"diff_data: Can't get sample_byte_format for file %s\n",
file2);
mtrf_free(h1_sbf);
return(100);
}
if ((h2_sbf = (char *)mtrf_malloc( size + 1 )) == CNULL ){
fprintf(fp,"diff_data: malloc failed for sbf string\n");
mtrf_free(h1_sbf);
return(100);
}
if ((n = sp_get_data( h2, "sample_byte_format", h2_sbf, &size )) != 0){
fprintf(fp,"diff_data: Can't Load sample_byte_format for file %s\n",
file2);
mtrf_free(h1_sbf); mtrf_free(h2_sbf);
return(100);
}
h2_sbf[size] = '\0';
if (! strsame(h1_sbf,h2_sbf)){
mtrf_free(h1_sbf); mtrf_free(h2_sbf);
if (verbose)
fprintf(fp,"diff_data: Sphere files %s and %s differ in their sample_byte_format\n",
file1,file2);
fclose(fp1);
fclose(fp2);
return(1000);
}
/* The check passed, continue the test */
mtrf_free(h1_sbf); mtrf_free(h2_sbf);
}
do {
c1 = fgetc(fp1);
c2 = fgetc(fp2);
if (c1 != c2){
if (verbose)
fprintf(fp,"diff_data: Sphere files %s and %s differ at character %d\n",
file1,file2,chr);
fclose(fp1);
fclose(fp2);
return(100);
}
chr ++;
} while (!feof(fp1));
if (!feof(fp2)){
sp_close_header(h1);
sp_close_header(h2);
fclose(fp1);
fclose(fp2);
return(100);
}
sp_close_header(h1);
sp_close_header(h2);
if (fp1 != stdin) fclose(fp1);
if (fp2 != stdin) fclose(fp2);
return(0);
}
/*if check_checksum = 1 the checksum will be checked if = 0 it won't*/
read_wav_data(FOB *fp, short int **pwaveform, header_t *header, int check_checksum)
{ int i;
char sample_byte_format[MAX_HEADER_FIELD];
short *waveform;
int len;
int string_len;
short test_short = 1;
char *char_ptr;
char temp_char1, temp_char2;
int checksum;
string_len = MAX_HEADER_FIELD;
sp_get_data(header,"sample_byte_format",sample_byte_format, &string_len);
sample_byte_format[string_len] = '\0';
string_len = sizeof(int);
sp_get_data(header,"sample_count",(char *)&len,&string_len);
/* printf("read byte_format %s ", sample_byte_format); */
waveform = *pwaveform = (short*) calloc(len, sizeof(short));
/* if((strcmp(sample_byte_format, "01") == 0) || (strcmp(sample_byte_format, "10") == 0))*/
if (0)
{ fread(waveform, sizeof(short), len, fp);
/*if byte ordering of file was different from machine, swapem*/
if ((sp_htons(test_short) == test_short && strcmp("01", sample_byte_format) == 0) ||
(sp_htons(test_short) != test_short && strcmp("10", sample_byte_format) == 0))
{ printf("swapping");
char_ptr = (char*)waveform;
for(i=0;i<len;i++)
{ temp_char1 = *char_ptr;
temp_char2 = *(char_ptr+1);
*(char_ptr++) = temp_char2;
*(char_ptr++) = temp_char1;
}
}
}
else
{ if (1) /* if(strcmp(sample_byte_format, "shortpack-v0") == 0)*/
{ read_shortpacked_data(waveform, len, fp); /*reads into machines byte-order*/
/* printf("reading shortpack");*/
}
else
{ fprintf(stderr,"SORRY! don't know about sample_byte_format %s\n", sample_byte_format);
longjmp(exitenv,-1);
/* exit(-1); */
}
}
if(check_checksum)
{ string_len = sizeof(int);
if(sp_get_data(header,"sample_checksum",(char *)&checksum,&string_len) < 0)
{ printf("read_wav_data: HEY! can't read checksum in header!!\n");
}
else
{ if(checksum != compute_checksum(waveform, len))
{ printf("read_wav_data: CHECKSUM ERROR: in header %d computed %d\n", checksum, compute_checksum(waveform, len));
}
}
}
return len;
}
write_wav_data(FOB *fp, short int *waveform, header_t *header)
{ int i;
char sample_byte_format[MAX_HEADER_FIELD];
int swap;
int string_len;
int len;
short test_short = 1;
char *char_ptr;
char temp_char1, temp_char2;
string_len = MAX_HEADER_FIELD;
sp_get_data(header,"sample_byte_format",sample_byte_format, &string_len);
sample_byte_format[string_len] = '\0';
printf("write sample_byte_format %s ", sample_byte_format);
string_len = sizeof(int);
sp_get_data(header,"sample_count",(char *)&len,&string_len);
if((strcmp(sample_byte_format, "01") == 0) || (strcmp(sample_byte_format, "10") == 0))
{ /*if byte ordering of file was different from machine, swapem*/
if ((sp_htons(test_short) == test_short && strcmp("01", sample_byte_format) == 0) ||
(sp_htons(test_short) != test_short && strcmp("10", sample_byte_format) == 0))
{ char_ptr = (char*)waveform;
printf("swapping ");
for(i=0;i<len;i++)
{ temp_char1 = *char_ptr;
temp_char2 = *(char_ptr+1);
*(char_ptr++) = temp_char2;
*(char_ptr++) = temp_char1;
}
swap = 1;
}
else
{ swap = 0;
}
fwrite(waveform, sizeof(short), len, fp);
if(swap) /*remember to swap back!*/
{ char_ptr = (char*)waveform;
for(i=0;i<len;i++)
{ temp_char1 = *char_ptr;
temp_char2 = *(char_ptr+1);
*(char_ptr++) = temp_char2;
*(char_ptr++) = temp_char1;
}
}
}
else
{ if(strcmp(sample_byte_format, "shortpack-v0") == 0)
{ printf("writing with shortpack");
write_shortpacked_data(waveform, len, fp); /*writes from machines byte-order*/
}
else
{ fprintf(stderr,"SORRY! don't know about sample_byte_format %s\n", sample_byte_format);
longjmp(exitenv,-1);
/* exit(-1); */
}
}
printf("\n");
}
