window_process

Digital Signal Processing Library

Voice Lab

window_process

void window_process(double *d_window_i, int window_type,\
 int window_size, double **d_window_o)
{
 int i;

 /* calculate d_window_o */
 switch(window_type) {
 case 1:
  /* rectangular window */
  for(i = 0 ;i < window_size; i++)\
 (*d_window_o)[i] = d_window_i[i];
  break;
 case 2:
  /* hamming window */
  for(i = 0; i %lt; window_size; i++) {
   (*d_window_o)[i] = d_window_i[i]*\
      (0.54 - 0.46*cos(2.0*PI*(i)/(window_size-1.0)));
  }
  break;
 case 3:
  /* Hann window */
  for(i = 0 ;i %lt; window_size; i++) \
    (*d_window_o)[i] = d_window_i[i]*\
        (0.5 - 0.5*cos(2.0*PI*(i)/(window_size-1.0)));
  break;
 }
 return;
}

cut_off

Digital Signal Processing Library

Voice Lab

cut_off

int cut_off(double offset, int sample_rate, int window_size, int overlap)
{
        int aux;

        aux = offset * sample_rate * overlap / window_size;
        return(aux);
}

window_preemphasis

Digital Signal Processing Library

Voice Lab

window_preemphasis

void window_preemphasis(double *d_window_i, int window_size, double **d_window_o)
{
 int i;

 (*d_window_o)[0] = d_window_i[0];

 for(i = 1; i < window_size; i++) {
  (*d_window_o)[i] = d_window_i[i] - 0.95*d_window_i[i-1];
 }
 return;
}

int2double

Digital Signal Processing Library

Voice Lab

int2double

void int2double(int *window, int window_size, double **d_window, int normalize)
{
 int i;
 double  max;

 /* copy first element, and use it as first maximum amount */
 (*d_window)[0] = (double)window[0];
 max = (*d_window)[0];

 /* for each additional element, copy and check if greater than maximum */
 for(i = 1; i < window_size; i++) {
  (*d_window)[i] = (double)window[i];
  if((*d_window)[i] >= 0) {
   /* value positive or zero */
   if((*d_window)[i] > max) max = (*d_window)[i];
  } else {
   /* value negative, invert sign before comparisson */
   if((-(*d_window)[i]) > max) max = -(*d_window)[i];
  }
 }
 DEBUG_WRITE2(1, "Max value: %f\n", max);

 /* section to mormalize vector */
 if(normalize == 1) {
  for(i = 0; i < window_size; i++) {
   (*d_window)[i] = (*d_window)[i]/max;
  }
 }
 return;
}

free_d_window

Digital Signal Processing Library

Voice Lab

free_d_window

void free_d_window(double *d_window)
{
        free(d_window);
        return;
}

free_window

Digital Signal Processing Library

Voice Lab

free_window

void free_window(int *window)
{
        free(window);
        return;
}

position_file_pointer

Digital Signal Processing Library

Voice Lab

position_file_pointer

int position_file_pointer(int window_number, int window_size, int data_size,
 int header_length, int sample_rate, int overlap, FILE *input_file)
{
        int file_pos;

        /* The position takes into account the file header size, the window number and size */
        /* In our specific case, we use 50% overlapping windows */

        /*
        ** Overlap values:
        ** 1 -> no overlap
        ** 2 -> 50% overlap
        */

        if(sample_rate == 50000) {
                file_pos = (window_number*window_size*data_size*2) / overlap;
        } else {
                file_pos = (window_number*window_size*data_size) / overlap;
        }
        if(fseek(input_file, (file_pos+header_length), SEEK_SET) == -1) {
                return(-1);
        }
        return(ftell(input_file));
}

read_window

Digital Signal Processing Library

Voice Lab

read_window

int read_window(int **window, int window_size,\
 int data_length, int sample_rate, FILE *input_file)
{
 int file_pos;
 int i, data;

 /* Read the next window */
 for(i =0; i < window_size; i++) {
  /* The read_25 routine takes into account the data width */
  /* (in our case 2 bytes per INT) */
  if(read_25(input_file, data_length, sample_rate, &data)\
 < data_length) {
   return(-1);
  }
  /* fill window array */
  (*window)[i] = data;
 }
 print_window(&(**window), window_size);
 return(0);
}

get_number_frames

Digital Signal Processing Library

Voice Lab

get_number_frames

int get_number_frames(FILE *in_file, int header_length, int data_length,
 int sample_rate, int window_size, int overlap)
{
        int number;

        fseek(in_file, 0, SEEK_END);
        number = ftell(in_file);

        number -= header_length;

        /* if sample rate = 50K, use half of the values */
        if(sample_rate == 50000) number /= 2;

        /* Truncate number to a multiple of data_length */
        number /= data_length;

        /* Truncate number to a multiple of window_size */
        switch(overlap) {
        case 2:
                number = (number * 2) / window_size;
                number--;
                break;
        case 1:
        default:
                number /= window_size;
                break;
        }

        /* seek to beginning of data segment */
        fseek(in_file, header_length, SEEK_SET);

        return(number);
}

copy_d_window

Digital Signal Processing Library

Voice Lab

copy_d_window

void copy_d_window(double *d_window_i, int window_size, double **d_window_o)
{
        int i;

        for(i = 0; i < window_size; i++) {
                (*d_window_o)[i] = d_window_i[i];
        }
        return;
}

allocate_window

Digital Signal Processing Library

Voice Lab

allocate_window

void allocate_window(int **window, int window_size)
{
     (*window) = malloc(window_size * sizeof(int));
     if((*window) == NULL) {
             fprintf(stderr, "Error allocating memory for \
 window (allocate_window)\n");
             exit(1);
     }
     return;
}