static void sig_dequeue(struct proc* p)
{
struct signal_t* ptr = p->sig_queue;
if(ptr)
{
p->sig_queue = ptr->next;
sig_free(ptr);
}
}
int main(void)
{
t_options opt_val;
t_options *opt = &opt_val;
options_init( opt, SR, BS );
t_num
*x = sig_init(opt),
*y = sig_init(opt);
t_phasor phs;
dsp_alg_phasor_init( &phs, opt, 0 );
dsp_alg_bias(BS, 441, x, x);
dsp_alg_phasor( &phs, x, y );
sig_print( opt, y );
sig_free(x);
sig_free(y);
return 0;
}
slist_t * parse_idb()
{
slist_t * sl;
psig_t * sig;
size_t fct_num, i;
qvector<ea_t> class_l;
fct_num = get_func_qty();
sl = siglist_init(fct_num, NULL);
if (!sl) return NULL;
for (i=0; i<fct_num; i++)
{
sig = sig_generate(i, class_l);
if (sig)
{
// removes 1 line jump functions
if (sig->sig == 0 || sig->lines <= 1)
sig_free(sig);
else
siglist_add(sl, sig);
}
}
if (!siglist_realloc(sl, class_l.size()))
{
siglist_free(sl);
return NULL;
}
for (i=0; i<class_l.size(); i++)
{
sig = sig_class_generate(class_l[i]);
if (sig)
siglist_add(sl, sig);
}
siglist_sort(sl);
return sl;
}
/*
* Main standard loop for LPC analysis.
*/
int cepstral_analysis(sigstream_t *is, spfstream_t *os)
{
unsigned long l, d, j;
float *w = NULL, *r, *lift = NULL;
sample_t *buf;
spsig_t *s;
spf_t *a, *k, *c;
float sigma;
int status;
l = (unsigned long)(fm_l * is->Fs / 1000.0); /* frame length in samples */
d = (unsigned long)(fm_d * is->Fs / 1000.0); /* frame shift in samples */
/* ----- initialize some more stuff ----- */
if ((s = sig_alloc(l)) == NULL) /* frame signal */
return(SPRO_ALLOC_ERR);
if (win) {
if ((buf = (sample_t *)malloc(l * sizeof(sample_t))) == NULL) /* frame buffer */
return(SPRO_ALLOC_ERR);
if ((w = set_sig_win(l, win)) == NULL) {
free(buf); sig_free(s);
return(SPRO_ALLOC_ERR);
}
}
else
buf = s->s;
if ((r = (spf_t *)malloc((nlpc + 1) * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
return(SPRO_ALLOC_ERR);
}
if ((a = (spf_t *)malloc(nlpc * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(r);
return(SPRO_ALLOC_ERR);
}
if ((k = (spf_t *)malloc(nlpc * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(r); free(a);
return(SPRO_ALLOC_ERR);
}
if ((c = (spf_t *)malloc((numceps + 1) * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(r); free(a); free(k);
return(SPRO_ALLOC_ERR);
}
if (lifter)
if ((lift = set_lifter(lifter, numceps)) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(r); free(a); free(k); free(c);
return(SPRO_ALLOC_ERR);
}
/* ----- loop on each frame ----- */
while (get_next_sig_frame(is, channel, l, d, emphco, buf)) {
/* weight signal */
if (win)
sig_weight(s, buf, w);
/* run LPC analysis */
if ((status = sig_correl(s, alpha, r, nlpc)) != 0) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k); free(r); free(c); if (lift) free(lift);
return(status);
}
lpc(r, nlpc, a, k, &sigma);
lpc_to_cep(a, nlpc, numceps, c);
if (lifter)
for (j = 0; j < numceps; j++)
*(c+j) *= *(lift+j);
if (flag & WITHE) {
if (sigma < SPRO_ENERGY_FLOOR)
sigma = SPRO_ENERGY_FLOOR;
*(c+numceps) = (spf_t)(2.0 * log(sigma));
}
/* write vector to stream */
if (spf_stream_write(os, c, 1) != 1) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k); free(r); free(c); if (lift) free(lift);
return(SPRO_FEATURE_WRITE_ERR);
}
}
/* ----- reset memory ----- */
if (win) {
free(buf);
free(w);
}
sig_free(s);
free(r);
free(a);
free(k);
free(c);
if (lift)
free(lift);
return(0);
}
/*
* Main standard loop for LPC analysis.
*/
int lpc_analysis(sigstream_t *is, spfstream_t *os)
{
unsigned long l, d, j;
float *w = NULL, *r;
sample_t *buf, *p;
spsig_t *s;
spf_t *a, *k, *c = NULL;
float sigma;
int status;
l = (unsigned long)(fm_l * is->Fs / 1000.0); /* frame length in samples */
d = (unsigned long)(fm_d * is->Fs / 1000.0); /* frame shift in samples */
/* ----- initialize some more stuff ----- */
if ((s = sig_alloc(l)) == NULL) /* frame signal */
return(SPRO_ALLOC_ERR);
if (win) {
if ((buf = (sample_t *)malloc(l * sizeof(sample_t))) == NULL) /* frame buffer */
return(SPRO_ALLOC_ERR);
if ((w = set_sig_win(l, win)) == NULL) {
free(buf); sig_free(s);
return(SPRO_ALLOC_ERR);
}
}
else
buf = s->s;
if ((a = (spf_t *)malloc((ncoeff + 1) * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
return(SPRO_ALLOC_ERR);
}
if ((k = (spf_t *)malloc((ncoeff + 1) * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a);
return(SPRO_ALLOC_ERR);
}
if ((r = (spf_t *)malloc((ncoeff + 1) * sizeof(spf_t))) == NULL) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k);
return(SPRO_ALLOC_ERR);
}
/* ----- loop on each frame ----- */
while (get_next_sig_frame(is, channel, l, d, emphco, buf)) {
/* weight signal */
if (win)
sig_weight(s, buf, w);
/* run LPC analysis */
if ((status = sig_correl(s, alpha, r, ncoeff)) != 0) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k); free(r);
return(status);
}
lpc(r, ncoeff, a, k, &sigma);
switch (ctype) {
case LPC:
c = a;
break;
case REFC:
c = k;
break;
case LAR:
c = a;
refc_to_lar(k, ncoeff, c);
break;
case LSP:
c = k;
if ((status = lpc_to_lsf(a, ncoeff, c)) != 0) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k); free(r);
return(status);
}
break;
}
if (flag & WITHE) {
if (sigma < SPRO_ENERGY_FLOOR)
sigma = SPRO_ENERGY_FLOOR;
*(c+ncoeff) = (spf_t)(2.0 * log(sigma));
}
/* write vector to stream */
if (spf_stream_write(os, c, 1) != 1) {
if (win) free(buf); sig_free(s); if (win) free(w);
free(a); free(k); free(r);
return(SPRO_FEATURE_WRITE_ERR);
}
}
/* ----- reset memory ----- */
if (win) {
free(buf);
free(w);
}
sig_free(s);
free(a);
free(k);
free(r);
return(0);
}
int generate_diff(deng_t ** d, slist_t * l1, slist_t * l2, char * file, bool display, options_t * opt)
{
int ret;
clist_t * cl1, * cl2;
int un1, un2, idf, mf;
deng_t * eng;
eng = diff_engine_initialize(l1, l2, opt);
if (eng == NULL)
return -1;
cl1 = clist_init(l1);
cl2 = clist_init(l2);
if (file)
ret = diff_run(eng, cl1, cl2, DIFF_EQUAL_NAME, DIFF_NEQUAL_STR, false);
else
{
ret = diff_run(eng, cl1, cl2, DIFF_EQUAL_SIG_HASH_CRC, DIFF_EQUAL_SIG_HASH, false);
ret = diff_run(eng, cl1, cl2, DIFF_NEQUAL_PRED, DIFF_NEQUAL_STR, false);
}
//printf("%s\n",file);
if (display)
{
eng->mlist = siglist_init(eng->matched, file);
eng->ulist = siglist_init(eng->unmatched, file);
eng->ilist = siglist_init(eng->identical, file);
un1 = un2 = idf = mf = 0;
for (size_t i=0; i<l1->num; i++)
{
if (sig_is_class(l1->sigs[i]))
{
sig_free(l1->sigs[i]);
continue;
}
if (sig_get_matched_type(l1->sigs[i]) == DIFF_UNMATCHED)
{
sig_set_nfile(l1->sigs[i], 1);
siglist_add(eng->ulist, l1->sigs[i]);
un1++;
}
else
{
// was || should be && ?
if (l1->sigs[i]->hash2 == l1->sigs[i]->msig->hash2 && sig_equal(l1->sigs[i], l1->sigs[i]->msig, DIFF_EQUAL_SIG_HASH))
{
siglist_add(eng->ilist, l1->sigs[i]);
idf++;
}
else
{
siglist_add(eng->mlist, l1->sigs[i]);
mf++;
}
}
}
for (size_t i=0; i<l2->num; i++)
{
if (sig_is_class(l2->sigs[i]))
{
sig_free(l2->sigs[i]);
continue;
}
if (sig_get_matched_type(l2->sigs[i]) == DIFF_UNMATCHED)
{
sig_set_nfile(l2->sigs[i], 2);
siglist_add(eng->ulist, l2->sigs[i]);
un2++;
}
}
msg("Identical functions: %d\n", idf);
msg("Matched functions: %d\n", mf);
msg("Unmatched functions 1: %d\n", un1);
msg("Unmatched functions 2: %d\n", un2);
display_results(eng);
}
if (d)
*d = eng;
return 0;
}
