/*
* Arguments : const mxArray *prhs[3]
* const mxArray *plhs[2]
* Return Type : void
*/
void get_coherence_api(const mxArray *prhs[3], const mxArray *plhs[2])
{
real_T (*mscxy)[513];
real_T (*frequency_list)[513];
real_T (*x)[768];
real_T (*y)[768];
real_T fs;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mscxy = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
frequency_list = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
/* Marshall function inputs */
x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
y = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "y");
fs = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "fs");
/* Invoke the target function */
get_coherence(*x, *y, fs, *mscxy, *frequency_list);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(*mscxy);
plhs[1] = b_emlrt_marshallOut(*frequency_list);
}
void makeHistFutTablewithRearrange_api(const mxArray * const prhs[4], const
mxArray *plhs[1])
{
emxArray_uint8_T *testm;
emxArray_real_T *rmat;
emxArray_real_T *y;
real_T range;
real_T dims;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_uint8_T(&st, &testm, 2, &h_emlrtRTEI, true);
emxInit_real_T1(&st, &rmat, 1, &h_emlrtRTEI, true);
emxInit_real_T(&st, &y, 2, &h_emlrtRTEI, true);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[0]), "testm", testm);
range = c_emlrt_marshallIn(&st, emlrtAliasP((const mxArray *)prhs[1]), "range");
dims = c_emlrt_marshallIn(&st, emlrtAliasP((const mxArray *)prhs[2]), "dims");
e_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[3]), "rmat", rmat);
/* Invoke the target function */
makeHistFutTablewithRearrange(&st, testm, range, dims, rmat, y);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(y);
y->canFreeData = false;
emxFree_real_T(&y);
rmat->canFreeData = false;
emxFree_real_T(&rmat);
testm->canFreeData = false;
emxFree_uint8_T(&testm);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void PlotResults_api(const mxArray * const prhs[4])
{
emxArray_real_T *t;
emxArray_real_T *sigIn;
emxArray_real_T *u;
emxArray_real_T *r;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &t, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &sigIn, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &u, 2, &ub_emlrtRTEI, true);
b_emxInit_real_T(&st, &r, 1, &ub_emlrtRTEI, true);
/* Marshall function inputs */
e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "t", t);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "sigIn", sigIn);
g_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "u", u);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "r", r);
/* Invoke the target function */
PlotResults(&st, t, sigIn, u, r);
r->canFreeData = false;
emxFree_real_T(&r);
u->canFreeData = false;
emxFree_real_T(&u);
sigIn->canFreeData = false;
emxFree_real_T(&sigIn);
t->canFreeData = false;
emxFree_real_T(&t);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Done_api(const mxArray * const prhs[5], const mxArray *plhs[1])
{
emxArray_real_T *spacePoints;
emxArray_real_T *timePoints;
emxArray_real_T *f;
real_T k;
real_T t;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &f, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
k = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "k");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "spacePoints", spacePoints);
t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "t");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "timePoints", timePoints);
g_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "f", f);
/* Invoke the target function */
k = Done(&st, k, spacePoints, t, timePoints, f);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(k);
f->canFreeData = false;
emxFree_real_T(&f);
timePoints->canFreeData = false;
emxFree_real_T(&timePoints);
spacePoints->canFreeData = false;
emxFree_real_T(&spacePoints);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Cone_api(const mxArray * const prhs[3], const mxArray *plhs[1])
{
emxArray_real_T *x;
emxArray_real_T *spacePoints;
emxArray_real_T *t;
emxArray_real_T *vals;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &t, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &vals, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "spacePoints", spacePoints);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "t", t);
/* Invoke the target function */
Cone(&st, x, spacePoints, t, vals);
/* Marshall function outputs */
plhs[0] = e_emlrt_marshallOut(vals);
vals->canFreeData = false;
emxFree_real_T(&vals);
t->canFreeData = false;
emxFree_real_T(&t);
spacePoints->canFreeData = false;
emxFree_real_T(&spacePoints);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void BoneStar_api(const mxArray * const prhs[4], const mxArray *plhs[1])
{
real_T (*vals)[2];
emxArray_real_T *spacePoints;
emxArray_real_T *timePoints;
real_T k;
real_T t;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
vals = (real_T (*)[2])mxMalloc(sizeof(real_T [2]));
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
k = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "k");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "spacePoints", spacePoints);
t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "t");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "timePoints", timePoints);
/* Invoke the target function */
BoneStar(&st, k, spacePoints, t, timePoints, *vals);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(*vals);
timePoints->canFreeData = false;
emxFree_real_T(&timePoints);
spacePoints->canFreeData = false;
emxFree_real_T(&spacePoints);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void G_api(const mxArray * const prhs[3], const mxArray *plhs[1])
{
emxArray_real_T *Y0;
emxArray_real_T *vecS0;
real_T (*para)[2];
real_T g;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &Y0, 2, &l_emlrtRTEI, true);
emxInit_real_T1(&st, &vecS0, 1, &l_emlrtRTEI, true);
/* Marshall function inputs */
para = emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[0]), "para");
c_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[1]), "Y0", Y0);
e_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[2]), "vecS0", vecS0);
/* Invoke the target function */
g = G(&st, *para, Y0, vecS0);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(g);
vecS0->canFreeData = false;
emxFree_real_T(&vecS0);
Y0->canFreeData = false;
emxFree_real_T(&Y0);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void BWbetaNloop_api(const mxArray *prhs[2], const mxArray *plhs[1])
{
emxArray_real_T *beta;
emxArray_real_T *updater;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&beta, 2, TRUE);
b_emxInit_real_T(&updater, 3, TRUE);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, TRUE, -1);
/* Marshall function inputs */
emlrt_marshallIn(emlrtAlias(prhs[0]), "beta", beta);
c_emlrt_marshallIn(emlrtAlias(prhs[1]), "updater", updater);
/* Invoke the target function */
BWbetaNloop(beta, updater);
/* Marshall function outputs */
emlrt_marshallOut(beta, prhs[0]);
plhs[0] = prhs[0];
updater->canFreeData = FALSE;
emxFree_real_T(&updater);
beta->canFreeData = FALSE;
emxFree_real_T(&beta);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
/*
* Arguments : const mxArray *prhs[5]
* const mxArray *plhs[1]
* Return Type : void
*/
void SpringForce_api(const mxArray *prhs[5], const mxArray *plhs[1])
{
emxArray_real_T *particleDist;
emxArray_real_T *springConst;
emxArray_boolean_T *connectivityMap;
emxArray_real_T *minParticleDist;
emxArray_real_T *fixedParticleNum;
emxArray_real_T *force;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &particleDist, 2, true);
emxInit_real_T(&st, &springConst, 2, true);
emxInit_boolean_T(&st, &connectivityMap, 2, true);
emxInit_real_T(&st, &minParticleDist, 2, true);
emxInit_real_T(&st, &fixedParticleNum, 2, true);
emxInit_real_T(&st, &force, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
prhs[4] = emlrtProtectR2012b(prhs[4], 4, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "particleDist", particleDist);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "springConst", springConst);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "connectivityMap",
connectivityMap);
emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "minParticleDist", minParticleDist);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "fixedParticleNum",
fixedParticleNum);
/* Invoke the target function */
SpringForce(particleDist, springConst, connectivityMap, minParticleDist,
fixedParticleNum, force);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(force);
force->canFreeData = false;
emxFree_real_T(&force);
fixedParticleNum->canFreeData = false;
emxFree_real_T(&fixedParticleNum);
minParticleDist->canFreeData = false;
emxFree_real_T(&minParticleDist);
connectivityMap->canFreeData = false;
emxFree_boolean_T(&connectivityMap);
springConst->canFreeData = false;
emxFree_real_T(&springConst);
particleDist->canFreeData = false;
emxFree_real_T(&particleDist);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void swipep_api(const mxArray *prhs[8], const mxArray *plhs[3])
{
emxArray_real_T *x;
emxArray_real_T *p;
emxArray_real_T *t;
emxArray_real_T *s;
real_T fs;
real_T (*plim)[2];
real_T dt;
real_T dlog2p;
real_T dERBs;
real_T woverlap;
real_T sTHR;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 1, true);
emxInit_real_T(&st, &p, 1, true);
emxInit_real_T(&st, &t, 1, true);
emxInit_real_T(&st, &s, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
fs = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "fs");
plim = k_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "plim");
dt = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "dt");
dlog2p = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "dlog2p");
dERBs = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "dERBs");
woverlap = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "woverlap");
sTHR = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "sTHR");
/* Invoke the target function */
swipep(x, fs, *plim, dt, dlog2p, dERBs, woverlap, sTHR, p, t, s);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(p);
plhs[1] = c_emlrt_marshallOut(t);
plhs[2] = c_emlrt_marshallOut(s);
s->canFreeData = false;
emxFree_real_T(&s);
t->canFreeData = false;
emxFree_real_T(&t);
p->canFreeData = false;
emxFree_real_T(&p);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void features_ufb_api(const mxArray *prhs[7], const mxArray *plhs[1])
{
emxArray_real_T *ftvec;
emxArray_real_T *wvec;
emxArray_real_T *ilog;
emxArray_real_T *ftmin;
emxArray_real_T *ftmax;
real_T fbmin;
real_T fbmax;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
b_emxInit_real_T(&st, &ftvec, 2, true);
emxInit_real_T(&st, &wvec, 1, true);
b_emxInit_real_T(&st, &ilog, 2, true);
b_emxInit_real_T(&st, &ftmin, 2, true);
b_emxInit_real_T(&st, &ftmax, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
prhs[4] = emlrtProtectR2012b(prhs[4], 4, false, -1);
/* Marshall function inputs */
i_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "ftvec", ftvec);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "wvec", wvec);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "ilog", ilog);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "ftmin", ftmin);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "ftmax", ftmax);
fbmin = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "fbmin");
fbmax = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "fbmax");
/* Invoke the target function */
fbmin = features_ufb(ftvec, wvec, ilog, ftmin, ftmax, fbmin, fbmax);
/* Marshall function outputs */
plhs[0] = b_emlrt_marshallOut(fbmin);
ftmax->canFreeData = false;
emxFree_real_T(&ftmax);
ftmin->canFreeData = false;
emxFree_real_T(&ftmin);
ilog->canFreeData = false;
emxFree_real_T(&ilog);
wvec->canFreeData = false;
emxFree_real_T(&wvec);
ftvec->canFreeData = false;
emxFree_real_T(&ftvec);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void fastdfa_api(const mxArray *prhs[1], const mxArray *plhs[3])
{
emxArray_real_T *x;
emxArray_real_T *intervals;
emxArray_real_T *flucts;
real_T alpha;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 1, true);
emxInit_real_T(&st, &intervals, 1, true);
emxInit_real_T(&st, &flucts, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
/* Invoke the target function */
fastdfa(x, &alpha, intervals, flucts);
/* Marshall function outputs */
plhs[0] = b_emlrt_marshallOut(alpha);
plhs[1] = c_emlrt_marshallOut(intervals);
plhs[2] = c_emlrt_marshallOut(flucts);
flucts->canFreeData = false;
emxFree_real_T(&flucts);
intervals->canFreeData = false;
emxFree_real_T(&intervals);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void nsht_legmat_api(const mxArray * const prhs[3], const mxArray *plhs[2])
{
emxArray_real_T *thetas;
emxArray_real_T *P;
emxArray_real_T *Sc;
real_T L;
real_T m;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&thetas, 2, &b_emlrtRTEI, TRUE);
emxInit_real_T(&P, 2, &b_emlrtRTEI, TRUE);
emxInit_real_T(&Sc, 2, &b_emlrtRTEI, TRUE);
/* Marshall function inputs */
emlrt_marshallIn(emlrtAlias(prhs[0]), "thetas", thetas);
L = c_emlrt_marshallIn(emlrtAliasP(prhs[1]), "L");
m = c_emlrt_marshallIn(emlrtAliasP(prhs[2]), "m");
/* Invoke the target function */
nsht_legmat(thetas, L, m, P, Sc);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(P);
plhs[1] = emlrt_marshallOut(Sc);
Sc->canFreeData = FALSE;
emxFree_real_T(&Sc);
P->canFreeData = FALSE;
emxFree_real_T(&P);
thetas->canFreeData = FALSE;
emxFree_real_T(&thetas);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
void BERCalculationSIMO_api(const mxArray * const prhs[2], const mxArray *plhs[1])
{
emxArray_real_T *bitsRX;
real_T type;
const mxArray *tmp;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&bitsRX, 1, &b_emlrtRTEI, TRUE);
/* Marshall function inputs */
c_emlrt_marshallIn(emlrtAlias(prhs[0]), "bitsRX", bitsRX);
type = emlrt_marshallIn(emlrtAliasP(prhs[1]), "type");
/* Marshall in global variables */
tmp = mexGetVariable("global", "d");
if (tmp) {
e_emlrt_marshallIn(tmp, "d", &d);
d_dirty = 0U;
}
/* Invoke the target function */
type = BERCalculationSIMO(bitsRX, type);
/* Marshall out global variables */
mexPutVariable("global", "d", b_emlrt_marshallOut(&d));
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(type);
bitsRX->canFreeData = FALSE;
emxFree_real_T(&bitsRX);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
void JenkinsCompare_api(JenkinsCompareStackData *SD, const mxArray * const prhs
[2], const mxArray *plhs[1])
{
emxArray_real_T *y;
real_T (*x)[78596];
real_T sampleRate;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &y, 2, &gb_emlrtRTEI, true);
/* Marshall function inputs */
x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
sampleRate = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "sampleRate");
/* Invoke the target function */
JenkinsCompare(SD, &st, *x, sampleRate, y);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(y);
y->canFreeData = false;
emxFree_real_T(&y);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void extractaudiophon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
emxArray_real_T *rawaudio;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mxMalloc(0U);
mxMalloc(0U);
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &rawaudio, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "rawaudio", rawaudio);
/* Invoke the target function */
extractaudiophon(rawaudio);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut();
plhs[1] = emlrt_marshallOut();
rawaudio->canFreeData = false;
emxFree_real_T(&rawaudio);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void vadsplitphon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
emxArray_real_T *x;
int32_T i_size[2];
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mxMalloc(0U);
mxMalloc(0U);
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
/* Invoke the target function */
vadsplitphon(x, i_size);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut();
plhs[1] = i_emlrt_marshallOut(i_size);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void mfcc_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
emxArray_real_T *samples;
emxArray_real_T *cepstra;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &samples, 1, true);
b_emxInit_real_T(&st, &cepstra, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "samples", samples);
/* Invoke the target function */
mfcc(samples, cepstra);
/* Marshall function outputs */
plhs[0] = h_emlrt_marshallOut(cepstra);
cepstra->canFreeData = false;
emxFree_real_T(&cepstra);
samples->canFreeData = false;
emxFree_real_T(&samples);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Ccoeff_api(const mxArray * const prhs[4], const mxArray *plhs[1])
{
emxArray_real_T *x;
emxArray_real_T *vals;
real_T k;
real_T t;
real_T spacePoints;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &vals, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
k = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "k");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "x", x);
t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "t");
spacePoints = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "spacePoints");
/* Invoke the target function */
Ccoeff(&st, k, x, t, spacePoints, vals);
/* Marshall function outputs */
plhs[0] = d_emlrt_marshallOut(vals);
vals->canFreeData = false;
emxFree_real_T(&vals);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void features_bvav2_api(const mxArray *prhs[2], const mxArray *plhs[1])
{
real_T (*ft)[13];
emxArray_real_T *audio;
real_T srate;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
ft = (real_T (*)[13])mxMalloc(sizeof(real_T [13]));
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &audio, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "audio", audio);
srate = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "srate");
/* Invoke the target function */
features_bvav2(audio, srate, *ft);
/* Marshall function outputs */
plhs[0] = g_emlrt_marshallOut(*ft);
audio->canFreeData = false;
emxFree_real_T(&audio);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Bcoeff_api(const mxArray * const prhs[5], const mxArray *plhs[1])
{
emxArray_real_T *timePoints;
real_T ksi;
real_T j;
real_T x;
real_T t;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
ksi = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "ksi");
j = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "j");
x = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "x");
t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "t");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "timePoints", timePoints);
/* Invoke the target function */
ksi = Bcoeff(&st, ksi, j, x, t, timePoints);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(ksi);
timePoints->canFreeData = false;
emxFree_real_T(&timePoints);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void lomb_api(const mxArray *prhs[4], const mxArray *plhs[3])
{
emxArray_real_T *t;
emxArray_real_T *h;
emxArray_real_T *f;
emxArray_real_T *P;
emxArray_real_T *prob;
real_T ofac;
real_T hifac;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &t, 1, true);
emxInit_real_T(&st, &h, 1, true);
emxInit_real_T(&st, &f, 1, true);
emxInit_real_T(&st, &P, 1, true);
emxInit_real_T(&st, &prob, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "t", t);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "h", h);
ofac = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "ofac");
hifac = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "hifac");
/* Invoke the target function */
lomb(t, h, ofac, hifac, f, P, prob);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(f);
plhs[1] = c_emlrt_marshallOut(P);
plhs[2] = c_emlrt_marshallOut(prob);
prob->canFreeData = false;
emxFree_real_T(&prob);
P->canFreeData = false;
emxFree_real_T(&P);
f->canFreeData = false;
emxFree_real_T(&f);
h->canFreeData = false;
emxFree_real_T(&h);
t->canFreeData = false;
emxFree_real_T(&t);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
static boolean_T l_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u,
const emlrtMsgIdentifier *parentId)
{
boolean_T y;
y = r_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
emlrtDestroyArray(&u);
return y;
}
/* Function Definitions */
real_T b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
emlrtMsgIdentifier *parentId)
{
real_T y;
y = n_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
emlrtDestroyArray(&u);
return y;
}
/*
* Arguments : const emlrtStack *sp
* const mxArray *u
* const emlrtMsgIdentifier *parentId
* Return Type : double (*)[4]
*/
static double (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u,
const emlrtMsgIdentifier *parentId))[4]
{
double (*y)[4];
y = c_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
emlrtDestroyArray(&u);
return y;
}
/* Function Definitions */
static real_T (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
emlrtMsgIdentifier *parentId))[2]
{
real_T (*y)[2];
y = g_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
emlrtDestroyArray(&u);
return y;
}
/* Function Definitions */
static real_T b_emlrt_marshallIn(const mxArray *u, const emlrtMsgIdentifier
*parentId)
{
real_T y;
y = c_emlrt_marshallIn(emlrtAlias(u), parentId);
emlrtDestroyArray(&u);
return y;
}
static void e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *timePoints,
const char_T *identifier, emxArray_real_T *y)
{
emlrtMsgIdentifier thisId;
thisId.fIdentifier = identifier;
thisId.fParent = NULL;
f_emlrt_marshallIn(sp, emlrtAlias(timePoints), &thisId, y);
emlrtDestroyArray(&timePoints);
}
/*
* Arguments : const emlrtStack *sp
* const mxArray *engKinMat_engKinInx_wayInx
* const char_T *identifier
* emxArray_real_T *y
* Return Type : void
*/
static void e_emlrt_marshallIn(const emlrtStack *sp, const mxArray
*engKinMat_engKinInx_wayInx, const char_T *identifier, emxArray_real_T *y)
{
emlrtMsgIdentifier thisId;
thisId.fIdentifier = identifier;
thisId.fParent = NULL;
f_emlrt_marshallIn(sp, emlrtAlias(engKinMat_engKinInx_wayInx), &thisId, y);
emlrtDestroyArray(&engKinMat_engKinInx_wayInx);
}
static void i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *r, const
char_T *identifier, emxArray_real_T *y)
{
emlrtMsgIdentifier thisId;
thisId.fIdentifier = identifier;
thisId.fParent = NULL;
j_emlrt_marshallIn(sp, emlrtAlias(r), &thisId, y);
emlrtDestroyArray(&r);
}
