onset.c File Reference

#include "f2c.h"

Include dependency graph for onset.c:

Go to the source code of this file.

Functions
int	onset_ (real *pebuf, integer *osbuf, integer *osptr, integer *oslen, integer *sbufl, integer *sbufh, integer *lframe, struct lpc10_encoder_state *st)

Variables
static real	c_b2 = 1.f

Function Documentation

onset_()

int onset_	(	real *	pebuf,
		integer *	osbuf,
		integer *	osptr,
		integer *	oslen,
		integer *	sbufl,
		integer *	sbufh,
		integer *	lframe,
		struct lpc10_encoder_state *	st
	)

Definition at line 129 of file onset.c.

{
    /* Initialized data */
 
    real *n;
    real *d__;
    real *l2buf;
    real *l2sum1;
    integer *l2ptr1;
    integer *l2ptr2;
    logical *hyst;
 
    /* System generated locals */
    integer pebuf_offset, i__1;
    real r__1;
 
    /* Builtin functions */
    double r_sign(real *, real *);
 
    /* Local variables */
    integer i__;
    integer *lasti;
    real l2sum2;
    real *fpc;
 
/*       Arguments */
/* $Log$
 * Revision 1.15  2004/06/26 03:50:14  markster
 * Merge source cleanups (bug #1911)
 *
 * Revision 1.14  2003/02/12 13:59:15  matteo
 * mer feb 12 14:56:57 CET 2003
 *
 * Revision 1.1.1.1  2003/02/12 13:59:15  matteo
 * mer feb 12 14:56:57 CET 2003
 *
 * Revision 1.2  2000/01/05 08:20:39  markster
 * Some OSS fixes and a few lpc changes to make it actually work
 *
 * Revision 1.2  1996/08/20  20:37:55  jaf
 * Removed all static local variables that were SAVE'd in the Fortran
 * code, and put them in struct lpc10_encoder_state that is passed as an
 * argument.
 *
 * Removed init function, since all initialization is now done in
 * init_lpc10_encoder_state().
 *
 * Revision 1.1  1996/08/19  22:31:18  jaf
 * Initial revision
 * */
/* Revision 1.3  1996/03/29  22:03:47  jaf */
/* Removed definitions for any constants that were no longer used. */
 
/* Revision 1.2  1996/03/26  19:34:33  jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */
 
/* Revision 1.1  1996/02/07  14:43:51  jaf */
/* Initial revision */
 
/*   LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/*       Parameters/constants */
/*   Parameters for onset detection algorithm: */
/*    L2        Threshold for filtered slope of FPC (function of L2WID!) */
/*    L2LAG Lag due to both filters which compute filtered slope of FPC */
/*    L2WID Width of the filter which computes the slope of FPC */
/*    OSHYST    The number of samples of slope(FPC) which must be below */
/*          the threshold before a new onset may be declared. */
/*       Local variables that need not be saved */
/*       Local state */
/*   Variables */
/*    N, D       Numerator and denominator of prediction filters */
/*    FPC        Current prediction coefs */
/*    L2BUF, L2SUM1, L2SUM2    State of slope filter */
/*       The only "significant" change I've made is to change L2SUM2 out
*/
/*       of the list of local variables that need to be saved, since it */
/*       didn't need to be. */
/*       L2SUM1 need not be, but avoiding saving it would require a small
*/
/*       change to the body of the code.  See comments below for an */
/*       example of how the code could be changed to avoid saving L2SUM1.
*/
/*       FPC and LASTI are saved from one invocation to the next, but */
/*       they are not given initial values.  This is acceptable, because
*/
/*       FPC will be assigned a value the first time that this function */
/*       is called after D is initialized to 1, since the formula to */
/*       change D will not change it to 0 in one step, and the IF (D */
/*       .NE. 0) statement will execute its THEN part, initializing FPC.
*/
 
/*       LASTI's value will not be used until HYST is .TRUE., and */
/*       whenever HYST is changed from its initial value of .FALSE., */
/*       LASTI is assigned a value. */
/*       In a C version of this coder, it would be nice if all of these */
/*       saved things, in this and all other subroutines, could be stored
*/
/*       in a single struct lpc10_coder_state_t, initialized with a call
*/
/*       to a function like lpc10_init(&lpc10_coder_state).  In this way,
*/
/*       a program that used these functions could conveniently alternate
*/
/*       coding more than one distinct audio stream. */
 
    n = &(st->n);
    d__ = &(st->d__);
    fpc = &(st->fpc);
    l2buf = &(st->l2buf[0]);
    l2sum1 = &(st->l2sum1);
    l2ptr1 = &(st->l2ptr1);
    l2ptr2 = &(st->l2ptr2);
    lasti = &(st->lasti);
    hyst = &(st->hyst);
 
    /* Parameter adjustments */
    if (osbuf) {
    --osbuf;
    }
    if (pebuf) {
    pebuf_offset = *sbufl;
    pebuf -= pebuf_offset;
    }
 
    /* Function Body */
 
/*       The following line subtracted a hard-coded "180" from LASTI, */
/*       instead of using a variable like LFRAME or a constant like */
/*       MAXFRM.  I changed it to LFRAME, for "generality". */
    if (*hyst) {
    *lasti -= *lframe;
    }
    i__1 = *sbufh;
    for (i__ = *sbufh - *lframe + 1; i__ <= i__1; ++i__) {
/*   Compute FPC; Use old FPC on divide by zero; Clamp FPC to +/- 1.
*/
    *n = (pebuf[i__] * pebuf[i__ - 1] + (*n) * 63.f) / 64.f;
/* Computing 2nd power */
    r__1 = pebuf[i__ - 1];
    *d__ = (r__1 * r__1 + (*d__) * 63.f) / 64.f;
    if ((*d__) != 0.f) {
        if (abs(*n) > (*d__)) {
        *fpc = (real)r_sign(&c_b2, n);
        } else {
        *fpc = (*n) / (*d__);
        }
    }
/*   Filter FPC */
/*       In order to allow L2SUM1 not to be saved from one invocation
of */
/*       this subroutine to the next, one could change the sequence of
 */
/*       assignments below, up to the IF statement, to the following.
 In */
/*       addition, the initial value of L2PTR2 should be changed to */
/*       L2WID/2 instead of L2WID/2+1. */
 
/*       L2SUM1 = L2BUF(L2PTR2) */
/*       L2PTR2 = MOD(L2PTR2,L2WID)+1 */
/*       L2SUM1 = L2SUM1 - L2BUF(L2PTR2) + FPC */
/*       L2BUF(L2PTR2) = L2SUM1 */
 
/* *       The following lines didn't change from the original: */
/*       L2SUM2 = L2BUF(L2PTR1) */
/*       L2BUF(L2PTR1) = FPC */
/*       L2PTR1 = MOD(L2PTR1,L2WID)+1 */
 
    l2sum2 = l2buf[*l2ptr1 - 1];
    *l2sum1 = *l2sum1 - l2buf[*l2ptr2 - 1] + *fpc;
    l2buf[*l2ptr2 - 1] = *l2sum1;
    l2buf[*l2ptr1 - 1] = *fpc;
    *l2ptr1 = *l2ptr1 % 16 + 1;
    *l2ptr2 = *l2ptr2 % 16 + 1;
    if ((r__1 = *l2sum1 - l2sum2, abs(r__1)) > 1.7f) {
        if (! (*hyst)) {
/*   Ignore if buffer full */
        if (*osptr <= *oslen) {
            osbuf[*osptr] = i__ - 9;
            ++(*osptr);
        }
        *hyst = TRUE_;
        }
        *lasti = i__;
/*       After one onset detection, at least OSHYST sample times m
ust go */
/*       by before another is allowed to occur. */
    } else if ((*hyst) && i__ - *lasti >= 10) {
        *hyst = FALSE_;
    }
    }
    return 0;
} /* onset_ */

References abs, c_b2, lpc10_encoder_state::d__, FALSE_, lpc10_encoder_state::fpc, lpc10_encoder_state::hyst, lpc10_encoder_state::l2buf, lpc10_encoder_state::l2ptr1, lpc10_encoder_state::l2ptr2, lpc10_encoder_state::l2sum1, lpc10_encoder_state::lasti, lframe, lpc10_encoder_state::n, r_sign(), and TRUE_.

Referenced by analys_().

Variable Documentation

c_b2

real c_b2 = 1.f

static

Definition at line 43 of file onset.c.

Referenced by onset_().