#include "lpc10.h"

Include dependency graph for f2c.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	alist

struct	cilist

struct	cllist

struct	complex

struct	doublecomplex

struct	icilist

struct	inlist

union	Multitype

struct	Namelist

struct	olist

struct	Vardesc

Macros
#define	abs(x) ((x) >= 0 ? (x) : -(x))

#define	dabs(x) (doublereal)abs(x)

#define	dmax(a, b) (doublereal)max(a,b)

#define	dmin(a, b) (doublereal)min(a,b)

#define	Extern extern

#define	F2C_proc_par_types 1

#define	FALSE_ (0)

#define	max(a, b) ((a) >= (b) ? (a) : (b))

#define	min(a, b) ((a) <= (b) ? (a) : (b))

#define	TRUE_ (1)

#define	VOID void

Typedefs
typedef char *	address

typedef VOID	C_f

typedef VOID(*	C_fp) (VOID)

typedef doublereal(*	D_fp) (VOID)

typedef double	doublereal

typedef doublereal	E_f

typedef doublereal()(	E_fp) (VOID)

typedef long int	flag

typedef long int	ftnint

typedef long int	ftnlen

typedef VOID	H_f

typedef VOID(*	H_fp) (VOID)

typedef integer(*	I_fp) (VOID)

typedef char	integer1

typedef shortint(*	J_fp) (VOID)

typedef shortlogical(*	K_fp) (VOID)

typedef logical(*	L_fp) (VOID)

typedef char	logical1

typedef union Multitype	Multitype

typedef struct Namelist	Namelist

typedef real(*	R_fp) (VOID)

typedef int(*	S_fp) (VOID)

typedef short int	shortlogical

typedef int(*	U_fp) (VOID)

typedef struct Vardesc	Vardesc

typedef VOID	Z_f

typedef VOID(*	Z_fp) (VOID)

Functions
int	bsynz_ (real coef, integer ip, integer iv, real sout, real rms, real ratio, real g2pass, struct lpc10_decoder_state st)

int	chanrd_ (integer order, integer ipitv, integer irms, integer irc, integer *ibits)

int	chanwr_ (integer order, integer ipitv, integer irms, integer irc, integer ibits, struct lpc10_encoder_state st)

int	chanwr_0_ (int n__, integer order, integer ipitv, integer irms, integer irc, integer ibits, struct lpc10_encoder_state st)

int	dcbias_ (integer len, real speech, real *sigout)

int	decode_ (integer ipitv, integer irms, integer irc, integer voice, integer pitch, real rms, real rc, struct lpc10_decoder_state st)

int	deemp_ (real x, integer n, struct lpc10_decoder_state *st)

int	difmag_ (real speech, integer lpita, integer tau, integer ltau, integer maxlag, real amdf, integer minptr, integer maxptr)

int	dyptrk_ (real amdf, integer ltau, integer minptr, integer voice, integer pitch, integer midx, struct lpc10_encoder_state *st)

int	encode_ (integer voice, integer pitch, real rms, real rc, integer ipitch, integer irms, integer *irc)

int	energy_ (integer len, real speech, real *rms)

int	ham84_ (integer input, integer output, integer *errcnt)

int	hp100_ (real speech, integer start, integer end, struct lpc10_encoder_state st)

integer	i_nint (real *x)

int	inithp100_ (void)

int	initlpcdec_ (void)

int	initlpcenc_ (void)

int	invert_ (integer order, real phi, real psi, real rc)

int	irc2pc_ (real rc, real pc, integer order, real gprime, real *g2pass)

int	ivfilt_ (real lpbuf, real ivbuf, integer len, integer nsamp, real *ivrc)

int	lpcdec_ (integer bits, real speech)

int	lpcenc_ (real speech, integer bits)

int	lpfilt_ (real inbuf, real lpbuf, integer len, integer nsamp)

integer	median_ (integer d1, integer d2, integer *d3)

int	mload_ (integer order, integer awins, integer awinf, real speech, real phi, real psi)

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

int	pitsyn_ (integer order, integer voice, integer pitch, real rms, real rc, integer lframe, integer ivuv, integer ipiti, real rmsi, real rci, integer nout, real ratio, struct lpc10_decoder_state *st)

int	placea_ (integer ipitch, integer voibuf, integer obound, integer af, integer vwin, integer awin, integer ewin, integer lframe, integer *maxwin)

int	placev_ (integer osbuf, integer osptr, integer oslen, integer obound, integer vwin, integer af, integer lframe, integer minwin, integer maxwin, integer dvwinl, integer *dvwinh)

integer	pow_ii (integer ap, integer bp)

int	preemp_ (real inbuf, real pebuf, integer nsamp, real coef, real *z__)

int	prepro_ (real speech, integer length, struct lpc10_encoder_state *st)

double	r_sign (real a, real b)

integer	random_ (struct lpc10_decoder_state *st)

int	rcchk_ (integer order, real rc1f, real *rc2f)

int	synths_ (integer voice, integer pitch, real rms, real rc, real speech, integer k, struct lpc10_decoder_state *st)

int	tbdm_ (real speech, integer lpita, integer tau, integer ltau, real amdf, integer minptr, integer maxptr, integer mintau)

int	voicin_ (integer vwin, real inbuf, real lpbuf, integer buflim, integer half, real minamd, real maxamd, integer mintau, real ivrc, integer obound, integer voibuf, integer af, struct lpc10_encoder_state *st)

int	vparms_ (integer vwin, real inbuf, real lpbuf, integer buflim, integer half, real dither, integer mintau, integer zc, integer lbe, integer fbe, real qs, real rc1, real ar_b__, real ar_f__)

Macro Definition Documentation

◆ abs

#define abs ( x ) ((x) >= 0 ? (x) : -(x))

◆ dabs

#define dabs ( x ) (doublereal)abs(x)

Definition at line 196 of file f2c.h.

◆ dmax

#define dmax	(	a,
		b
	)	(doublereal)max(a,b)

Definition at line 200 of file f2c.h.

Referenced by P4().

◆ dmin

#define dmin	(	a,
		b
	)	(doublereal)min(a,b)

Definition at line 199 of file f2c.h.

◆ Extern

#define Extern extern

Definition at line 72 of file f2c.h.

◆ F2C_proc_par_types

#define F2C_proc_par_types 1

Definition at line 204 of file f2c.h.

◆ FALSE_

#define FALSE_ (0)

Definition at line 68 of file f2c.h.

Referenced by decode_(), init_lpc10_encoder_state(), onset_(), pitsyn_(), placea_(), and placev_().

◆ max

#define max	(	a,
		b
	)	((a) >= (b) ? (a) : (b))

◆ min

#define min	(	a,
		b
	)	((a) <= (b) ? (a) : (b))

Definition at line 197 of file f2c.h.

Referenced by acf_rand_exec(), action_meetmelistrooms(), au_seek(), background_detect_exec(), bsynz_(), encode_(), g719seek(), g726_seek(), g729_seek(), gsm_seek(), handle_clear_profile(), handle_show_profile(), handle_showchan(), history_get(), ilbc_seek(), invert_(), limits_interval_playback(), main(), meetme_show_cmd(), mp3_seek(), osp_report_qos(), placev_(), serialize_showchan(), siren14seek(), siren7seek(), slinear_seek(), synths_(), tbdm_(), voicin_(), vox_seek(), vparms_(), and wav_seek().

◆ TRUE_

#define TRUE_ (1)

Definition at line 67 of file f2c.h.

Referenced by init_lpc10_decoder_state(), lpcini_(), onset_(), pitsyn_(), placea_(), and placev_().

◆ VOID

#define VOID void

Definition at line 163 of file f2c.h.

Typedef Documentation

◆ address

typedef char* address

Definition at line 59 of file f2c.h.

◆ C_f

typedef VOID C_f

Definition at line 231 of file f2c.h.

◆ C_fp

typedef VOID(* C_fp) (VOID)

Definition at line 223 of file f2c.h.

◆ D_fp

typedef doublereal(* D_fp) (VOID)

Definition at line 222 of file f2c.h.

◆ doublereal

typedef double doublereal

barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."

From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition)

Definition at line 50 of file f2c.h.

◆ E_f

typedef doublereal E_f

Definition at line 234 of file f2c.h.

◆ E_fp

typedef doublereal(*)(* E_fp) (VOID)

Definition at line 222 of file f2c.h.

◆ flag

typedef long int flag

Definition at line 83 of file f2c.h.

◆ ftnint

typedef long int ftnint

Definition at line 85 of file f2c.h.

◆ ftnlen

typedef long int ftnlen

Definition at line 84 of file f2c.h.

◆ H_f

typedef VOID H_f

Definition at line 232 of file f2c.h.

◆ H_fp

typedef VOID(* H_fp) (VOID)

Definition at line 227 of file f2c.h.

◆ I_fp

typedef integer(* I_fp) (VOID)

Definition at line 220 of file f2c.h.

◆ integer1

typedef char integer1

Definition at line 64 of file f2c.h.

◆ J_fp

typedef shortint(* J_fp) (VOID)

Definition at line 219 of file f2c.h.

◆ K_fp

typedef shortlogical(* K_fp) (VOID)

Definition at line 226 of file f2c.h.

◆ L_fp

typedef logical(* L_fp) (VOID)

Definition at line 225 of file f2c.h.

◆ logical1

typedef char logical1

Definition at line 63 of file f2c.h.

◆ Multitype

typedef union Multitype Multitype

Definition at line 176 of file f2c.h.

◆ Namelist

typedef struct Namelist Namelist

Definition at line 193 of file f2c.h.

◆ R_fp

typedef real(* R_fp) (VOID)

Definition at line 221 of file f2c.h.

◆ S_fp

typedef int(* S_fp) (VOID)

Definition at line 228 of file f2c.h.

◆ shortlogical

typedef short int shortlogical

Definition at line 62 of file f2c.h.

◆ U_fp

typedef int(* U_fp) (VOID)

Definition at line 218 of file f2c.h.

◆ Vardesc

typedef struct Vardesc Vardesc

Definition at line 186 of file f2c.h.

◆ Z_f

typedef VOID Z_f

Definition at line 233 of file f2c.h.

◆ Z_fp

typedef VOID(* Z_fp) (VOID)

Definition at line 224 of file f2c.h.

Function Documentation

◆ bsynz_()

int bsynz_	(	real *	coef,
		integer *	ip,
		integer *	iv,
		real *	sout,
		real *	rms,
		real *	ratio,
		real *	g2pass,
		struct lpc10_decoder_state *	st
	)

Definition at line 122 of file bsynz.c.

References contrl_1, lpc10_decoder_state::exc, lpc10_decoder_state::exc2, lpc10_decoder_state::hpi1, lpc10_decoder_state::hpi2, lpc10_decoder_state::hpi3, lpc10_decoder_state::ipo, lpc10_decoder_state::lpi1, lpc10_decoder_state::lpi2, lpc10_decoder_state::lpi3, min, random_(), and lpc10_decoder_state::rmso_bsynz.

Referenced by synths_().

 {
     /* Initialized data */
 
     integer *ipo;
     real *rmso;
     static integer kexc[25] = { 8,-16,26,-48,86,-162,294,-502,718,-728,184,
        672,-610,-672,184,728,718,502,294,162,86,48,26,16,8 };
     real *exc;
     real *exc2;
     real *lpi1;
     real *lpi2;
     real *lpi3;
     real *hpi1;
     real *hpi2;
     real *hpi3;
 
     /* System generated locals */
     integer i__1, i__2;
     real r__1, r__2;
 
     /* Builtin functions */
     double sqrt(doublereal);
 
     /* Local variables */
     real gain, xssq;
     integer i__, j, k;
     real noise[166], pulse;
     integer px;
     real sscale;
     extern integer random_(struct lpc10_decoder_state *);
     real xy, sum, ssq;
     real lpi0, hpi0;
 
 /* $Log$
  * Revision 1.15  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.14  2003/02/12 13:59:14  matteo
  * mer feb 12 14:56:57 CET 2003
  *
  * Revision 1.1.1.1  2003/02/12 13:59:14  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:18:55  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:32:58  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 */
 /*       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:14  matteo
  * mer feb 12 14:56:57 CET 2003
  *
  * Revision 1.1.1.1  2003/02/12 13:59:14  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:18:55  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:32:58  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*       Function return value definitions */
 /*    Parameters/constants */
 /*       KEXC is not a Fortran PARAMETER, but it is an array initialized
 */
 /*       with a DATA statement that is never modified. */
 /*       Local variables that need not be saved */
 /*       NOISE is declared with range (1:MAXPIT+MAXORD), but only indices
 */
 /*       ORDER+1 through ORDER+IP are ever used, and I think that IP */
 /*       .LE. MAXPIT.  Why not declare it to be in the range (1:MAXPIT) */
 /*       and use that range? */
 /*       Local state */
 /*       I believe that only indices 1 through ORDER of EXC need to be */
 /*       saved from one invocation to the next, but we may as well save */
 /*       the whole array. */
 /*       None of these local variables were given initial values in the */
 /*       original code.  I'm guessing that 0 is a reasonable initial */
 /*       value for all of them. */
     /* Parameter adjustments */
     if (coef) {
    --coef;
    }
     if (sout) {
    --sout;
    }
 
     /* Function Body */
     ipo = &(st->ipo);
     exc = &(st->exc[0]);
     exc2 = &(st->exc2[0]);
     lpi1 = &(st->lpi1);
     lpi2 = &(st->lpi2);
     lpi3 = &(st->lpi3);
     hpi1 = &(st->hpi1);
     hpi2 = &(st->hpi2);
     hpi3 = &(st->hpi3);
     rmso = &(st->rmso_bsynz);
 
 /*                  MAXPIT+MAXORD=166 */
 /*  Calculate history scale factor XY and scale filter state */
 /* Computing MIN */
     r__1 = *rmso / (*rms + 1e-6f);
     xy = min(r__1,8.f);
     *rmso = *rms;
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    exc2[i__ - 1] = exc2[*ipo + i__ - 1] * xy;
     }
     *ipo = *ip;
     if (*iv == 0) {
 /*  Generate white noise for unvoiced */
    i__1 = *ip;
    for (i__ = 1; i__ <= i__1; ++i__) {
        exc[contrl_1.order + i__ - 1] = (real) (random_(st) / 64);
    }
 /*  Impulse doublet excitation for plosives */
 /*       (RANDOM()+32768) is in the range 0 to 2**16-1.  Therefore the
  */
 /*       following expression should be evaluated using integers with
 at */
 /*       least 32 bits (16 isn't enough), and PX should be in the rang
 e */
 /*       ORDER+1+0 through ORDER+1+(IP-2) .EQ. ORDER+IP-1. */
    px = (random_(st) + 32768) * (*ip - 1) / 65536 + contrl_1.order + 1;
    r__1 = *ratio / 4 * 1.f;
    pulse = r__1 * 342;
    if (pulse > 2e3f) {
        pulse = 2e3f;
    }
    exc[px - 1] += pulse;
    exc[px] -= pulse;
 /*  Load voiced excitation */
     } else {
    sscale = (real)sqrt((real) (*ip)) / 6.928f;
    i__1 = *ip;
    for (i__ = 1; i__ <= i__1; ++i__) {
        exc[contrl_1.order + i__ - 1] = 0.f;
        if (i__ <= 25) {
       exc[contrl_1.order + i__ - 1] = sscale * kexc[i__ - 1];
        }
        lpi0 = exc[contrl_1.order + i__ - 1];
        r__2 = exc[contrl_1.order + i__ - 1] * .125f + *lpi1 * .75f;
        r__1 = r__2 + *lpi2 * .125f;
        exc[contrl_1.order + i__ - 1] = r__1 + *lpi3 * 0.f;
        *lpi3 = *lpi2;
        *lpi2 = *lpi1;
        *lpi1 = lpi0;
    }
    i__1 = *ip;
    for (i__ = 1; i__ <= i__1; ++i__) {
        noise[contrl_1.order + i__ - 1] = random_(st) * 1.f / 64;
        hpi0 = noise[contrl_1.order + i__ - 1];
        r__2 = noise[contrl_1.order + i__ - 1] * -.125f + *hpi1 * .25f;
        r__1 = r__2 + *hpi2 * -.125f;
        noise[contrl_1.order + i__ - 1] = r__1 + *hpi3 * 0.f;
        *hpi3 = *hpi2;
        *hpi2 = *hpi1;
        *hpi1 = hpi0;
    }
    i__1 = *ip;
    for (i__ = 1; i__ <= i__1; ++i__) {
        exc[contrl_1.order + i__ - 1] += noise[contrl_1.order + i__ - 1];
    }
     }
 /*   Synthesis filters: */
 /*    Modify the excitation with all-zero filter  1 + G*SUM */
     xssq = 0.f;
     i__1 = *ip;
     for (i__ = 1; i__ <= i__1; ++i__) {
    k = contrl_1.order + i__;
    sum = 0.f;
    i__2 = contrl_1.order;
    for (j = 1; j <= i__2; ++j) {
        sum += coef[j] * exc[k - j - 1];
    }
    sum *= *g2pass;
    exc2[k - 1] = sum + exc[k - 1];
     }
 /*   Synthesize using the all pole filter  1 / (1 - SUM) */
     i__1 = *ip;
     for (i__ = 1; i__ <= i__1; ++i__) {
    k = contrl_1.order + i__;
    sum = 0.f;
    i__2 = contrl_1.order;
    for (j = 1; j <= i__2; ++j) {
        sum += coef[j] * exc2[k - j - 1];
    }
    exc2[k - 1] = sum + exc2[k - 1];
    xssq += exc2[k - 1] * exc2[k - 1];
     }
 /*  Save filter history for next epoch */
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    exc[i__ - 1] = exc[*ip + i__ - 1];
    exc2[i__ - 1] = exc2[*ip + i__ - 1];
     }
 /*  Apply gain to match RMS */
     r__1 = *rms * *rms;
     ssq = r__1 * *ip;
     gain = (real)sqrt(ssq / xssq);
     i__1 = *ip;
     for (i__ = 1; i__ <= i__1; ++i__) {
    sout[i__] = gain * exc2[contrl_1.order + i__ - 1];
     }
     return 0;
 } /* bsynz_ */

◆ chanrd_()

int chanrd_	(	integer *	order,
		integer *	ipitv,
		integer *	irms,
		integer *	irc,
		integer *	ibits
	)

Definition at line 229 of file chanwr.c.

References chanwr_0_(), and NULL.

Referenced by lpc10_decode().

 {
     return chanwr_0_(1, order, ipitv, irms, irc, ibits, NULL);
     }

◆ chanwr_()

int chanwr_	(	integer *	order,
		integer *	ipitv,
		integer *	irms,
		integer *	irc,
		integer *	ibits,
		struct lpc10_encoder_state *	st
	)

Definition at line 223 of file chanwr.c.

References chanwr_0_().

Referenced by lpc10_encode().

 {
     return chanwr_0_(0, order, ipitv, irms, irc, ibits, st);
     }

◆ chanwr_0_()

int chanwr_0_	(	int	n__,
		integer *	order,
		integer *	ipitv,
		integer *	irms,
		integer *	irc,
		integer *	ibits,
		struct lpc10_encoder_state *	st
	)

Definition at line 132 of file chanwr.c.

References lpc10_encoder_state::isync, and order.

Referenced by chanrd_(), and chanwr_().

 {
     /* Initialized data */
 
     integer *isync;
     static integer bit[10] = { 2,4,8,8,8,8,16,16,16,16 };
     static integer iblist[53] = { 13,12,11,1,2,13,12,11,1,2,13,10,11,2,1,10,
        13,12,11,10,2,13,12,11,10,2,1,12,7,6,1,10,9,8,7,4,6,9,8,7,5,1,9,8,
        4,6,1,5,9,8,7,5,6 };
 
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     integer itab[13], i__;
 
 /*       Arguments */
 /*       Parameters/constants */
 /*       These arrays are not Fortran PARAMETER's, but they are defined */
 /*       by DATA statements below, and their contents are never altered.
 */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       ISYNC is only used by CHANWR, not by ENTRY CHANRD. */
 
     /* Parameter adjustments */
     --irc;
     --ibits;
 
     /* Function Body */
     switch(n__) {
    case 1: goto L_chanrd;
    }
 
     isync = &(st->isync);
 
 /* ***********************************************************************
  */
 /*    Place quantized parameters into bitstream */
 /* ***********************************************************************
  */
 /*   Place parameters into ITAB */
     itab[0] = *ipitv;
     itab[1] = *irms;
     itab[2] = 0;
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    itab[i__ + 2] = irc[*order + 1 - i__] & 32767;
     }
 /*   Put 54 bits into IBITS array */
     for (i__ = 1; i__ <= 53; ++i__) {
    ibits[i__] = itab[iblist[i__ - 1] - 1] & 1;
    itab[iblist[i__ - 1] - 1] /= 2;
     }
     ibits[54] = *isync & 1;
     *isync = 1 - *isync;
     return 0;
 /* ***********************************************************************
  */
 /*    Reconstruct parameters from bitstream */
 /* ***********************************************************************
  */
 
 L_chanrd:
 /*   Reconstruct ITAB */
     for (i__ = 1; i__ <= 13; ++i__) {
    itab[i__ - 1] = 0;
     }
     for (i__ = 1; i__ <= 53; ++i__) {
    itab[iblist[54 - i__ - 1] - 1] = (itab[iblist[54 - i__ - 1] - 1] << 1)
        + ibits[54 - i__];
     }
 /*   Sign extend RC's */
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    if ((itab[i__ + 2] & bit[i__ - 1]) != 0) {
        itab[i__ + 2] -= bit[i__ - 1] << 1;
    }
     }
 /*   Restore variables */
     *ipitv = itab[0];
     *irms = itab[1];
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    irc[i__] = itab[*order + 4 - i__ - 1];
     }
     return 0;
 } /* chanwr_ */

◆ dcbias_()

int dcbias_	(	integer *	len,
		real *	speech,
		real *	sigout
	)

Definition at line 79 of file dcbias.c.

References len().

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     real bias;
     integer i__;
 
 /*    Arguments */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     --sigout;
     --speech;
 
     /* Function Body */
     bias = 0.f;
     i__1 = *len;
     for (i__ = 1; i__ <= i__1; ++i__) {
    bias += speech[i__];
     }
     bias /= *len;
     i__1 = *len;
     for (i__ = 1; i__ <= i__1; ++i__) {
    sigout[i__] = speech[i__] - bias;
     }
     return 0;
 } /* dcbias_ */

◆ decode_()

int decode_	(	integer *	ipitv,
		integer *	irms,
		integer *	irc,
		integer *	voice,
		integer *	pitch,
		real *	rms,
		real *	rc,
		struct lpc10_decoder_state *	st
	)

Definition at line 147 of file lpc10/decode.c.

References abs, c__2, contrl_1, lpc10_decoder_state::dpit, lpc10_decoder_state::drc, lpc10_decoder_state::drms, lpc10_decoder_state::erate, FALSE_, lpc10_decoder_state::first, first, ham84_(), lpc10_decoder_state::iavgp, lpc10_decoder_state::iovoic, lpc10_decoder_state::iptold, lpc10_decoder_state::ivp2h, median_(), and pow_ii().

Referenced by lpc10_decode().

 {
     /* Initialized data */
 
     logical *first;
     static integer ethrs = 2048;
     static integer ethrs1 = 128;
     static integer ethrs2 = 1024;
     static integer ethrs3 = 2048;
     static integer ivtab[32] = { 24960,24960,24960,24960,25480,25480,25483,
        25480,16640,1560,1560,1560,16640,1816,1563,1560,24960,24960,24859,
        24856,26001,25881,25915,25913,1560,1560,7800,3640,1561,1561,3643,
        3641 };
     static real corth[32]  /* was [4][8] */ = { 32767.f,10.f,5.f,0.f,
        32767.f,8.f,4.f,0.f,32.f,6.4f,3.2f,0.f,32.f,6.4f,3.2f,0.f,32.f,
        11.2f,6.4f,0.f,32.f,11.2f,6.4f,0.f,16.f,5.6f,3.2f,0.f,16.f,5.6f,
        3.2f,0.f };
     static integer detau[128] = { 0,0,0,3,0,3,3,31,0,3,3,21,3,3,29,30,0,3,3,
        20,3,25,27,26,3,23,58,22,3,24,28,3,0,3,3,3,3,39,33,32,3,37,35,36,
        3,38,34,3,3,42,46,44,50,40,48,3,54,3,56,3,52,3,3,1,0,3,3,108,3,78,
        100,104,3,84,92,88,156,80,96,3,3,74,70,72,66,76,68,3,62,3,60,3,64,
        3,3,1,3,116,132,112,148,152,3,3,140,3,136,3,144,3,3,1,124,120,128,
        3,3,3,3,1,3,3,3,1,3,1,1,1 };
     static integer rmst[64] = { 1024,936,856,784,718,656,600,550,502,460,420,
        384,352,328,294,270,246,226,206,188,172,158,144,132,120,110,102,
        92,84,78,70,64,60,54,50,46,42,38,34,32,30,26,24,22,20,18,17,16,15,
        14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
     static integer detab7[32] = { 4,11,18,25,32,39,46,53,60,66,72,77,82,87,92,
        96,101,104,108,111,114,115,117,119,121,122,123,124,125,126,127,
        127 };
     static real descl[8] = { .6953f,.625f,.5781f,.5469f,.5312f,.5391f,.4688f,
        .3828f };
     integer *ivp2h;
     static integer deadd[8] = { 1152,-2816,-1536,-3584,-1280,-2432,768,-1920 }
        ;
     static integer qb[8] = { 511,511,1023,1023,1023,1023,2047,4095 };
     static integer nbit[10] = { 8,8,5,5,4,4,4,4,3,2 };
     static integer zrc[10] = { 0,0,0,0,0,3,0,2,0,0 };
     static integer bit[5] = { 2,4,8,16,32 };
     integer *iovoic;
     integer *iavgp;
     integer *iptold;
     integer *erate;
     integer *drc;
     integer *dpit;
     integer *drms;
 
     /* System generated locals */
     integer i__1, i__2;
 
     /* Builtin functions */
     integer pow_ii(integer *, integer *);
 
     /* Local variables */
     extern /* Subroutine */ int ham84_(integer *, integer *, integer *);
     integer ipit, iout, i__, icorf, index, ivoic, ixcor, i1, i2, i4;
     extern integer median_(integer *, integer *, integer *);
     integer ishift, errcnt, lsb;
 
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/09/19 01:20:22  markster
  * Code cleanups (bug #66)
  *
  * Revision 1.2  2003/09/19 01:20:22  markster
  * Code cleanups (bug #66)
  *
  * Revision 1.1.1.1  2003/02/12 13:59:14  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:22:39  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:32:38  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 */
 /*       Arguments */
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/09/19 01:20:22  markster
  * Code cleanups (bug #66)
  *
  * Revision 1.2  2003/09/19 01:20:22  markster
  * Code cleanups (bug #66)
  *
  * Revision 1.1.1.1  2003/02/12 13:59:14  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:22:39  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:32:38  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*       Function return value definitions */
 
 /*       Parameters/constants */
 
 /*       The variables below that are not Fortran PARAMETER's are */
 /*       initialized with DATA statements, and then never modified. */
 /*       The following are used regardless of CORRP's value. */
 
 /*       DETAU, NBIT, QB, DEADD, DETAB7, RMST, DESCL */
 
 /*       The following are used only if CORRP is .TRUE. */
 
 /*       ETHRS, ETHRS1, ETHRS2, ETHRS3, IVTAB, BIT, CORTH, ZRC */
 
 /*       Local variables that need not be saved */
 
 /*       The following are used regardless of CORRP's value */
 /*       The following are used only if CORRP is .TRUE. */
 
 /*       Local state */
 
 /*       The following are used regardless of CORRP's value */
 /*       The following are used only if CORRP is .TRUE. */
 /*       I am guessing the initial values for IVP2H, IOVOIC, DRC, DPIT, */
 /*       and DRMS.  They should be checked to see if they are reasonable.
 */
 /*       I'm also guessing for ERATE, but I think 0 is the right initial
 */
 /*       value. */
     /* Parameter adjustments */
     if (irc) {
    --irc;
    }
     if (voice) {
    --voice;
    }
     if (rc) {
    --rc;
    }
 
     /* Function Body */
 
     iptold = &(st->iptold);
     first = &(st->first);
     ivp2h = &(st->ivp2h);
     iovoic = &(st->iovoic);
     iavgp = &(st->iavgp);
     erate = &(st->erate);
     drc = &(st->drc[0]);
     dpit = &(st->dpit[0]);
     drms = &(st->drms[0]);
 
 /* DATA statements for "constants" defined above. */
 /*    IF (LISTL.GE.3) WRITE(FDEBUG,800) IPITV,IRMS,(IRC(J),J=1,ORDER) */
 /* 800   FORMAT(1X,' <<ERRCOR IN>>',T32,6X,I6,I5,T50,10I8) */
 /*  If no error correction, do pitch and voicing then jump to decode */
     i4 = detau[*ipitv];
     if (! contrl_1.corrp) {
    voice[1] = 1;
    voice[2] = 1;
    if (*ipitv <= 1) {
        voice[1] = 0;
    }
    if (*ipitv == 0 || *ipitv == 2) {
        voice[2] = 0;
    }
    *pitch = i4;
    if (*pitch <= 4) {
        *pitch = *iptold;
    }
    if (voice[1] == 1 && voice[2] == 1) {
        *iptold = *pitch;
    }
    if (voice[1] != voice[2]) {
        *pitch = *iptold;
    }
    goto L900;
     }
 /*  Do error correction pitch and voicing */
     if (i4 > 4) {
    dpit[0] = i4;
    ivoic = 2;
    *iavgp = (*iavgp * 15 + i4 + 8) / 16;
     } else {
    ivoic = i4;
    dpit[0] = *iavgp;
     }
     drms[0] = *irms;
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    drc[i__ * 3 - 3] = irc[i__];
     }
 /*  Determine index to IVTAB from V/UV decision */
 /*  If error rate is high then use alternate table */
     index = (*ivp2h << 4) + (*iovoic << 2) + ivoic + 1;
     i1 = ivtab[index - 1];
     ipit = i1 & 3;
     icorf = i1 / 8;
     if (*erate < ethrs) {
    icorf /= 64;
     }
 /*  Determine error rate:  4=high    1=low */
     ixcor = 4;
     if (*erate < ethrs3) {
    ixcor = 3;
     }
     if (*erate < ethrs2) {
    ixcor = 2;
     }
     if (*erate < ethrs1) {
    ixcor = 1;
     }
 /*  Voice/unvoice decision determined from bits 0 and 1 of IVTAB */
     voice[1] = icorf / 2 & 1;
     voice[2] = icorf & 1;
 /*  Skip decoding on first frame because present data not yet available */
     if (*first) {
    *first = FALSE_;
 /*          Assign PITCH a "default" value on the first call, since */
 /*          otherwise it would be left uninitialized.  The two lines
 */
 /*          below were copied from above, since it seemed like a */
 /*          reasonable thing to do for the first call. */
    *pitch = i4;
    if (*pitch <= 4) {
        *pitch = *iptold;
    }
    goto L500;
     }
 /*  If bit 4 of ICORF is set then correct RMS and RC(1) - RC(4). */
 /*    Determine error rate and correct errors using a Hamming 8,4 code */
 /*    during transition or unvoiced frame.  If IOUT is negative, */
 /*    more than 1 error occurred, use previous frame's parameters. */
     if ((icorf & bit[3]) != 0) {
    errcnt = 0;
    lsb = drms[1] & 1;
    index = (drc[22] << 4) + drms[1] / 2;
    ham84_(&index, &iout, &errcnt);
    drms[1] = drms[2];
    if (iout >= 0) {
        drms[1] = (iout << 1) + lsb;
    }
    for (i__ = 1; i__ <= 4; ++i__) {
        if (i__ == 1) {
       i1 = ((drc[25] & 7) << 1) + (drc[28] & 1);
        } else {
       i1 = drc[(9 - i__) * 3 - 2] & 15;
        }
        i2 = drc[(5 - i__) * 3 - 2] & 31;
        lsb = i2 & 1;
        index = (i1 << 4) + i2 / 2;
        ham84_(&index, &iout, &errcnt);
        if (iout >= 0) {
       iout = (iout << 1) + lsb;
       if ((iout & 16) == 16) {
           iout += -32;
       }
        } else {
       iout = drc[(5 - i__) * 3 - 1];
        }
        drc[(5 - i__) * 3 - 2] = iout;
    }
 /*  Determine error rate */
    *erate = (integer)(*erate * .96875f + errcnt * 102);
     }
 /*  Get unsmoothed RMS, RC's, and PITCH */
     *irms = drms[1];
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    irc[i__] = drc[i__ * 3 - 2];
     }
     if (ipit == 1) {
    dpit[1] = dpit[2];
     }
     if (ipit == 3) {
    dpit[1] = dpit[0];
     }
     *pitch = dpit[1];
 /*  If bit 2 of ICORF is set then smooth RMS and RC's, */
     if ((icorf & bit[1]) != 0) {
    if ((i__1 = drms[1] - drms[0], (real) abs(i__1)) >= corth[ixcor + 3]
       && (i__2 = drms[1] - drms[2], (real) abs(i__2)) >= corth[
       ixcor + 3]) {
        *irms = median_(&drms[2], &drms[1], drms);
    }
    for (i__ = 1; i__ <= 6; ++i__) {
        if ((i__1 = drc[i__ * 3 - 2] - drc[i__ * 3 - 3], (real) abs(i__1))
            >= corth[ixcor + ((i__ + 2) << 2) - 5] && (i__2 = drc[i__ *
            3 - 2] - drc[i__ * 3 - 1], (real) abs(i__2)) >= corth[
           ixcor + ((i__ + 2) << 2) - 5]) {
       irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[
          i__ * 3 - 3]);
        }
    }
     }
 /*  If bit 3 of ICORF is set then smooth pitch */
     if ((icorf & bit[2]) != 0) {
    if ((i__1 = dpit[1] - dpit[0], (real) abs(i__1)) >= corth[ixcor - 1]
       && (i__2 = dpit[1] - dpit[2], (real) abs(i__2)) >= corth[
       ixcor - 1]) {
        *pitch = median_(&dpit[2], &dpit[1], dpit);
    }
     }
 /*  If bit 5 of ICORF is set then RC(5) - RC(10) are loaded with */
 /*  values so that after quantization bias is removed in decode */
 /*  the values will be zero. */
 L500:
     if ((icorf & bit[4]) != 0) {
    i__1 = contrl_1.order;
    for (i__ = 5; i__ <= i__1; ++i__) {
        irc[i__] = zrc[i__ - 1];
    }
     }
 /*  House keeping  - one frame delay */
     *iovoic = ivoic;
     *ivp2h = voice[2];
     dpit[2] = dpit[1];
     dpit[1] = dpit[0];
     drms[2] = drms[1];
     drms[1] = drms[0];
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    drc[i__ * 3 - 1] = drc[i__ * 3 - 2];
    drc[i__ * 3 - 2] = drc[i__ * 3 - 3];
     }
 L900:
 /*    IF (LISTL.GE.3)WRITE(FDEBUG,801)VOICE,PITCH,IRMS,(IRC(J),J=1,ORDER) */
 /* 801   FORMAT(1X,'<<ERRCOR OUT>>',T32,2I3,I6,I5,T50,10I8) */
 /*   Decode RMS */
     *irms = rmst[(31 - *irms) * 2];
 /*  Decode RC(1) and RC(2) from log-area-ratios */
 /*  Protect from illegal coded value (-16) caused by bit errors */
     for (i__ = 1; i__ <= 2; ++i__) {
    i2 = irc[i__];
    i1 = 0;
    if (i2 < 0) {
        i1 = 1;
        i2 = -i2;
        if (i2 > 15) {
       i2 = 0;
        }
    }
    i2 = detab7[i2 * 2];
    if (i1 == 1) {
        i2 = -i2;
    }
    ishift = 15 - nbit[i__ - 1];
    irc[i__] = i2 * pow_ii(&c__2, &ishift);
     }
 /*  Decode RC(3)-RC(10) to sign plus 14 bits */
     i__1 = contrl_1.order;
     for (i__ = 3; i__ <= i__1; ++i__) {
    i2 = irc[i__];
    ishift = 15 - nbit[i__ - 1];
    i2 *= pow_ii(&c__2, &ishift);
    i2 += qb[i__ - 3];
    irc[i__] = (integer)(i2 * descl[i__ - 3] + deadd[i__ - 3]);
     }
 /*    IF (LISTL.GE.3) WRITE(FDEBUG,811) IRMS, (IRC(I),I=1,ORDER) */
 /* 811   FORMAT(1X,'<<DECODE OUT>>',T45,I4,1X,10I8) */
 /*  Scale RMS and RC's to reals */
     *rms = (real) (*irms);
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    rc[i__] = irc[i__] / 16384.f;
     }
     return 0;
 } /* decode_ */

◆ deemp_()

int deemp_	(	real *	x,
		integer *	n,
		struct lpc10_decoder_state *	st
	)

Definition at line 106 of file deemp.c.

References lpc10_decoder_state::dei1, lpc10_decoder_state::dei2, lpc10_decoder_state::deo1, lpc10_decoder_state::deo2, and lpc10_decoder_state::deo3.

Referenced by synths_().

 {
     /* Initialized data */
 
     real *dei1;
     real *dei2;
     real *deo1;
     real *deo2;
     real *deo3;
 
     /* System generated locals */
     integer i__1;
     real r__1;
 
     /* Local variables */
     integer k;
     real dei0;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       All of the locals saved below were not given explicit initial */
 /*       values in the original code.  I think 0 is a safe choice. */
     /* Parameter adjustments */
     if (x) {
    --x;
    }
 
     /* Function Body */
 
     dei1 = &(st->dei1);
     dei2 = &(st->dei2);
     deo1 = &(st->deo1);
     deo2 = &(st->deo2);
     deo3 = &(st->deo3);
 
     i__1 = *n;
     for (k = 1; k <= i__1; ++k) {
    dei0 = x[k];
    r__1 = x[k] - *dei1 * 1.9998f + *dei2;
    x[k] = r__1 + *deo1 * 2.5f - *deo2 * 2.0925f + *deo3 * .585f;
    *dei2 = *dei1;
    *dei1 = dei0;
    *deo3 = *deo2;
    *deo2 = *deo1;
    *deo1 = x[k];
     }
     return 0;
 } /* deemp_ */

◆ difmag_()

int difmag_	(	real *	speech,
		integer *	lpita,
		integer *	tau,
		integer *	ltau,
		integer *	maxlag,
		real *	amdf,
		integer *	minptr,
		integer *	maxptr
	)

Definition at line 90 of file difmag.c.

References abs.

Referenced by tbdm_().

 {
     /* System generated locals */
     integer i__1, i__2;
     real r__1;
 
     /* Local variables */
     integer i__, j, n1, n2;
     real sum;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       None */
     /* Parameter adjustments */
     --amdf;
     --tau;
     --speech;
 
     /* Function Body */
     *minptr = 1;
     *maxptr = 1;
     i__1 = *ltau;
     for (i__ = 1; i__ <= i__1; ++i__) {
    n1 = (*maxlag - tau[i__]) / 2 + 1;
    n2 = n1 + *lpita - 1;
    sum = 0.f;
    i__2 = n2;
    for (j = n1; j <= i__2; j += 4) {
        sum += (r__1 = speech[j] - speech[j + tau[i__]], abs(r__1));
    }
    amdf[i__] = sum;
    if (amdf[i__] < amdf[*minptr]) {
        *minptr = i__;
    }
    if (amdf[i__] > amdf[*maxptr]) {
        *maxptr = i__;
    }
     }
     return 0;
 } /* difmag_ */

◆ dyptrk_()

int dyptrk_	(	real *	amdf,
		integer *	ltau,
		integer *	minptr,
		integer *	voice,
		integer *	pitch,
		integer *	midx,
		struct lpc10_encoder_state *	st
	)

Definition at line 129 of file dyptrk.c.

References lpc10_encoder_state::alphax, lpc10_encoder_state::ipoint, lpc10_encoder_state::p, and lpc10_encoder_state::s.

Referenced by analys_().

 {
     /* Initialized data */
 
     real *s;
     integer *p;
     integer *ipoint;
     real *alphax;
 
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     integer pbar;
     real sbar;
     integer iptr, i__, j;
     real alpha, minsc, maxsc;
 
 /*       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:25:29  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:32:26  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    Parameters/constants */
 /*       Local variables that need not be saved */
 /*       Note that PATH is only used for debugging purposes, and can be */
 /*       removed. */
 /*       Local state */
 /*       It would be a bit more "general" to define S(LTAU), if Fortran */
 /*       allows the argument of a function to be used as the dimension of
 */
 /*       a local array variable. */
 /*       IPOINT is always in the range 0 to DEPTH-1. */
 /*       WARNING! */
 
 /*       In the original version of this subroutine, IPOINT, ALPHAX, */
 /*       every element of S, and potentially any element of P with the */
 /*       second index value .NE. IPTR were read without being given */
 /*       initial values (all indices of P with second index equal to */
 /*       IPTR are all written before being read in this subroutine). */
 
 /*       From examining the code carefully, it appears that all of these
 */
 /*       should be saved from one invocation to the next. */
 
 /*       I've run lpcsim with the "-l 6" option to see all of the */
 /*       debugging information that is printed out by this subroutine */
 /*       below, and it appears that S, P, IPOINT, and ALPHAX are all */
 /*       initialized to 0 (these initial values would likely be different
 */
 /*       on different platforms, compilers, etc.).  Given that the output
 */
 /*       of the coder sounds reasonable, I'm going to initialize these */
 /*       variables to 0 explicitly. */
 
     s = &(st->s[0]);
     p = &(st->p[0]);
     ipoint = &(st->ipoint);
     alphax = &(st->alphax);
 
 
     /* Parameter adjustments */
     if (amdf) {
    --amdf;
    }
 
     /* Function Body */
 
 /*   Calculate the confidence factor ALPHA, used as a threshold slope in
 */
 /*   SEESAW.  If unvoiced, set high slope so that every point in P array
 */
 /*  is marked as a potential pitch frequency.  A scaled up version (ALPHAX
 )*/
 /*   is used to maintain arithmetic precision. */
     if (*voice == 1) {
    *alphax = *alphax * .75f + amdf[*minptr] / 2.f;
     } else {
    *alphax *= .984375f;
     }
     alpha = *alphax / 16;
     if (*voice == 0 && *alphax < 128.f) {
    alpha = 8.f;
     }
 /* SEESAW: Construct a pitch pointer array and intermediate winner functio
 n*/
 /*   Left to right pass: */
     iptr = *ipoint + 1;
     p[iptr * 60 - 60] = 1;
     i__ = 1;
     pbar = 1;
     sbar = s[0];
     i__1 = *ltau;
     for (i__ = 1; i__ <= i__1; ++i__) {
    sbar += alpha;
    if (sbar < s[i__ - 1]) {
        s[i__ - 1] = sbar;
        p[i__ + iptr * 60 - 61] = pbar;
    } else {
        sbar = s[i__ - 1];
        p[i__ + iptr * 60 - 61] = i__;
        pbar = i__;
    }
     }
 /*   Right to left pass: */
     i__ = pbar - 1;
     sbar = s[i__];
     while(i__ >= 1) {
    sbar += alpha;
    if (sbar < s[i__ - 1]) {
        s[i__ - 1] = sbar;
        p[i__ + iptr * 60 - 61] = pbar;
    } else {
        pbar = p[i__ + iptr * 60 - 61];
        i__ = pbar;
        sbar = s[i__ - 1];
    }
    --i__;
     }
 /*   Update S using AMDF */
 /*   Find maximum, minimum, and location of minimum */
     s[0] += amdf[1] / 2;
     minsc = s[0];
     maxsc = minsc;
     *midx = 1;
     i__1 = *ltau;
     for (i__ = 2; i__ <= i__1; ++i__) {
    s[i__ - 1] += amdf[i__] / 2;
    if (s[i__ - 1] > maxsc) {
        maxsc = s[i__ - 1];
    }
    if (s[i__ - 1] < minsc) {
        *midx = i__;
        minsc = s[i__ - 1];
    }
     }
 /*   Subtract MINSC from S to prevent overflow */
     i__1 = *ltau;
     for (i__ = 1; i__ <= i__1; ++i__) {
    s[i__ - 1] -= minsc;
     }
     maxsc -= minsc;
 /*   Use higher octave pitch if significant null there */
     j = 0;
     for (i__ = 20; i__ <= 40; i__ += 10) {
    if (*midx > i__) {
        if (s[*midx - i__ - 1] < maxsc / 4) {
       j = i__;
        }
    }
     }
     *midx -= j;
 /*   TRACE: look back two frames to find minimum cost pitch estimate */
     j = *ipoint;
     *pitch = *midx;
     for (i__ = 1; i__ <= 2; ++i__) {
    j = j % 2 + 1;
    *pitch = p[*pitch + j * 60 - 61];
     }
 
 /*       The following statement subtracts one from IPOINT, mod DEPTH.  I
 */
 /*       think the author chose to add DEPTH-1, instead of subtracting 1,
 */
 /*       because then it will work even if MOD doesn't work as desired on
 */
 /*       negative arguments. */
 
     *ipoint = (*ipoint + 1) % 2;
     return 0;
 } /* dyptrk_ */

◆ encode_()

int encode_	(	integer *	voice,
		integer *	pitch,
		real *	rms,
		real *	rc,
		integer *	ipitch,
		integer *	irms,
		integer *	irc
	)

Definition at line 111 of file encode.c.

References c__2, contrl_1, max, min, and pow_ii().

Referenced by lpc10_encode().

 {
     /* Initialized data */
 
     static integer enctab[16] = { 0,7,11,12,13,10,6,1,14,9,5,2,3,4,8,15 };
     static integer entau[60] = { 19,11,27,25,29,21,23,22,30,14,15,7,39,38,46,
        42,43,41,45,37,53,49,51,50,54,52,60,56,58,26,90,88,92,84,86,82,83,
        81,85,69,77,73,75,74,78,70,71,67,99,97,113,112,114,98,106,104,108,
        100,101,76 };
     static integer enadd[8] = { 1920,-768,2432,1280,3584,1536,2816,-1152 };
     static real enscl[8] = { .0204f,.0167f,.0145f,.0147f,.0143f,.0135f,.0125f,
        .0112f };
     static integer enbits[8] = { 6,5,4,4,4,4,3,3 };
     static integer entab6[64] = { 0,0,0,0,0,0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,
        3,3,3,3,3,4,4,4,4,4,4,4,5,5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,9,9,
        9,10,10,11,11,12,13,14,15 };
     static integer rmst[64] = { 1024,936,856,784,718,656,600,550,502,460,420,
        384,352,328,294,270,246,226,206,188,172,158,144,132,120,110,102,
        92,84,78,70,64,60,54,50,46,42,38,34,32,30,26,24,22,20,18,17,16,15,
        14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
 
     /* System generated locals */
     integer i__1, i__2;
 
     /* Builtin functions */
     integer pow_ii(integer *, integer *);
 
     /* Local variables */
     integer idel, nbit, i__, j, i2, i3, mrk;
 
 /* $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.1  1996/08/19  22:32:21  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 */
 /*       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.1  1996/08/19  22:32:21  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*       Parameters/constants */
 /*       These arrays are not Fortran PARAMETER's, but they are defined */
 /*       by DATA statements below, and their contents are never altered.
 */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     --irc;
     --rc;
     --voice;
 
     /* Function Body */
 /*  Scale RMS and RC's to integers */
     *irms = (integer)*rms;
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    irc[i__] = (integer)(rc[i__] * 32768.f);
     }
 /*    IF(LISTL.GE.3)WRITE(FDEBUG,800)VOICE,PITCH,IRMS,(IRC(I),I=1,ORDER) */
 /* 800   FORMAT(1X,/,' <<ENCODE IN>>',T32,2I3,I6,I5,T50,10I8) */
 /*  Encode pitch and voicing */
     if (voice[1] != 0 && voice[2] != 0) {
    *ipitch = entau[*pitch - 1];
     } else {
    if (contrl_1.corrp) {
        *ipitch = 0;
        if (voice[1] != voice[2]) {
       *ipitch = 127;
        }
    } else {
        *ipitch = (voice[1] << 1) + voice[2];
    }
     }
 /*  Encode RMS by binary table search */
     j = 32;
     idel = 16;
     *irms = min(*irms,1023);
     while(idel > 0) {
    if (*irms > rmst[j - 1]) {
        j -= idel;
    }
    if (*irms < rmst[j - 1]) {
        j += idel;
    }
    idel /= 2;
     }
     if (*irms > rmst[j - 1]) {
    --j;
     }
     *irms = 31 - j / 2;
 /*  Encode RC(1) and (2) as log-area-ratios */
     for (i__ = 1; i__ <= 2; ++i__) {
    i2 = irc[i__];
    mrk = 0;
    if (i2 < 0) {
        i2 = -i2;
        mrk = 1;
    }
    i2 /= 512;
    i2 = min(i2,63);
    i2 = entab6[i2];
    if (mrk != 0) {
        i2 = -i2;
    }
    irc[i__] = i2;
     }
 /*  Encode RC(3) - (10) linearly, remove bias then scale */
     i__1 = contrl_1.order;
     for (i__ = 3; i__ <= i__1; ++i__) {
    i2 = irc[i__] / 2;
    i2 = (integer)((i2 + enadd[contrl_1.order + 1 - i__ - 1]) * enscl[
       contrl_1.order + 1 - i__ - 1]);
 /* Computing MIN */
    i__2 = max(i2,-127);
    i2 = min(i__2,127);
    nbit = enbits[contrl_1.order + 1 - i__ - 1];
    i3 = 0;
    if (i2 < 0) {
        i3 = -1;
    }
    i2 /= pow_ii(&c__2, &nbit);
    if (i3 == -1) {
        --i2;
    }
    irc[i__] = i2;
     }
 /*          Protect the most significant bits of the most */
 /*     important parameters during non-voiced frames. */
 /*     RC(1) - RC(4) are protected using 20 parity bits */
 /*     replacing RC(5) - RC(10). */
     if (contrl_1.corrp) {
    if (*ipitch == 0 || *ipitch == 127) {
        irc[5] = enctab[(irc[1] & 30) / 2];
        irc[6] = enctab[(irc[2] & 30) / 2];
        irc[7] = enctab[(irc[3] & 30) / 2];
        irc[8] = enctab[(*irms & 30) / 2];
        irc[9] = enctab[(irc[4] & 30) / 2] / 2;
        irc[10] = enctab[(irc[4] & 30) / 2] & 1;
    }
     }
 /*    IF(LISTL.GE.3)WRITE(FDEBUG,801)VOICE,IPITCH,IRMS,(IRC(J),J=1,ORDER) */
 /* 801   FORMAT(1X,'<<ENCODE OUT>>',T32,2I3,I6,I5,T50,10I8) */
     return 0;
 } /* encode_ */

◆ energy_()

int energy_	(	integer *	len,
		real *	speech,
		real *	rms
	)

Definition at line 78 of file energy.c.

References len().

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
 
     /* Builtin functions */
     double sqrt(doublereal);
 
     /* Local variables */
     integer i__;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     --speech;
 
     /* Function Body */
     *rms = 0.f;
     i__1 = *len;
     for (i__ = 1; i__ <= i__1; ++i__) {
    *rms += speech[i__] * speech[i__];
     }
     *rms = (real)sqrt(*rms / *len);
     return 0;
 } /* energy_ */

◆ ham84_()

int ham84_	(	integer *	input,
		integer *	output,
		integer *	errcnt
	)

Definition at line 85 of file ham84.c.

References gsm_state::j.

Referenced by decode_().

 {
     /* Initialized data */
 
     static integer dactab[128] = { 16,0,0,3,0,5,14,7,0,9,14,11,14,13,30,14,0,
        9,2,7,4,7,7,23,9,25,10,9,12,9,14,7,0,5,2,11,5,21,6,5,8,11,11,27,
        12,5,14,11,2,1,18,2,12,5,2,7,12,9,2,11,28,12,12,15,0,3,3,19,4,13,
        6,3,8,13,10,3,13,29,14,13,4,1,10,3,20,4,4,7,10,9,26,10,4,13,10,15,
        8,1,6,3,6,5,22,6,24,8,8,11,8,13,6,15,1,17,2,1,4,1,6,15,8,1,10,15,
        12,15,15,31 };
 
     integer i__, j, parity;
 
 /*       Arguments */
 /*       Parameters/constants */
 /*       Local variables that need not be saved */
 /*  Determine parity of input word */
     parity = *input & 255;
     parity ^= parity / 16;
     parity ^= parity / 4;
     parity ^= parity / 2;
     parity &= 1;
     i__ = dactab[*input & 127];
     *output = i__ & 15;
     j = i__ & 16;
     if (j != 0) {
 /*          No errors detected in seven bits */
    if (parity != 0) {
        ++(*errcnt);
    }
     } else {
 /*          One or two errors detected */
    ++(*errcnt);
    if (parity == 0) {
 /*             Two errors detected */
        ++(*errcnt);
        *output = -1;
    }
     }
     return 0;
 } /* ham84_ */

◆ hp100_()

int hp100_	(	real *	speech,
		integer *	start,
		integer *	end,
		struct lpc10_encoder_state *	st
	)

Definition at line 113 of file hp100.c.

References end, lpc10_encoder_state::z11, lpc10_encoder_state::z12, lpc10_encoder_state::z21, and lpc10_encoder_state::z22.

Referenced by prepro_().

 {
     /* Temporary local copies of variables in lpc10_encoder_state.
        I've only created these because it might cause the loop below
        to execute a bit faster to access local variables, rather than
        variables in the lpc10_encoder_state structure.  It is just a
        guess that it will be faster. */
 
     real z11;
     real z21;
     real z12;
     real z22;
 
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     integer i__;
     real si, err;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*       Local state */
     /* Parameter adjustments */
     if (speech) {
    --speech;
    }
 
     /* Function Body */
 
     z11 = st->z11;
     z21 = st->z21;
     z12 = st->z12;
     z22 = st->z22;
 
     i__1 = *end;
     for (i__ = *start; i__ <= i__1; ++i__) {
    si = speech[i__];
    err = si + z11 * 1.859076f - z21 * .8648249f;
    si = err - z11 * 2.f + z21;
    z21 = z11;
    z11 = err;
    err = si + z12 * 1.935715f - z22 * .9417004f;
    si = err - z12 * 2.f + z22;
    z22 = z12;
    z12 = err;
    speech[i__] = si * .902428f;
     }
 
     st->z11 = z11;
     st->z21 = z21;
     st->z12 = z12;
     st->z22 = z22;
 
     return 0;
 } /* hp100_ */

◆ i_nint()

integer i_nint ( real * x )

Definition at line 80 of file f2clib.c.

Referenced by placea_(), r_sign(), voicin_(), and vparms_().

 {
 return( (integer)((*x)>=0 ?
    floor(*x + .5) : -floor(.5 - *x)) );
 }

◆ inithp100_()

int inithp100_ ( void )

◆ initlpcdec_()

int initlpcdec_ ( void )

◆ initlpcenc_()

int initlpcenc_ ( void )

◆ invert_()

int invert_	(	integer *	order,
		real *	phi,
		real *	psi,
		real *	rc
	)

Definition at line 93 of file invert.c.

References abs, max, min, and order.

Referenced by analys_().

 {
     /* System generated locals */
     unsigned i__2;
     integer phi_dim1, phi_offset, i__1, i__3;
     real r__1, r__2;
 
     /* Local variables */
     real save;
     integer i__, j, k;
     real v[100]   /* was [10][10] */;
 
 /*       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.1  1996/08/19  22:32:00  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 */
 /*       Local variables that need not be saved */
 /*  Decompose PHI into V * D * V' where V is a triangular matrix whose */
 /*   main diagonal elements are all 1, V' is the transpose of V, and */
 /*   D is a vector.  Here D(n) is stored in location V(n,n). */
     /* Parameter adjustments */
     --rc;
     --psi;
     phi_dim1 = *order;
     phi_offset = phi_dim1 + 1;
     phi -= phi_offset;
 
     /* Function Body */
     i__1 = *order;
     for (j = 1; j <= i__1; ++j) {
    i__2 = *order;
    for (i__ = j; i__ <= i__2; ++i__) {
        v[i__ + j * 10 - 11] = phi[i__ + j * phi_dim1];
    }
    i__2 = j - 1;
    for (k = 1; k <= i__2; ++k) {
        save = v[j + k * 10 - 11] * v[k + k * 10 - 11];
        i__3 = *order;
        for (i__ = j; i__ <= i__3; ++i__) {
       v[i__ + j * 10 - 11] -= v[i__ + k * 10 - 11] * save;
        }
    }
 /*  Compute intermediate results, which are similar to RC's */
    if ((r__1 = v[j + j * 10 - 11], abs(r__1)) < 1e-10f) {
        goto L100;
    }
    rc[j] = psi[j];
    i__2 = j - 1;
    for (k = 1; k <= i__2; ++k) {
        rc[j] -= rc[k] * v[j + k * 10 - 11];
    }
    v[j + j * 10 - 11] = 1.f / v[j + j * 10 - 11];
    rc[j] *= v[j + j * 10 - 11];
 /* Computing MAX */
 /* Computing MIN */
    r__2 = rc[j];
    r__1 = min(r__2,.999f);
    rc[j] = max(r__1,-.999f);
     }
     return 0;
 /*  Zero out higher order RC's if algorithm terminated early */
 L100:
     i__1 = *order;
     for (i__ = j; i__ <= i__1; ++i__) {
    rc[i__] = 0.f;
     }
 /*  Back substitute for PC's (if needed) */
 /* 110   DO J = ORDER,1,-1 */
 /*       PC(J) = RC(J) */
 /*       DO I = 1,J-1 */
 /*          PC(J) = PC(J) - PC(I)*V(J,I) */
 /*       END DO */
 /*    END DO */
     return 0;
 } /* invert_ */

◆ irc2pc_()

int irc2pc_	(	real *	rc,
		real *	pc,
		integer *	order,
		real *	gprime,
		real *	g2pass
	)

Definition at line 82 of file irc2pc.c.

References order.

Referenced by synths_().

 {
     /* System generated locals */
     integer i__1, i__2;
 
     /* Builtin functions */
     double sqrt(doublereal);
 
     /* Local variables */
     real temp[10];
     integer i__, j;
 
 /*    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.1  1996/08/19  22:31:56  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 */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     --pc;
     --rc;
 
     /* Function Body */
     *g2pass = 1.f;
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    *g2pass *= 1.f - rc[i__] * rc[i__];
     }
     *g2pass = *gprime * (real)sqrt(*g2pass);
     pc[1] = rc[1];
     i__1 = *order;
     for (i__ = 2; i__ <= i__1; ++i__) {
    i__2 = i__ - 1;
    for (j = 1; j <= i__2; ++j) {
        temp[j - 1] = pc[j] - rc[i__] * pc[i__ - j];
    }
    i__2 = i__ - 1;
    for (j = 1; j <= i__2; ++j) {
        pc[j] = temp[j - 1];
    }
    pc[i__] = rc[i__];
     }
     return 0;
 } /* irc2pc_ */

◆ ivfilt_()

int ivfilt_	(	real *	lpbuf,
		real *	ivbuf,
		integer *	len,
		integer *	nsamp,
		real *	ivrc
	)

Definition at line 89 of file ivfilt.c.

References len().

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     integer i__, j, k;
     real r__[3], pc1, pc2;
 
 /*    Arguments */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       None */
 /*  Calculate Autocorrelations */
     /* Parameter adjustments */
     --ivbuf;
     --lpbuf;
     --ivrc;
 
     /* Function Body */
     for (i__ = 1; i__ <= 3; ++i__) {
    r__[i__ - 1] = 0.f;
    k = (i__ - 1) << 2;
    i__1 = *len;
    for (j = (i__ << 2) + *len - *nsamp; j <= i__1; j += 2) {
        r__[i__ - 1] += lpbuf[j] * lpbuf[j - k];
    }
     }
 /*  Calculate predictor coefficients */
     pc1 = 0.f;
     pc2 = 0.f;
     ivrc[1] = 0.f;
     ivrc[2] = 0.f;
     if (r__[0] > 1e-10f) {
    ivrc[1] = r__[1] / r__[0];
    ivrc[2] = (r__[2] - ivrc[1] * r__[1]) / (r__[0] - ivrc[1] * r__[1]);
    pc1 = ivrc[1] - ivrc[1] * ivrc[2];
    pc2 = ivrc[2];
     }
 /*  Inverse filter LPBUF into IVBUF */
     i__1 = *len;
     for (i__ = *len + 1 - *nsamp; i__ <= i__1; ++i__) {
    ivbuf[i__] = lpbuf[i__] - pc1 * lpbuf[i__ - 4] - pc2 * lpbuf[i__ - 8];
     }
     return 0;
 } /* ivfilt_ */

◆ lpcdec_()

int lpcdec_	(	integer *	bits,
		real *	speech
	)

◆ lpcenc_()

int lpcenc_	(	real *	speech,
		integer *	bits
	)

◆ lpfilt_()

int lpfilt_	(	real *	inbuf,
		real *	lpbuf,
		integer *	len,
		integer *	nsamp
	)

Definition at line 83 of file lpfilt.c.

References inbuf(), lpc10_decoder_state::j, and len().

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     integer j;
     real t;
 
 /*    Arguments */
 /*    Parameters/constants */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       None */
     /* Parameter adjustments */
     --lpbuf;
     --inbuf;
 
     /* Function Body */
     i__1 = *len;
     for (j = *len + 1 - *nsamp; j <= i__1; ++j) {
    t = (inbuf[j] + inbuf[j - 30]) * -.0097201988f;
    t += (inbuf[j - 1] + inbuf[j - 29]) * -.0105179986f;
    t += (inbuf[j - 2] + inbuf[j - 28]) * -.0083479648f;
    t += (inbuf[j - 3] + inbuf[j - 27]) * 5.860774e-4f;
    t += (inbuf[j - 4] + inbuf[j - 26]) * .0130892089f;
    t += (inbuf[j - 5] + inbuf[j - 25]) * .0217052232f;
    t += (inbuf[j - 6] + inbuf[j - 24]) * .0184161253f;
    t += (inbuf[j - 7] + inbuf[j - 23]) * 3.39723e-4f;
    t += (inbuf[j - 8] + inbuf[j - 22]) * -.0260797087f;
    t += (inbuf[j - 9] + inbuf[j - 21]) * -.0455563702f;
    t += (inbuf[j - 10] + inbuf[j - 20]) * -.040306855f;
    t += (inbuf[j - 11] + inbuf[j - 19]) * 5.029835e-4f;
    t += (inbuf[j - 12] + inbuf[j - 18]) * .0729262903f;
    t += (inbuf[j - 13] + inbuf[j - 17]) * .1572008878f;
    t += (inbuf[j - 14] + inbuf[j - 16]) * .2247288674f;
    t += inbuf[j - 15] * .250535965f;
    lpbuf[j] = t;
     }
     return 0;
 } /* lpfilt_ */

◆ median_()

integer median_	(	integer *	d1,
		integer *	d2,
		integer *	d3
	)

Definition at line 69 of file median.c.

Referenced by decode_().

 {
     /* System generated locals */
     integer ret_val;
 
 /*       Arguments */
     ret_val = *d2;
     if (*d2 > *d1 && *d2 > *d3) {
    ret_val = *d1;
    if (*d3 > *d1) {
        ret_val = *d3;
    }
     } else if (*d2 < *d1 && *d2 < *d3) {
    ret_val = *d1;
    if (*d3 < *d1) {
        ret_val = *d3;
    }
     }
     return ret_val;
 } /* median_ */

◆ mload_()

int mload_	(	integer *	order,
		integer *	awins,
		integer *	awinf,
		real *	speech,
		real *	phi,
		real *	psi
	)

Definition at line 99 of file mload.c.

References order.

Referenced by analys_().

 {
     /* System generated locals */
     integer phi_dim1, phi_offset, i__1, i__2;
 
     /* Local variables */
     integer c__, i__, r__, start;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*   Load first column of triangular covariance matrix PHI */
     /* Parameter adjustments */
     --psi;
     phi_dim1 = *order;
     phi_offset = phi_dim1 + 1;
     phi -= phi_offset;
     --speech;
 
     /* Function Body */
     start = *awins + *order;
     i__1 = *order;
     for (r__ = 1; r__ <= i__1; ++r__) {
    phi[r__ + phi_dim1] = 0.f;
    i__2 = *awinf;
    for (i__ = start; i__ <= i__2; ++i__) {
        phi[r__ + phi_dim1] += speech[i__ - 1] * speech[i__ - r__];
    }
     }
 /*   Load last element of vector PSI */
     psi[*order] = 0.f;
     i__1 = *awinf;
     for (i__ = start; i__ <= i__1; ++i__) {
    psi[*order] += speech[i__] * speech[i__ - *order];
     }
 /*   End correct to get additional columns of PHI */
     i__1 = *order;
     for (r__ = 2; r__ <= i__1; ++r__) {
    i__2 = r__;
    for (c__ = 2; c__ <= i__2; ++c__) {
        phi[r__ + c__ * phi_dim1] = phi[r__ - 1 + (c__ - 1) * phi_dim1] -
           speech[*awinf + 1 - r__] * speech[*awinf + 1 - c__] +
           speech[start - r__] * speech[start - c__];
    }
     }
 /*   End correct to get additional elements of PSI */
     i__1 = *order - 1;
     for (c__ = 1; c__ <= i__1; ++c__) {
    psi[c__] = phi[c__ + 1 + phi_dim1] - speech[start - 1] * speech[start
       - 1 - c__] + speech[*awinf] * speech[*awinf - c__];
     }
 /*   Copy lower triangular section into upper (why bother?) */
 /*       I'm commenting this out, since the upper triangular half of PHI
 */
 /*       is never used by later code, unless a sufficiently high level of
 */
 /*       tracing is turned on. */
 /*    DO R = 1,ORDER */
 /*       DO C = 1,R-1 */
 /*          PHI(C,R) = PHI(R,C) */
 /*       END DO */
 /*    END DO */
     return 0;
 } /* mload_ */

◆ 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.

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_().

 {
     /* 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_ */

◆ pitsyn_()

int pitsyn_	(	integer *	order,
		integer *	voice,
		integer *	pitch,
		real *	rms,
		real *	rc,
		integer *	lframe,
		integer *	ivuv,
		integer *	ipiti,
		real *	rmsi,
		real *	rci,
		integer *	nout,
		real *	ratio,
		struct lpc10_decoder_state *	st
	)

Definition at line 132 of file pitsyn.c.

References FALSE_, first, lpc10_decoder_state::first_pitsyn, lpc10_decoder_state::ipito, lpc10_decoder_state::ivoico, lpc10_decoder_state::jsamp, order, lpc10_decoder_state::rco, lpc10_decoder_state::rmso, and TRUE_.

Referenced by synths_().

 {
     /* Initialized data */
 
     real *rmso;
     logical *first;
 
     /* System generated locals */
     integer rci_dim1 = 0, rci_offset, i__1, i__2;
     real r__1;
 
     /* Builtin functions */
     double log(doublereal), exp(doublereal);
 
     /* Local variables */
     real alrn, alro, yarc[10], prop;
     integer i__, j, vflag, jused, lsamp;
     integer *jsamp;
     real slope;
     integer *ipito;
     real uvpit;
     integer ip, nl, ivoice;
     integer *ivoico;
     integer istart;
     real *rco;
     real xxy;
 
 /*       Arguments */
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/11/23 22:14:32  markster
  * Various warning cleanups
  *
  * 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:40:12  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:31:12  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 */
 /*       Local variables that need not be saved */
 /*       LSAMP is initialized in the IF (FIRST) THEN clause, but it is */
 /*       not used the first time through, and it is given a value before
 */
 /*       use whenever FIRST is .FALSE., so it appears unnecessary to */
 /*       assign it a value when FIRST is .TRUE. */
 /*       Local state */
 /* FIRST  - .TRUE. only on first call to PITSYN. */
 /* IVOICO - Previous VOICE(2) value. */
 /* IPITO  - Previous PITCH value. */
 /* RMSO   - Previous RMS value. */
 /* RCO    - Previous RC values. */
 
 /* JSAMP  - If this routine is called N times with identical values of */
 /*          LFRAME, then the total length of all pitch periods returned */
 /*          is always N*LFRAME-JSAMP, and JSAMP is always in the range 0
 */
 /*          to MAXPIT-1 (see below for why this is so).  Thus JSAMP is */
 /*          the number of samples "left over" from the previous call to */
 /*          PITSYN, that haven't been "used" in a pitch period returned */
 /*          from this subroutine.  Every time this subroutine is called,
 */
 /*          it returns pitch periods with a total length of at most */
 /*          LFRAME+JSAMP. */
 
 /* IVOICO, IPITO, RCO, and JSAMP need not be assigned an initial value */
 /* with a DATA statement, because they are always initialized on the */
 /* first call to PITSYN. */
 
 /* FIRST and RMSO should be initialized with DATA statements, because */
 /* even on the first call, they are used before being initialized. */
     /* Parameter adjustments */
     if (rc) {
    --rc;
    }
     if (rci) {
    rci_dim1 = *order;
    rci_offset = rci_dim1 + 1;
    rci -= rci_offset;
    }
     if (voice) {
    --voice;
    }
     if (ivuv) {
    --ivuv;
    }
     if (ipiti) {
    --ipiti;
    }
     if (rmsi) {
    --rmsi;
    }
 
     /* Function Body */
     ivoico = &(st->ivoico);
     ipito = &(st->ipito);
     rmso = &(st->rmso);
     rco = &(st->rco[0]);
     jsamp = &(st->jsamp);
     first = &(st->first_pitsyn);
 
     if (*rms < 1.f) {
    *rms = 1.f;
     }
     if (*rmso < 1.f) {
    *rmso = 1.f;
     }
     uvpit = 0.f;
     *ratio = *rms / (*rmso + 8.f);
     if (*first) {
    lsamp = 0;
    ivoice = voice[2];
    if (ivoice == 0) {
        *pitch = *lframe / 4;
    }
    *nout = *lframe / *pitch;
    *jsamp = *lframe - *nout * *pitch;
 
 /*          SYNTHS only calls this subroutine with PITCH in the range
 20 */
 /*          to 156.  LFRAME = MAXFRM = 180, so NOUT is somewhere in th
 e */
 /*          range 1 to 9. */
 
 /*          JSAMP is "LFRAME mod PITCH", so it is in the range 0 to */
 /*          (PITCH-1), or 0 to MAXPIT-1=155, after the first call. */
 
    i__1 = *nout;
    for (i__ = 1; i__ <= i__1; ++i__) {
        i__2 = *order;
        for (j = 1; j <= i__2; ++j) {
       rci[j + i__ * rci_dim1] = rc[j];
        }
        ivuv[i__] = ivoice;
        ipiti[i__] = *pitch;
        rmsi[i__] = *rms;
    }
    *first = FALSE_;
     } else {
    vflag = 0;
    lsamp = *lframe + *jsamp;
    slope = (*pitch - *ipito) / (real) lsamp;
    *nout = 0;
    jused = 0;
    istart = 1;
    if (voice[1] == *ivoico && voice[2] == voice[1]) {
        if (voice[2] == 0) {
 /* SSUV - -   0  ,  0  ,  0 */
       *pitch = *lframe / 4;
       *ipito = *pitch;
       if (*ratio > 8.f) {
           *rmso = *rms;
       }
        }
 /* SSVC - -   1  ,  1  ,  1 */
        slope = (*pitch - *ipito) / (real) lsamp;
        ivoice = voice[2];
    } else {
        if (*ivoico != 1) {
       if (*ivoico == voice[1]) {
 /* UV2VC2 - -  0  ,  0  ,  1 */
           nl = lsamp - *lframe / 4;
       } else {
 /* UV2VC1 - -  0  ,  1  ,  1 */
           nl = lsamp - *lframe * 3 / 4;
       }
       ipiti[1] = nl / 2;
       ipiti[2] = nl - ipiti[1];
       ivuv[1] = 0;
       ivuv[2] = 0;
       rmsi[1] = *rmso;
       rmsi[2] = *rmso;
       i__1 = *order;
       for (i__ = 1; i__ <= i__1; ++i__) {
           rci[i__ + rci_dim1] = rco[i__ - 1];
           rci[i__ + (rci_dim1 << 1)] = rco[i__ - 1];
           rco[i__ - 1] = rc[i__];
       }
       slope = 0.f;
       *nout = 2;
       *ipito = *pitch;
       jused = nl;
       istart = nl + 1;
       ivoice = 1;
        } else {
       if (*ivoico != voice[1]) {
 /* VC2UV1 - -   1  ,  0  ,  0 */
           lsamp = *lframe / 4 + *jsamp;
       } else {
 /* VC2UV2 - -   1  ,  1  ,  0 */
           lsamp = *lframe * 3 / 4 + *jsamp;
       }
       i__1 = *order;
       for (i__ = 1; i__ <= i__1; ++i__) {
           yarc[i__ - 1] = rc[i__];
           rc[i__] = rco[i__ - 1];
       }
       ivoice = 1;
       slope = 0.f;
       vflag = 1;
        }
    }
 /* Here is the value of most variables that are used below, depending
 on */
 /* the values of IVOICO, VOICE(1), and VOICE(2).  VOICE(1) and VOICE(2
 ) */
 /* are input arguments, and IVOICO is the value of VOICE(2) on the */
 /* previous call (see notes for the IF (NOUT .NE. 0) statement near th
 e */
 /* end).  Each of these three values is either 0 or 1.  These three */
 /* values below are given as 3-bit long strings, in the order IVOICO,
 */
 /* VOICE(1), and VOICE(2).  It appears that the code above assumes tha
 t */
 /* the bit sequences 010 and 101 never occur, but I wonder whether a
 */
 /* large enough number of bit errors in the channel could cause such a
  */
 /* thing to happen, and if so, could that cause NOUT to ever go over 1
 1? */
 
 /* Note that all of the 180 values in the table are really LFRAME, but
  */
 /* 180 has fewer characters, and it makes the table a little more */
 /* concrete.  If LFRAME is ever changed, keep this in mind.  Similarly
 , */
 /* 135's are 3*LFRAME/4, and 45's are LFRAME/4.  If LFRAME is not a */
 /* multiple of 4, then the 135 for NL-JSAMP is actually LFRAME-LFRAME/
 4, */
 /* and the 45 for NL-JSAMP is actually LFRAME-3*LFRAME/4. */
 
 /* Note that LSAMP-JSAMP is given as the variable.  This was just for
 */
 /* brevity, to avoid adding "+JSAMP" to all of the column entries. */
 /* Similarly for NL-JSAMP. */
 
 /* Variable    | 000  001    011,010  111       110       100,101 */
 /* ------------+-------------------------------------------------- */
 /* ISTART      | 1    NL+1   NL+1     1         1         1 */
 /* LSAMP-JSAMP | 180  180    180      180       135       45 */
 /* IPITO       | 45   PITCH  PITCH    oldPITCH  oldPITCH  oldPITCH */
 /* SLOPE       | 0    0      0        seebelow  0         0 */
 /* JUSED       | 0    NL     NL       0         0         0 */
 /* PITCH       | 45   PITCH  PITCH    PITCH     PITCH     PITCH */
 /* NL-JSAMP    | --   135    45       --        --        -- */
 /* VFLAG       | 0    0      0        0         1         1 */
 /* NOUT        | 0    2      2        0         0         0 */
 /* IVOICE      | 0    1      1        1         1         1 */
 
 /* while_loop  | once once   once     once      twice     twice */
 
 /* ISTART      | --   --     --       --        JUSED+1   JUSED+1 */
 /* LSAMP-JSAMP | --   --     --       --        180       180 */
 /* IPITO       | --   --     --       --        oldPITCH  oldPITCH */
 /* SLOPE       | --   --     --       --        0         0 */
 /* JUSED       | --   --     --       --        ??        ?? */
 /* PITCH       | --   --     --       --        PITCH     PITCH */
 /* NL-JSAMP    | --   --     --       --        --        -- */
 /* VFLAG       | --   --     --       --        0         0 */
 /* NOUT        | --   --     --       --        ??        ?? */
 /* IVOICE      | --   --     --       --        0         0 */
 
 
 /* UVPIT is always 0.0 on the first pass through the DO WHILE (.TRUE.)
  */
 /* loop below. */
 
 /* The only possible non-0 value of SLOPE (in column 111) is */
 /* (PITCH-IPITO)/FLOAT(LSAMP) */
 
 /* Column 101 is identical to 100.  Any good properties we can prove
 */
 /* for 100 will also hold for 101.  Similarly for 010 and 011. */
 
 /* SYNTHS calls this subroutine with PITCH restricted to the range 20
 to */
 /* 156.  IPITO is similarly restricted to this range, after the first
 */
 /* call.  IP below is also restricted to this range, given the */
 /* definitions of IPITO, SLOPE, UVPIT, and that I is in the range ISTA
 RT */
 /* to LSAMP. */
 
    while(TRUE_) {
 
 /*             JUSED is the total length of all pitch periods curr
 ently */
 /*             in the output arrays, in samples. */
 
 /*             An invariant of the DO I = ISTART,LSAMP loop below,
  under */
 /*             the condition that IP is always in the range 1 thro
 ugh */
 /*             MAXPIT, is: */
 
 /*             (I - MAXPIT) .LE. JUSED .LE. (I-1) */
 
 /*             Note that the final value of I is LSAMP+1, so that
 after */
 /*             the DO loop is complete, we know: */
 
 /*             (LSAMP - MAXPIT + 1) .LE. JUSED .LE. LSAMP */
 
        i__1 = lsamp;
        for (i__ = istart; i__ <= i__1; ++i__) {
       r__1 = *ipito + slope * i__;
       ip = (integer)(r__1 + .5f);
       if (uvpit != 0.f) {
           ip = (integer)uvpit;
       }
       if (ip <= i__ - jused) {
           ++(*nout);
 
 /*                   The following check is no longer nece
 ssary, now that */
 /*                   we can prove that NOUT will never go
 over 16. */
 
 /*           IF (NOUT .GT. 16) STOP 'PITSYN: too many epochs'
 */
 
           ipiti[*nout] = ip;
           *pitch = ip;
           ivuv[*nout] = ivoice;
           jused += ip;
           prop = (jused - ip / 2) / (real) lsamp;
           i__2 = *order;
           for (j = 1; j <= i__2; ++j) {
          alro = (real)log((rco[j - 1] + 1) / (1 - rco[j - 1]));
          alrn = (real)log((rc[j] + 1) / (1 - rc[j]));
          xxy = alro + prop * (alrn - alro);
          xxy = (real)exp(xxy);
          rci[j + *nout * rci_dim1] = (xxy - 1) / (xxy + 1);
           }
           rmsi[*nout] = (real)(log(*rmso) + prop * (log(*rms) - log(*rmso)));
           rmsi[*nout] = (real)exp(rmsi[*nout]);
       }
        }
        if (vflag != 1) {
       goto L100;
        }
 
 /*             I want to prove what range UVPIT must lie in after
 the */
 /*             assignments to it below.  To do this, I must determ
 ine */
 /*             what range (LSAMP-ISTART) must lie in, after the */
 /*             assignments to ISTART and LSAMP below. */
 
 /*             Let oldLSAMP be the value of LSAMP at this point in
  the */
 /*             execution.  This is 135+JSAMP in state 110, or 45+J
 SAMP in */
 /*             states 100 or 101. */
 
 /*             Given the loop invariant on JUSED above, we know th
 at: */
 
 /*             (oldLSAMP - MAXPIT + 1) .LE. JUSED .LE. oldLSAMP */
 
 /*             ISTART is one more than this. */
 
 /*             Let newLSAMP be the value assigned to LSAMP below.
  This */
 /*             is 180+JSAMP.  Thus (newLSAMP-oldLSAMP) is either 4
 5 or */
 /*             135, depending on the state. */
 
 /*             Thus, the range of newLSAMP-ISTART is: */
 
 /*             (newLSAMP-(oldLSAMP+1)) .LE. newLSAMP-ISTART */
 /*             .LE. (newLSAMP-(oldLSAMP - MAXPIT + 2)) */
 
 /*             or: */
 
 /*             46 .LE. newLSAMP-ISTART .LE. 133+MAXPIT .EQ. 289 */
 
 /*             Therefore, UVPIT is in the range 23 to 144 after th
 e first */
 /*             assignment to UVPIT below, and after the conditiona
 l */
 /*             assignment, it is in the range 23 to 90. */
 
 /*             The important thing is that it is in the range 20 t
 o 156, */
 /*             so that in the loop above, IP is always in this ran
 ge. */
 
        vflag = 0;
        istart = jused + 1;
        lsamp = *lframe + *jsamp;
        slope = 0.f;
        ivoice = 0;
        uvpit = (real) ((lsamp - istart) / 2);
        if (uvpit > 90.f) {
       uvpit /= 2;
        }
        *rmso = *rms;
        i__1 = *order;
        for (i__ = 1; i__ <= i__1; ++i__) {
       rc[i__] = yarc[i__ - 1];
       rco[i__ - 1] = yarc[i__ - 1];
        }
    }
 L100:
    *jsamp = lsamp - jused;
     }
 /*       Given that the maximum pitch period MAXPIT .LT. LFRAME (this is
 */
 /*       currently true on every call, since SYNTHS always sets */
 /*       LFRAME=180), NOUT will always be .GE. 1 at this point. */
     if (*nout != 0) {
    *ivoico = voice[2];
    *ipito = *pitch;
    *rmso = *rms;
    i__1 = *order;
    for (i__ = 1; i__ <= i__1; ++i__) {
        rco[i__ - 1] = rc[i__];
    }
     }
     return 0;
 } /* pitsyn_ */

◆ placea_()

int placea_	(	integer *	ipitch,
		integer *	voibuf,
		integer *	obound,
		integer *	af,
		integer *	vwin,
		integer *	awin,
		integer *	ewin,
		integer *	lframe,
		integer *	maxwin
	)

Definition at line 116 of file placea.c.

References FALSE_, i_nint(), lframe, and TRUE_.

Referenced by analys_().

 {
     /* System generated locals */
     real r__1;
 
     /* Builtin functions */
     integer i_nint(real *);
 
     /* Local variables */
     logical allv, winv;
     integer i__, j, k, l, hrange;
     logical ephase;
     integer lrange;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     ewin -= 3;
     awin -= 3;
     vwin -= 3;
     --voibuf;
 
     /* Function Body */
     lrange = (*af - 2) * *lframe + 1;
     hrange = *af * *lframe;
 /*   Place the Analysis window based on the voicing window */
 /*   placement, onsets, tentative voicing decision, and pitch. */
 
 /*   Case 1:  Sustained Voiced Speech */
 /*   If the five most recent voicing decisions are */
 /*   voiced, then the window is placed phase-synchronously with the */
 /*   previous window, as close to the present voicing window if possible.
 */
 /*   If onsets bound the voicing window, then preference is given to */
 /*   a phase-synchronous placement which does not overlap these onsets. */
 
 /*   Case 2:  Voiced Transition */
 /*   If at least one voicing decision in AF is voicied, and there are no
 */
 /*   onsets, then the window is placed as in case 1. */
 
 /*   Case 3:  Unvoiced Speech or Onsets */
 /*   If both voicing decisions in AF are unvoiced, or there are onsets, */
 /*   then the window is placed coincident with the voicing window. */
 
 /*   Note:  During phase-synchronous placement of windows, the length */
 /*   is not altered from MAXWIN, since this would defeat the purpose */
 /*   of phase-synchronous placement. */
 /* Check for case 1 and case 2 */
     allv = voibuf[((*af - 2) << 1) + 2] == 1;
     allv = allv && voibuf[((*af - 1) << 1) + 1] == 1;
     allv = allv && voibuf[((*af - 1) << 1) + 2] == 1;
     allv = allv && voibuf[(*af << 1) + 1] == 1;
     allv = allv && voibuf[(*af << 1) + 2] == 1;
     winv = voibuf[(*af << 1) + 1] == 1 || voibuf[(*af << 1) + 2] == 1;
     if (allv || (winv && *obound == 0)) {
 /* APHASE:  Phase synchronous window placement. */
 /* Get minimum lower index of the window. */
    i__ = (lrange + *ipitch - 1 - awin[((*af - 1) << 1) + 1]) / *ipitch;
    i__ *= *ipitch;
    i__ += awin[((*af - 1) << 1) + 1];
 /* L = the actual length of this frame's analysis window. */
    l = *maxwin;
 /* Calculate the location where a perfectly centered window would star
 t. */
    k = (vwin[(*af << 1) + 1] + vwin[(*af << 1) + 2] + 1 - l) / 2;
 /* Choose the actual location to be the pitch multiple closest to this
 . */
    r__1 = (real) (k - i__) / *ipitch;
    awin[(*af << 1) + 1] = i__ + i_nint(&r__1) * *ipitch;
    awin[(*af << 1) + 2] = awin[(*af << 1) + 1] + l - 1;
 /* If there is an onset bounding the right of the voicing window and t
 he */
 /* analysis window overlaps that, then move the analysis window backwa
 rd */
 /* to avoid this onset. */
    if (*obound >= 2 && awin[(*af << 1) + 2] > vwin[(*af << 1) + 2]) {
        awin[(*af << 1) + 1] -= *ipitch;
        awin[(*af << 1) + 2] -= *ipitch;
    }
 /* Similarly for the left of the voicing window. */
    if ((*obound == 1 || *obound == 3) && awin[(*af << 1) + 1] < vwin[(*
       af << 1) + 1]) {
        awin[(*af << 1) + 1] += *ipitch;
        awin[(*af << 1) + 2] += *ipitch;
    }
 /* If this placement puts the analysis window above HRANGE, then */
 /* move it backward an integer number of pitch periods. */
    while(awin[(*af << 1) + 2] > hrange) {
        awin[(*af << 1) + 1] -= *ipitch;
        awin[(*af << 1) + 2] -= *ipitch;
    }
 /* Similarly if the placement puts the analysis window below LRANGE.
 */
    while(awin[(*af << 1) + 1] < lrange) {
        awin[(*af << 1) + 1] += *ipitch;
        awin[(*af << 1) + 2] += *ipitch;
    }
 /* Make Energy window be phase-synchronous. */
    ephase = TRUE_;
 /* Case 3 */
     } else {
    awin[(*af << 1) + 1] = vwin[(*af << 1) + 1];
    awin[(*af << 1) + 2] = vwin[(*af << 1) + 2];
    ephase = FALSE_;
     }
 /* RMS is computed over an integer number of pitch periods in the analysis
  */
 /*window.  When it is not placed phase-synchronously, it is placed as clos
 e*/
 /* as possible to onsets. */
     j = (awin[(*af << 1) + 2] - awin[(*af << 1) + 1] + 1) / *ipitch * *ipitch;
     if (j == 0 || ! winv) {
    ewin[(*af << 1) + 1] = vwin[(*af << 1) + 1];
    ewin[(*af << 1) + 2] = vwin[(*af << 1) + 2];
     } else if (! ephase && *obound == 2) {
    ewin[(*af << 1) + 1] = awin[(*af << 1) + 2] - j + 1;
    ewin[(*af << 1) + 2] = awin[(*af << 1) + 2];
     } else {
    ewin[(*af << 1) + 1] = awin[(*af << 1) + 1];
    ewin[(*af << 1) + 2] = awin[(*af << 1) + 1] + j - 1;
     }
     return 0;
 } /* placea_ */

◆ placev_()

int placev_	(	integer *	osbuf,
		integer *	osptr,
		integer *	oslen,
		integer *	obound,
		integer *	vwin,
		integer *	af,
		integer *	lframe,
		integer *	minwin,
		integer *	maxwin,
		integer *	dvwinl,
		integer *	dvwinh
	)

Definition at line 112 of file placev.c.

References FALSE_, lframe, max, min, and TRUE_.

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1, i__2;
 
     /* Local variables */
     logical crit;
     integer i__, q, osptr1, hrange, lrange;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*   Variables */
 /*    LRANGE, HRANGE  Range in which window is placed */
 /*    OSPTR1     OSPTR excluding samples in 3F */
 /*       Local state */
 /*       None */
 /*   Voicing Window Placement */
 
 /*         __________________ __________________ ______________ */
 /*        |                  |                  | */
 /*        |        1F        |        2F        |        3F ... */
 /*        |__________________|__________________|______________ */
 
 /*    Previous | */
 /*      Window | */
 /*  ...________| */
 
 /*             |                                | */
 /*      ------>| This window's placement range  |<------ */
 /*             |                                | */
 
 /*   There are three cases.  Note that these are different from those */
 /*   given in the LPC-10e phase 1 report. */
 
 /*   1.  If there are no onsets in this range, then the voicing window */
 /*   is centered in the pitch window.  If such a placement is not within
 */
 /*   the window's placement range, then the window is placed in the left-
 */
 /*   most portion of the placement range.  Its length is always MAXWIN. */
 
 /*   2.  If the first onset is in 2F and there is sufficient room to place
  */
 /*   the window immediately before this onset, then the window is placed
 */
 /*   there, and its length is set to the maximum possible under these */
 /*   constraints. */
 
 /*    "Critical Region Exception":  If there is another onset in 2F */
 /*    such that a window can be placed between the two onsets, the */
 /*    window is placed there (ie, as in case 3). */
 
 /*   3.  Otherwise, the window is placed immediately after the onset.  The
  */
 /*   window's length */
 /*  is the longest length that can fit in the range under these constraint
 s,*/
 /*  except that the window may be shortened even further to avoid overlapp
 ing*/
 /*  other onsets in the placement range.  In any case, the window's length
 */
 /*   is at least MINWIN. */
 
 /*   Note that the values of MINWIN and LFRAME must be chosen such */
 /*   that case 2 = false implies case 3 = true.   This means that */
 /*   MINWIN <= LFRAME/2.  If this were not the case, then a fourth case */
 /*   would have to be added for when the window cannot fit either before
 */
 /*   or after the onset. */
 
 /*   Note also that onsets which weren't in 2F last time may be in 1F this
  */
 /*  time, due to the filter delays in computing onsets.  The result is tha
 t*/
 /*   occasionally a voicing window will overlap that onset.  The only way
 */
 /*   to circumvent this problem is to add more delay in processing input
 */
 /*   speech.  In the trade-off between delay and window-placement, window
 */
 /*   placement lost. */
 /* Compute the placement range */
     /* Parameter adjustments */
     --osbuf;
     vwin -= 3;
 
     /* Function Body */
 /* Computing MAX */
     i__1 = vwin[((*af - 1) << 1) + 2] + 1, i__2 = (*af - 2) * *lframe + 1;
     lrange = max(i__1,i__2);
     hrange = *af * *lframe;
 /* Compute OSPTR1, so the following code only looks at relevant onsets. */
     for (osptr1 = *osptr - 1; osptr1 >= 1; --osptr1) {
    if (osbuf[osptr1] <= hrange) {
        goto L90;
    }
     }
 L90:
     ++osptr1;
 /* Check for case 1 first (fast case): */
     if (osptr1 <= 1 || osbuf[osptr1 - 1] < lrange) {
 /* Computing MAX */
    i__1 = vwin[((*af - 1) << 1) + 2] + 1;
    vwin[(*af << 1) + 1] = max(i__1,*dvwinl);
    vwin[(*af << 1) + 2] = vwin[(*af << 1) + 1] + *maxwin - 1;
    *obound = 0;
     } else {
 /* Search backward in OSBUF for first onset in range. */
 /* This code relies on the above check being performed first. */
    for (q = osptr1 - 1; q >= 1; --q) {
        if (osbuf[q] < lrange) {
       goto L100;
        }
    }
 L100:
    ++q;
 /* Check for case 2 (placement before onset): */
 /* Check for critical region exception: */
    i__1 = osptr1 - 1;
    for (i__ = q + 1; i__ <= i__1; ++i__) {
        if (osbuf[i__] - osbuf[q] >= *minwin) {
       crit = TRUE_;
       goto L105;
        }
    }
    crit = FALSE_;
 L105:
 /* Computing MAX */
    i__1 = (*af - 1) * *lframe, i__2 = lrange + *minwin - 1;
    if (! crit && osbuf[q] > max(i__1,i__2)) {
        vwin[(*af << 1) + 2] = osbuf[q] - 1;
 /* Computing MAX */
        i__1 = lrange, i__2 = vwin[(*af << 1) + 2] - *maxwin + 1;
        vwin[(*af << 1) + 1] = max(i__1,i__2);
        *obound = 2;
 /* Case 3 (placement after onset) */
    } else {
        vwin[(*af << 1) + 1] = osbuf[q];
 L110:
        ++q;
        if (q >= osptr1) {
       goto L120;
        }
        if (osbuf[q] > vwin[(*af << 1) + 1] + *maxwin) {
       goto L120;
        }
        if (osbuf[q] < vwin[(*af << 1) + 1] + *minwin) {
       goto L110;
        }
        vwin[(*af << 1) + 2] = osbuf[q] - 1;
        *obound = 3;
        return 0;
 L120:
 /* Computing MIN */
        i__1 = vwin[(*af << 1) + 1] + *maxwin - 1;
        vwin[(*af << 1) + 2] = min(i__1,hrange);
        *obound = 1;
    }
     }
     return 0;
 } /* placev_ */

◆ pow_ii()

integer pow_ii	(	integer *	ap,
		integer *	bp
	)

Definition at line 30 of file f2clib.c.

References a, b, and r_sign().

Referenced by decode_(), and encode_().

 {
    integer pow, x, n;
    unsigned long u;
 
    x = *ap;
    n = *bp;
 
    if (n <= 0) {
       if (n == 0 || x == 1)
          return 1;
       if (x != -1)
          return x == 0 ? 0 : 1/x;
       n = -n;
       }
    u = n;
    for(pow = 1; ; )
       {
       if(u & 01)
          pow *= x;
       if(u >>= 1)
          x *= x;
       else
          break;
       }
    return(pow);
    }

◆ preemp_()

int preemp_	(	real *	inbuf,
		real *	pebuf,
		integer *	nsamp,
		real *	coef,
		real *	z__
	)

Definition at line 82 of file preemp.c.

References inbuf().

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
 
     /* Local variables */
     real temp;
     integer i__;
 
 /*       Arguments */
 /*       Local variables */
 
 /*       None of these need to have their values saved from one */
 /*       invocation to the next. */
 
 /*       Logically, this subroutine computes the output sequence */
 /*       pebuf(1:nsamp) defined by: */
 
 /*       pebuf(i) = inbuf(i) - coef * inbuf(i-1) */
 
 /*       where inbuf(0) is defined by the value of z given as input to */
 /*       this subroutine. */
 
 /*       What is this filter's frequency response and phase response? */
 
 /*       Why is this filter applied to the speech? */
 
 /*       Could it be more efficient to apply multiple filters */
 /*       simultaneously, by combining them into one equivalent filter? */
 
 /*       Are there ever cases when "factoring" one high-order filter into
 */
 /*       multiple smaller-order filter actually reduces the number of */
 /*       arithmetic operations needed to perform them? */
 /*       When I first read this subroutine, I didn't understand why the */
 /*       variable temp was used.  It seemed that the statements in the do
 */
 /*       loop could be replaced with the following: */
 
 /*           pebuf(i) = inbuf(i) - coef * z */
 /*           z = inbuf(i) */
 
 /*       The reason for temp is so that even if pebuf and inbuf are the */
 /*       same arrays in memory (i.e., they are aliased), then this */
 /*       subroutine will still work correctly.  I didn't realize this */
 /*       until seeing the comment after PEBUF above that says "(can be */
 /*       equal to INBUF)". */
     /* Parameter adjustments */
     --pebuf;
     --inbuf;
 
     /* Function Body */
     i__1 = *nsamp;
     for (i__ = 1; i__ <= i__1; ++i__) {
    temp = inbuf[i__] - *coef * *z__;
    *z__ = inbuf[i__];
    pebuf[i__] = temp;
 /* L10: */
     }
     return 0;
 } /* preemp_ */

◆ prepro_()

int prepro_	(	real *	speech,
		integer *	length,
		struct lpc10_encoder_state *	st
	)

Definition at line 101 of file prepro.c.

References c__1, and hp100_().

Referenced by lpc10_encode().

 {
     extern /* Subroutine */ int hp100_(real *, integer *, integer *, struct lpc10_encoder_state *);
 
 /*       Arguments */
 /*   High Pass Filter at 100 Hz */
     /* Parameter adjustments */
     if (speech) {
    --speech;
    }
 
     /* Function Body */
     hp100_(&speech[1], &c__1, length, st);
     return 0;
 } /* prepro_ */

◆ r_sign()

double r_sign	(	real *	a,
		real *	b
	)

Definition at line 64 of file f2clib.c.

References a, and i_nint().

Referenced by onset_(), pow_ii(), and vparms_().

 {
 double x;
 x = (*a >= 0 ? *a : - *a);
 return( *b >= 0 ? x : -x);
 }

◆ random_()

integer random_ ( struct lpc10_decoder_state * st )

Definition at line 93 of file random.c.

References lpc10_decoder_state::j, lpc10_decoder_state::k, and lpc10_decoder_state::y.

Referenced by bsynz_().

 {
     /* Initialized data */
 
     integer *j;
     integer *k;
     shortint *y;
 
     /* System generated locals */
     integer ret_val;
 
 /*    Parameters/constants */
 /*       Local state */
 /*   The following is a 16 bit 2's complement addition, */
 /*   with overflow checking disabled */
 
     j = &(st->j);
     k = &(st->k);
     y = &(st->y[0]);
 
     y[*k - 1] += y[*j - 1];
     ret_val = y[*k - 1];
     --(*k);
     if (*k <= 0) {
    *k = 5;
     }
     --(*j);
     if (*j <= 0) {
    *j = 5;
     }
     return ret_val;
 } /* random_ */

◆ rcchk_()

int rcchk_	(	integer *	order,
		real *	rc1f,
		real *	rc2f
	)

Definition at line 82 of file rcchk.c.

References abs, and order.

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1;
     real r__1;
 
     /* Local variables */
     integer i__;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
     /* Parameter adjustments */
     --rc2f;
     --rc1f;
 
     /* Function Body */
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    if ((r__1 = rc2f[i__], abs(r__1)) > .99f) {
        goto L10;
    }
     }
     return 0;
 /*       Note: In version embedded in other software, all calls to ERROR
 */
 /*       should probably be removed. */
 L10:
 
 /*       This call to ERROR is only needed for debugging purposes. */
 
 /*       CALL ERROR('RCCHK',2,I) */
     i__1 = *order;
     for (i__ = 1; i__ <= i__1; ++i__) {
    rc2f[i__] = rc1f[i__];
     }
     return 0;
 } /* rcchk_ */

◆ synths_()

int synths_	(	integer *	voice,
		integer *	pitch,
		real *	rms,
		real *	rc,
		real *	speech,
		integer *	k,
		struct lpc10_decoder_state *	st
	)

Definition at line 170 of file synths.c.

References bsynz_(), buf, lpc10_decoder_state::buf, lpc10_decoder_state::buflen, c_b2, contrl_1, deemp_(), irc2pc_(), max, min, and pitsyn_().

Referenced by lpc10_decode().

 {
     /* Initialized data */
 
     real *buf;
     integer *buflen;
 
     /* System generated locals */
     integer i__1;
     real r__1, r__2;
 
     /* Local variables */
     real rmsi[16];
     integer nout, ivuv[16], i__, j;
     extern /* Subroutine */ int deemp_(real *, integer *, struct lpc10_decoder_state *);
     real ratio;
     integer ipiti[16];
     real g2pass;
     real pc[10];
     extern /* Subroutine */ int pitsyn_(integer *, integer *, integer *, real
        *, real *, integer *, integer *, integer *, real *, real *,
        integer *, real *, struct lpc10_decoder_state *);
     real rci[160] /* was [10][16] */;
 
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/09/27 02:45:37  markster
  * Fix various compiler warnings (bug #322)
  *
  * Revision 1.2  2003/09/27 02:45:37  markster
  * Fix various compiler warnings (bug #322)
  *
  * 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:42:59  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:30:33  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 */
 /*       Arguments */
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/09/27 02:45:37  markster
  * Fix various compiler warnings (bug #322)
  *
  * Revision 1.2  2003/09/27 02:45:37  markster
  * Fix various compiler warnings (bug #322)
  *
  * 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:42:59  jaf
  * Removed all static local variables that were SAVE'd in the Fortran
  * code, and put them in struct lpc10_decoder_state that is passed as an
  * argument.
  *
  * Removed init function, since all initialization is now done in
  * init_lpc10_decoder_state().
  *
  * Revision 1.1  1996/08/19  22:30:33  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*       Parameters/constants */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       BUF is a buffer of speech samples that would have been returned
 */
 /*       by the older version of SYNTHS, but the newer version doesn't, */
 /*       so that the newer version can always return MAXFRM samples on */
 /*       every call.  This has the effect of delaying the return of */
 /*       samples for one additional frame time. */
 
 /*       Indices 1 through BUFLEN contain samples that are left over from
 */
 /*       the last call to SYNTHS.  Given the way that PITSYN works, */
 /*       BUFLEN should always be in the range MAXFRM-MAXPIT+1 through */
 /*       MAXFRM, inclusive, after a call to SYNTHS is complete. */
 
 /*       On the first call to SYNTHS (or the first call after */
 /*       reinitializing with the entry INITSYNTHS), BUFLEN is MAXFRM, and
 */
 /*       a frame of silence is always returned. */
     /* Parameter adjustments */
     if (voice) {
    --voice;
    }
     if (rc) {
    --rc;
    }
     if (speech) {
    --speech;
    }
 
     /* Function Body */
     buf = &(st->buf[0]);
     buflen = &(st->buflen);
 
 /* Computing MAX */
     i__1 = min(*pitch,156);
     *pitch = max(i__1,20);
     i__1 = contrl_1.order;
     for (i__ = 1; i__ <= i__1; ++i__) {
 /* Computing MAX */
 /* Computing MIN */
    r__2 = rc[i__];
    r__1 = min(r__2,.99f);
    rc[i__] = max(r__1,-.99f);
     }
     pitsyn_(&contrl_1.order, &voice[1], pitch, rms, &rc[1], &contrl_1.lframe,
        ivuv, ipiti, rmsi, rci, &nout, &ratio, st);
     if (nout > 0) {
    i__1 = nout;
    for (j = 1; j <= i__1; ++j) {
 
 /*             Add synthesized speech for pitch period J to the en
 d of */
 /*             BUF. */
 
        irc2pc_(&rci[j * 10 - 10], pc, &contrl_1.order, &c_b2, &g2pass);
        bsynz_(pc, &ipiti[j - 1], &ivuv[j - 1], &buf[*buflen], &rmsi[j - 1]
           , &ratio, &g2pass, st);
        deemp_(&buf[*buflen], &ipiti[j - 1], st);
        *buflen += ipiti[j - 1];
    }
 
 /*          Copy first MAXFRM samples from BUF to output array SPEECH
 */
 /*          (scaling them), and then remove them from the beginning of
  */
 /*          BUF. */
 
    for (i__ = 1; i__ <= 180; ++i__) {
        speech[i__] = buf[i__ - 1] / 4096.f;
    }
    *k = 180;
    *buflen += -180;
    i__1 = *buflen;
    for (i__ = 1; i__ <= i__1; ++i__) {
        buf[i__ - 1] = buf[i__ + 179];
    }
     }
     return 0;
 } /* synths_ */

◆ tbdm_()

int tbdm_	(	real *	speech,
		integer *	lpita,
		integer *	tau,
		integer *	ltau,
		real *	amdf,
		integer *	minptr,
		integer *	maxptr,
		integer *	mintau
	)

Definition at line 94 of file tbdm.c.

References difmag_(), max, and min.

Referenced by analys_().

 {
     /* System generated locals */
     integer i__1, i__2, i__3, i__4;
 
     /* Local variables */
     real amdf2[6];
     integer minp2, ltau2, maxp2, i__;
     extern /* Subroutine */ int difmag_(real *, integer *, integer *, integer
        *, integer *, real *, integer *, integer *);
     integer minamd, ptr, tau2[6];
 
 /*    Arguments */
 /*    REAL SPEECH(LPITA+TAU(LTAU)), AMDF(LTAU) */
 /*   Stupid TOAST doesn't understand expressions */
 /*       Local variables that need not be saved */
 /*       Local state */
 /*       None */
 /*   Compute full AMDF using log spaced lags, find coarse minimum */
     /* Parameter adjustments */
     --speech;
     --amdf;
     --tau;
 
     /* Function Body */
     difmag_(&speech[1], lpita, &tau[1], ltau, &tau[*ltau], &amdf[1], minptr,
        maxptr);
     *mintau = tau[*minptr];
     minamd = (integer)amdf[*minptr];
 /*   Build table containing all lags within +/- 3 of the AMDF minimum */
 /*    excluding all that have already been computed */
     ltau2 = 0;
     ptr = *minptr - 2;
 /* Computing MAX */
     i__1 = *mintau - 3;
 /* Computing MIN */
     i__3 = *mintau + 3, i__4 = tau[*ltau] - 1;
     i__2 = min(i__3,i__4);
     for (i__ = max(i__1,41); i__ <= i__2; ++i__) {
    while(tau[ptr] < i__) {
        ++ptr;
    }
    if (tau[ptr] != i__) {
        ++ltau2;
        tau2[ltau2 - 1] = i__;
    }
     }
 /*   Compute AMDF of the new lags, if there are any, and choose one */
 /*    if it is better than the coarse minimum */
     if (ltau2 > 0) {
    difmag_(&speech[1], lpita, tau2, &ltau2, &tau[*ltau], amdf2, &minp2, &
       maxp2);
    if (amdf2[minp2 - 1] < (real) minamd) {
        *mintau = tau2[minp2 - 1];
        minamd = (integer)amdf2[minp2 - 1];
    }
     }
 /*   Check one octave up, if there are any lags not yet computed */
     if (*mintau >= 80) {
    i__ = *mintau / 2;
    if ((i__ & 1) == 0) {
        ltau2 = 2;
        tau2[0] = i__ - 1;
        tau2[1] = i__ + 1;
    } else {
        ltau2 = 1;
        tau2[0] = i__;
    }
    difmag_(&speech[1], lpita, tau2, &ltau2, &tau[*ltau], amdf2, &minp2, &
       maxp2);
    if (amdf2[minp2 - 1] < (real) minamd) {
        *mintau = tau2[minp2 - 1];
        minamd = (integer)amdf2[minp2 - 1];
        *minptr += -20;
    }
     }
 /*   Force minimum of the AMDF array to the high resolution minimum */
     amdf[*minptr] = (real) minamd;
 /*   Find maximum of AMDF within 1/2 octave of minimum */
 /* Computing MAX */
     i__2 = *minptr - 5;
     *maxptr = max(i__2,1);
 /* Computing MIN */
     i__1 = *minptr + 5;
     i__2 = min(i__1,*ltau);
     for (i__ = *maxptr + 1; i__ <= i__2; ++i__) {
    if (amdf[i__] > amdf[*maxptr]) {
        *maxptr = i__;
    }
     }
     return 0;
 } /* tbdm_ */

◆ voicin_()

int voicin_	(	integer *	vwin,
		real *	inbuf,
		real *	lpbuf,
		integer *	buflim,
		integer *	half,
		real *	minamd,
		real *	maxamd,
		integer *	mintau,
		real *	ivrc,
		integer *	obound,
		integer *	voibuf,
		integer *	af,
		struct lpc10_encoder_state *	st
	)

Definition at line 258 of file voicin.c.

References lpc10_encoder_state::dither, lpc10_encoder_state::fbue, lpc10_encoder_state::fbve, i_nint(), L1, L2, lpc10_encoder_state::lbue, lpc10_encoder_state::lbve, max, lpc10_encoder_state::maxmin, min, lpc10_encoder_state::ofbue, lpc10_encoder_state::olbue, lpc10_encoder_state::sfbue, lpc10_encoder_state::slbue, lpc10_encoder_state::snr, value, lpc10_encoder_state::voice, and vparms_().

Referenced by analys_().

 {
     /* Initialized data */
 
     real *dither;
     static real vdc[100]   /* was [10][10] */ = { 0.f,1714.f,-110.f,
        334.f,-4096.f,-654.f,3752.f,3769.f,0.f,1181.f,0.f,874.f,-97.f,
        300.f,-4096.f,-1021.f,2451.f,2527.f,0.f,-500.f,0.f,510.f,-70.f,
        250.f,-4096.f,-1270.f,2194.f,2491.f,0.f,-1500.f,0.f,500.f,-10.f,
        200.f,-4096.f,-1300.f,2e3f,2e3f,0.f,-2e3f,0.f,500.f,0.f,0.f,
        -4096.f,-1300.f,2e3f,2e3f,0.f,-2500.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,
        0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,
        0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,
        0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f };
     static integer nvdcl = 5;
     static real vdcl[10] = { 600.f,450.f,300.f,200.f,0.f,0.f,0.f,0.f,0.f,0.f }
        ;
 
     /* System generated locals */
     integer inbuf_offset = 0, lpbuf_offset = 0, i__1, i__2;
     real r__1, r__2;
 
     /* Builtin functions */
     integer i_nint(real *);
     double sqrt(doublereal);
 
     /* Local variables */
     real ar_b__, ar_f__;
     integer *lbve, *lbue, *fbve, *fbue;
     integer snrl, i__;
     integer *ofbue, *sfbue;
     real *voice;
     integer *olbue, *slbue;
     real value[9];
     integer zc;
     logical ot;
     real qs;
     real *maxmin;
     integer vstate;
     real rc1;
     extern /* Subroutine */ int vparms_(integer *, real *, real *, integer *,
        integer *, real *, integer *, integer *, integer *, integer *,
        real *, real *, real *, real *);
     integer fbe, lbe;
     real *snr;
     real snr2;
 
 /*    Global Variables: */
 /*       Arguments */
 /* $Log$
  * Revision 1.16  2004/06/26 03:50:14  markster
  * Merge source cleanups (bug #1911)
  *
  * Revision 1.15  2003/11/23 22:14:32  markster
  * Various warning cleanups
  *
  * 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:40  markster
  * Some OSS fixes and a few lpc changes to make it actually work
  *
  * Revision 1.2  1996/08/20  20:45:00  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:30:14  jaf
  * Initial revision
  * */
 /* Revision 1.3  1996/03/29  22:05:55  jaf */
 /* Commented out the common block variables that are not needed by the */
 /* embedded version. */
 
 /* Revision 1.2  1996/03/26  19:34:50  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:44:09  jaf */
 /* Initial revision */
 
 /*   LPC Processing control variables: */
 
 /* *** Read-only: initialized in setup */
 
 /*  Files for Speech, Parameter, and Bitstream Input & Output, */
 /*    and message and debug outputs. */
 
 /* Here are the only files which use these variables: */
 
 /* lpcsim.f setup.f trans.f error.f vqsetup.f */
 
 /* Many files which use fdebug are not listed, since it is only used in */
 /* those other files conditionally, to print trace statements. */
 /*    integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*  LPC order, Frame size, Quantization rate, Bits per frame, */
 /*    Error correction */
 /* Subroutine SETUP is the only place where order is assigned a value, */
 /* and that value is 10.  It could increase efficiency 1% or so to */
 /* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
 */
 /* a variable in a COMMON block, since it is used in many places in the */
 /* core of the coding and decoding routines.  Actually, I take that back.
 */
 /* At least when compiling with f2c, the upper bound of DO loops is */
 /* stored in a local variable before the DO loop begins, and then that is
 */
 /* compared against on each iteration. */
 /* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
 /* Similarly for quant, which is given a value of 2400 in SETUP.  quant */
 /* is used in only a few places, and never in the core coding and */
 /* decoding routines, so it could be eliminated entirely. */
 /* nbits is similar to quant, and is given a value of 54 in SETUP. */
 /* corrp is given a value of .TRUE. in SETUP, and is only used in the */
 /* subroutines ENCODE and DECODE.  It doesn't affect the speed of the */
 /* coder significantly whether it is .TRUE. or .FALSE., or whether it is
 */
 /* a constant or a variable, since it is only examined once per frame. */
 /* Leaving it as a variable that is set to .TRUE.  seems like a good */
 /* idea, since it does enable some error-correction capability for */
 /* unvoiced frames, with no change in the coding rate, and no noticeable
 */
 /* quality difference in the decoded speech. */
 /*    integer quant, nbits */
 /* *** Read/write: variables for debugging, not needed for LPC algorithm
 */
 
 /*  Current frame, Unstable frames, Output clip count, Max onset buffer,
 */
 /*    Debug listing detail level, Line count on listing page */
 
 /* nframe is not needed for an embedded LPC10 at all. */
 /* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
 /* ERROR, which is only called from RCCHK.  When LPC10 is embedded into */
 /* an application, I would recommend removing the call to ERROR in RCCHK,
 */
 /* and remove ERROR and nunsfm completely. */
 /* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
 */
 /* sread.f.  When LPC10 is embedded into an application, one might want */
 /* to cause it to be incremented in a routine that takes the output of */
 /* SYNTHS and sends it to an audio device.  It could be optionally */
 /* displayed, for those that might want to know what it is. */
 /* maxosp is never initialized to 0 in SETUP, although it probably should
 */
 /* be, and it is updated in subroutine ANALYS.  I doubt that its value */
 /* would be of much interest to an application in which LPC10 is */
 /* embedded. */
 /* listl and lincnt are not needed for an embedded LPC10 at all. */
 /*    integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
 /*    common /contrl/ quant, nbits */
 /*    common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
 /*    Parameters/constants */
 /*       Voicing coefficient and Linear Discriminant Analysis variables:
 */
 /*       Max number of VDC's and VDC levels */
 /*       The following are not Fortran PARAMETER's, but they are */
 /*       initialized with DATA statements, and never modified. */
 /*       Actual number of VDC's and levels */
 /*       Local variables that need not be saved */
 /*       Note: */
 
 /*       VALUE(1) through VALUE(8) are assigned values, but VALUE(9) */
 /*       never is.  Yet VALUE(9) is read in the loop that begins "DO I =
 */
 /*       1, 9" below.  I believe that this doesn't cause any problems in
 */
 /*       this subroutine, because all VDC(9,*) array elements are 0, and
 */
 /*       this is what is multiplied by VALUE(9) in all cases.  Still, it
 */
 /*       would save a multiplication to change the loop to "DO I = 1, 8".
 */
 /*       Local state */
 /*       WARNING! */
 
 /*       VOICE, SFBUE, and SLBUE should be saved from one invocation to */
 /*       the next, but they are never given an initial value. */
 
 /*       Does Fortran 77 specify some default initial value, like 0, or */
 /*       is it undefined?  If it is undefined, then this code should be */
 /*       corrected to specify an initial value. */
 
 /*       For VOICE, note that it is "shifted" in the statement that */
 /*       begins "IF (HALF .EQ. 1) THEN" below.  Also, uninitialized */
 /*       values in the VOICE array can only affect entries in the VOIBUF
 */
 /*       array that are for the same frame, or for an older frame.  Thus
 */
 /*       the effects of uninitialized values in VOICE cannot linger on */
 /*       for more than 2 or 3 frame times. */
 
 /*       For SFBUE and SLBUE, the effects of uninitialized values can */
 /*       linger on for many frame times, because their previous values */
 /*       are exponentially decayed.  Thus it is more important to choose
 */
 /*       initial values for these variables.  I would guess that a */
 /*       reasonable initial value for SFBUE is REF/16, the same as used */
 /*       for FBUE and OFBUE.  Similarly, SLBUE can be initialized to */
 /*       REF/32, the same as for LBUE and OLBUE. */
 
 /*       These guessed initial values should be validated by re-running */
 /*       the modified program on some audio samples. */
 
 /*   Declare and initialize filters: */
 
     dither = (&st->dither);
     snr = (&st->snr);
     maxmin = (&st->maxmin);
     voice = (&st->voice[0]);
     lbve = (&st->lbve);
     lbue = (&st->lbue);
     fbve = (&st->fbve);
     fbue = (&st->fbue);
     ofbue = (&st->ofbue);
     olbue = (&st->olbue);
     sfbue = (&st->sfbue);
     slbue = (&st->slbue);
 
     /* Parameter adjustments */
     if (vwin) {
    --vwin;
    }
     if (buflim) {
    --buflim;
    }
     if (inbuf) {
    inbuf_offset = buflim[1];
    inbuf -= inbuf_offset;
    }
     if (lpbuf) {
    lpbuf_offset = buflim[3];
    lpbuf -= lpbuf_offset;
    }
     if (ivrc) {
    --ivrc;
    }
     if (obound) {
    --obound;
    }
     if (voibuf) {
    --voibuf;
    }
 
     /* Function Body */
 
 /*       The following variables are saved from one invocation to the */
 /*       next, but are not initialized with DATA statements.  This is */
 /*       acceptable, because FIRST is initialized ot .TRUE., and the */
 /*       first time that this subroutine is then called, they are all */
 /*       given initial values. */
 
 /*       SNR */
 /*       LBVE, LBUE, FBVE, FBUE, OFBUE, OLBUE */
 
 /*       MAXMIN is initialized on the first call, assuming that HALF */
 /*       .EQ. 1 on first call.  This is how ANALYS calls this subroutine.
 */
 
 /*   Voicing Decision Parameter vector (* denotes zero coefficient): */
 
 /*    * MAXMIN */
 /*      LBE/LBVE */
 /*      ZC */
 /*      RC1 */
 /*      QS */
 /*      IVRC2 */
 /*      aR_B */
 /*      aR_F */
 /*    * LOG(LBE/LBVE) */
 /*  Define 2-D voicing decision coefficient vector according to the voicin
 g*/
 /*  parameter order above.  Each row (VDC vector) is optimized for a speci
 fic*/
 /*   SNR.  The last element of the vector is the constant. */
 /*             E    ZC    RC1    Qs   IVRC2  aRb   aRf        c */
 
 /*  The VOICE array contains the result of the linear discriminant functio
 n*/
 /*   (analog values).  The VOIBUF array contains the hard-limited binary
 */
 /*   voicing decisions.  The VOICE and VOIBUF arrays, according to FORTRAN
  */
 /*   memory allocation, are addressed as: */
 
 /*       (half-frame number, future-frame number) */
 
 /*       |   Past    |  Present  |  Future1  |  Future2  | */
 /*       | 1,0 | 2,0 | 1,1 | 2,1 | 1,2 | 2,2 | 1,3 | 2,3 |  --->  time */
 
 /*   Update linear discriminant function history each frame: */
     if (*half == 1) {
    voice[0] = voice[2];
    voice[1] = voice[3];
    voice[2] = voice[4];
    voice[3] = voice[5];
    *maxmin = *maxamd / max(*minamd,1.f);
     }
 /*   Calculate voicing parameters twice per frame: */
     vparms_(&vwin[1], &inbuf[inbuf_offset], &lpbuf[lpbuf_offset], &buflim[1],
        half, dither, mintau, &zc, &lbe, &fbe, &qs, &rc1, &ar_b__, &
        ar_f__);
 /*   Estimate signal-to-noise ratio to select the appropriate VDC vector.
 */
 /*   The SNR is estimated as the running average of the ratio of the */
 /*   running average full-band voiced energy to the running average */
 /*   full-band unvoiced energy. SNR filter has gain of 63. */
     r__1 = (*snr + *fbve / (real) max(*fbue,1)) * 63 / 64.f;
     *snr = (real) i_nint(&r__1);
     snr2 = *snr * *fbue / max(*lbue,1);
 /*   Quantize SNR to SNRL according to VDCL thresholds. */
     snrl = 1;
     i__1 = nvdcl - 1;
     for (snrl = 1; snrl <= i__1; ++snrl) {
    if (snr2 > vdcl[snrl - 1]) {
        goto L69;
    }
     }
 /*    (Note:  SNRL = NVDCL here) */
 L69:
 /*   Linear discriminant voicing parameters: */
     value[0] = *maxmin;
     value[1] = (real) lbe / max(*lbve,1);
     value[2] = (real) zc;
     value[3] = rc1;
     value[4] = qs;
     value[5] = ivrc[2];
     value[6] = ar_b__;
     value[7] = ar_f__;
 /*   Evaluation of linear discriminant function: */
     voice[*half + 3] = vdc[snrl * 10 - 1];
     for (i__ = 1; i__ <= 8; ++i__) {
    voice[*half + 3] += vdc[i__ + snrl * 10 - 11] * value[i__ - 1];
     }
 /*   Classify as voiced if discriminant > 0, otherwise unvoiced */
 /*   Voicing decision for current half-frame:  1 = Voiced; 0 = Unvoiced */
     if (voice[*half + 3] > 0.f) {
    voibuf[*half + 6] = 1;
     } else {
    voibuf[*half + 6] = 0;
     }
 /*   Skip voicing decision smoothing in first half-frame: */
 /*     Give a value to VSTATE, so that trace statements below will print
 */
 /*     a consistent value from one call to the next when HALF .EQ. 1. */
 /*     The value of VSTATE is not used for any other purpose when this is
 */
 /*     true. */
     vstate = -1;
     if (*half == 1) {
    goto L99;
     }
 /*   Voicing decision smoothing rules (override of linear combination): */
 
 /*    Unvoiced half-frames:  At least two in a row. */
 /*    -------------------- */
 
 /*    Voiced half-frames:    At least two in a row in one frame. */
 /*    -------------------    Otherwise at least three in a row. */
 /*                 (Due to the way transition frames are encoded) */
 
 /*    In many cases, the discriminant function determines how to smooth. */
 /* In the following chart, the decisions marked with a * may be overridden
 .*/
 
 /*   Voicing override of transitions at onsets: */
 /*    If a V/UV or UV/V voicing decision transition occurs within one-half
 */
 /*    frame of an onset bounding a voicing window, then the transition is */
 /*    moved to occur at the onset. */
 
 /*    P  1F */
 /*    ----- ----- */
 /*    0   0   0   0 */
 /*    0   0   0*  1  (If there is an onset there) */
 /*    0   0   1*  0* (Based on 2F and discriminant distance) */
 /*    0   0   1   1 */
 /*    0   1*  0   0  (Always) */
 /*    0   1*  0*  1  (Based on discriminant distance) */
 /*    0*  1   1   0* (Based on past, 2F, and discriminant distance) */
 /*    0   1*  1   1  (If there is an onset there) */
 /*    1   0*  0   0  (If there is an onset there) */
 /*    1   0   0   1 */
 /*    1   0*  1*  0  (Based on discriminant distance) */
 /*    1   0*  1   1  (Always) */
 /*    1   1   0   0 */
 /*    1   1   0*  1* (Based on 2F and discriminant distance) */
 /*    1   1   1*  0  (If there is an onset there) */
 /*    1   1   1   1 */
 
 /*   Determine if there is an onset transition between P and 1F. */
 /*   OT (Onset Transition) is true if there is an onset between */
 /*   P and 1F but not after 1F. */
     ot = ((obound[1] & 2) != 0 || obound[2] == 1) && (obound[3] & 1) == 0;
 /*   Multi-way dispatch on voicing decision history: */
     vstate = (voibuf[3] << 3) + (voibuf[4] << 2) + (voibuf[5] << 1) + voibuf[
        6];
     switch (vstate + 1) {
    case 1:  goto L99;
    case 2:  goto L1;
    case 3:  goto L2;
    case 4:  goto L99;
    case 5:  goto L4;
    case 6:  goto L5;
    case 7:  goto L6;
    case 8:  goto L7;
    case 9:  goto L8;
    case 10:  goto L99;
    case 11:  goto L10;
    case 12:  goto L11;
    case 13:  goto L99;
    case 14:  goto L13;
    case 15:  goto L14;
    case 16:  goto L99;
     }
 L1:
     if (ot && voibuf[7] == 1) {
    voibuf[5] = 1;
     }
     goto L99;
 L2:
     if (voibuf[7] == 0 || voice[2] < -voice[3]) {
    voibuf[5] = 0;
     } else {
    voibuf[6] = 1;
     }
     goto L99;
 L4:
     voibuf[4] = 0;
     goto L99;
 L5:
     if (voice[1] < -voice[2]) {
    voibuf[4] = 0;
     } else {
    voibuf[5] = 1;
     }
     goto L99;
 /*   VOIBUF(2,0) must be 0 */
 L6:
     if (voibuf[1] == 1 || voibuf[7] == 1 || voice[3] > voice[0]) {
    voibuf[6] = 1;
     } else {
    voibuf[3] = 1;
     }
     goto L99;
 L7:
     if (ot) {
    voibuf[4] = 0;
     }
     goto L99;
 L8:
     if (ot) {
    voibuf[4] = 1;
     }
     goto L99;
 L10:
     if (voice[2] < -voice[1]) {
    voibuf[5] = 0;
     } else {
    voibuf[4] = 1;
     }
     goto L99;
 L11:
     voibuf[4] = 1;
     goto L99;
 L13:
     if (voibuf[7] == 0 && voice[3] < -voice[2]) {
    voibuf[6] = 0;
     } else {
    voibuf[5] = 1;
     }
     goto L99;
 L14:
     if (ot && voibuf[7] == 0) {
    voibuf[5] = 0;
     }
 /*    GOTO 99 */
 L99:
 /*   Now update parameters: */
 /*   ---------------------- */
 
 /*  During unvoiced half-frames, update the low band and full band unvoice
 d*/
 /*   energy estimates (LBUE and FBUE) and also the zero crossing */
 /*   threshold (DITHER).  (The input to the unvoiced energy filters is */
 /*   restricted to be less than 10dB above the previous inputs of the */
 /*   filters.) */
 /*   During voiced half-frames, update the low-pass (LBVE) and all-pass */
 /*   (FBVE) voiced energy estimates. */
     if (voibuf[*half + 6] == 0) {
 /* Computing MIN */
    i__1 = fbe, i__2 = *ofbue * 3;
    r__1 = (*sfbue * 63 + (min(i__1,i__2) << 3)) / 64.f;
    *sfbue = i_nint(&r__1);
    *fbue = *sfbue / 8;
    *ofbue = fbe;
 /* Computing MIN */
    i__1 = lbe, i__2 = *olbue * 3;
    r__1 = (*slbue * 63 + (min(i__1,i__2) << 3)) / 64.f;
    *slbue = i_nint(&r__1);
    *lbue = *slbue / 8;
    *olbue = lbe;
     } else {
    r__1 = (*lbve * 63 + lbe) / 64.f;
    *lbve = i_nint(&r__1);
    r__1 = (*fbve * 63 + fbe) / 64.f;
    *fbve = i_nint(&r__1);
     }
 /*   Set dither threshold to yield proper zero crossing rates in the */
 /*   presence of low frequency noise and low level signal input. */
 /*   NOTE: The divisor is a function of REF, the expected energies. */
 /* Computing MIN */
 /* Computing MAX */
     r__2 = (real)(sqrt((real) (*lbue * *lbve)) * 64 / 3000);
     r__1 = max(r__2,1.f);
     *dither = min(r__1,20.f);
 /*   Voicing decisions are returned in VOIBUF. */
     return 0;
 } /* voicin_ */

◆ vparms_()

int vparms_	(	integer *	vwin,
		real *	inbuf,
		real *	lpbuf,
		integer *	buflim,
		integer *	half,
		real *	dither,
		integer *	mintau,
		integer *	zc,
		integer *	lbe,
		integer *	fbe,
		real *	qs,
		real *	rc1,
		real *	ar_b__,
		real *	ar_f__
	)

Definition at line 134 of file vparms.c.

References abs, c_b2, i_nint(), max, min, r_sign(), and stop.

Referenced by voicin_().

 {
     /* System generated locals */
     integer inbuf_offset, lpbuf_offset, i__1;
     real r__1, r__2;
 
     /* Builtin functions */
     double r_sign(real *, real *);
     integer i_nint(real *);
 
     /* Local variables */
     integer vlen, stop, i__;
     real e_pre__;
     integer start;
     real ap_rms__, e_0__, oldsgn, lp_rms__, e_b__, e_f__, r_b__, r_f__, e0ap;
 
 /*       Arguments */
 /*       Local variables that need not be saved */
 /*   Calculate zero crossings (ZC) and several energy and correlation */
 /*   measures on low band and full band speech.  Each measure is taken */
 /*   over either the first or the second half of the voicing window, */
 /*   depending on the variable HALF. */
     /* Parameter adjustments */
     --vwin;
     --buflim;
     lpbuf_offset = buflim[3];
     lpbuf -= lpbuf_offset;
     inbuf_offset = buflim[1];
     inbuf -= inbuf_offset;
 
     /* Function Body */
     lp_rms__ = 0.f;
     ap_rms__ = 0.f;
     e_pre__ = 0.f;
     e0ap = 0.f;
     *rc1 = 0.f;
     e_0__ = 0.f;
     e_b__ = 0.f;
     e_f__ = 0.f;
     r_f__ = 0.f;
     r_b__ = 0.f;
     *zc = 0;
     vlen = vwin[2] - vwin[1] + 1;
     start = vwin[1] + (*half - 1) * vlen / 2 + 1;
     stop = start + vlen / 2 - 1;
 
 /* I'll use the symbol HVL in the table below to represent the value */
 /* VLEN/2.  Note that if VLEN is odd, then HVL should be rounded down, */
 /* i.e., HVL = (VLEN-1)/2. */
 
 /* HALF  START          STOP */
 
 /* 1     VWIN(1)+1      VWIN(1)+HVL */
 /* 2     VWIN(1)+HVL+1  VWIN(1)+2*HVL */
 
 /* Note that if VLEN is even and HALF is 2, then STOP will be */
 /* VWIN(1)+VLEN = VWIN(2)+1.  That could be bad, if that index of INBUF */
 /* is undefined. */
 
     r__1 = inbuf[start - 1] - *dither;
     oldsgn = (real)r_sign(&c_b2, &r__1);
     i__1 = stop;
     for (i__ = start; i__ <= i__1; ++i__) {
    lp_rms__ += (r__1 = lpbuf[i__], abs(r__1));
    ap_rms__ += (r__1 = inbuf[i__], abs(r__1));
    e_pre__ += (r__1 = inbuf[i__] - inbuf[i__ - 1], abs(r__1));
 /* Computing 2nd power */
    r__1 = inbuf[i__];
    e0ap += r__1 * r__1;
    *rc1 += inbuf[i__] * inbuf[i__ - 1];
 /* Computing 2nd power */
    r__1 = lpbuf[i__];
    e_0__ += r__1 * r__1;
 /* Computing 2nd power */
    r__1 = lpbuf[i__ - *mintau];
    e_b__ += r__1 * r__1;
 /* Computing 2nd power */
    r__1 = lpbuf[i__ + *mintau];
    e_f__ += r__1 * r__1;
    r_f__ += lpbuf[i__] * lpbuf[i__ + *mintau];
    r_b__ += lpbuf[i__] * lpbuf[i__ - *mintau];
    r__1 = inbuf[i__] + *dither;
    if (r_sign(&c_b2, &r__1) != oldsgn) {
        ++(*zc);
        oldsgn = -oldsgn;
    }
    *dither = -(*dither);
     }
 /*   Normalized short-term autocovariance coefficient at unit sample delay
  */
     *rc1 /= max(e0ap,1.f);
 /*  Ratio of the energy of the first difference signal (6 dB/oct preemphas
 is)*/
 /*   to the energy of the full band signal */
 /* Computing MAX */
     r__1 = ap_rms__ * 2.f;
     *qs = e_pre__ / max(r__1,1.f);
 /*   aR_b is the product of the forward and reverse prediction gains, */
 /*   looking backward in time (the causal case). */
     *ar_b__ = r_b__ / max(e_b__,1.f) * (r_b__ / max(e_0__,1.f));
 /*  aR_f is the same as aR_b, but looking forward in time (non causal case
 ).*/
     *ar_f__ = r_f__ / max(e_f__,1.f) * (r_f__ / max(e_0__,1.f));
 /*   Normalize ZC, LBE, and FBE to old fixed window length of 180. */
 /*   (The fraction 90/VLEN has a range of .58 to 1) */
     r__2 = (real) (*zc << 1);
     r__1 = r__2 * (90.f / vlen);
     *zc = i_nint(&r__1);
 /* Computing MIN */
     r__1 = lp_rms__ / 4 * (90.f / vlen);
     i__1 = i_nint(&r__1);
     *lbe = min(i__1,32767);
 /* Computing MIN */
     r__1 = ap_rms__ / 4 * (90.f / vlen);
     i__1 = i_nint(&r__1);
     *fbe = min(i__1,32767);
     return 0;
 } /* vparms_ */

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ abs

◆ dabs

◆ dmax

◆ dmin

◆ Extern

◆ F2C_proc_par_types

◆ FALSE_

◆ max

◆ min

◆ TRUE_

◆ VOID

Typedef Documentation

◆ address

◆ C_f

◆ C_fp

◆ D_fp

◆ doublereal

◆ E_f

◆ E_fp

◆ flag

◆ ftnint

◆ ftnlen

◆ H_f

◆ H_fp

◆ I_fp

◆ integer1

◆ J_fp

◆ K_fp

◆ L_fp

◆ logical1

◆ Multitype

◆ Namelist

◆ R_fp

◆ S_fp

◆ shortlogical

◆ U_fp

◆ Vardesc

◆ Z_f

◆ Z_fp

Function Documentation

◆ bsynz_()

◆ chanrd_()

◆ chanwr_()

◆ chanwr_0_()

◆ dcbias_()

◆ decode_()

◆ deemp_()

◆ difmag_()

◆ dyptrk_()

◆ encode_()

◆ energy_()

◆ ham84_()

◆ hp100_()

◆ i_nint()

◆ inithp100_()

◆ initlpcdec_()

◆ initlpcenc_()

◆ invert_()

◆ irc2pc_()

◆ ivfilt_()

◆ lpcdec_()

◆ lpcenc_()

◆ lpfilt_()

◆ median_()

◆ mload_()

◆ onset_()

◆ pitsyn_()

◆ placea_()

◆ placev_()

◆ pow_ii()

◆ preemp_()

◆ prepro_()

◆ r_sign()

◆ random_()

◆ rcchk_()