File: _coder_gjbf_api.c

    1   /*
    2    * _coder_gjbf_api.c
    3    *
    4    * Code generation for function '_coder_gjbf_api'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "_coder_gjbf_api.h"
   12   #include "gjbf_emxutil.h"
   13   #include "gjbf_data.h"
   14   #include "blas.h"
   15   
   16   /* Variable Definitions */
   17   static emlrtRTEInfo f_emlrtRTEI = { 1, 1, "_coder_gjbf_api", "" };
   18   
   19   /* Function Declarations */
   20   static real_T (*ab_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   21     const emlrtMsgIdentifier *msgId))[16];
   22   static real_T (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   23     emlrtMsgIdentifier *parentId))[14112];
   24   static const mxArray *b_emlrt_marshallOut(const emxArray_real_T *u);
   25   static void bb_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
   26     emlrtMsgIdentifier *msgId);
   27   static real_T c_emlrt_marshallIn(const emlrtStack *sp, const mxArray *fs, const
   28     char_T *identifier);
   29   static const mxArray *c_emlrt_marshallOut(const emxArray_real_T *u);
   30   static real_T d_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   31     emlrtMsgIdentifier *parentId);
   32   static const mxArray *d_emlrt_marshallOut(const real_T u[14112]);
   33   static real_T (*e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *spos,
   34     const char_T *identifier))[3];
   35   static real_T (*emlrt_marshallIn(const emlrtStack *sp, const mxArray *x, const
   36     char_T *identifier))[14112];
   37   static const mxArray *emlrt_marshallOut(const real_T u_data[], const int32_T
   38     u_size[1]);
   39   static real_T (*f_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   40     emlrtMsgIdentifier *parentId))[3];
   41   static real_T (*g_emlrt_marshallIn(const emlrtStack *sp, const mxArray *mpos,
   42     const char_T *identifier))[48];
   43   static real_T (*h_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   44     emlrtMsgIdentifier *parentId))[48];
   45   static real_T (*i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *phi,
   46     const char_T *identifier))[320];
   47   static real_T (*j_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   48     emlrtMsgIdentifier *parentId))[320];
   49   static void k_emlrt_marshallIn(const emlrtStack *sp, const mxArray *xPrev, const
   50     char_T *identifier, emxArray_real_T *y);
   51   static void l_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   52     emlrtMsgIdentifier *parentId, emxArray_real_T *y);
   53   static void m_emlrt_marshallIn(const emlrtStack *sp, const mxArray *bp, const
   54     char_T *identifier, real_T **y_data, int32_T y_size[1]);
   55   static void n_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   56     emlrtMsgIdentifier *parentId, real_T **y_data, int32_T y_size[1]);
   57   static real_T (*o_emlrt_marshallIn(const emlrtStack *sp, const mxArray *snr1,
   58     const char_T *identifier))[16];
   59   static real_T (*p_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   60     emlrtMsgIdentifier *parentId))[16];
   61   static void q_emlrt_marshallIn(const emlrtStack *sp, const mxArray *bmF, const
   62     char_T *identifier);
   63   static void r_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
   64     emlrtMsgIdentifier *parentId);
   65   static real_T (*s_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   66     const emlrtMsgIdentifier *msgId))[14112];
   67   static real_T t_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
   68     emlrtMsgIdentifier *msgId);
   69   static real_T (*u_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   70     const emlrtMsgIdentifier *msgId))[3];
   71   static real_T (*v_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   72     const emlrtMsgIdentifier *msgId))[48];
   73   static real_T (*w_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   74     const emlrtMsgIdentifier *msgId))[320];
   75   static void x_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
   76     emlrtMsgIdentifier *msgId, emxArray_real_T *ret);
   77   static void y_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
   78     emlrtMsgIdentifier *msgId, real_T **ret_data, int32_T ret_size[1]);
   79   
   80   /* Function Definitions */
   81   static real_T (*ab_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
   82     const emlrtMsgIdentifier *msgId))[16]
   83   {
   84     real_T (*ret)[16];
   85     static const int32_T dims[2] = { 1, 16 };
   86   
   87     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims);
   88     ret = (real_T (*)[16])mxGetData(src);
   89     emlrtDestroyArray(&src);
   90     return ret;
   91   }
   92     static real_T (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u,
   93     const emlrtMsgIdentifier *parentId))[14112]
   94   {
   95     real_T (*y)[14112];
   96     y = s_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
   97     emlrtDestroyArray(&u);
   98     return y;
   99   }
  100   
  101   static const mxArray *b_emlrt_marshallOut(const emxArray_real_T *u)
  102   {
  103     const mxArray *y;
  104     const mxArray *m25;
  105     static const int32_T iv50[3] = { 0, 0, 0 };
  106   
  107     y = NULL;
  108     m25 = emlrtCreateNumericArray(3, iv50, mxDOUBLE_CLASS, mxREAL);
  109     mxSetData((mxArray *)m25, (void *)u->data);
  110     emlrtSetDimensions((mxArray *)m25, u->size, 3);
  111     emlrtAssign(&y, m25);
  112     return y;
  113   }
  114   
  115   static void bb_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  116     emlrtMsgIdentifier *msgId)
  117   {
  118     static const int32_T dims[2] = { 0, 0 };
  119   
  120     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims);
  121     mxGetData(src);
  122     emlrtDestroyArray(&src);
  123   }
  124   
  125   static real_T c_emlrt_marshallIn(const emlrtStack *sp, const mxArray *fs, const
  126     char_T *identifier)
  127   {
  128     real_T y;
  129     emlrtMsgIdentifier thisId;
  130     thisId.fIdentifier = identifier;
  131     thisId.fParent = NULL;
  132     thisId.bParentIsCell = false;
  133     y = d_emlrt_marshallIn(sp, emlrtAlias(fs), &thisId);
  134     emlrtDestroyArray(&fs);
  135     return y;
  136   }
  137   
  138   static const mxArray *c_emlrt_marshallOut(const emxArray_real_T *u)
  139   {
  140     const mxArray *y;
  141     const mxArray *m26;
  142     static const int32_T iv51[3] = { 0, 0, 0 };
  143   
  144     y = NULL;
  145     m26 = emlrtCreateNumericArray(3, iv51, mxDOUBLE_CLASS, mxREAL);
  146     mxSetData((mxArray *)m26, (void *)u->data);
  147     emlrtSetDimensions((mxArray *)m26, u->size, 3);
  148     emlrtAssign(&y, m26);
  149     return y;
  150   }
  151   
  152   static real_T d_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  153     emlrtMsgIdentifier *parentId)
  154   {
  155     real_T y;
  156     y = t_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  157     emlrtDestroyArray(&u);
  158     return y;
  159   }
  160   
  161   static const mxArray *d_emlrt_marshallOut(const real_T u[14112])
  162   {
  163     const mxArray *y;
  164     const mxArray *m27;
  165     static const int32_T iv52[2] = { 0, 0 };
  166   
  167     static const int32_T iv53[2] = { 882, 16 };
  168   
  169     y = NULL;
  170     m27 = emlrtCreateNumericArray(2, iv52, mxDOUBLE_CLASS, mxREAL);
  171     mxSetData((mxArray *)m27, (void *)u);
  172     emlrtSetDimensions((mxArray *)m27, iv53, 2);
  173     emlrtAssign(&y, m27);
  174     return y;
  175   }
  176   
  177   static real_T (*e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *spos,
  178     const char_T *identifier))[3]
  179   {
  180     real_T (*y)[3];
  181     emlrtMsgIdentifier thisId;
  182     thisId.fIdentifier = identifier;
  183     thisId.fParent = NULL;
  184     thisId.bParentIsCell = false;
  185     y = f_emlrt_marshallIn(sp, emlrtAlias(spos), &thisId);
  186     emlrtDestroyArray(&spos);
  187     return y;
  188   }
  189     static real_T (*emlrt_marshallIn(const emlrtStack *sp, const mxArray *x, const
  190     char_T *identifier))[14112]
  191   {
  192     real_T (*y)[14112];
  193     emlrtMsgIdentifier thisId;
  194     thisId.fIdentifier = identifier;
  195     thisId.fParent = NULL;
  196     thisId.bParentIsCell = false;
  197     y = b_emlrt_marshallIn(sp, emlrtAlias(x), &thisId);
  198     emlrtDestroyArray(&x);
  199     return y;
  200   }
  201   
  202   static const mxArray *emlrt_marshallOut(const real_T u_data[], const int32_T
  203     u_size[1])
  204   {
  205     const mxArray *y;
  206     const mxArray *m24;
  207     static const int32_T iv49[1] = { 0 };
  208   
  209     y = NULL;
  210     m24 = emlrtCreateNumericArray(1, iv49, mxDOUBLE_CLASS, mxREAL);
  211     mxSetData((mxArray *)m24, (void *)u_data);
  212     emlrtSetDimensions((mxArray *)m24, u_size, 1);
  213     emlrtAssign(&y, m24);
  214     return y;
  215   }
  216   
  217   static real_T (*f_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  218     emlrtMsgIdentifier *parentId))[3]
  219   {
  220     real_T (*y)[3];
  221     y = u_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  222     emlrtDestroyArray(&u);
  223     return y;
  224   }
  225     static real_T (*g_emlrt_marshallIn(const emlrtStack *sp, const mxArray *mpos,
  226     const char_T *identifier))[48]
  227   {
  228     real_T (*y)[48];
  229     emlrtMsgIdentifier thisId;
  230     thisId.fIdentifier = identifier;
  231     thisId.fParent = NULL;
  232     thisId.bParentIsCell = false;
  233     y = h_emlrt_marshallIn(sp, emlrtAlias(mpos), &thisId);
  234     emlrtDestroyArray(&mpos);
  235     return y;
  236   }
  237   
  238   static real_T (*h_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  239     emlrtMsgIdentifier *parentId))[48]
  240   {
  241     real_T (*y)[48];
  242     y = v_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  243     emlrtDestroyArray(&u);
  244     return y;
  245   }
  246     static real_T (*i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *phi,
  247     const char_T *identifier))[320]
  248   {
  249     real_T (*y)[320];
  250     emlrtMsgIdentifier thisId;
  251     thisId.fIdentifier = identifier;
  252     thisId.fParent = NULL;
  253     thisId.bParentIsCell = false;
  254     y = j_emlrt_marshallIn(sp, emlrtAlias(phi), &thisId);
  255     emlrtDestroyArray(&phi);
  256     return y;
  257   }
  258   
  259   static real_T (*j_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  260     emlrtMsgIdentifier *parentId))[320]
  261   {
  262     real_T (*y)[320];
  263     y = w_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  264     emlrtDestroyArray(&u);
  265     return y;
  266   }
  267     static void k_emlrt_marshallIn(const emlrtStack *sp, const mxArray *xPrev,
  268     const char_T *identifier, emxArray_real_T *y)
  269   {
  270     emlrtMsgIdentifier thisId;
  271     thisId.fIdentifier = identifier;
  272     thisId.fParent = NULL;
  273     thisId.bParentIsCell = false;
  274     l_emlrt_marshallIn(sp, emlrtAlias(xPrev), &thisId, y);
  275     emlrtDestroyArray(&xPrev);
  276   }
  277   
  278   static void l_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  279     emlrtMsgIdentifier *parentId, emxArray_real_T *y)
  280   {
  281     x_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y);
  282     emlrtDestroyArray(&u);
  283   }
  284   
  285   static void m_emlrt_marshallIn(const emlrtStack *sp, const mxArray *bp, const
  286     char_T *identifier, real_T **y_data, int32_T y_size[1])
  287   {
  288     emlrtMsgIdentifier thisId;
  289     thisId.fIdentifier = identifier;
  290     thisId.fParent = NULL;
  291     thisId.bParentIsCell = false;
  292     n_emlrt_marshallIn(sp, emlrtAlias(bp), &thisId, y_data, y_size);
  293     emlrtDestroyArray(&bp);
  294   }
  295   
  296   static void n_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  297     emlrtMsgIdentifier *parentId, real_T **y_data, int32_T y_size[1])
  298   {
  299     y_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y_data, y_size);
  300     emlrtDestroyArray(&u);
  301   }
  302   
  303   static real_T (*o_emlrt_marshallIn(const emlrtStack *sp, const mxArray *snr1,
  304     const char_T *identifier))[16]
  305   {
  306     real_T (*y)[16];
  307     emlrtMsgIdentifier thisId;
  308     thisId.fIdentifier = identifier;
  309     thisId.fParent = NULL;
  310     thisId.bParentIsCell = false;
  311     y = p_emlrt_marshallIn(sp, emlrtAlias(snr1), &thisId);
  312     emlrtDestroyArray(&snr1);
  313     return y;
  314   }
  315     static real_T (*p_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u,
  316     const emlrtMsgIdentifier *parentId))[16]
  317   {
  318     real_T (*y)[16];
  319     y = ab_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  320     emlrtDestroyArray(&u);
  321     return y;
  322   }
  323   
  324   static void q_emlrt_marshallIn(const emlrtStack *sp, const mxArray *bmF, const
  325     char_T *identifier)
  326   {
  327     emlrtMsgIdentifier thisId;
  328     thisId.fIdentifier = identifier;
  329     thisId.fParent = NULL;
  330     thisId.bParentIsCell = false;
  331     r_emlrt_marshallIn(sp, emlrtAlias(bmF), &thisId);
  332     emlrtDestroyArray(&bmF);
  333   }
  334   
  335   static void r_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  336     emlrtMsgIdentifier *parentId)
  337   {
  338     bb_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  339     emlrtDestroyArray(&u);
  340   }
  341   
  342   static real_T (*s_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
  343     const emlrtMsgIdentifier *msgId))[14112]
  344   {
  345     real_T (*ret)[14112];
  346     static const int32_T dims[2] = { 882, 16 };
  347   
  348     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims);
  349     ret = (real_T (*)[14112])mxGetData(src);
  350     emlrtDestroyArray(&src);
  351     return ret;
  352   }
  353     static real_T t_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
  354     const emlrtMsgIdentifier *msgId)
  355   {
  356     real_T ret;
  357     static const int32_T dims = 0;
  358     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 0U, &dims);
  359     ret = *(real_T *)mxGetData(src);
  360     emlrtDestroyArray(&src);
  361     return ret;
  362   }
  363   
  364   static real_T (*u_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
  365     const emlrtMsgIdentifier *msgId))[3]
  366   {
  367     real_T (*ret)[3];
  368     static const int32_T dims[1] = { 3 };
  369   
  370     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 1U, dims);
  371     ret = (real_T (*)[3])mxGetData(src);
  372     emlrtDestroyArray(&src);
  373     return ret;
  374   }
  375     static real_T (*v_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
  376     const emlrtMsgIdentifier *msgId))[48]
  377   {
  378     real_T (*ret)[48];
  379     static const int32_T dims[2] = { 3, 16 };
  380   
  381     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims);
  382     ret = (real_T (*)[48])mxGetData(src);
  383     emlrtDestroyArray(&src);
  384     return ret;
  385   }
  386   
  387   static real_T (*w_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src,
  388     const emlrtMsgIdentifier *msgId))[320]
  389   {
  390     real_T (*ret)[320];
  391     static const int32_T dims[2] = { 20, 16 };
  392   
  393     emlrtCheckBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims);
  394     ret = (real_T (*)[320])mxGetData(src);
  395     emlrtDestroyArray(&src);
  396     return ret;
  397   }
  398     static void x_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  399     emlrtMsgIdentifier *msgId, emxArray_real_T *ret)
  400   {
  401     static const int32_T dims[2] = { 882, 16 };
  402   
  403     boolean_T bv17[2] = { true, false };
  404   
  405     int32_T iv54[2];
  406     emlrtCheckVsBuiltInR2012b(sp, msgId, src, "double", false, 2U, dims, &bv17[0],
  407       iv54);
  408     ret->size[0] = iv54[0];
  409     ret->size[1] = iv54[1];
  410     ret->allocatedSize = ret->size[0] * ret->size[1];
  411     ret->data = (real_T *)mxGetData(src);
  412     ret->canFreeData = false;
  413     emlrtDestroyArray(&src);
  414   }
  415   
  416   static void y_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const
  417     emlrtMsgIdentifier *msgId, real_T **ret_data, int32_T ret_size[1])
  418   {
  419     static const int32_T dims[1] = { 882 };
  420   
  421     boolean_T bv18[1] = { true };
  422   
  423     int32_T iv55[1];
  424     emlrtCheckVsBuiltInR2012b(sp, msgId, src, "double", false, 1U, dims, &bv18[0],
  425       iv55);
  426     ret_size[0] = iv55[0];
  427     *ret_data = (real_T *)mxGetData(src);
  428     emlrtDestroyArray(&src);
  429   }
  430   
  431   void gjbf_api(gjbfStackData *SD, const mxArray * const prhs[24], const mxArray
  432                 *plhs[7])
  433   {
  434     real_T (*snrAll)[14112];
  435     real_T (*z)[14112];
  436     real_T (*mcAdapt)[14112];
  437     real_T (*y_data)[1764];
  438     real_T (*b_data)[1764];
  439     emxArray_real_T *xPrev;
  440     emxArray_real_T *zp;
  441     emxArray_real_T *bmw;
  442     emxArray_real_T *mcWall;
  443     real_T (*x)[14112];
  444     real_T fs;
  445     real_T (*spos)[3];
  446     real_T (*mpos)[48];
  447     real_T c;
  448     real_T p;
  449     real_T q;
  450     real_T mu;
  451     real_T order;
  452     real_T beta;
  453     real_T (*phi)[320];
  454     real_T (*psi)[320];
  455     real_T K;
  456     real_T (*bp_data)[882];
  457     int32_T bp_size[1];
  458     real_T (*bw1)[320];
  459     real_T (*mw1)[320];
  460     real_T snrThresh;
  461     real_T snrRate;
  462     real_T (*snr1)[16];
  463     real_T iw;
  464     int32_T y_size[1];
  465     int32_T b_size[1];
  466     emlrtStack st = { NULL, NULL, NULL };
  467   
  468     st.tls = emlrtRootTLSGlobal;
  469     snrAll = (real_T (*)[14112])mxMalloc(sizeof(real_T [14112]));
  470     z = (real_T (*)[14112])mxMalloc(sizeof(real_T [14112]));
  471     mcAdapt = (real_T (*)[14112])mxMalloc(sizeof(real_T [14112]));
  472     y_data = (real_T (*)[1764])mxMalloc(sizeof(real_T [1764]));
  473     b_data = (real_T (*)[1764])mxMalloc(sizeof(real_T [1764]));
  474     emlrtHeapReferenceStackEnterFcnR2012b(&st);
  475     emxInit_real_T(&st, &xPrev, 2, &f_emlrtRTEI, true);
  476     emxInit_real_T(&st, &zp, 2, &f_emlrtRTEI, true);
  477     emxInit_real_T1(&st, &bmw, 3, &f_emlrtRTEI, true);
  478     emxInit_real_T1(&st, &mcWall, 3, &f_emlrtRTEI, true);
  479   
  480     /* Marshall function inputs */
  481     x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
  482     fs = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "fs");
  483     spos = e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "spos");
  484     mpos = g_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "mpos");
  485     c = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "c");
  486     p = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "p");
  487     q = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "q");
  488     mu = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "mu");
  489     order = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "order");
  490     beta = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[9]), "beta");
  491     phi = i_emlrt_marshallIn(&st, emlrtAlias(prhs[10]), "phi");
  492     psi = i_emlrt_marshallIn(&st, emlrtAlias(prhs[11]), "psi");
  493     K = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[12]), "K");
  494     k_emlrt_marshallIn(&st, emlrtAlias(prhs[13]), "xPrev", xPrev);
  495     m_emlrt_marshallIn(&st, emlrtAlias(prhs[14]), "bp", (real_T **)&bp_data,
  496                        bp_size);
  497     k_emlrt_marshallIn(&st, emlrtAlias(prhs[15]), "zp", zp);
  498     bw1 = i_emlrt_marshallIn(&st, emlrtAlias(prhs[16]), "bw1");
  499     mw1 = i_emlrt_marshallIn(&st, emlrtAlias(prhs[17]), "mw1");
  500     snrThresh = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[18]), "snrThresh");
  501     snrRate = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[19]), "snrRate");
  502     snr1 = o_emlrt_marshallIn(&st, emlrtAlias(prhs[20]), "snr1");
  503     q_emlrt_marshallIn(&st, emlrtAlias(prhs[21]), "bmF");
  504     q_emlrt_marshallIn(&st, emlrtAlias(prhs[22]), "mcWForce");
  505     iw = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[23]), "iw");
  506   
  507     /* Invoke the target function */
  508     gjbf(SD, &st, *x, fs, *spos, *mpos, c, p, q, mu, order, beta, *phi, *psi, K,
  509          xPrev, *bp_data, bp_size, zp, *bw1, *mw1, snrThresh, snrRate, *snr1, iw, *
  510          y_data, y_size, bmw, mcWall, *snrAll, *b_data, b_size, *z, *mcAdapt);
  511   
  512     /* Marshall function outputs */
  513     plhs[0] = emlrt_marshallOut(*y_data, y_size);
  514     plhs[1] = b_emlrt_marshallOut(bmw);
  515     plhs[2] = c_emlrt_marshallOut(mcWall);
  516     plhs[3] = d_emlrt_marshallOut(*snrAll);
  517     plhs[4] = emlrt_marshallOut(*b_data, b_size);
  518     plhs[5] = d_emlrt_marshallOut(*z);
  519     plhs[6] = d_emlrt_marshallOut(*mcAdapt);
  520     mcWall->canFreeData = false;
  521     emxFree_real_T(&mcWall);
  522     bmw->canFreeData = false;
  523     emxFree_real_T(&bmw);
  524     zp->canFreeData = false;
  525     emxFree_real_T(&zp);
  526     xPrev->canFreeData = false;
  527     emxFree_real_T(&xPrev);
  528     emlrtHeapReferenceStackLeaveFcnR2012b(&st);
  529   }
  530   
  531   /* End of code generation (_coder_gjbf_api.c) */
  532