sndfnint.c

Audacity是一款用於錄音和編輯聲音的、免費的開放源碼軟體。它可以執行於Mac OS X、Microsoft Windows、GNU/Linux和其它作業系統

    double arg10 = 0.0;
    LVAL arg11 = xlgetarg();
    double result;

    xllastarg();
    result = sound_save(arg1, arg2, arg3, arg4, arg5, arg6, arg7, &arg8, &arg9, &arg10, arg11);
    {	LVAL *next = &getvalue(RSLT_sym);
	*next = cons(NIL, NIL);
	car(*next) = cvflonum(arg8);	next = &cdr(*next);
	*next = cons(NIL, NIL);
	car(*next) = cvfixnum(arg9);	next = &cdr(*next);
	*next = cons(NIL, NIL);
	car(*next) = cvflonum(arg10);
    }
    return cvflonum(result);
}


/* xlc_snd_overwrite -- interface to C routine sound_overwrite */
/**/
LVAL xlc_snd_overwrite(void)
{
    LVAL arg1 = xlgetarg();
    long arg2 = getfixnum(xlgafixnum());
    unsigned char * arg3 = getstring(xlgastring());
    long arg4 = getfixnum(xlgafixnum());
    long arg5 = getfixnum(xlgafixnum());
    long arg6 = getfixnum(xlgafixnum());
    long arg7 = getfixnum(xlgafixnum());
    long arg8 = getfixnum(xlgafixnum());
    double arg9 = testarg2(xlgaanynum());
    long arg10 = getfixnum(xlgafixnum());
    double arg11 = 0.0;
    double result;

    xllastarg();
    result = sound_overwrite(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, &arg11);
    {	LVAL *next = &getvalue(RSLT_sym);
	*next = cons(NIL, NIL);
	car(*next) = cvflonum(arg11);
    }
    return cvflonum(result);
}


#include "sndmax.h"

/* xlc_snd_max -- interface to C routine sound_max */
/**/
LVAL xlc_snd_max(void)
{
    LVAL arg1 = xlgetarg();
    long arg2 = getfixnum(xlgafixnum());
    double result;

    xllastarg();
    result = sound_max(arg1, arg2);
    return cvflonum(result);
}


#include "compose.h"

/* xlc_snd_compose -- interface to C routine snd_compose */
/**/
LVAL xlc_snd_compose(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "inverse.h"

/* xlc_snd_inverse -- interface to C routine snd_inverse */
/**/
LVAL xlc_snd_inverse(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    sound_type result;

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


#include "resamp.h"

/* xlc_snd_resample -- interface to C routine snd_resample */
/**/
LVAL xlc_snd_resample(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type result;

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


#include "resampv.h"

/* xlc_snd_resamplev -- interface to C routine snd_resamplev */
/**/
LVAL xlc_snd_resamplev(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type arg3 = getsound(xlgasound());
    sound_type result;

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


#include "fft.h"

/* xlc_snd_fft -- interface to C routine snd_fft */
/**/
LVAL xlc_snd_fft(void)
{
    sound_type arg1 = getsound(xlgasound());
    long arg2 = getfixnum(xlgafixnum());
    long arg3 = getfixnum(xlgafixnum());
    LVAL arg4 = xlgetarg();
    LVAL result;

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


#include "avg.h"

/* xlc_snd_avg -- interface to C routine snd_avg */
/**/
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);
}


#include "amosc.h"

/* xlc_snd_amosc -- interface to C routine snd_amosc */
/**/
LVAL xlc_snd_amosc(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    sound_type arg6 = getsound(xlgasound());
    double arg7 = testarg2(xlgaanynum());
    sound_type result;

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


#include "clip.h"

/* xlc_snd_clip -- interface to C routine snd_clip */
/**/
LVAL xlc_snd_clip(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type result;

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


#include "const.h"

/* xlc_snd_const -- interface to C routine snd_const */
/**/
LVAL xlc_snd_const(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    sound_type result;

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


#include "fmosc.h"

/* xlc_snd_fmosc -- interface to C routine snd_fmosc */
/**/
LVAL xlc_snd_fmosc(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    double arg4 = testarg2(xlgaanynum());
    double arg5 = testarg2(xlgaanynum());
    sound_type arg6 = getsound(xlgasound());
    double arg7 = testarg2(xlgaanynum());
    sound_type result;

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


#include "integrate.h"

/* xlc_snd_integrate -- interface to C routine snd_integrate */
/**/
LVAL xlc_snd_integrate(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_integrate(arg1);
    return cvsound(result);
}


#include "log.h"

/* xlc_snd_log -- interface to C routine snd_log */
/**/
LVAL xlc_snd_log(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_log(arg1);
    return cvsound(result);
}


#include "maxv.h"

/* xlc_snd_maxv -- interface to C routine snd_maxv */
/**/
LVAL xlc_snd_maxv(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "osc.h"

/* xlc_snd_osc -- interface to C routine snd_osc */
/**/
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);
}


#include "prod.h"

/* xlc_snd_prod -- interface to C routine snd_prod */
/**/
LVAL xlc_snd_prod(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "buzz.h"

/* xlc_snd_buzz -- interface to C routine snd_buzz */
/**/
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);
}


#include "pwl.h"

/* xlc_snd_pwl -- interface to C routine snd_pwl */
/**/
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);
}


#include "recip.h"

/* xlc_snd_recip -- interface to C routine snd_recip */
/**/
LVAL xlc_snd_recip(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_recip(arg1);
    return cvsound(result);
}


#include "upsample.h"

/* xlc_snd_up -- interface to C routine snd_up */
/**/
LVAL xlc_snd_up(void)
{
    double arg1 = testarg2(xlgaanynum());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "scale.h"

/* xlc_snd_normalize -- interface to C routine snd_normalize */
/**/
LVAL xlc_snd_normalize(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type result;

    xllastarg();
    result = snd_normalize(arg1);
    return cvsound(result);
}


#include "sine.h"

/* xlc_snd_sine -- interface to C routine snd_sine */
/**/
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);
}


#include "partial.h"

/* xlc_snd_partial -- interface to C routine snd_partial */
/**/
LVAL xlc_snd_partial(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    sound_type arg3 = getsound(xlgasound());
    sound_type result;

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


#include "white.h"

/* xlc_snd_white -- interface to C routine snd_white */
/**/
LVAL xlc_snd_white(void)
{
    double arg1 = testarg2(xlgaanynum());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    sound_type result;

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


#include "tone.h"

/* xlc_snd_tone -- interface to C routine snd_tone */
/**/
LVAL xlc_snd_tone(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type result;

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


#include "tonev.h"

/* xlc_snd_tonev -- interface to C routine snd_tonev */
/**/
LVAL xlc_snd_tonev(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "atonev.h"

/* xlc_snd_atonev -- interface to C routine snd_atonev */
/**/
LVAL xlc_snd_atonev(void)
{
    sound_type arg1 = getsound(xlgasound());
    sound_type arg2 = getsound(xlgasound());
    sound_type result;

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


#include "atone.h"

/* xlc_snd_atone -- interface to C routine snd_atone */
/**/
LVAL xlc_snd_atone(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    sound_type result;

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


#include "reson.h"

/* xlc_snd_reson -- interface to C routine snd_reson */
/**/
LVAL xlc_snd_reson(void)
{
    sound_type arg1 = getsound(xlgasound());
    double arg2 = testarg2(xlgaanynum());
    double arg3 = testarg2(xlgaanynum());
    long arg4 = getfixnum(xlgafixnum());
    sound_type result;

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