LVAL xlc_snd_shape(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    double arg3 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_shape(arg1, arg2, arg3);
    return cvsound(result);
}

LVAL xlc_snd_pwl(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    LVAL arg3 = xlgetarg();
    sound_type result;

    xllastarg();
    result = snd_pwl(arg1, arg2, arg3);
    return cvsound(result);
}

LVAL xlc_snd_eqbandvvv(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type arg3 = getsound(xlgasound());
    sound_type arg4 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_eqbandvvv(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_flute_freq(void)
{
    double arg1 = testarg2(xlgaanynum());
    sound_type arg2 = getsound(xlgasound());
    sound_type arg3 = getsound(xlgasound());
    double arg4 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_flute_freq(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_sine(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_sine(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_avg(void)
{
    sound_type arg1 = getsound(xlgasound());
    long arg2 = getfixnum(xlgafixnum());
    long arg3 = getfixnum(xlgafixnum());
    long arg4 = getfixnum(xlgafixnum());
    sound_type result;

    xllastarg();
    result = snd_avg(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_alpassvv(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type arg3 = getsound(xlgasound());
    double arg4 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_alpassvv(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_slider(void)
{
    long arg1 = getfixnum(xlgafixnum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_slider(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL xlc_snd_aresoncv(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type arg3 = getsound(xlgasound());
    long arg4 = getfixnum(xlgafixnum());
    sound_type result;

    xllastarg();
    result = snd_aresoncv(arg1, arg2, arg3, arg4);
    return cvsound(result);
}

LVAL snd_make_yin(sound_type s, double low_step, double high_step, long stepsize)
{
    LVAL result;
    int j;
    register yin_susp_type susp;
    rate_type sr = s->sr;
    time_type t0 = s->t0;

    falloc_generic(susp, yin_susp_node, "snd_make_yin");
    susp->susp.fetch = yin_fetch;
    susp->terminate_cnt = UNKNOWN;

    /* initialize susp state */
    susp->susp.free = yin_free;
    susp->susp.sr = sr / stepsize;
    susp->susp.t0 = t0;
    susp->susp.mark = yin_mark;
    susp->susp.print_tree = yin_print_tree;
    susp->susp.name = "yin";
    susp->logically_stopped = false;
    susp->susp.log_stop_cnt = logical_stop_cnt_cvt(s);
    susp->susp.current = 0;
    susp->s = s;
    susp->s_cnt = 0;
    susp->m = (long) (sr / step_to_hz(high_step));
    if (susp->m < 2) susp->m = 2;
    /* add 1 to make sure we round up */
    susp->middle = (long) (sr / step_to_hz(low_step)) + 1;
    susp->blocksize = susp->middle * 2;
    susp->stepsize = stepsize;
    /* blocksize must be at least step size to implement stepping */
    if (susp->stepsize > susp->blocksize) susp->blocksize = susp->stepsize;
    susp->block = (sample_type *) malloc(susp->blocksize * sizeof(sample_type));
    susp->temp = (float *) malloc((susp->middle - susp->m + 1) * sizeof(float));
    susp->fillptr = susp->block;
    susp->endptr = susp->block + susp->blocksize;

    xlsave1(result);

    result = newvector(2);      /* create array for F0 and harmonicity */
    /* create sounds to return */
    for (j = 0; j < 2; j++) {
        sound_type snd = sound_create((snd_susp_type)susp,
                                      susp->susp.t0, susp->susp.sr, 1.0);
        LVAL snd_lval = cvsound(snd);
        /*      nyquist_printf("yin_create: sound %d is %x, LVAL %x\n", j, snd, snd_lval); */
        setelement(result, j, snd_lval);
        susp->chan[j] = snd->list;
        /* DEBUG: ysnd[j] = snd; */
    }
    xlpop();
    return result;
}

LVAL xlc_snd_stkchorus(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_stkchorus(arg1, arg2, arg3, arg4, arg5);
    return cvsound(result);
}

LVAL xlc_snd_siosc(void)
{
    LVAL arg1 = xlgetarg();
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    sound_type arg5 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_siosc(arg1, arg2, arg3, arg4, arg5);
    return cvsound(result);
}

LVAL xlc_snd_ifft(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    LVAL arg3 = xlgetarg();
    long arg4 = getfixnum(xlgafixnum());
    LVAL arg5 = xlgetarg();
    sound_type result;

    xllastarg();
    result = snd_ifft(arg1, arg2, arg3, arg4, arg5);
    return cvsound(result);
}

LVAL xlc_snd_buzz(void)
{
    long arg1 = getfixnum(xlgafixnum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    sound_type arg5 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_buzz(arg1, arg2, arg3, arg4, arg5);
    return cvsound(result);
}

LVAL xlc_snd_phasevocoder(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    long arg3 = getfixnum(xlgafixnum());
    long arg4 = getfixnum(xlgafixnum());
    long arg5 = getfixnum(xlgafixnum());
    sound_type result;

    xllastarg();
    result = snd_phasevocoder(arg1, arg2, arg3, arg4, arg5);
    return cvsound(result);
}

double sound_max(LVAL snd_expr, long n)
{
    LVAL s_as_lval;
    sound_type s = NULL;
    long blocklen;
    sample_block_values_type sbufp;
    register double maximum = 0;

    s_as_lval = xleval(snd_expr);
    /* BE CAREFUL - DO NOT ALLOW GC TO RUN WHILE LVAL IS UNPROTECTED */
    if (exttypep(s_as_lval, a_sound)) {
        /* if snd_expr was simply a symbol, then s now points to
        a shared sound_node.  If we read samples from it, then
        the sound bound to the symbol will be destroyed, so
        copy it first.  If snd_expr was a real expression that
        computed a new value, then the next garbage collection
        will reclaim the sound_node.  We need to make the new
        sound reachable by the garbage collector to that any
        lisp data reachable from the sound do not get collected.
        To make the sound reachable, we need to allocate a node,
        and the GC might run, so we need to protect the OLD s
        but then make it unreachable.
        We will let the GC collect the sound in the end.
        */
        xlprot1(s_as_lval);
        s = sound_copy(getsound(s_as_lval));
        s_as_lval = cvsound(s);	/* destroys only ref. to original */
        /* printf("sound_max: copy is %x, lval %x\n", s, s_as_lval); */
        while (n > 0) {
            long togo, j;
            sample_block_type sampblock = 
              sound_get_next(s, &blocklen);
            if (sampblock == zero_block || blocklen == 0) {
                break;
            }
            togo = MIN(blocklen, n);
            sbufp = sampblock->samples;
            for (j = 0; j < togo; j++) {
                register double samp = *sbufp++;
                if (samp > maximum) maximum = samp;
                else if (-samp > maximum) maximum = -samp;
            }
            n -= togo;
        }
        xlpop();
    } else {
        xlerror("sound_max: expression did not return a sound",
                 s_as_lval);
    }
    return maximum * s->scale;
}

LVAL xlc_snd_mandolin(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    double arg6 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_mandolin(arg1, arg2, arg3, arg4, arg5, arg6);
    return cvsound(result);
}

LVAL xlc_snd_osc(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    double arg6 = testarg2(xlgaanynum());
    double arg7 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_osc(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
    return cvsound(result);
}

LVAL xlc_snd_flute_all(void)
{
    double arg1 = testarg2(xlgaanynum());
    sound_type arg2 = getsound(xlgasound());
    sound_type arg3 = getsound(xlgasound());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    sound_type arg6 = getsound(xlgasound());
    sound_type arg7 = getsound(xlgasound());
    double arg8 = testarg2(xlgaanynum());
    sound_type result;

    xllastarg();
    result = snd_flute_all(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    return cvsound(result);
}

LVAL xlc_snd_sampler(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    double arg6 = testarg2(xlgaanynum());
    sound_type arg7 = getsound(xlgasound());
    long arg8 = getfixnum(xlgafixnum());
    sound_type result;

    xllastarg();
    result = snd_sampler(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    return cvsound(result);
}