f2c.h File Reference

#include "lpc10.h"

Include dependency graph for f2c.h:

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

Go to the source code of 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))

Definition at line 195 of file f2c.h.

Referenced by __ast_dsp_silence_noise(), addr_range_hash_cb(), amdf_pitch(), ast_dsp_busydetect(), ast_frame_adjust_volume(), audiohook_read_frame_both(), calc_energy(), calc_timestamp(), decode_(), difmag_(), do_alignment_detection(), goertzel_sample(), hash_ao2_destroy(), hash_ao2_find_first(), hash_ao2_new_node(), invert_(), jitterbuffer_frame_get_ntp_timestamp(), manager_add_queue_member(), manager_pause_queue_member(), measurenoise(), onset_(), parse_config(), quantize(), rcchk_(), rtp_raw_write(), sms_process(), update(), and vparms_().

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))

Definition at line 198 of file f2c.h.

Referenced by __get_page(), __put_page(), acf_rand_exec(), action_waitevent(), ast_base64encode_full(), ast_base64url_encode_full(), ast_dsp_prog_reset(), ast_el_read_char(), ast_waitfor_nandfds(), au_seek(), background_detect_exec(), drc_sample(), dundi_lookup_thread(), encode_(), g719seek(), g726_seek(), g729_seek(), gsm_seek(), handle_clear_profile(), handle_getdata(), handle_show_profile(), hash_test_lookup(), history_get(), ilbc_seek(), invert_(), max_heapify(), misdn_lib_maxports_get(), misdn_write(), mp3_seek(), osp_report_qos(), pcm_seek(), placev_(), precache_trans(), process_opcode(), siren14seek(), siren7seek(), slinear_seek(), synths_(), tbdm_(), voicin_(), vox_seek(), vparms_(), wait_result(), and wav_seek().

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