fextract_t *fextract_pitch_energy_create(int frame_len, char *m_e_params) {
fextract_t *fex;
dsp_fextract_t *mfcc;
fex = (fextract_t *) rs_malloc(sizeof(fextract_t),"emotion feature extraction data");
fex->n_features = V2_N_FEATURES;
/* Abtastrate etc. ... */
fex->samplerate = SAMPLERATE;
fex->frame_len = frame_len; /* global frame length (in frames) */
fex->pitch = pitch_create(AC_GAUSS);
fex->frame_shift = fex->frame_len - ((fex->pitch->method == AC_GAUSS? 2 : 1 ) * fex->pitch->periodsPerWindow / fex->pitch->minimumPitch - fex->pitch->dt) * fex->samplerate ; /* global shift (in frames) */
fex->hnr = NULL;
fex->vq = NULL;
/* MFCCs ... */
mfcc = (dsp_fextract_t *) rs_malloc(sizeof(dsp_fextract_t), "feature extraction data");
mfcc->type = dsp_fextype_MFCC;
mfcc->version = DSP_MK_VERSION(1, 4);
if (!dsp_mfcc_create(mfcc, m_e_params)) {
rs_free(mfcc);
mfcc = NULL;
rs_warning("Could not initialize MFCC configuration!");
}
fex->mfcc=mfcc;
return(fex);
}
svm_classifier_t *svm_update_classifier(svm_classifier_t *svm, int class_ind, mx_real_t *features) {
int i, j, cur;
struct svm_problem *prob = &(svm->problem);
if (svm->finished)
rs_warning("SVM classifier is being updated after training!");
cur=prob->l++;
if (prob->l > svm->max_instances) {
svm->max_instances += MAX_INSTANCES;
prob->x = (struct svm_node **) rs_realloc(prob->x,sizeof(struct svm_node *)*svm->max_instances,"SVM list of instances");
prob->y = (double *) rs_realloc(prob->y,sizeof(double)*svm->max_instances,"SVM number of instances");
}
prob->y[cur] = (mx_real_t) class_ind;
prob->x[cur]= (struct svm_node *) rs_malloc(sizeof(struct svm_node)*(svm->feature_dim+1),"SVM instance");
for (i=0,j=0;i<svm->feature_dim;i++) {
if (features[i]) {
prob->x[cur][j].index=i+1;
prob->x[cur][j++].value=features[i];
}
}
prob->x[cur][j].index=-1;
return svm;
}
int _asegment_fixed(char *seg_info, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
int i, frame_length, frame_shift;
int n_segments =0;
int *_length;
dsp_sample_t **_segments;
if (sscanf(seg_info,"%d:%d",&frame_length,&frame_shift) != 2) {
rs_error("Frame length and/or frame shift information in wrong format!");
return -1;
}
n_segments= (n_samples - frame_length) / frame_shift + 1;
_segments = (dsp_sample_t **) rs_malloc(n_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_malloc(n_segments*sizeof(int),"Segment lengths");
for (i=0;i<n_segments;i++) {
_segments[i] = (dsp_sample_t *) rs_malloc(frame_length * sizeof(dsp_sample_t),"signal segments");
_length[i]=frame_length;
if (!memcpy(_segments[i],signal+i*frame_shift,frame_length*sizeof(dsp_sample_t))) {
rs_warning("Signal was shorter than expected!");
return -1;
}
}
*signal_segment=_segments;
*length=_length;
return n_segments;
}
char *rs_line_read(FILE *fp, char comment_char)
{
static char *line = NULL;
char *cp;
int len, i;
/* evtl. Zeilenpuffer erzeugen ... */
if (line == NULL)
line = rs_malloc(_line_len * sizeof(char), "line buffer");
/* ... und solange noch Zeilen gelesen werden koennen ... */
while (fgets(line, _line_len, fp) != NULL) {
/* ... ggf. '\n' am Zeilenende loeschen ... */
while (line[(len = strlen(line)) - 1] != '\n') {
/* ... bei Pufferueberlauf ggf. erweitern ... */
rs_warning("line longer than %d characters read - expanding!",
_line_len);
/* ... falls ueberlange TEXT-Zeile ... */
for (i = 0; i < len; i++)
if (!(isprint(line[i]) || isspace(line[i])))
rs_error("non-printable character '0x%02x' encountered in excess text line!", line[i]);
_line_len += RS_LINE_LEN_DEFAULT;
line = rs_realloc(line, _line_len * sizeof(char),
"extended line buffer");
if (fgets(line + len, _line_len - len, fp) == NULL) {
len++;
break;
}
}
line[len - 1] = '\0';
/* ... ggf. Kommentare ueberspringen ... */
if (comment_char && line[0] == comment_char)
continue;
/* ... und am Zeilenende loeschen falls nicht "escaped" ... */
if (comment_char) {
cp = line + 1;
while (cp = strrchr(cp, comment_char)) {
if (cp[-1] != '\\') {
*cp = '\0';
break;
}
}
}
/* ... und Zeilen mit Inhalt zurueckgeben */
for (cp = line; *cp; cp++)
if (!isspace(*cp))
return(line);
}
/* ... sonst Dateiende signalisieren */
return(NULL);
}
naive_bayes_classifier_t *nB_fscan(naive_bayes_classifier_t *nB, char *filename, fx_select_t *sel) {
int class_ind, start, end, i;
FILE *fp = NULL, *feature_fp = NULL;
mx_real_t *features=NULL;
char *line=NULL, *token;
char *fname =NULL;
char *class_name = (char *) rs_malloc(STRING_LENGTH*sizeof(char),"String");
int full_feature_dim=sel?sel->n_features:nB->feature_dim;
if (!nB)
rs_error("classifier could not be initialised!");
fp = fopen(filename,"r");
if (fp == NULL) {
rs_error("Cannot open file %s!",filename);
}
else {
features = (mx_real_t *) rs_calloc(full_feature_dim, sizeof(mx_real_t), "feature vector");
while ((line= (char *) rs_line_read(fp,';'))) {
fname = (char *) strtok(line,"\t ");
feature_fp = fopen(fname, "r");
if (feature_fp == NULL) {
rs_warning("can't open '%s '!", fname);
while (getchar() != '\n');
continue;
}
line+= strlen(fname)+1;
if (feature_fp) {
for (token = (char *) strtok(line," "); token != NULL; token = (char *) strtok(NULL, " ")) {
if (sscanf(token,"%[^[]s",class_name) !=1 )
rs_error("wrong length information for file %s!",fname);
token += strlen(class_name);
if (sscanf(token,"[%d..%d]",&start,&end) !=2)
rs_error("wrong length information for file %s!",fname);
for (i=start;i<=end;i++) {
if (fread(features,sizeof(mx_real_t),full_feature_dim,feature_fp)!=full_feature_dim)
rs_perror("fread stopped after %d elements in file %s -- %d", i, fname, errno);
else {
if (sel)
if ( fx_select_apply(&features,sel,features)!= sel->n_features)
rs_error("Feature selection did not succeed!");
class_ind = cl_name2number(&(nB->mapping),class_name,nB->n_classes);
nB=nB_update_classifier(nB,class_ind,features);
}
}
}
fclose(feature_fp);
}
}
nB_finish_classifier(nB);
}
fclose(fp);
rs_free(class_name);
rs_free(features);
return nB;
}
rs_IO *rs_fopen(char *name, char *mode)
{
FILE *fp;
rs_IO *io;
int mode_read, mode_mapped;
void *buf;
int buf_size;
/* Lese-/Schreibmodus bestimmen ... */
if (strchr(mode, 'w') || strchr(mode, 'a'))
mode_read = 0;
else if (strchr(mode, 'r'))
mode_read = 1;
else rs_error("illegal mode '%s' for 'rs_fopen()'!", mode);
/* ... ggf. ge-"mapped" (nur lesend) ... */
if (strchr(mode, 'm')) {
if (mode_read)
mode_mapped = 1;
else {
mode_mapped = 0;
rs_warning("mapped file IO not supported for writing!");
}
}
else mode_mapped = 0;
/* ... Spezialnamen '-' umsetzen ... */
if (strcmp(name, "-") == 0) {
if (mode_mapped)
rs_error("mapped file IO not supported for stdin/out!");
fp = (mode_read) ? stdin : stdout;
}
else fp = fopen(name, (mode_read) ? "r" : "w");
if (!fp)
return(NULL);
if (!mode_mapped) {
io = rs_malloc(sizeof(rs_IO), "IO data");
io->type = rs_iotype_file;
io->base_size = RS_BINIO_BASE_SIZE_DEFAULT;
io->fp = fp;
}
else {
fseek(fp, 0, SEEK_END);
buf_size = ftell(fp);
rewind(fp);
buf = rs_malloc(buf_size, "mapped file buffer");
fread(buf, buf_size, 1, fp);
io = rs_mopen(buf, buf_size, "r");
}
return(io);
}
svm_classifier_t *svm_finish_classifier(svm_classifier_t *svm) {
int i, j, nr_fold=5, total_correct, best_correct=0, best_c=svm->param.C, best_g=svm->param.gamma;
const char *error_msg;
double *result = (double *) rs_malloc(sizeof(double)*svm->problem.l,"cross validation result");
rs_msg("Building SVM classifier...");
if (svm->finished)
rs_warning("SVM classifier is already trained!");
error_msg = svm_check_parameter(&(svm->problem),&(svm->param));
if(error_msg)
rs_error("%s",error_msg);
/* Skalierung */
_create_scaling(svm->problem,svm->feature_dim,&(svm->max),&(svm->min));
for (i=0;i<svm->problem.l;i++)
_scale_instance(&(svm->problem.x[i]),svm->feature_dim,svm->max,svm->min);
/* Cross-Validation, um C und G zu bestimmen bei RBF-Kernel */
if (svm->param.kernel_type == RBF) {
svm->param.probability = 0;
for (i=0;i<C_G_ITER;i++) {
total_correct=0;
svm->param.C=pow(2,C[i]);
svm->param.gamma=pow(2,G[i]);
svm_cross_validation(&(svm->problem),&(svm->param),nr_fold,result);
for(j=0;j<svm->problem.l;j++) {
if(result[j] == svm->problem.y[j])
++total_correct;
}
if (total_correct > best_correct) {
best_correct=total_correct;
best_c=C[i];
best_g=G[i];
}
rs_msg("C-G-Selektion-Iteration # %d: tried c=%g and g=%g => CV rate is %g; current best c=%g and g=%g with CV rate %g",i+1,pow(2,C[i]),pow(2,G[i]),total_correct*100.0/svm->problem.l,pow(2,best_c),pow(2,best_g),best_correct*100.0/svm->problem.l);
}
/* Training */
svm->param.C=pow(2,best_c);
svm->param.gamma=pow(2,best_g);
svm->param.probability = 1;
}
svm->model=svm_train(&(svm->problem),&(svm->param));
svm->finished=1;
// @begin_add_johannes
rs_free (result);
// @end_add_johannes
return svm;
}
naive_bayes_classifier_t *nB_finish_classifier(naive_bayes_classifier_t *nB) {
int i,j;
if (!nB->finished) {
for (j=0;j<nB->n_classes;j++) {
if (nB->n_instances[j] <1)
rs_warning("creating model for unseen class %s!",nB->mapping[j]);
for (i=0;i<nB->feature_dim;i++) {
if (nB->n_instances[j] <1) {
nB->means[j][i] = 0;
nB->std_dev[j][i] = 0;
}
else {
nB->means[j][i]/=(1.0*nB->n_instances[j]);
// @begin_change_johannes
//if (isnan(nB->means[j][i]))
if (_isnan(nB->means[j][i]))
// @end_change_johannes
nB->means[j][i]=0;
nB->std_dev[j][i]= sqrt(nB->std_dev[j][i]/(1.0*nB->n_instances[j]) - nB->means[j][i] * nB->means[j][i]);
// @begin_change_johannes
//if (isnan(nB->std_dev[j][i]))
if (_isnan(nB->std_dev[j][i]))
// @end_change_johannes
nB->std_dev[j][i]=0;
}
}
if (nB->n_instances[nB->n_classes] <1)
nB->class_probs[j] = 0;
else
nB->class_probs[j] = 1.0*nB->n_instances[j]/nB->n_instances[nB->n_classes];
}
nB->finished=1;
}
else
rs_warning("Trying to finish finished classifier!");
return nB;
}
int emo_afile_segment(char *file, asegmentation_method_t *method, asegmentation_type_t type, dsp_sample_t ***signal_segment, int **segment_length) {
int size=SEGMENT_LENGTH, n_samples=0, n_segments, samples_read;
FILE *fp;
dsp_sample_t *signal=NULL;
dsp_vad_t *Vad;
signal = (dsp_sample_t *) rs_malloc(sizeof(dsp_sample_t) * size, "Signal data");
if (!method)
method = (asegmentation_method_t *) rs_malloc(sizeof(asegmentation_method_t),"Audio segmentation method");
if (strcmp(file,"-")==0)
fp = stdin;
else
fp = fopen(file,"r");
if (!fp) {
rs_warning("Cannot open file %s!",file);
return -1;
}
while ((samples_read =fread(signal+n_samples,sizeof(dsp_sample_t),BLOCKSIZE,fp)) && samples_read >0) {
n_samples+=samples_read;
if (size <= n_samples) {
size +=SEGMENT_LENGTH;
signal = (dsp_sample_t *) rs_realloc(signal,sizeof(dsp_sample_t) * size, "Signal data");
}
if (samples_read != BLOCKSIZE)
break;
}
fclose(fp);
if (type == vad && !method->vad) {
Vad = dsp_vad_create(DSP_MK_VERSION(1,0),VAD_FRAME_LEN);
method->vad = Vad;
}
n_segments = emo_asegment(method,type,signal,n_samples,signal_segment,segment_length);
if (n_segments == -1)
rs_error("Aborting during procession of file %s!",file);
rs_free(signal);
return n_segments;
}
/**
* _vonMises_Iteration(result, lambda, A, startvec, threshold, maxiter, dim)
* eine komplette von Mises-Iteration auf der Matrix 'A' ['dim' x 'dim']
* ergibt den zum groessten Eigenwert 'lambda' gehoerenden Eigenvektor
* 'result' ['dim'] bei Vorgabe der Konvergenzschwelle 'threshold'
**/
static int _vonMises_Iteration(mx_vector_t *result, mx_real_t *lambda,
mx_matrix_t A, mx_vector_t startvec,
mx_real_t threshold, int maxiter, int dim)
{
int iter = 0, i;
mx_real_t dist, _dist;
mx_vector_t oldvec = mx_vector_create(dim);
for (i = 0; i < dim; i++)
oldvec[i] = startvec[i];
do {
dist = _dist = 0.00;
if (_vonMises_Step(result, lambda, A, oldvec, dim) <= 0) {
dist = MX_REAL_MAX;
break;
}
for (i = 0; i < dim; i++) {
_dist = fabs((*result)[i]) - fabs(oldvec[i]);
dist += _dist * _dist;
}
dist = sqrt(dist);
for (i = 0; i < dim; i++) {
oldvec[i] = (*result)[i];
}
if (dist < threshold)
break;
} while (iter++ < maxiter);
if (dist > threshold) {
rs_warning("Abort in vonMises-Iteration (%f)", dist);
mx_vector_destroy(oldvec);
return(0);
}
mx_vector_destroy(oldvec);
return(1);
}
int _asegment_vad(dsp_vad_t *vad, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
int va=0, i, out_sample;
int n_segments =0, last_va=0, samples=0;
int max_segments=MAX_SEGMENTS, segment_length = SEGMENT_LENGTH;
int delay_len=vad->sigbuf->length;
int *_length;
dsp_sample_t *voice;
dsp_sample_t **_segments;
int temp=0;
dsp_sample_t *_signal;
_signal = (dsp_sample_t *) rs_malloc(n_samples*sizeof(dsp_sample_t),"signal copy");
for (i=0;i<n_samples;i++)
_signal[i]=signal[i];
if (!vad) {
rs_warning("No voice activity detection info available!");
return -1;
}
voice = (dsp_sample_t *) rs_malloc(vad->frame_len * sizeof(dsp_sample_t),"Voice frame");
_segments = (dsp_sample_t **) rs_malloc(max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_malloc(max_segments * sizeof(int),"Segment lengths");
for (i=0;i<=n_samples-VAD_FRAME_SHIFT || va >=0;i+=VAD_FRAME_SHIFT) {
if (i > n_samples-VAD_FRAME_SHIFT) {
va = dsp_vad_calc(voice,vad,NULL);
}
else {
if (i>n_samples-vad->frame_len) {
int j, new_len=i+vad->frame_len;
_signal= (dsp_sample_t *) rs_realloc(_signal,new_len*sizeof(dsp_sample_t),"Signal buffer");
for (j=n_samples;j<new_len;j++)
_signal[j]=0;
}
va = dsp_vad_calc(voice, vad, _signal+i);
}
if (va >=0 && ((va && !last_va) || (!va && last_va)) && samples >0) {
out_sample=i-(delay_len-vad->sigbuf->need_elems)*160;
if (out_sample>=n_samples)
out_sample=n_samples-1;
if (va) {
if (n_segments >= max_segments) {
max_segments += MAX_SEGMENTS;
_segments = (dsp_sample_t **) rs_realloc(_segments,max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_realloc(_length,max_segments * sizeof(int),"Segment lengths");
}
_segments[n_segments] = (dsp_sample_t *) rs_malloc(segment_length * sizeof(dsp_sample_t),"Signal segment");
if (output)
fprintf(stderr,"[%d..",out_sample);
}
else {
if (output)
fprintf(stderr,"%d] ",out_sample-1);
_length[n_segments]=last_va*VAD_FRAME_SHIFT;
n_segments++;
segment_length=SEGMENT_LENGTH;
}
}
if (!va)
last_va=0;
if (va==1 && samples>0) {
if ((last_va+1)*VAD_FRAME_SHIFT > segment_length) {
segment_length += SEGMENT_LENGTH;
_segments[n_segments] = (dsp_sample_t *) rs_realloc(_segments[n_segments],segment_length * sizeof(dsp_sample_t),"Signal segment");
}
samples+=VAD_FRAME_SHIFT;
memcpy(_segments[n_segments]+last_va*VAD_FRAME_SHIFT,voice,VAD_FRAME_SHIFT*sizeof(dsp_sample_t));
last_va++;
}
temp=0;
while (va==0) {
temp++;
samples+=VAD_FRAME_SHIFT;
va = dsp_vad_calc(voice, vad, NULL);
}
}
if (last_va && samples >0) {
out_sample=i-(delay_len-vad->sigbuf->need_elems)*160;
if (out_sample>=n_samples)
out_sample=n_samples;
if (output)
fprintf(stderr,"%d] ",out_sample-1);
_length[n_segments]=last_va*VAD_FRAME_SHIFT;
n_segments++;
}
if (output)
fprintf(stderr,";\n");
rs_free(voice);
rs_free(_signal);
*signal_segment=_segments;
*length=_length;
return n_segments;
}
/*
* Check/fix OS header fields and data.
*
* The OS header is much simpler than an application header, and its
* correctness is not as crucial to validation. The most important
* parts of the OS header are the key ID and (for newer calculators)
* the hardware compatibility level. There is no date stamp required.
* The page count is not required, and if present, is used only to
* display the transfer percentage (when using the 84+ boot code.)
*
* TI only sets the OS and program image size fields in their TI-73 OS
* headers. (Bizarrely, they are set in the true OS header, but not
* in the fake OS header that is transferred to page 1A. Furthermore,
* the OS size field is incorrect.) In any case, these fields appear
* to be ignored by all versions of the boot code.
*/
int rs_repair_ti8x_os(RSProgram* os, /* OS */
unsigned int flags) /* flags */
{
unsigned long hdrstart, hdrsize, fieldhead, fieldstart,
fieldsize, ossize;
unsigned char* hdr;
int i;
/* Pad the OS to a multiple of 16384. (While strictly speaking we
could get away with only padding each page to a multiple of 256,
such "partial OSes" are not supported by most linking
software.) */
rs_program_set_length(os, ((os->length + 0x3fff) & ~0x3fff));
/* If no OS header was provided in the input, try to get a header
from page 1A instead */
if (os->header_length < 6
|| os->header[0] != 0x80
|| os->header[1] != 0x0f) {
for (i = 0; i < os->npagenums; i++) {
if (os->pagenums[i] == 0x1a) {
rs_free(os->header);
if (!(os->header = rs_malloc(256)))
return RS_ERR_OUT_OF_MEMORY;
memcpy(os->header, os->data + ((unsigned long) i << 14), 256);
os->header_length = 256;
break;
}
}
}
/* Clear old header/signature (not done on the TI-73 because
official TI-73 OSes contain a fake header; I don't recommend
doing this for third-party OSes) */
if (os->calctype != RS_CALC_TI73)
for (i = 0; i < os->npagenums; i++)
if (os->pagenums[i] == 0x1a)
memset(os->data + ((unsigned long) i << 14), 0xff, 512);
/* Fix header size. OS headers must always begin with an 800x field
and end with an 807x field (TI always uses 800F and 807F, as for
apps; I'm not sure whether it's required.) */
if (os->header_length < 6
|| os->header[0] != 0x80
|| (os->header[1] & 0xf0) != 0) {
rs_error(NULL, os, "no OS header found");
return RS_ERR_MISSING_HEADER;
}
rs_get_field_size(os->header, &hdrstart, NULL);
hdr = os->header + hdrstart;
hdrsize = os->header_length - hdrstart;
if (rs_find_app_field(0x8070, hdr, hdrsize,
&fieldhead, &fieldstart, &fieldsize)) {
rs_error(NULL, os, "OS header has no program image field");
return RS_ERR_MISSING_PROGRAM_IMAGE;
}
hdrsize = fieldstart;
os->header_length = hdrstart + hdrsize;
if ((os->header_length % 64) == 55) {
if (flags & RS_IGNORE_ALL_WARNINGS) {
rs_warning(NULL, os, "OS header has length 55 mod 64");
rs_warning(NULL, os, "(this will fail to validate on TI-83+ BE)");
}
else {
rs_error(NULL, os, "OS header has length 55 mod 64");
rs_error(NULL, os, "(this will fail to validate on TI-83+ BE)");
return RS_ERR_INVALID_PROGRAM_SIZE;
}
}
/* Fix OS / OS image sizes if requested */
if (flags & RS_FIX_OS_SIZE) {
ossize = os->length + hdrsize;
if (rs_set_field_size(os->header, ossize)) {
rs_error(NULL, os, "cannot set OS length");
return RS_ERR_FIELD_TOO_SMALL;
}
if (rs_set_field_size(hdr + fieldhead, os->length)) {
rs_error(NULL, os, "cannot set OS image length");
return RS_ERR_FIELD_TOO_SMALL;
}
}
/* Check for key ID */
if (rs_find_app_field(0x8010, hdr, hdrsize, NULL, NULL, NULL)) {
if (flags & RS_IGNORE_ALL_WARNINGS)
rs_warning(NULL, os, "OS header has no key ID field");
else {
rs_error(NULL, os, "OS header has no key ID field");
return RS_ERR_MISSING_KEY_ID;
}
}
/* Check/fix page count */
if (rs_find_app_field(0x8080, hdr, hdrsize,
NULL, &fieldstart, &fieldsize)) {
if (os->length != 14 * 0x4000L) {
rs_warning(NULL, os, "OS header has no page count field");
}
}
else if (fieldsize != 1) {
rs_warning(NULL, os, "OS header has an invalid page count field");
}
else if (flags & RS_FIX_PAGE_COUNT) {
hdr[fieldstart] = os->length >> 14;
}
/**
* mx_matrix_eigenv_n(_ew, _ev, _a, dim, n)
* berechnet die ersten 'n' Eigenwrte bzw. -vektoren von '_a'
* und gibt diese in '_ew' bzw. '_ev' zurueck
* gibt die (auf 1 normierten) Eigenvektoren spaltenweise in 'ev'
* zurueck, dabei Sortierung nach Eigenwerten
**/
int mx_matrix_eigenv_n(mx_real_t **_ew, mx_matrix_t *_ev, mx_matrix_t _a,
int dim, int n)
{
mx_real_t *ew;
mx_matrix_t a, ev, __a, calcW;
mx_vector_t startvec = mx_vector_create(dim);
int i, j;
int maxiter = MAXITER;
mx_real_t threshold = VONMISES_THRESH;
int n_ew = n;
ew_sort_t *ew_sort = NULL;
if (n_ew > dim) {
rs_warning("# requested eigenvects (%d) larger than dim (%d), "
"bounding to %d",
n_ew, dim, dim);
n_ew = dim;
}
/* ggf. Ergebnisvektor erzeugen */
if(!*_ew)
*_ew = mx_vector_create(n_ew);
ew = *_ew;
/* Rechenmatrix erzeugen */
calcW = mx_matrix_create(dim, dim);
a = _a;
__a = mx_matrix_create(dim, dim);
startvec[0] = 1;
for (j = 1; j < dim; j++)
startvec[j] = j;
for (i = 0; i < n_ew; i++) {
/* ... i-ter Eigenvektor ... */
if(!_vonMises_Iteration(&(calcW[i]),
&(ew[i]),
a,
startvec,
threshold,
maxiter,
dim))
break;
/* ... Originalmatrix bzgl. i-tem Eigen{wert,vektor}
deflatieren ... */
_matrix_deflate(&__a,
a,
calcW[i],
ew[i],
dim);
a = __a;
}
if (i < n_ew) {
rs_warning("vonMises-Iteration aborted after %d eigenvals", i);
n_ew = i;
}
/* ... cleanup ... */
mx_matrix_destroy(__a, dim);
mx_vector_destroy(startvec);
/* ... Eigenvektoren normieren ... */
for (i = 0; i < n_ew; i++)
mx_vector_norm(&(calcW[i]), calcW[i], dim);
/* ... spaltenweises return! ... */
a = mx_matrix_dup(calcW, dim, dim);
mx_matrix_transp(&calcW, a, dim, dim);
/* ... sortieren ... */
ew_sort = rs_malloc(dim*sizeof(ew_sort_t), "ew_sort");
for(i = 0; i < n_ew; i++) {
ew_sort[i].val = ew[i];
ew_sort[i].org_pos = i;
}
qsort(ew_sort, n_ew, sizeof(ew_sort_t), _ew_sort_f);
mx_matrix_destroy(a, dim);
a = mx_matrix_dup(calcW, dim, dim);
for (i = 0; i < dim; i++)
for(j = 0; j < n_ew; j++)
calcW[i][j] = a[i][ew_sort[j].org_pos];
for(i = 0; i < n_ew; i++)
ew[i] = ew_sort[i].val;
mx_matrix_destroy(a, dim);
free(ew_sort);
/* ggf. Ergebnismatrix erzeugen */
if(!*_ev)
*_ev = mx_matrix_create(dim, n_ew);
ev = *_ev;
for (i = 0; i < dim; i++)
for (j = 0; j < n_ew; j++)
ev[i][j] = calcW[i][j];
mx_matrix_destroy(calcW, dim);
return(n_ew);
}
/**
* mx_matrix_eigenv(ew, ev, _a, dim)
* berechnet Eigenwerte 'ew' und Eigenvektoren 'ev' der 'dim' dimensionalen
* matrix '_a' (Jacoby-Rot)
* gibt die (auf 1 normierten) Eigenvektoren spaltenweise in 'ev'
zurueck, dabei Sortierung nach Eigenwerten
**/
int mx_matrix_eigenv(mx_real_t **_ew, mx_matrix_t *_ev, mx_matrix_t _a, int dim)
{
int r,c,p,q,i,j;
mx_real_t phi, *ew;
mx_matrix_t a, ev;
ew_sort_t *ew_sort = NULL;
/* ggf. Ergebnismatrix erzeugen */
if(!*_ev)
*_ev = mx_matrix_create(dim, dim);
ev = *_ev;
/* ggf. Ergebnisvektor erzeugen */
if(!*_ew)
*_ew = mx_vector_create(dim);
ew = *_ew;
a = mx_matrix_dup(_a, dim, dim);
__mfill(ev,dim,r,c,(r == c) ? 1 : 0);
for (p=1; p<dim-1; p++)
for (q=p+1; q<dim; q++) {
if(a[p-1][p] == 0) {
phi = (a[p-1][q] < 0) ?
M_PI_2 : ((a[p-1][q] == 0) ?
0 : -M_PI_2);
rs_warning("mx_matrix_eigenw(): zero value in "
"Jacobi-Rot, bounding phi to "
"default! (%f/%f/%f)\n",
a[p-1][p],
a[p-1][q],
phi);
} else
phi=atan(-a[p-1][q]/a[p-1][p]);
_matrix_mrot(a,dim,p,q,phi);
_matrix_mrotr(ev,dim,p,q,phi);
}
while (_matrix_pivot(a,dim,&p,&q) > LOCAL_EPSILON) {
/* fprintf(stderr, "pivot: %d / %d\n", p ,q); */
/* emergency break; atan is defined in [-Pi/2...Pi/2]
set phi manually */
if(a[q][q] == a[p][p]) {
phi = (a[p][q] < 0) ?
-M_PI_4 : ((a[p][q] == 0) ?
0 : M_PI_4);
rs_warning("mx_matrix_eigenw(): zero value in "
"Jacobi-Rot, bounding phi to "
"default! (%f/%f/%f/%f)\n",
a[p][q],
a[q][q],
a[p][p],
phi);
} else
/* see Numerical Recipes 11.1.8 and cot->tan */
phi=0.5*atan(2.0*a[p][q]/(a[q][q]-a[p][p]));
_matrix_mrot(a,dim,p,q,phi);
_matrix_mrotr(ev,dim,p,q,phi);
}
for(i=0;i<dim;i++)
ew[i] = (fabs(a[i][i]) < LOCAL_EPSILON) ? 0.00 : (a[i][i]);
/* sort ew/ev */
ew_sort = rs_malloc(dim*sizeof(ew_sort_t), "ew_sort");
for(i=0;i<dim;i++) {
ew_sort[i].val = ew[i];
ew_sort[i].org_pos = i;
}
qsort(ew_sort, dim, sizeof(ew_sort_t), _ew_sort_f);
mx_matrix_destroy(a, dim);
a = mx_matrix_dup(ev, dim, dim);
for(i=0;i<dim;i++)
for(j=0;j<dim;j++)
ev[i][j] = a[i][ew_sort[j].org_pos];
for(i=0;i<dim;i++)
ew[i] = ew_sort[i].val;
mx_matrix_destroy(a, dim);
free(ew_sort);
return(dim);
}
int _asegment_info(char *seg_info, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
char delim;
int stat=0, frame_length, start, end, i;
int last=0, n_segments=0;
int max_segments=MAX_SEGMENTS;
int *_length;
dsp_sample_t **_segments;
_segments = (dsp_sample_t **) rs_malloc(max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_malloc(max_segments * sizeof(int),"Segment lengths");
if ((seg_info = strchr(seg_info,'[')))
seg_info++;
while (seg_info && (stat = sscanf(seg_info, "%d..%d%c", &start,&end,&delim)) == 3) {
if (end +1 > n_samples) {
rs_warning("Wrong segmentation info: Trying to read %d samples from an audio signal that is only %d samples long!",end,n_samples);
return -1;
}
if (n_segments >= max_segments) {
max_segments+=MAX_SEGMENTS;
_segments = (dsp_sample_t**) rs_realloc(_segments,max_segments*sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_realloc(_length,max_segments*sizeof(int),"Segment lengths");
}
frame_length = end-start+1;
if (last) {
_segments[n_segments] = (dsp_sample_t *) rs_realloc(_segments[n_segments],(last+frame_length)*sizeof(dsp_sample_t),"signal segments");
_length[n_segments]+=frame_length;
}
else {
_segments[n_segments] = (dsp_sample_t *) rs_malloc(frame_length *sizeof(dsp_sample_t),"signal segments");
_length[n_segments]=frame_length;
}
memcpy(_segments[n_segments]+last,signal+start,frame_length*sizeof(dsp_sample_t));
switch (delim) {
case '-':
last+=frame_length;
if ((seg_info = strchr(seg_info,'-')))
seg_info++;
break;
case ']':
last=0;
n_segments++;
if ((seg_info = strchr(seg_info,'[')))
seg_info++;
break;
default:
rs_warning("Problem with segmentation information: wrong delimiter '%c'!",delim);
rs_free(_length);
for (i=0;i<n_segments;i++)
rs_free(_segments[i]);
rs_free(_segments);
return -1;
}
}
if (stat !=3) {
rs_warning("Problem with segmentation information: %s!",seg_info);
return -1;
}
*signal_segment=_segments;
*length=_length;
return n_segments;
}
int _fextract_calc(fextract_t *fex, mx_real_t *features, dsp_sample_t *signal, char *pfile) {
mx_real_t *pitch=NULL, *hnr=NULL;
mx_real_t **_mfcc_series, **_energy_series;
mx_real_t overall_max=0, overall_max_ind=0;
int nframes=0, i, j, n_voiced_frames, max;
int last_max=0, last_min=0, ser=0, max_sum=0, en_mean=0, fcount=0;
fextract_series_t * serie=NULL;
if (fex->frame_len==0) {
rs_warning("Cannot compute features for segment of size 0!");
return -1;
}
fex->n_features=V1_N_FEATURES;
_mfcc_series= (mx_real_t **) rs_malloc(MFCC_FEATURES * sizeof(mx_real_t *), "mfcc feature series");
for (i=0;i<MFCC_FEATURES;i++)
_mfcc_series[i]= (mx_real_t *) rs_malloc(MAX_FRAMES * sizeof(mx_real_t), "mfcc features");
_energy_series= (mx_real_t **) rs_malloc(ENERGY_FEATURES * sizeof(mx_real_t *), "energy feature series");
for (i=0;i<3;i++)
_energy_series[i]= (mx_real_t *) rs_malloc(MAX_FRAMES * sizeof(mx_real_t), "energy features");
if (pfile) {
FILE *pfile_fp= fopen(pfile,"r");
if (!pfile_fp)
rs_warning("pitch file %s not found!",pfile);
/* read external pitch values */
pitch = (mx_real_t *) rs_malloc(MAX_FRAMES * sizeof(mx_real_t),"external pitch values");
j=MAX_FRAMES;
i=0;
while (fscanf(pfile_fp,"%g",&pitch[i])==1) {
if (j == i+1) {
j+=MAX_FRAMES;
pitch = (mx_real_t *) rs_realloc(pitch,j*sizeof(mx_real_t),"external pitch values");
}
i++;
}
nframes=i;
fclose(pfile_fp);
}
else {
pitch= pitch_calc (fex->pitch,signal,fex->frame_len);
nframes=fex->pitch->nframes;
}
if (!pitch) {
for (;fcount<STATS*9+7;fcount++)
features[fcount]=-1.0;
n_voiced_frames=-1.0;
}
else {
const int series_size=9;
// @begin_change_johannes
//fextract_series_t *serien[series_size];
fextract_series_t *serien[9];
// @end_change_johannes
// printRawXML(pitch,nframes,"pitch");
pitch_frame_candidates_destroy(fex->pitch);
for (i=0;i<series_size;i++)
serien[i]=series_create(MAX_SERIES);
if (pitch[0]!=0)
series_add(serien[0],pitch[0]);
for (i=1;i<nframes-1;i++) {
if (pitch[i]!=0)
series_add(serien[0],pitch[i]);
if (pitch[i-1]<pitch[i] && pitch[i]>pitch[i+1]) {
series_add(serien[1],pitch[i]);
if (pitch[i] > overall_max) {
overall_max=pitch[i];
overall_max_ind=i;
}
series_add(serien[2],i-last_min);
series_add(serien[3],pitch[i]-pitch[last_min]);
series_add(serien[4],(pitch[i]-pitch[last_min])/(i-last_min));
last_max=i;
}
else
if (pitch[i-1]>pitch[i] && pitch[i]<pitch[i+1]) {
series_add(serien[5],pitch[i]);
series_add(serien[6],i-last_max);
series_add(serien[7],pitch[i]-pitch[last_max]);
series_add(serien[8],(pitch[i]-pitch[last_max])/(i-last_max));
last_min=i;
}
}
overall_max_ind = 1.0 * (overall_max_ind+1) / nframes;
if (nframes >1 && pitch[nframes-1]!=0)
series_add(serien[0],pitch[nframes-1]);
for (i=0; i<series_size; i++) {
getStatistics(features+fcount,serien[i]->series,serien[i]->nSeries); //pitch statistics features
fcount+=STATS;
}
// normierter Mittelwert, normierter Median, normiertes 1. Quartil, normiertes 3. Quartil
if (features[1]-features[2]) {
features[fcount++]=(features[0]-features[2])/(features[1]-features[2]);
features[fcount++]=(features[5]-features[2])/(features[1]-features[2]);
features[fcount++]=(features[6]-features[2])/(features[1]-features[2]);
features[fcount++]=(features[7]-features[2])/(features[1]-features[2]);
}
else {
features[fcount++]=0;
features[fcount++]=0;
features[fcount++]=0;
features[fcount++]=0;
}
features[fcount++]=1.0 * serien[1]->nSeries/nframes; // Anzahl Maxima pro Frames pro Segment
features[fcount++]=1.0 * serien[5]->nSeries/nframes; // Anzahl Minima pro Frames pro Segment
features[fcount++]=overall_max_ind; // Position des Maximums
n_voiced_frames=serien[0]->nSeries;
for (i=0;i<series_size;i++)
series_destroy(serien[i]);
}
getEnergy_and_MFCC(fex->mfcc, signal, fex->frame_len, &_energy_series, &_mfcc_series, &ser);
// ser=0;
if (ser) {
const int series_size = 8;
// @begin_change_johannes
//fextract_series_t *serien[series_size];
fextract_series_t *serien[8];
// @end_change_johannes
for (i=0;i<series_size;i++)
serien[i]=series_create(MAX_SERIES);
fcount+=getMFCCFeatures(features+fcount, _mfcc_series,ser);
/* Energie-Merkmale: */
last_max=last_min=0;
for (i=1;i<ser-1;i++) {
if (_energy_series[0][i-1]<_energy_series[0][i] && _energy_series[0][i]>_energy_series[0][i+1]) {
series_add(serien[0], _energy_series[0][i]); //Maxima
max_sum += _energy_series[0][i];
series_add(serien[1], i-last_min); // Laenge der Maxima
series_add(serien[2], _energy_series[0][i]-_energy_series[0][last_min]); // Groesse der Maxima
series_add(serien[3], (_energy_series[0][i]-_energy_series[0][last_min])/(i-last_min)); // Steigung der Maxima
last_max=i;
}
else
if (_energy_series[0][i-1]>_energy_series[0][i] && _energy_series[0][i]<_energy_series[0][i+1]) {
series_add(serien[4], _energy_series[0][i]); //Maxima
series_add(serien[5], i-last_max); // Laenge der Maxima
series_add(serien[6], _energy_series[0][i]-_energy_series[0][last_max]); // Groesse der Maxima
series_add(serien[7], (_energy_series[0][i]-_energy_series[0][last_min])/(i-last_max)); // Steigung der Maxima
last_max=i;
}
}
getStatistics(features+fcount,_energy_series[0],ser); // energy statistics
en_mean=features[fcount+1];
fcount+=STATS;
for (i=0;i<series_size;i++) {
getStatistics(features+fcount,serien[i]->series,serien[i]->nSeries);
fcount+=STATS;
}
max=serien[0]->nSeries;
for (j=1;j<3;j++) {
series_reset(serien[0]); series_reset(serien[1]);
for (i=1;i<ser-1;i++) {
if (_energy_series[j][i-1]<_energy_series[j][i] && _energy_series[j][i]>_energy_series[j][i+1]) {
series_add(serien[0], _energy_series[j][i]);
}
else
if (_energy_series[j][i-1]>_energy_series[j][i] && _energy_series[j][i]<_energy_series[j][i+1]) {
series_add(serien[1], _energy_series[j][i]);
}
}
getStatistics(features+fcount,_energy_series[j],ser); // energy delta statistics
fcount+=STATS;
getStatistics(features+fcount,serien[0]->series,serien[0]->nSeries);
fcount+=STATS;
getStatistics(features+fcount,serien[1]->series,serien[1]->nSeries);
fcount+=STATS;
}
features[fcount++]= max? (1.0 * max_sum/max) - en_mean:0; // Mittelwert der Maxima minus globaler Mittelwert
features[fcount++]= (1.0 * max)/ser; // Anzahl Maxima pro Frames pro Segment
for (i=0;i<series_size;i++)
series_destroy(serien[i]);
}
else {
for (;fcount < 141*STATS+9;fcount++)
features[fcount]=-1;
}
/* Voiced/Unvoiced-Merkmal: */
features[fcount++]=nframes ? (1.0 * n_voiced_frames)/nframes : -1; // Anzahl stimmloser Frames pro Frames pro Segment
/* Spectral Center of gravity-Merkmale: */
serie = getOnlyCoG(signal,fex->frame_len);
if (serie) {
getStatistics(features+fcount,serie->series,serie->nSeries);
series_destroy(serie);
fcount+=STATS;
}
else
for (;fcount< 142*STATS+10;fcount++)
features[fcount]=-1;
/* Dauer-Merkmal: */
features[fcount++]=fex->frame_len;
/* Harmonics-to-Noise-Ratio-Merkmale: */
hnr=hnr_calc(fex->hnr,signal,fex->frame_len);
nframes=fex->hnr->nframes;
if (!hnr)
for (;fcount<145*STATS+11;fcount++)
features[fcount]=-1.0;
else {
const int series_size=3;
// @begin_change_johannes
//fextract_series_t *serien[series_size];
fextract_series_t *serien[3];
// @end_change_johannes
pitch_frame_candidates_destroy(fex->hnr);
for (i=0;i<series_size;i++)
serien[i]=series_create(MAX_SERIES);
if (hnr[0]!=0)
series_add(serien[0],hnr[0]);
for (i=1;i<nframes-1;i++) {
if (hnr[i]!=-200) {
series_add(serien[0],hnr[i]);
if ((hnr[i-1]!=-200) && (hnr[i+1]!=200)) { // stimmlose Bereiche nicht beruecksichtigen
if (hnr[i-1]<hnr[i] && hnr[i]>hnr[i+1])
series_add(serien[1],hnr[i]);
else
if (hnr[i-1]>hnr[i] && hnr[i]<hnr[i+1])
series_add(serien[2],hnr[i]);
}
}
}
if (nframes >1 && hnr[nframes-1]!=0)
series_add(serien[0],hnr[nframes-1]);
for (i=0; i<series_size; i++) {
getStatistics(features+fcount,serien[i]->series,serien[i]->nSeries); //hnr statistics features
fcount+=STATS;
}
}
/* Aufraeumen... */
for (i=0;i<MFCC_FEATURES;i++)
if (_mfcc_series[i])
rs_free(_mfcc_series[i]);
if (_mfcc_series)
rs_free(_mfcc_series);
for (i=0;i<ENERGY_FEATURES;i++)
if (_energy_series[i])
rs_free(_energy_series[i]);
if (_energy_series)
rs_free(_energy_series);
if (pitch)
rs_free(pitch);
if (hnr)
rs_free(hnr);
/* for (;fcount<V1_N_FEATURES;fcount++) */
/* features[fcount]=0.0; */
if (fcount != V1_N_FEATURES)
rs_error("number of features is not correct (%d expected, %d calculated)!",V1_N_FEATURES,fcount);
return V1_N_FEATURES;
}
int Criterion(double *value, int* indices, int dim, int n_classes, fx_select_t *sel, char **file_names, int n_splits, cType classifier, char *cparam) {
int i, n_feat=-1, j, n_instances=0,n;
int *evaluation=NULL, *_eval=NULL;
fx_select_t *sel_subset = fx_select_create(sel->n_features);
classifier_t *cl = NULL;
double val=0;
if (ev_verbose) {
fprintf(stderr,"Now evaluating subset ");
printFset(indices,dim);
}
j=0;
for (i=0; i<sel_subset->n_features && j<dim;i++) {
if (sel->selected[i]==1) {
n_feat++;
if (indices[j]==n_feat) {
sel_subset->selected[i]=1;
j++;
}
}
}
if (j!=dim) {
rs_warning("Problem with feature subset selection!");
return -1;
}
sel_subset->n_selected=dim;
for (i=0;i<n_splits*2;i+=2) {
char *tmpparam=NULL;
if (cparam) {
tmpparam=(char *) rs_malloc((strlen(cparam)+1)*sizeof(char),"classifier param");
strcpy(tmpparam,cparam);
}
cl=cl_new_classifier(classifier,n_classes,sel_subset->n_selected,tmpparam);
cl=cl_fscan(cl,classifier,file_names[i],sel_subset);
n=cl_classify_file(cl,classifier,file_names[i+1],sel_subset,&_eval);
n_instances+=n;
if (n_instances-n==0)
evaluation=rs_malloc(n_instances*2*sizeof(int),"evaluation data");
else
evaluation=rs_realloc(evaluation,n_instances*2*sizeof(int),"evaluation data");
for (j=0;j<n*2;j++)
evaluation[j+(n_instances-n)*2]=_eval[j];
rs_free(_eval);
if (tmpparam)
rs_free(tmpparam);
cl_destroy(cl,classifier);
}
if (evaluation)
val=cl_eval(evaluation,n_classes,n_instances);
rs_free(evaluation);
fx_select_destroy(sel_subset);
if (ev_verbose)
fprintf(stderr,"... has evaluation %g\n",val);
*value=val;
return 0;
}
/*
Gibt die Segmente einer Datei aus, entweder in Dateien oder auf die
Standardausgabe
Argumente:
file: Name der Audiodatei, die segmentiert werden soll
outdir: Verzeichnis, in dem die Segmente gespeichert werden sollen
n_segments: Anzahl der Segmente der Audiodatei
signal_segment: Array, der die Signaldaten der Segmente enthaelt
segment_length: Array, der die Laenge der Segmente enthaelt
Rueckgabe:
0: Kein Fehler
-1: Fehler
(besser: Anzahl der geschriebenen Segmente...)
*/
int emo_afile_output(char *file, char *outdir, int n_segments, dsp_sample_t **signal_segment, int *segment_length){
int i=0, n_segments_out=0;
char outfile[STRING_LENGTH], *name;
FILE *out_fp;
if (outdir && strcmp(outdir,"-")==0) {
for (i=0;i<n_segments;i++) {
if (output)
fprintf(stderr,"%d\n",segment_length[i]);
fwrite(signal_segment[i],sizeof(dsp_sample_t),segment_length[i],stdout);
n_segments_out++;
}
}
else {
if (strcmp(file,"-")!=0) {
int len;
i=strlen(file)-1;
while (i>=0 && file[i] != '.' && file[i] != '/')
i--;
if (i<0 || file[i] == '/')
i=strlen(file);
len=strrchr(file,'/')?strlen(strrchr(file,'/')):0;
len = i+1-(strrchr(file,'/')?strlen(file)-strlen(strrchr(file,'/'))+1:0);
name = (char *) rs_malloc(len*sizeof(char),"Target file name");
strncpy(name,strrchr(file,'/')?strrchr(file,'/')+1:file,len-1);
name[len-1]='\0';
while (i>=0 && file[i] != '/')
i--;
}
else
name = "";
if (!outdir) {
if (strcmp(file,"-")!=0) {
i=strlen(file);
outdir = (char *) rs_malloc((i+1)*sizeof(char),"Target directory name");
outdir[i]='\0';
//
while (i>-1) {
outdir[i]=file[i];
i--;
}
}
else
outdir="";
}
else
if (outdir[strlen(outdir)-1] != '/') {
int len=strlen(outdir);
char *temp= rs_malloc((len+2)*sizeof(char),"Audio output directory name");
for (i=0;i<len;i++)
temp[i]=outdir[i];
temp[len]='/';
temp[len+1]='\0';
outdir=temp;
}
for (i=0;i<n_segments;i++) {
if (i<9)
sprintf(outfile,"%s%s_0%d.pcm",outdir,name,i+1);
else
sprintf(outfile,"%s%s_%d.pcm",outdir,name,i+1);
out_fp = fopen(outfile,"w");
if (!out_fp) {
rs_warning("Cannot write signal segment %d to file %s!",i,outfile);
break;
}
if (output)
fprintf(stderr,"\tSegment %d has length %d\n",i+1,segment_length[i]);
if (fwrite(signal_segment[i],sizeof(dsp_sample_t),segment_length[i],out_fp) == segment_length[i])
n_segments_out++;
fclose(out_fp);
}
rs_free(name);
}
return n_segments_out;
}
/*
Segmentiert eine Liste von Dateien
Argumente:
filelist: Name der Datei, die die Dateien enthaelt, die segmentiert
werden sollen
method: dsp_vad_t* fuer voice activity detection,
int fuer frames mit fester Laenge
char* fuer Segmentierungsinfo
type: vad, fixed oder info
Rueckgabewert:
Anzahl der Signalabschnitte in signal_segment;
-1, falls ein Fehler aufgetreten ist
*/
int emo_afilelist_segment(char *filelist, asegmentation_method_t *method, asegmentation_type_t type,int audio_output){
FILE *fp;
int n_segments=0;
int *segment_length=NULL;
dsp_sample_t **signal_segment=NULL;
fp = fopen(filelist,"r");
if (!fp) {
rs_warning("Cannot open input file: %s!",filelist);
return -1;
}
switch (type) {
case vad: {
int stat=0, x=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH];
if (!method)
method = (asegmentation_method_t *) rs_malloc(sizeof(asegmentation_method_t),"Audio segmentation method");
if (!method->vad)
method->vad = dsp_vad_create(DSP_MK_VERSION(1,0),VAD_FRAME_LEN);
//rest der zeile ueberspringen
while(fscanf(fp,"%s\t%s",filename,outdir)==2 && stat >=0) {
if (output)
fprintf(stderr,"%s\t%s\t",filename,outdir);
stat=emo_afile_segment(filename,method,vad,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output && stat != emo_afile_output(filename,outdir,stat,signal_segment,segment_length)) {
rs_warning("Output of segments of file %s failed!",filename);
return -1;
}
if (segment_length)
rs_free(segment_length);
if (signal_segment) {
int i;
for (i=0;i<stat;i++)
if (signal_segment[i])
rs_free(signal_segment[i]);
rs_free(signal_segment);
}
n_segments+=stat;
while (x != '\n' && x != EOF)
x=fgetc(fp);
x=0;
}
break;
}
case fixed: {
int stat=0, x=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH];
if (!method->segmentation_info) {
rs_warning("No segment length or shift info available!");
return -1;
}
while(fscanf(fp,"%s\t%s",filename,outdir)==2 && stat >=0) {
stat=emo_afile_segment(filename,method,fixed,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output) {
stat = emo_afile_output(filename,outdir,stat,signal_segment,segment_length);
if (stat == -1){
rs_warning("Output of segments of file %s failed!",filename);
}
return -1;
}
n_segments+=stat;
while (x != '\n' && x != EOF)
x=fgetc(fp);
x=0;
}
break;
}
case info: {
int stat=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH], seg_info[10*STRING_LENGTH];
if (!method->segmentation_info) {
rs_warning("No segment length or shift info available!");
return -1;
}
while(fscanf(fp,"%s\t%s\t%[^\n]s",filename,outdir,seg_info)==3 && stat >=0) {
method->segmentation_info=seg_info;
stat=emo_afile_segment(filename,method,info,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output && stat != emo_afile_output(filename,outdir,stat,signal_segment,segment_length)) {
rs_warning("Output of segments of file %s failed!",filename);
return -1;
}
n_segments+=stat;
}
break;
}
default: rs_warning("Unknown segmentation type: %d",type);
return -1;
}
fclose(fp);
return n_segments;
}
/*
* _dsp_mfcc_1_3_configure(fex, params)
*/
int _dsp_mfcc_1_3_configure(dsp_fextract_t *fex, char *params)
{
dsp_mfcc_t *cfg = fex->config;
struct channel_t *ch = NULL;
int i, pos, status;
char *cp;
mx_real_t *param;
/* Abtastrate etc. ... */
fex->samplerate = V1_1_SAMPLERATE;
fex->n_channels = V1_1_N_CHANNELS;
fex->frame_len = V1_1_FRAME_LEN;
fex->frame_shift = V1_1_FRAME_SHIFT;
fex->n_features = V1_1_N_FEATURES;
/* Verzoegerungselement fuer Ableitung erzeugen ... */
cfg->wderiv = dsp_delay_create(V1_1_W_LENGTH,
sizeof(mx_real_t),
V1_1_N_BASEFEATURES);
/* Kanaladaption erzeugen/initialisieren */
if (!params || rs_line_is_empty(params)) {
ch = channel + 0;
rs_warning("no channel type for MFCCs v%d.%d given"
" - using '%s'!",
DSP_VERSION_MAJOR(fex->version),
DSP_VERSION_MINOR(fex->version),
ch->name);
}
else {
for (i = 0; i < V1_3_N_PARAM_DEFAULTS; i++) {
if (strcmp(params, channel[i].name) == 0) {
rs_msg("MFCCs v%d.%d use channel type '%s'!",
DSP_VERSION_MAJOR(fex->version),
DSP_VERSION_MINOR(fex->version),
ch->name);
break;
}
}
}
/* ... falls kein impliziter/gegebener Kanaltyp, Parameter einlesen */
if (!ch && params) {
/* ... create temporary channel data ... */
ch = rs_calloc(1, sizeof(struct channel_t),
"temporary channel data");
/* ... scan parameters from 'params' string ... */
cp = params;
for (i = 0; i < V1_3_N_PARAMS; i++) {
status = sscanf(cp, "%g%n", ch->param + i, &pos);
if (status != 1) {
if (!rs_line_is_empty(cp))
rs_error("error in channel definition: '%s'!",
params);
break;
}
cp += pos;
}
for (/* i = <implicit> */; i < V1_3_N_PARAMS; i++)
ch->param[i] = 0.0;
/********
rs_msg("MFCC channel parameters set to '%s'!", params);
********/
}
cfg->channel = dsp_channel_init(V1_1_N_BASEFEATURES,
V1_2_I_ENERGY, V1_3_MINTIME, V1_3_MAXTIME,
V1_2_DECAY, V1_2_ENERGY_PERCENT,
ch->param);
return(0);
}
