void convert_adjustment_to_imelda(norm_info *norm, preprocessed *prep)
{
int ii;
imeldata fram[MAX_DIMEN];
ASSERT(prep);
ASSERT(norm);
for (ii = 0; ii < 12; ii++) /* TODO: fix dimension properly, and sort out rouding/type */
fram[ii] = (imeldata) norm->adjust[ii]; /* TODO: review types */
for (; ii < prep->dim; ii++)
fram[ii] = 0;
linear_transform_frame(prep, fram, False);
for (ii = 0; ii < prep->dim; ii++)
norm->imelda_adjust[ii] = fram[ii];
#if DEBUG
log_report("NORM AUX: ");
for (ii = 0; ii < norm->dim; ii++)
log_report("%d ", (int)norm->imelda_adjust[ii]);
log_report("\n");
#endif
norm->adj_valid = True;
return;
}
void cepstrum_params(front_channel *channel, front_wave *waveobj,
front_freq *freqobj, front_cep *cepobj)
{
#if SPEC_CORRECT
/* 2.30 Apply a spectrum correction */
if (cepobj->mel_loop)
mel_spectrum_correction(freqobj->filterbank, cepobj->mel_loop, channel->num_freq);
#endif
/* 2.33 Calculate log dB energy values */
mel_loglookup_with_offset(cepobj, channel);
#if DEBUG
log_report("Filterbank output: ");
write_scaled_frames(freqobj->nf, 1, channel->filterbank, D_FIXED, 1 / (float)LOG_SCALE);
#endif
/* 2.34 Cosine transformation */
icostrans(cepobj->cs, channel->filterbank, channel->cep,
channel->num_freq, cepobj->mel_dim);
#if DEBUG
log_report("Cepstrum coefficients: ");
write_scaled_frames((cepobj->mel_dim + 1), 1, channel->cep, D_FIXED, (float)1 / (0x01 << (LOG_SCALE_SHIFT + COSINE_TABLE_SHIFT)));
#endif
return;
}
void init_preprocessed(preprocessed *prep, int dimen, float imelda_scale)
/*
** To setup the preprocessed structure
*/
{
ASSERT(prep);
ASSERT(dimen > 0);
prep->dim = dimen;
prep->seq = (imeldata *) CALLOC(prep->dim, sizeof(imeldata),
"srec.prep->seq");
prep->seq_unnorm = (imeldata *) CALLOC(prep->dim, sizeof(imeldata),
"srec.prep->seq_unnorm");
prep->last_frame = (featdata *) CALLOC(prep->dim, sizeof(featdata),
"srec.prep->last_frame");
/* Setup constants for distance calculation
*/
/* TODO: check numbers for non-zero */
prep->add.scale = (prdata)((2 * imelda_scale * imelda_scale) / MUL_SCALE
+ 0.5) - (prdata)0.5;
prep->add.inv_scale = (prdata)(((float)(0x01 << 12) * MUL_SCALE) /
(2 * imelda_scale * imelda_scale) + 0.5) -
(prdata)0.5;
prep->mul.multable_factor_gaussian = 1;
prep->mul.multable_factor = (prdata)(((MUL_SCALE * (0x01 << EUCLID_SHIFT)
* prep->uni_score_scale)
/ (2 * (imelda_scale * imelda_scale
* FUDGE_FACTOR * FUDGE_FACTOR))) / 128 + 0.5)
- (prdata)0.5;
prep->mul.grand_mod_cov = (prdata)((MUL_SCALE * prep->uni_score_scale *
prep->whole_dim *
log((imelda_scale * FUDGE_FACTOR) /
(SIGMA_BIAS * root_pi_over_2))) / 128 + 0.5)
- (prdata)0.5 - prep->uni_score_offset;
prep->mul.grand_mod_cov_gaussian = (prdata)(2 * imelda_scale * imelda_scale *
prep->use_dim *
log(imelda_scale /
(SIGMA_BIAS * root_pi_over_2)) + 0.5)
- (prdata)0.5;
#if DEBUG
log_report("grand_mod_cov %.1f, grand_mod_cov_gaussian %.1f\n",
(float)prep->mul.grand_mod_cov,
(float)prep->mul.grand_mod_cov_gaussian);
log_report("multable_factor %f, multable_factor_gaussian %f\n",
(float)prep->mul.multable_factor,
(float)prep->mul.multable_factor_gaussian);
#endif
create_cepstrum_offsets(prep);
return;
}
void read_cb(uv_fs_t* read_req) {
int r = 0;
if (read_req->result < 0) CHECK(read_req->result, "uv_fs_read callback");
/* extracting our context from the read_req */
context_t* context = read_req->data;
/* 4. Report the contents of the buffer */
/*
log_report("%s", read_req->bufsml->base);
log_info("%s", read_req->bufsml->base);
free(read_req->bufsml->base);
log_report("%s", context->iov->base);
log_info("%s", context->iov->base);
if I don't call log_report/log_info on context->iov, then valgrind has 0 erro!
*/
log_report("%s", context->iov.base);
log_info("%s", context->iov.base);
/* 5. Close the file descriptor (synchronously) */
uv_fs_t close_req;
r = uv_fs_close(read_req->loop, &close_req, context->open_req->result, NULL);
if (r < 0) CHECK(abs(r), "uv_fs_close");
/* cleanup all requests and context */
uv_fs_req_cleanup(context->open_req);
uv_fs_req_cleanup(read_req);
uv_fs_req_cleanup(&close_req);
free(context);
}
void CA_DetachCMSfromUtterance(CA_Wave *hWave, CA_Utterance *hUtt)
{
TRY_CA_EXCEPT
ASSERT(hWave);
if (hWave->is_configuredForAgc == False)
SERVICE_ERROR(UNCONFIGURED_CMS_AND_AGC);
if (hUtt && hUtt->data.gen_utt.do_channorm == False)
SERVICE_ERROR(UTTERANCE_INVALID);
if (hWave->is_attached == False)
SERVICE_ERROR(UNATTACHED_CMS_AND_AGC);
if (hWave->data.channel->spchchan && hUtt->data.gen_utt.spchchan
&& hWave->data.channel->spchchan != hUtt->data.gen_utt.spchchan)
{
log_report("Mismatched channel and utterance\n");
SERVICE_ERROR(BAD_CHANNEL);
} /* TODO: find a better code */
hUtt->data.gen_utt.channorm = NULL;
hUtt->data.gen_utt.spchchan = NULL;
hUtt->data.gen_utt.do_channorm = False;
hWave->is_attached = False;
return;
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hWave)
}
static void
harakiri(uint32_t index)
{
#ifdef HARAKIRI_ENABLED
extern uint16_t __stage_0_config__;
const uint16_t *stage0conf_addr = (uint16_t *)&__stage_0_config__;
flash_err_t rv;
FUTURE_HOOK_1(harakiri_0, &index);
if (index % sizeof(uint16_t) != 0) return;
if (index > 0x4000) return;
index >>= 1;
// XXX must not be run XiP!!!
rv = _flash_init(); /* call that first to close flash if it's opened */
if (0 != stage0conf_addr[index-1]) return;
if (0 == stage0conf_addr[index]) return;
if (FLASH_ERR_OK != rv) {
# ifdef LOG_REPORT_BEFORE_BOARD_INIT_ALLOWED
log_report(LOG_GLOBAL, "harakiri FAILING?!\n");
# endif
}
rv = _flash_write((void *)&stage0conf_addr[index], "\x00\x00", 2);
# ifdef LOG_REPORT_BEFORE_BOARD_INIT_ALLOWED
log_report_fmt(LOG_GLOBAL, "harakiri @%08x: %s\n", &stage0conf_addr[index], rv == FLASH_ERR_OK ? "SUCCESS" : "FAILURE");
# endif
#endif /* HARAKIRI_ENABLED */
}
/*************************************************************************************************
* ssi_register_handler
*
* Registers a function to be called when "keyword" is parsed by the http-server. This handler-
* function has to provide the HTML or JavaScript text which is inserted after the keyword tag.
*
* Example for keyword tag in HTML: <!--#registry_content--> (where "registry_content" is the keyword)
*
* @param keyword, max length: 20 characters including "\0" termination, case sensitive!
* @param function_pointer
*/
void ssi_register_handler(const char *keyword, ssi_handler function_pointer)
{
if (strlen(keyword) > SSI_KEYWORD_MAX_LENGTH)
{
log_report(UECU_LOG_ERROR, module_name, "tag %s too long, truncated", keyword);
}
/* Make tag array bigger to fit the new keyword
* Note: see here http://stackoverflow.com/questions/5935933/dynamically-create-an-array-of-strings-with-malloc
*/
tags = pvPortRealloc(tags, (number_of_tags + 1) * sizeof(char *));
if (tags != NULL)
{
tags[number_of_tags] = keyword;
}
handlers = pvPortRealloc(handlers, (number_of_tags + 1) * sizeof(handlers));
if (handlers != NULL)
{
handlers[number_of_tags] = function_pointer;
}
number_of_tags++;
}
void lattice_add_word_tokens(srec_word_lattice *wl, frameID frame,
wtokenID word_token_list_head)
{
if (frame >= wl->max_frames)
{
log_report("lattice_add_word_tokens: max_frame not big enough\n");
ASSERT(0);
}
wl->words_for_frame[frame] = word_token_list_head;
}
int srec_print_results(multi_srec *recm, int max_choices)
{
char transcription[MAX_LEN];
bigcostdata cost;
srec_get_top_choice_transcription(recm, transcription, MAX_LEN, 1);
srec_get_top_choice_score(recm, &cost, SCOREMODE_INCLUDE_SILENCE);
log_report("R: %8ld %8ld %s\t%.1f\n", 0, 0, transcription, cost);
return 0;
}
static int check_parameter_range(int parval, int parmin, int parmax, const char* parname)
{
if (parval > parmax)
{
log_report("Error: %s value %d is out-of-range [%d,%d]\n", parname,
parval, parmin, parmax);
return 1;
}
else
{
return 0;
}
}
int main() {
int err;
double uptime;
err = uv_uptime(&uptime);
CHECK(err, "uv_uptime");
log_info("Uptime: %f", uptime);
log_report("Uptime: %f", uptime);
size_t resident_set_memory;
return 0;
}
void create_sample_buffer(wave_info *wave, int frame_size, int window_size)
{
ASSERT(wave);
ASSERT(frame_size > 0);
ASSERT(window_size >= frame_size);
wave->income = (samdata *) CALLOC(window_size, sizeof(samdata), "cfront.wave.income");
wave->outgo = (samdata *) CALLOC(window_size, sizeof(samdata), "cfront.wave.outgo");
wave->window_size = window_size;
wave->frame_size = frame_size;
#if DEBUG
log_report("window %d frame %d\n", window_size, frame_size);
#endif
return;
}
static retval_t THERMAL_turn_heaters_off(thermal_zones_t zone) {
log_report(LOG_SS_THERMAL, "Turning heaters on\n");
switch (zone) {
case THERMAL_ZONE_STARTRACKER:
return POWER_turnOff(POWER_SW_HEATER_1);
case THERMAL_ZONE_LOWER_1:
return POWER_turnOff(POWER_SW_HEATER_2);
case THERMAL_ZONE_LOWER_2:
return POWER_turnOff(POWER_SW_HEATER_3);
case THERMAL_ZONE_COUNT:
break;
}
return RV_ILLEGAL;
}
static retval_t cmd_dump_runtime_stats(const subsystem_t *self, frame_t *iframe, frame_t *oframe) {
#if ( configGENERATE_RUN_TIME_STATS == 1 )
#define FREERTOS_STAT_BUFSIZE_PER_TASK 40
#define CANOPUS_CMOCKERY_ESTIMATED_TASKS_COUNT 42
signed char buf[CANOPUS_CMOCKERY_ESTIMATED_TASKS_COUNT * FREERTOS_STAT_BUFSIZE_PER_TASK];
vTaskGetRunTimeStats(buf);
log_report(LOG_SS_PLATFORM, (const char *)buf);
FUTURE_HOOK_4(cmd_dump_runtime_stats, buf, sizeof(buf), iframe, oframe);
return RV_SUCCESS;
#else
return RV_NOTIMPLEMENTED;
#endif
}
int CA_GetAnnotationSNR(CA_Annotation* hAnnotation)
{
TRY_CA_EXCEPT
ASSERT(hAnnotation);
#if DO_SUBTRACTED_SEGMENTATION
return hAnnotation->data->snr;
#endif
/* SERVICE_ERROR (FEATURE_NOT_SUPPORTED); */
log_report("W: CA_GetAnnotationSNR - function not supported.\n");
return 0;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void doit(int fd)
{
int clientfd, port, size = 0;
ssize_t linecounter;
rio_t client_rio, server_rio;
char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE], serveraddr[MAXLINE], path[MAXLINE], message[MAXLINE];
//read the HTTP request
rio_readinitb(&client_rio, fd);
rio_readlineb(&client_rio, buf, MAXLINE);
sscanf(buf, "%s %s %s", method, uri, version);
if(strcasecmp(method, "GET") != 0)
{
clienterror(fd, method, "501", "Not Implemented", "Proxy does not implement this method");
return;
}
read_requesthdrs(&client_rio);
//parse it to determine the name of the end server
port = parse_uri(uri, serveraddr, path);
//filter
if(is_blocked_address(serveraddr))
{
clienterror(fd, serveraddr, "403", "Forbidden", "Proxy does not access this server");
return;
}
//open a connection to the end server
if((clientfd = open_clientfd(serveraddr, port)) < 0)
{
clienterror(fd, serveraddr, "404", "Not Found", "Proxy does not found this server");
return;
}
//send it the request
sprintf(message, "GET %s HTTP/1.0\r\n", path);
rio_writen(clientfd, message, strlen(message));
sprintf(message, "HOST: %s\r\n\r\n", serveraddr);
rio_writen(clientfd, message, strlen(message));
//receive the reply, and forward the reply to the browser if the request is not blocked.
rio_readinitb(&server_rio, clientfd);
while((linecounter = rio_readlineb(&server_rio, message, MAXLINE)) != 0)
{
rio_writen(fd, message, linecounter);
size += linecounter;
}
//log
sem_wait(&mutex);
log_report(serveraddr, size);
sem_post(&mutex);
}
static void grpc_timers_log_add(int tag, marker_type type, void* id,
const char* file, int line) {
grpc_timer_entry* entry;
/* TODO (vpai) : Improve concurrency */
if (count == MAX_COUNT) {
log_report();
}
entry = &log[count++];
grpc_precise_clock_now(&entry->tm);
entry->tag = tag;
entry->type = type;
entry->id = id;
entry->file = file;
entry->line = line;
}
int get_data_frame(preprocessed *prep, utterance_info *utt)
/*
** To get a frame amount of data and perform preprocessing functions
*/
{
int status_code;
ASSERT(prep);
ASSERT(utt);
if (utt->gen_utt.channorm && !utt->gen_utt.channorm->adj_valid)
convert_adjustment_to_imelda(utt->gen_utt.channorm, prep);
if (utt->gen_utt.dim != prep->dim)
SERVICE_ERROR(UTTERANCE_DIMEN_MISMATCH);
if (prep->post_proc & VFR)
{
if ((status_code = get_utterance_frame(prep, utt)) <= 0)
return (status_code);
log_report("get_data_frame vfr not supported\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
}
else
{
status_code = get_utterance_frame(prep, utt);
if (status_code == 0) return(status_code);
else if (status_code == -1) return(1);
}
if (prep->chan_offset)
apply_channel_offset(prep);
/* Apply linear transformation if necessary
*/
if (prep->post_proc & LIN_TRAN)
linear_transform_frame(prep, prep->seq, True);
memcpy(prep->seq_unnorm, prep->seq, prep->dim * sizeof(imeldata));
if (utt->gen_utt.channorm)
apply_channel_normalization_in_imelda(utt->gen_utt.channorm,
prep->seq, prep->seq_unnorm,
utt->gen_utt.channorm->dim);
return (1);
}
/*************************************************************************************************
* firmware_update_application_do_work
*
* Receives .hex file data, parses it, checks it and stores it in the EEPROM buffer if everything looks good
*
* @param *buffer
* @param buffer_length
*/
void firmware_update_application_do_work(char *buffer, uint32_t buffer_length)
{
static char current_line[50];
static uint8_t current_line_index = 0;
uint32_t i = 0;
if (current_firmware_update_status != UPDATE_FAILED)
{
for (i < 0; i < buffer_length; i++)
{
if (current_line_index < sizeof(current_line))
{
current_line[current_line_index] = *(buffer + i);
}
else
{
log_report(UECU_LOG_ERROR, module_name, "Line length in .srec file exceeds buffer.");
current_firmware_update_status = UPDATE_FAILED;
break;
}
if (current_line[current_line_index] == '\n')
{
if (current_line_index < 2)
{
/* ignore blank lines */
}
else if (firmware_parse_srec_line(current_line) == false)
{
current_firmware_update_status = UPDATE_FAILED;
break;
}
current_line_index = 0;
}
else
{
current_line_index++;
}
}
/* the remainder of current_line is processed next time */
}
}
static void grpc_timers_log_add(int tag, const char *tagstr, marker_type type,
void *id, const char *file, int line) {
grpc_timer_entry *entry;
/* TODO (vpai) : Improve concurrency */
if (count == MAX_COUNT) {
log_report();
}
entry = &log[count++];
entry->tm = gpr_now(GPR_CLOCK_PRECISE);
entry->tag = tag;
entry->tagstr = tagstr;
entry->type = type;
entry->id = id;
entry->file = file;
entry->line = line;
}
void read_cb(uv_fs_t* read_req) {
int r = 0;;
if (read_req->result < 0) CHECK(read_req->result, "uv_fs_read callback");
context_t* context = read_req->data;
/* 6. Report the contents of the buffer */
log_report("%s", context->iov.base);
log_info("%s", context->iov.base);
free(context->iov.base);
/* 7. Setup close request */
uv_fs_t *close_req = malloc(sizeof(uv_fs_t));
close_req->data = context;
/* 8. Close the file descriptor */
r = uv_fs_close(uv_default_loop(), close_req, context->open_req->result, close_cb);
if (r < 0) CHECK(r, "uv_fs_close");
}
void create_lookup_logadd(logadd_table_info *logtab, float mul_scale)
{
int ii;
ASSERT(logtab);
ASSERT(logtab->scale != 0);
logtab->logscale = mul_scale;
logtab->add_log_limit = (prdata)(ADD_LOG_LIMIT * mul_scale * logtab->scale);
if( DO_USE_LOGTAB__TABLE) {
logtab->table = logtab__table;
} else {
prdata* table = (prdata *) CALLOC(logtab->add_log_limit + 2, sizeof(prdata), "clib.logadd");
logtab->table = table;
PRINT_SOME_CODE( "/* values for default case %d */\n", 0);
PRINT_SOME_CODE( "#define DO_USE_LOGTAB__TABLE (logtab->scale == %d \\\n", logtab->scale);
PRINT_SOME_CODE( " && ( (int)(logtab->logscale*10000) == (int)(%ff*10000) \\\n", logtab->logscale);
PRINT_SOME_CODE( " && ADD_LOG_LIMIT == %d) \n", ADD_LOG_LIMIT);
PRINT_SOME_CODE( "static prdata logtab__table[%d] = {", logtab->add_log_limit + 2);
for (ii = 0; ii <= logtab->add_log_limit; ii++) {
table[ii] = (prdata)(logtab->scale * mul_scale * log(1
+ exp(-(float)ii / ((float)logtab->scale * mul_scale)))
+ 0.5) ;
PRINT_SOME_CODE(" %d,", table[ii]);
}
PRINT_SOME_CODE( ", 0 }; /*%i*/\n", 0); /*not sure why the +2 above, just append 0 for now*/
}
#ifdef SREC_ENGINE_VERBOSE_LOGGING
PLogMessage("L: log table scale is %f\n", (float)logtab->scale);
PLogMessage("L: log table has %d entries\n", (int)logtab->add_log_limit);
#endif
#if DEBUG
for (ii = 0; ii <= logtab->add_log_limit; ii++)
log_report("T: %d %f\n", ii, (float)logtab->table[ii]);
#endif
#if REPORT_USAGE
report_malloc_usage();
#endif
return;
}
void estimate_normalization_parameters(norm_info *channorm,
spect_dist_info **chandata, int dimen)
{
int ii, adjust;
ASSERT(channorm);
ASSERT(chandata);
ASSERT(dimen <= channorm->dim);
for (ii = 0; ii < dimen; ii++)
if (chandata[ii])
{
evaluate_parameters(chandata[ii]);
/* The additive expression is due to
** the normalization taking place before the
** utterance object is created
*/
adjust = mean_normalize_data(chandata[ii], 0);
/* channorm->adjust[ii]= adjust; */
#if USE_MEDIAN
shift_distribution_counts(chandata[ii], adjust);
#endif
shift_parameters(chandata[ii], adjust);
#if NORM_IN_IMELDA
channorm->imelda_adjust[ii] += adjust;
#else
channorm->adjust[ii] += adjust;
#endif
}
#if NORM_IN_IMELDA
channorm->adj_valid = True;
#if DEBUG
log_report("NORM IML: ");
for (ii = 0; ii < channorm->dim; ii++)
log_report("%d ", channorm->imelda_adjust[ii]);
log_report("\n");
#endif
#else
channorm->adj_valid = False;
#if DEBUG
log_report("NORM ADJ: ");
for (ii = 0; ii < channorm->dim; ii++)
log_report("%d ", channorm->adjust[ii]);
log_report("\n");
#endif
#endif
return;
}
void CA_LoadCMSParameters(CA_Wave *hWave, const char *basename,
CA_FrontendInputParams *hFrontArgs)
{
TRY_CA_EXCEPT
#if !defined(_RTT)
ASSERT(hWave);
/* ASSERT (basename); */
ASSERT(hFrontArgs);
if (hWave->is_configuredForAgc == True)
SERVICE_ERROR(CONFIGURED_CMS_AND_AGC);
if (hWave->is_attached == True)
SERVICE_ERROR(ATTACHED_CMS_AND_AGC);
hWave->data.channel->channorm = create_channel_normalization();
/* load_channel_parameters (basename, hWave->data.channel->channorm);
not used anymore, rather we spec this is the parfile directly */
hWave->data.channel->channorm->dim = MAX_CHAN_DIM;
setup_channel_normalization(hWave->data.channel->channorm,
hWave->data.channel->spchchan,
#if NORM_IN_IMELDA
hFrontArgs->mel_dim * 3, /* TODO: find appropriate number */
#else
hFrontArgs->mel_dim,
#endif
hFrontArgs->forget_factor);
hWave->data.channel->mel_dim = hFrontArgs->mel_dim; /* TODO: more checks */
hWave->data.channel->swicms = (swicms_norm_info*)CALLOC(1, sizeof(swicms_norm_info), "cfront.swicms");
if( swicms_init(hWave->data.channel->swicms) )
SERVICE_ERROR(UNEXPECTED_DATA_ERROR);
hWave->is_configuredForAgc = True;
#else
log_report("Channel normalization or RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
#endif
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hFrontend);
}
void CA_SaveAnnotation(CA_Annotation* hAnnotation, char* FileName)
{
TRY_CA_EXCEPT
#ifndef _RTT
ASSERT(hAnnotation);
if (!hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_NO_SEGMENTS);
}
save_annotations(hAnnotation->data, FileName);
return;
#else
log_report("RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
return;
#endif
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void Jacobi(double **matrix, int dim, double *egval, double **egvec)
/*
// Compute all eigenvalues and eigenvectors of the real symmetric matrix
// <mat> of size <dim>x<dim>. Fills in <egval> with the eigenvalues
// and <egvec[i]> with the i-th normalized eignevector of <mat>.
*/
{
int i, j, k;
int nRotations, /* number of Jacobi rotations that are performed */
iter;
double g, thresh, sum, c, s, t, tau, h;
double *b, *d, *z;
double **v, **a;
ASSERT(matrix);
ASSERT(egval);
ASSERT(egvec);
b = (double *) CALLOC(dim, sizeof(double), "clib.jacobi.b");
d = (double *) CALLOC(dim, sizeof(double), "clib.jacobi.d");
z = (double *) CALLOC(dim, sizeof(double), "clib.jacobi.z");
a = (double **) CALLOC(dim, sizeof(double *), "clib.jacobi.input_jacobi");
v = (double **) CALLOC(dim, sizeof(double *), "clib.jacobi.input_jacobi");
for (i = 0; i < dim; i++)
{
a[i] = (double *) CALLOC(dim, sizeof(double), "clib.jacobi.input_jacobi[]");
v[i] = (double *) CALLOC(dim, sizeof(double), "clib.jacobi.input_jacobi[]");
for (j = 0; j < dim; j++)
a[i][j] = (float) matrix[i][j];
}
/* initialize v to identity matrix, d and b to the diagonal of mat */
for (i = 0; i < dim; i++)
{
v[i][i] = 1.0;
b[i] = d[i] = a[i][i];
}
nRotations = 0;
iter = 0;
while (1)
{
sum = SumOffDiag(a, dim);
if (sum < EPSILON) /* normal convergence */
{
log_report("\nConverged after %u iterations", iter);
break;
}
if (iter >= MAX_ITER)
{
log_report("\nMax number %u of iterations reached",
MAX_ITER);
break;
}
if (iter < 3)
thresh = 20.0 * sum / (dim * dim); /* .. first 3 iterations only */
else
thresh = 0.0; /* .. thereafter */
for (i = 0; i < dim - 1; i++)
{
for (j = i + 1; j < dim; j++)
{
g = 100.0 * fabs(a[i][i]);
/* after 4 iter's, skip rotation if off-diag elmt is small */
if ((iter >= 4) && (g < EPSILON*fabs(d[i]))
&& (g < EPSILON*fabs(d[j])))
{
a[i][i] = 0.0;
}
else if (g > thresh)
{
h = d[j] - d[i];
if (g < EPSILON*fabs(h))
t = a[i][j] / h;
else
{
double theta = 0.5 * h / a[i][j];
t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
if (theta < 0.0) t = -t;
}
c = 1.0 / sqrt(1 + t * t);
s = t * c;
tau = s / (1.0 + c);
h = t * a[i][j];
z[i] -= h;
z[j] += h;
d[i] -= h;
d[j] += h;
a[i][j] = 0.0;
for (k = 0 ; k < i; k++) Rotate(a, dim, k, i, k, j, s, tau);
for (k = i + 1; k < j; k++) Rotate(a, dim, i, k, k, j, s, tau);
for (k = j + 1; k < dim; k++) Rotate(a, dim, i, k, j, k, s, tau);
for (k = 0; k < dim; k++) Rotate(v, dim, k, i, k, j, s, tau);
nRotations++;
}
}
}
for (i = 0; i < dim; i++) /* update d[] and re-initialize z[] */
{
b[i] += z[i];
d[i] = b[i];
z[i] = 0.0;
}
iter++;
}
/* save eigenvectors and eigenvalues */
for (i = 0; i < dim; i++)
{
/* the i-th column of v is the i-th eigenvector */
for (j = 0; j < dim; j++) egvec[i][j] = v[j][i]; /* TODO: should this be egvec[j][i] */
/* the i-th entry of d is the i-th eigenvalue */
egval[i] = d[i];
}
log_report("\nDiagonalization required %u Jacobi rotations",
nRotations);
FREE((char *)b);
FREE((char *)d);
FREE((char *)z);
for (i = 0; i < dim; i++)
{
FREE((char *)a[i]);
FREE((char *)v[i]);
}
FREE((char *)a);
FREE((char *)v);
return;
}
static void close_cb(uv_handle_t* client) {
free(client);
log_info("Closed connection");
log_report("Closed connection");
}
int CA_LoadPattern(CA_Pattern *hPattern, CA_PatInputParams *hPatInput,
int dimen , char *multable , char *imelda)
{
TRY_CA_EXCEPT
#ifndef _RTT
int ii, ret_code;
ASSERT(hPattern);
ASSERT(hPatInput);
if (hPattern->is_loaded == True)
SERVICE_ERROR(PATTERN_ALREADY_LOADED);
if (hPatInput->is_loaded == False)
SERVICE_ERROR(PATTERN_INPUT_NOT_LOADED);
hPattern->data.prep = (preprocessed *) CALLOC_CLR(1,
sizeof(preprocessed), "ca.hPattern->data.prep");
/* Load the Imelda transform if specified */
if (imelda && strlen(imelda) > 0)
{
ret_code = init_newton_transform(hPattern->data.prep, 0, imelda, hPatInput->dimen);
if (ret_code > 0)
SERVICE_ERROR(PATTERN_NOT_LOADED);
}
else
{
hPattern->data.prep->use_dim = hPatInput->dimen;
hPattern->data.prep->use_from = hPatInput->feat_start;
}
if (hPatInput->whole_dimen == 0)
hPattern->data.prep->whole_dim = hPatInput->dimen;
else
hPattern->data.prep->whole_dim = hPatInput->whole_dimen;
if (hPattern->data.prep->whole_dim > hPattern->data.prep->use_dim)
SERVICE_ERROR(BAD_PARAMETER);
hPattern->data.prep->mix_score_scale = (prdata)(128 * hPatInput->mix_score_scale + 0.5)
- (prdata)0.5;
hPattern->data.prep->uni_score_scale = (prdata)(128 * hPatInput->uni_score_scale + 0.5)
- (prdata)0.5;
hPattern->data.prep->uni_score_offset = (prdata) hPatInput->uni_score_offset;
hPattern->data.prep->imelda_scale = (prdata)hPatInput->imelda_scale;
init_preprocessed(hPattern->data.prep, dimen, hPatInput->imelda_scale); /* TODO: move this to Setup */
/* Annotation parameters */
hPattern->data.prep->end.rel_low = hPatInput->rel_low;
hPattern->data.prep->end.rel_high = hPatInput->rel_high;
hPattern->data.prep->end.gap_period = hPatInput->gap_period;
hPattern->data.prep->end.click_period = hPatInput->click_period;
hPattern->data.prep->end.breath_period = hPatInput->breath_period;
hPattern->data.prep->end.extend_annotation = hPatInput->extend_annotation;
hPattern->data.prep->end.min_annotation_frames = hPatInput->min_annotation_frames;
hPattern->data.prep->end.max_annotation_frames = hPatInput->max_annotation_frames;
hPattern->data.prep->end.min_segment_rel_c0 = hPatInput->min_segment_rel_c0;
hPattern->data.prep->end.min_initial_quiet_frames = hPatInput->min_initial_quiet_frames;
hPattern->data.prep->end.delete_leading_segments = hPatInput->delete_leading_segments;
hPattern->data.prep->end.leading_segment_min_frames = hPatInput->leading_segment_min_frames;
hPattern->data.prep->end.leading_segment_max_frames = hPatInput->leading_segment_max_frames;
hPattern->data.prep->end.leading_segment_min_silence_gap_frames
= hPatInput->leading_segment_min_silence_gap_frames;
hPattern->data.prep->end.leading_segment_accept_if_not_found
= hPatInput->leading_segment_accept_if_not_found;
#if DO_SUBTRACTED_SEGMENTATION
hPattern->data.prep->end.snr_holdoff = hPatInput->snr_holdoff;
hPattern->data.prep->end.min_acceptable_snr = hPatInput->min_acceptable_snr;
#endif
hPattern->data.prep->end.param = hPatInput->param;
hPattern->data.prep->end.beep_size = hPatInput->beep_size;
hPattern->data.prep->end.beep_threshold = hPatInput->beep_threshold;
/* log-lookup table */
create_lookup_logadd(&hPattern->data.prep->add, (float)MUL_SCALE);
/* Build the weights conversion table */
for (ii = 0; ii < MAX_WTS; ii++)
hPattern->data.prep->exp_wt[ii] =
(prdata)(WEIGHT_SCALE * exp((double)(0x01 << WT_ADJUST) *
(double) - ii / (MUL_SCALE * hPattern->data.prep->add.scale)) +
0.5) - (prdata)0.5;
hPattern->data.prep->ref_count = 1;
hPattern->is_loaded = True;
return (True);
#else
log_report("RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
return (False);
#endif
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
void CA_InheritAccumulates(CA_Transform *hTransform, CA_Pattern *hPattern)
{
TRY_CA_EXCEPT
int ii, jj;
ASSERT(hPattern);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform);
if (hTransform->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform->dim == hPattern->data.dim);
if (hTransform->do_mllr)
{
ASSERT(hPattern->true_accumulates);
ASSERT(hPattern->data.do_mllr);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii <= hTransform->dim; ii++)
for (jj = 0; jj <= hTransform->dim; jj++)
{
hTransform->mllr_acc.between[ii][jj] +=
hPattern->data.mllr_acc.between[ii][jj];
hTransform->mllr_acc.within[ii][jj] +=
hPattern->data.mllr_acc.within[ii][jj];
}
log_report("\nCA_InheritAccumulates MLLR inheriting %f frames (total now %f)\n\n", hPattern->data.mllr_acc.within[hTransform->dim][hTransform->dim], hTransform->mllr_acc.within[hTransform->dim][hTransform->dim]);
}
if (hTransform->do_imelda)
{
ASSERT(hPattern->data.do_imelda);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii < hTransform->dim; ii++)
for (jj = 0; jj < hTransform->dim; jj++)
{
hTransform->imelda_acc.between[ii][jj] +=
hPattern->data.imelda_acc.between[ii][jj];
hTransform->imelda_acc.within[ii][jj] +=
hPattern->data.imelda_acc.within[ii][jj];
}
for (ii = 0; ii < hTransform->dim; ii++)
{
hTransform->imelda_acc.bmean[ii] +=
hPattern->data.imelda_acc.bmean[ii];
hTransform->imelda_acc.wmean[ii] +=
hPattern->data.imelda_acc.wmean[ii];
}
hTransform->imelda_acc.num += hPattern->data.imelda_acc.num;
log_report("\nCA_InheritAccumulates Imelda inheriting %d frames (total now %d)\n\n", hPattern->data.imelda_acc.num, hTransform->imelda_acc.num);
}
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
int CA_SegmentUtterance(CA_Annotation* hAnnotation, CA_Utterance* hUtt,
CA_Pattern* hPattern)
{
TRY_CA_EXCEPT
int seg_cnt = 0;
int ii;
int total_length;
int num_segments_to_keep = 0;
int no_beep = False;
int has_trailing_silence = False;
#if REMOVE_QUIET_CHUNKS
int jj;
featdata *peakC0;
int max_peak;
#endif
ASSERT(hAnnotation);
ASSERT(hUtt);
ASSERT(hPattern);
ASSERT(hPattern->data.prep);
#if DO_SUBTRACTED_SEGMENTATION
if (hPattern->data.prep->is_setup_for_noise == False)
{
SERVICE_ERROR(PATTERN_NOT_SETUP_FOR_NOISE);
}
#endif
if (hUtt->data.utt_type == FILE_OUTPUT)
SERVICE_ERROR(UTTERANCE_INVALID);
if (hUtt->data.utt_type != FILE_INPUT &&
hUtt->data.utt_type != LIVE_INPUT)
{
SERVICE_ERROR(UTTERANCE_NOT_INITIALISED);
}
if (isFrameBufferActive(hUtt->data.gen_utt.frame))
{
SERVICE_ERROR(FB_INVALID_STATE);
}
if (!hAnnotation->label)
{
SERVICE_ERROR(ANNOTATE_NO_LABEL);
}
if (hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_SEGMENTS_EXIST);
}
hAnnotation->has_segments = False;
/* Segment the utterance using DP on c0 */
seg_cnt = annotation_segment_utterance(hAnnotation->data,
&hUtt->data,
hPattern->data.prep,
hAnnotation->label, &has_trailing_silence);
if (seg_cnt <= 0)
{
if (seg_cnt < 0)
return (seg_cnt);
return (NO_SEGMENTS_FOUND);
}
/* SPECIAL OPERATIONS:
** Now manipulate the segmentation to order:
1. Remove parts of a multi-segment utt that are % below some energy
measure of the "loudest" segment. NB this may remove a final chunk
that previously caused a NO_TRAILING_SILENCE
2. Declare it invalid if the first chunk is within n frames of the start.
3. Delete unwanted leading segment(s). The criteria are:
3a. Min/max segment duration.
3b. Min silence gap to next chunk
4. Check min/max overall length.
NB check MAX then look for trailing silence.
*/
#if REMOVE_QUIET_CHUNKS
/* 1. Remove parts of a multi-segment utt that are % below some energy
measure of the "loudest" segment. */
/* TODO :Add par hPattern->data.prep->end.min_segment_rel_c0 */
if ((hPattern->data.prep->end.min_segment_rel_c0 > 0) && (seg_cnt > 1))
{
peakC0 = (featdata*) VAR_ALLOCATE_CLR(seg_cnt, sizeof(featdata), "ca.peakC0");
max_peak = 0;
for (ii = 0; ii < seg_cnt; ii++)
{
peakC0[ii] = get_c0_peak_over_range(hUtt->data.gen_utt.frame,
hAnnotation->data->tcp[ii].begin,
hAnnotation->data->tcp[ii].begin
+ hAnnotation->data->tcp[ii].end);
if (peakC0[ii] > max_peak)
{
max_peak = peakC0[ii];
}
}
max_peak = max_peak - hPattern->data.prep->end.min_segment_rel_c0;
for (ii = 0; ii < seg_cnt; ii++)
{
if (peakC0[ii] < max_peak)
{
annotation_delete_segment(hAnnotation->data, ii);
/* reset flag if last seg is deleted */
if (!has_trailing_silence && (ii == seg_cnt - 1))
{
has_trailing_silence = True;
}
for (jj = ii; jj < seg_cnt - 1; jj++)
{
peakC0[jj] = peakC0[jj+1];
}
seg_cnt--;
ii--;
}
}
VAR_FREE((char *) peakC0, "peakC0");
if (seg_cnt < 1)
{
return (seg_cnt);
}
}
#endif
/*
** 2. Declare it invalid if the first chunk is within n frames of the start.
*/
if (hAnnotation->data->tcp[0].begin
< hPattern->data.prep->end.min_initial_quiet_frames)
{
annotation_delete_segment_info(hAnnotation->data);
hAnnotation->has_segments = False;
return (INITIAL_SILENCE_NOT_FOUND) ;
}
/*
** 3. Delete unwanted leading segment(s) - a beep, for example.
*/
if (hPattern->data.prep->end.delete_leading_segments > 0)
{
if (hPattern->data.prep->end.leading_segment_accept_if_not_found)
num_segments_to_keep = 1;
else
num_segments_to_keep = 0;
if (!annotation_delete_leading_segments(hAnnotation->data,
hPattern->data.prep->end.delete_leading_segments,
num_segments_to_keep,
hPattern->data.prep->end.leading_segment_min_frames,
hPattern->data.prep->end.leading_segment_max_frames,
hPattern->data.prep->end.leading_segment_min_silence_gap_frames))
{
if (hPattern->data.prep->end.leading_segment_accept_if_not_found)
no_beep = True;
else
{
annotation_delete_segment_info(hAnnotation->data);
hAnnotation->has_segments = False;
return (INITIAL_SEGMENT_NOT_IDENTIFIED) ;
}
}
}
/*
** 4. Check min/max overall length. "Beep" has already been deleted.
*/
total_length = 0;
for (ii = 0; ii < hAnnotation->data->numWords; ii++)
total_length += hAnnotation->data->tcp[ii].end;
if (total_length > hPattern->data.prep->end.max_annotation_frames)
{
annotation_delete_segment_info(hAnnotation->data);
hAnnotation->has_segments = False;
return (ANNOTATION_TOO_LONG);
}
/* Check for TOO LONG before checking for trailing silence - recognizer gernerally
terminates on speech when it runs out of hypos. BP */
if (!has_trailing_silence)
{
annotation_delete_segment_info(hAnnotation->data);
hAnnotation->has_segments = False;
return (NO_TRAILING_SILENCE);
}
if (total_length < hPattern->data.prep->end.min_annotation_frames)
{
annotation_delete_segment_info(hAnnotation->data);
hAnnotation->has_segments = False;
return (ANNOTATION_TOO_SHORT);
}
if (hAnnotation->data->numWords > 0)
{
annotation_decorate_labels(hAnnotation->data, hAnnotation->label);
hAnnotation->has_segments = True;
}
#if DEBUG
if (no_beep)
log_report("W: Initial segment not found\n");
#endif
ASSERT(hAnnotation->data->numWords > 0);
return (hAnnotation->data->numWords);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
