vector_write

Digital Signal Processing Library

Voice Lab

vector_write

void vector_write(double *vector, int vector_width, FILE *out_file, int options)
{
        int i, offset;

        /*
        ** The idea of the options flag is to make the program more flexible.
        ** The first bit is reserved for the offset.
        **   The offset can be 0 or 1. Under normal circumstances it will be 0.
        **   In the case of arrays being 1 more than the order,
        **   and needing to disregard the first element, set offset to 1.
        ** The fifth bit (0x10) is reserverd for the mode.
        **   If mode is 0, each value will be on a separate line.
        **   If mode is 1, each vector will occupy only one line.
        */

        offset = options & 0x01;

        if(options & 0x10) {
                for(i = offset; i < (vector_width+offset); i++) {
                        if(vector[i] >= 0) {
                                fprintf(out_file, " %lf ", vector[i]);
                        } else {
                                /* compensate for the minus sign */
                                fprintf(out_file, "%lf ", vector[i]);
                        }
                }
                fprintf(out_file, "\n");
        } else {
                for(i = offset; i < (vector_width+offset); i++) {
                        fprintf(out_file, "%lf\n", vector[i]);
                }
        }
        return;
}

matrix_write

Digital Signal Processing Library

Voice Lab

matrix_write

void matrix_write(double **vector, int vector_width, \
     int min, int max, char *file_name, int options)
{
        int i;
        FILE *out_file;

        /* open output file for writing */
        if((out_file = fopen(file_name,"w")) == NULL) {
                fprintf(stderr, "Cannot open output file: %s\n", file_name);
                exit(1);
        }

        for(i = min; i < max; i++) {
                vector_write(vector[i], vector_width, out_file, options);
        }

        fclose(out_file);
        return;
}

write_nsp_head

Digital Signal Processing Library

Voice Lab

write_nsp_head

void write_nsp_head(FILE *out_file, int data_size, int sample_rate, int data_length)
{
        int header_length;
        int size, i;
        time_t now;
        struct tm *times;
        char month[20], date_string[30], txt[120];

        fwrite("FORM", 1, sizeof("FORM")-1, out_file);
        fwrite("DS16", 1, sizeof("DS16")-1, out_file);

        /* This size should be the blocks from here to the end of the file */
        /* it should be the HEDR chunk(40) + Note Chunk(8 + note_string) + SDA chunk(8 + data_length) */
        /* Calculate size.... */
        strcpy(txt, "Repackaged by RRB. File downsampled to 25000");
        size = strlen(txt);
        if(size%2) size++;
        size += 40 + 8 + 8 + data_length;
        write_data(out_file, size, 4);

        fwrite("HEDR", 1, sizeof("HEDR")-1, out_file);

        size = 32;
        write_data(out_file, size, 4);

        time(&now);
        times = localtime(&now);
        switch(times->tm_mon) {
        case 0:
                strcpy(month, "Jan");
                break;
        case 1:
                strcpy(month, "Feb");
                break;
        case 2:
                strcpy(month, "Mar");
                break;
        case 3:
                strcpy(month, "Apr");
                break;
        case 4:
                strcpy(month, "May");
                break;
        case 5:
                strcpy(month, "Jun");
                break;
        case 6:
                strcpy(month, "Jul");
                break;
        case 7:
                strcpy(month, "Aug");
                break;
        case 8:
                strcpy(month, "Sep");
                break;
        case 9:
                strcpy(month, "Oct");
                break;
        case 10:
                strcpy(month, "Nov");
                break;
        case 11:
                strcpy(month, "Dec");
                break;
        }
        sprintf(date_string, "%s %2d %2d:%2d:%2d %4d", month, times->tm_mday,
                times->tm_hour, times->tm_min, times->tm_sec, 1900+times->tm_year);
        fwrite(date_string, 20, sizeof(char), out_file);

        printf("Date: %s\n", date_string);

        write_data(out_file, sample_rate, 4);
        printf("Sample Rate: %d\n", sample_rate);

        write_data(out_file, data_size, 4);
        write_data(out_file, 0xFFFF, 2);
        write_data(out_file, 0xFFFF, 2);

        fwrite("NOTE", 1, sizeof("NOTE")-1, out_file);

        size = strlen(txt);
        write_data(out_file, size, 4);

        fwrite(txt, size, sizeof(char), out_file);
        if(size%2) {
                write_data(out_file, 0, 1);
        }

        fwrite("SDA_", 1, sizeof("SDA_")-1, out_file);

        size = data_length;
        write_data(out_file, size, 4);
        printf("Data length: %d\n", data_length);

        size = ftell(out_file);
}

save_plot

Digital Signal Processing Library

Voice Lab


save_plot

void save_plot(double **matrix, int order, int num_vectors, char *file_name, int options)
{
        int i, j, offset;
        FILE *out_file;

        if((out_file = fopen(file_name,"w")) == NULL) {
                fprintf(stderr, "Cannot open output file: %s\n", file_name);
                exit(1);
        }

        offset = 0x01 & options;

        for(i = 0; i < num_vectors; i++) {
                for(j = offset; j < (order + offset); j++) {
                        fprintf(out_file, "%d, %d, %f\n", j, i, matrix[i][j]);
                }
                fprintf(out_file, "\n");
        }
        fclose(out_file);
}

check_wav

Digital Signal Processing Library

Voice Lab


check_wav

int check_wav(FILE *in_file_ptr, int *data_length, int *sample_rate)
{
        int header_length;
        int size;
        char header[MAX_HEADER_LENGTH];

        (*sample_rate) = -1;

        /* check if the file has a WAVe header */

        /* go to beginning of file */
        fseek(in_file_ptr,0,SEEK_SET);

        fread(&header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "RIFF", strlen("RIFF")) != 0) {
                /* not wave header */
                fseek(in_file_ptr,0,0);
                return(0);
        }

        fread(&size, sizeof(char), 4, in_file_ptr);
        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "WAVE", strlen("WAVE")) != 0) {
                /* not wave header */
                fseek(in_file_ptr,0,0);
                return(0);
        }
        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "fmt ", strlen("fmt ")) != 0) {
                /* not wave header */
                fseek(in_file_ptr,0,0);
                return(0);
        }
        fread(&size, sizeof(char), 4, in_file_ptr); /* size of wave section chunk (usually 16) */
        fread(header, sizeof(char), 2, in_file_ptr); /* Type of WAVE format. */
        fread(header, sizeof(char), 2, in_file_ptr); /* mono (0x01) or stereo (0x02). */
        fread(&(*sample_rate), sizeof(char), 4, in_file_ptr); /* Sample rate. */
        fread(&size, sizeof(char), 4, in_file_ptr); /* Bytes/Second. */

        fread(header, sizeof(char), 2, in_file_ptr); /* Block alignment. */
        (*data_length) = header[0];

        fread(header, sizeof(char), 2, in_file_ptr); /* Bits/Sample. */
        printf("Bits per sample: %d\n", header[0]);

        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "data", strlen("data")) != 0) {
                /* not valid wave header */
                fseek(in_file_ptr,0,0);
                (*sample_rate) = -1;
                return(0);
        }

        fread(&size, sizeof(char), 4, in_file_ptr);

        /* wave file found */
        header_length = ftell(in_file_ptr);
        return(header_length);
}

write_data

Digital Signal Processing Library

Voice Lab


write_data

int write_data(FILE *out_file, int data, int data_length)
{
        int count;
        char c[8];

        switch(data_length) {
        case 1:
                c[0] = 0xFF & data;
                count = fwrite(&c, sizeof(char), data_length, out_file);
                break;
        case 2:
                c[0] = 0xFF & data;
                c[1] = 0xFF & (data >> 8);
                count = fwrite(&c, sizeof(char), data_length, out_file);
                break;
        case 3:
                c[0] = 0xFF & data;
                c[1] = 0xFF & (data >> 8);
                c[2] = 0xFF & (data >> 16);
                count = fwrite(&c, sizeof(char), data_length, out_file);
                break;
        case 4:
                c[0] = 0xFF & data;
                c[1] = 0xFF & (data >> 8);
                c[2] = 0xFF & (data >> 16);
                c[3] = 0xFF & (data >> 24);
                count = fwrite(&c, sizeof(char), data_length, out_file);
                break;
        default:
                fprintf(stderr, "Data_length out of range:(%d)! What to do?\n", data_length);
                exit(1);
        }

        return(count);
}

read_25

Digital Signal Processing Library

Voice Lab


read_25

int read_25(FILE *in_file, int data_size, int sample_rate, int *result)
{
        int i, count;

        count = read_data(in_file, data_size, sample_rate, result);
        if(sample_rate == 50000) {
                /* Throw out the even data, reducing the data rate to 25000 */
                read_data(in_file, data_size, sample_rate, &i);
        }
        return(count);
}

read_data

Digital Signal Processing Library

Voice Lab


read_data

int read_data(FILE *in_file, int data_size, int sample_rate, int *result)
{
        unsigned char c[4];
        int i, count;

/* read and return the data */
        switch(data_size) {
        case 1:
                count = fread(&c, sizeof(char), data_size, in_file);
                (*result) = (int) c[0];
                break;
        case 2:
                count = fread(&c, sizeof(char), data_size, in_file);
                (*result) = c[0];
                (*result) |= c[1] << 8;
                if(c[1] & 0x80) {
                        for(i = 2; i < sizeof(int); i++) {
                                (*result) |= 0xFF<<(i*8);
                        }
                }
                break;
        case 3:
                count = fread(&c, sizeof(char), data_size, in_file);
                (*result) = c[0];
                (*result) |= c[1] << 8;
                (*result) |= c[2] << 16;
                if(c[2] & 0x80) {
                        for(i = 3; i < sizeof(int); i++) {
                                (*result) |= 0xFF<<(i*8);
                        }
                }
                break;
        case 4:
                count = fread(&c, sizeof(char), data_size, in_file);
                (*result) = c[0];
                (*result) |= c[1] << 8;
                (*result) |= c[2] << 16;
                (*result) |= c[3] << 24;
                if(c[3] & 0x80) {
                        for(i = 4; i < sizeof(int); i++) {
                                (*result) |= 0xFF<<(i*8);
                        }
                }
                break;
        default:
                fprintf(stderr, "Data_length out of range:(%d)! What to do?\n", data_size);
                exit(1);
        }
        return(count);
}

check_nsp

Digital Signal Processing Library

Voice Lab

check_nsp

int check_nsp(FILE *in_file_ptr, int *data_length, int *sample_rate)
{
        int header_length;
        int size, i, quit;
        char c, header[MAX_HEADER_LENGTH], month[20], day[20], hour[30], year[30], txt[120];

        (*sample_rate) = -1;

        /* information on header format taken from http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/CSL/CSL.html */
        fseek(in_file_ptr,0,0);
        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "FORM", strlen("FORM")) != 0) {
                /* file is not NSP */
                fseek(in_file_ptr,0,0);
                return(0);
        }

        fread(header, sizeof(char), 4, in_file_ptr);
        /* The chunk identifier DS16 indicates that the sound data is 16-bit integer. */
        if(strncmp(header, "DS16", strlen("DS16")) != 0) {
                /* file is not valid NSP */
                fseek(in_file_ptr,0,0);
                return(0);
        }
        (*data_length) = 2;

        fread(&size, sizeof(char), 4, in_file_ptr);

        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "HEDR", strlen("HEDR")) != 0) {
                /* file is not valid NSP */
                fseek(in_file_ptr,0,0);
                return(0);
        }

        fread(&size, sizeof(char), 4, in_file_ptr);

        fscanf(in_file_ptr, "%s ", &month);

        fscanf(in_file_ptr, "%s ", &day);

        fscanf(in_file_ptr, "%s ", &hour);

        fread(header, sizeof(char), 4, in_file_ptr);
        header[4] = '\0';
        sscanf(header, "%s ", &year);

        printf("Date: %s %s %s\n", day, month, year);
        printf("Time: %s\n", hour);

        fread(&(*sample_rate), sizeof(char), 4, in_file_ptr);
        printf("Sample Rate: %d\n", (*sample_rate));

        fread(&size, sizeof(char), 4, in_file_ptr);

        fread(&size, sizeof(char), 2, in_file_ptr);

        fread(&size, sizeof(char), 2, in_file_ptr);

        fread(header, sizeof(char), 4, in_file_ptr);
        if(strncmp(header, "NOTE", strlen("NOTE")) != 0) {
                /* file is not valid NSP */
                header[4] = '\0';
                printf("string = %s\n", header);
                fseek(in_file_ptr,0,0);
                (*sample_rate) = -1;
                return(0);
        }

        fread(&size, sizeof(char), 4, in_file_ptr);

        /* make size end on an even boundary */
        if(size%2) size++;

        if(size >= MAX_HEADER_LENGTH) {
                fprintf(stderr, "Please increase MAX_HEADER_LENGTH to at least %d and re-compile programs\n", size+1);
                exit(1);
        }

        for(i = 0; i < size; i++) {
                fread(&c, sizeof(char), 1, in_file_ptr);
                header[i] = c;
        }
        header[i] = '\0';

        fread(header, sizeof(char), 4, in_file_ptr);
        header[4] = '\0';

        fread(&size, sizeof(char), 4, in_file_ptr);
        printf("Data segment length = %d\n", size);

        header_length = ftell(in_file_ptr);
        return(header_length);
}

open_out_file

Digital Signal Processing Library

Voice Lab

open_out_file

FILE *open_out_file(char *out_name)
{
        FILE *output;

        /* Open output file and return the file pointer */
        if((output=fopen(out_name,"w"))==NULL) {
                fprintf(stderr, "Error opening file: %s\n", out_name);
                exit(1);
        }
        return(output);
}

file_ext

Digital Signal Processing Library

Voice Lab

file_ext

void file_ext(char *out_name, char *directory, char *base_name, char *extension)
{
        int i, j;
        int upper_case;
        char buffer[20];

        upper_case = isupper(base_name[2]);

        j = strlen(extension);

        /* 
        ** convert extension to propper case (upper or lower) 
        ** according to the rest of the filename
        */
        if(upper_case == 0) {
                for(i = 0; i <= j; i++) {
                        buffer[i] = tolower(extension[i]);
                }
        } else {
                for(i = 0; i <= j; i++) {
                        buffer[i] = toupper(extension[i]);
                }
        }
        /* copy directory name to output_name */
        strcpy(out_name, directory);

        /* add base name to output_name */
        strcat(out_name, base_name);

        /* add extension to output_name */
        strcat(out_name, buffer);
}

get_header

Digital Signal Processing Library

Voice Lab


get_header

int get_header(FILE *in_file_ptr, int *data_length, int *header_length)
{
        char header[2];

        /* go to beginning of file */
        fseek(in_file_ptr,0,0);

        /* read 1 character from beginning of file */
        fread(header, sizeof(char), 1, in_file_ptr);

        /* Test which character is at the beginning of the file */
        switch(header[0]) {
        case 'R':
                sample_rate = check_wav(in_file_ptr, data_length, header_length);
                break;
        case 'F':
                sample_rate = check_nsp(in_file_ptr, data_length, header_length);
                break;
        default:
                /* unknown file header */
                fseek(in_file_ptr,0,SEEK_SET);
                sample_rate = -1;
                (*header_length) = ftell(in_file_ptr);
                break;
        }
        return(sample_rate);
}