#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
◆ dabs
| #define dabs | ( | x | ) | (doublereal)abs(x) |
◆ dmax
◆ dmin
◆ Extern
◆ F2C_proc_par_types
◆ FALSE_
◆ max
◆ min
◆ TRUE_
◆ VOID
Typedef Documentation
◆ address
◆ C_f
◆ C_fp
◆ D_fp
| typedef doublereal(* D_fp) (VOID) |
◆ doublereal
| typedef double doublereal |
◆ E_f
| typedef doublereal E_f |
◆ E_fp
| typedef doublereal(*)(* E_fp) (VOID) |
◆ flag
◆ ftnint
◆ ftnlen
◆ H_f
◆ H_fp
◆ I_fp
◆ integer1
◆ J_fp
◆ K_fp
| typedef shortlogical(* K_fp) (VOID) |
◆ L_fp
◆ logical1
◆ Multitype
◆ Namelist
◆ R_fp
◆ S_fp
◆ shortlogical
| typedef short int shortlogical |
◆ U_fp
◆ Vardesc
◆ Z_f
◆ Z_fp
Function Documentation
◆ bsynz_()
|
extern |
Definition at line 122 of file bsynz.c.
125{
126 /* Initialized data */
127
128 integer *ipo;
129 real *rmso;
131 672,-610,-672,184,728,718,502,294,162,86,48,26,16,8 };
132 real *exc;
133 real *exc2;
134 real *lpi1;
135 real *lpi2;
136 real *lpi3;
137 real *hpi1;
138 real *hpi2;
139 real *hpi3;
140
141 /* System generated locals */
142 integer i__1, i__2;
143 real r__1, r__2;
144
145 /* Builtin functions */
147
148 /* Local variables */
149 real gain, xssq;
150 integer i__, j, k;
151 real noise[166], pulse;
152 integer px;
153 real sscale;
155 real xy, sum, ssq;
156 real lpi0, hpi0;
157
158/* $Log$
159 * Revision 1.15 2004/06/26 03:50:14 markster
160 * Merge source cleanups (bug #1911)
161 *
162 * Revision 1.14 2003/02/12 13:59:14 matteo
163 * mer feb 12 14:56:57 CET 2003
164 *
165 * Revision 1.1.1.1 2003/02/12 13:59:14 matteo
166 * mer feb 12 14:56:57 CET 2003
167 *
168 * Revision 1.2 2000/01/05 08:20:39 markster
169 * Some OSS fixes and a few lpc changes to make it actually work
170 *
171 * Revision 1.2 1996/08/20 20:18:55 jaf
172 * Removed all static local variables that were SAVE'd in the Fortran
173 * code, and put them in struct lpc10_decoder_state that is passed as an
174 * argument.
175 *
176 * Removed init function, since all initialization is now done in
177 * init_lpc10_decoder_state().
178 *
179 * Revision 1.1 1996/08/19 22:32:58 jaf
180 * Initial revision
181 * */
182/* Revision 1.3 1996/03/29 22:03:47 jaf */
183/* Removed definitions for any constants that were no longer used. */
184
185/* Revision 1.2 1996/03/26 19:34:33 jaf */
186/* Added comments indicating which constants are not needed in an */
187/* application that uses the LPC-10 coder. */
188
189/* Revision 1.1 1996/02/07 14:43:51 jaf */
190/* Initial revision */
191
192/* LPC Configuration parameters: */
193/* Frame size, Prediction order, Pitch period */
194/* Arguments */
195/* $Log$
196 * Revision 1.15 2004/06/26 03:50:14 markster
197 * Merge source cleanups (bug #1911)
198 *
199 * Revision 1.14 2003/02/12 13:59:14 matteo
200 * mer feb 12 14:56:57 CET 2003
201 *
202 * Revision 1.1.1.1 2003/02/12 13:59:14 matteo
203 * mer feb 12 14:56:57 CET 2003
204 *
205 * Revision 1.2 2000/01/05 08:20:39 markster
206 * Some OSS fixes and a few lpc changes to make it actually work
207 *
208 * Revision 1.2 1996/08/20 20:18:55 jaf
209 * Removed all static local variables that were SAVE'd in the Fortran
210 * code, and put them in struct lpc10_decoder_state that is passed as an
211 * argument.
212 *
213 * Removed init function, since all initialization is now done in
214 * init_lpc10_decoder_state().
215 *
216 * Revision 1.1 1996/08/19 22:32:58 jaf
217 * Initial revision
218 * */
219/* Revision 1.3 1996/03/29 22:05:55 jaf */
220/* Commented out the common block variables that are not needed by the */
221/* embedded version. */
222
223/* Revision 1.2 1996/03/26 19:34:50 jaf */
224/* Added comments indicating which constants are not needed in an */
225/* application that uses the LPC-10 coder. */
226
227/* Revision 1.1 1996/02/07 14:44:09 jaf */
228/* Initial revision */
229
230/* LPC Processing control variables: */
231
232/* *** Read-only: initialized in setup */
233
234/* Files for Speech, Parameter, and Bitstream Input & Output, */
235/* and message and debug outputs. */
236
237/* Here are the only files which use these variables: */
238
239/* lpcsim.f setup.f trans.f error.f vqsetup.f */
240
241/* Many files which use fdebug are not listed, since it is only used in */
242/* those other files conditionally, to print trace statements. */
243/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
244/* LPC order, Frame size, Quantization rate, Bits per frame, */
245/* Error correction */
246/* Subroutine SETUP is the only place where order is assigned a value, */
247/* and that value is 10. It could increase efficiency 1% or so to */
248/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
249*/
250/* a variable in a COMMON block, since it is used in many places in the */
251/* core of the coding and decoding routines. Actually, I take that back.
252*/
253/* At least when compiling with f2c, the upper bound of DO loops is */
254/* stored in a local variable before the DO loop begins, and then that is
255*/
256/* compared against on each iteration. */
257/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
258/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
259/* is used in only a few places, and never in the core coding and */
260/* decoding routines, so it could be eliminated entirely. */
261/* nbits is similar to quant, and is given a value of 54 in SETUP. */
262/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
263/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
264/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
265*/
266/* a constant or a variable, since it is only examined once per frame. */
267/* Leaving it as a variable that is set to .TRUE. seems like a good */
268/* idea, since it does enable some error-correction capability for */
269/* unvoiced frames, with no change in the coding rate, and no noticeable
270*/
271/* quality difference in the decoded speech. */
272/* integer quant, nbits */
273/* *** Read/write: variables for debugging, not needed for LPC algorithm
274*/
275
276/* Current frame, Unstable frames, Output clip count, Max onset buffer,
277*/
278/* Debug listing detail level, Line count on listing page */
279
280/* nframe is not needed for an embedded LPC10 at all. */
281/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
282/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
283/* an application, I would recommend removing the call to ERROR in RCCHK,
284*/
285/* and remove ERROR and nunsfm completely. */
286/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
287*/
288/* sread.f. When LPC10 is embedded into an application, one might want */
289/* to cause it to be incremented in a routine that takes the output of */
290/* SYNTHS and sends it to an audio device. It could be optionally */
291/* displayed, for those that might want to know what it is. */
292/* maxosp is never initialized to 0 in SETUP, although it probably should
293*/
294/* be, and it is updated in subroutine ANALYS. I doubt that its value */
295/* would be of much interest to an application in which LPC10 is */
296/* embedded. */
297/* listl and lincnt are not needed for an embedded LPC10 at all. */
298/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
299/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
300/* common /contrl/ quant, nbits */
301/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
302/* Function return value definitions */
303/* Parameters/constants */
304/* KEXC is not a Fortran PARAMETER, but it is an array initialized
305*/
306/* with a DATA statement that is never modified. */
307/* Local variables that need not be saved */
308/* NOISE is declared with range (1:MAXPIT+MAXORD), but only indices
309*/
310/* ORDER+1 through ORDER+IP are ever used, and I think that IP */
311/* .LE. MAXPIT. Why not declare it to be in the range (1:MAXPIT) */
312/* and use that range? */
313/* Local state */
314/* I believe that only indices 1 through ORDER of EXC need to be */
315/* saved from one invocation to the next, but we may as well save */
316/* the whole array. */
317/* None of these local variables were given initial values in the */
318/* original code. I'm guessing that 0 is a reasonable initial */
319/* value for all of them. */
320 /* Parameter adjustments */
321 if (coef) {
322 --coef;
323 }
324 if (sout) {
325 --sout;
326 }
327
328 /* Function Body */
329 ipo = &(st->ipo);
330 exc = &(st->exc[0]);
331 exc2 = &(st->exc2[0]);
332 lpi1 = &(st->lpi1);
333 lpi2 = &(st->lpi2);
334 lpi3 = &(st->lpi3);
335 hpi1 = &(st->hpi1);
336 hpi2 = &(st->hpi2);
337 hpi3 = &(st->hpi3);
338 rmso = &(st->rmso_bsynz);
339
340/* MAXPIT+MAXORD=166 */
341/* Calculate history scale factor XY and scale filter state */
342/* Computing MIN */
343 r__1 = *rmso / (*rms + 1e-6f);
344 xy = min(r__1,8.f);
345 *rmso = *rms;
346 i__1 = contrl_1.order;
347 for (i__ = 1; i__ <= i__1; ++i__) {
348 exc2[i__ - 1] = exc2[*ipo + i__ - 1] * xy;
349 }
350 *ipo = *ip;
351 if (*iv == 0) {
352/* Generate white noise for unvoiced */
353 i__1 = *ip;
354 for (i__ = 1; i__ <= i__1; ++i__) {
356 }
357/* Impulse doublet excitation for plosives */
358/* (RANDOM()+32768) is in the range 0 to 2**16-1. Therefore the
359 */
360/* following expression should be evaluated using integers with
361at */
362/* least 32 bits (16 isn't enough), and PX should be in the rang
363e */
364/* ORDER+1+0 through ORDER+1+(IP-2) .EQ. ORDER+IP-1. */
366 r__1 = *ratio / 4 * 1.f;
367 pulse = r__1 * 342;
368 if (pulse > 2e3f) {
369 pulse = 2e3f;
370 }
371 exc[px - 1] += pulse;
372 exc[px] -= pulse;
373/* Load voiced excitation */
374 } else {
376 i__1 = *ip;
377 for (i__ = 1; i__ <= i__1; ++i__) {
378 exc[contrl_1.order + i__ - 1] = 0.f;
379 if (i__ <= 25) {
380 exc[contrl_1.order + i__ - 1] = sscale * kexc[i__ - 1];
381 }
382 lpi0 = exc[contrl_1.order + i__ - 1];
383 r__2 = exc[contrl_1.order + i__ - 1] * .125f + *lpi1 * .75f;
384 r__1 = r__2 + *lpi2 * .125f;
385 exc[contrl_1.order + i__ - 1] = r__1 + *lpi3 * 0.f;
386 *lpi3 = *lpi2;
387 *lpi2 = *lpi1;
388 *lpi1 = lpi0;
389 }
390 i__1 = *ip;
391 for (i__ = 1; i__ <= i__1; ++i__) {
393 hpi0 = noise[contrl_1.order + i__ - 1];
394 r__2 = noise[contrl_1.order + i__ - 1] * -.125f + *hpi1 * .25f;
395 r__1 = r__2 + *hpi2 * -.125f;
396 noise[contrl_1.order + i__ - 1] = r__1 + *hpi3 * 0.f;
397 *hpi3 = *hpi2;
398 *hpi2 = *hpi1;
399 *hpi1 = hpi0;
400 }
401 i__1 = *ip;
402 for (i__ = 1; i__ <= i__1; ++i__) {
404 }
405 }
406/* Synthesis filters: */
407/* Modify the excitation with all-zero filter 1 + G*SUM */
408 xssq = 0.f;
409 i__1 = *ip;
410 for (i__ = 1; i__ <= i__1; ++i__) {
411 k = contrl_1.order + i__;
412 sum = 0.f;
413 i__2 = contrl_1.order;
414 for (j = 1; j <= i__2; ++j) {
415 sum += coef[j] * exc[k - j - 1];
416 }
417 sum *= *g2pass;
418 exc2[k - 1] = sum + exc[k - 1];
419 }
420/* Synthesize using the all pole filter 1 / (1 - SUM) */
421 i__1 = *ip;
422 for (i__ = 1; i__ <= i__1; ++i__) {
423 k = contrl_1.order + i__;
424 sum = 0.f;
425 i__2 = contrl_1.order;
426 for (j = 1; j <= i__2; ++j) {
427 sum += coef[j] * exc2[k - j - 1];
428 }
429 exc2[k - 1] = sum + exc2[k - 1];
430 xssq += exc2[k - 1] * exc2[k - 1];
431 }
432/* Save filter history for next epoch */
433 i__1 = contrl_1.order;
434 for (i__ = 1; i__ <= i__1; ++i__) {
435 exc[i__ - 1] = exc[*ip + i__ - 1];
436 exc2[i__ - 1] = exc2[*ip + i__ - 1];
437 }
438/* Apply gain to match RMS */
439 r__1 = *rms * *rms;
440 ssq = r__1 * *ip;
441 gain = (real)sqrt(ssq / xssq);
442 i__1 = *ip;
443 for (i__ = 1; i__ <= i__1; ++i__) {
444 sout[i__] = gain * exc2[contrl_1.order + i__ - 1];
445 }
446 return 0;
447} /* bsynz_ */
Definition lpc10.h:149
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_().
◆ chanrd_()
|
extern |
Definition at line 229 of file chanwr.c.
231{
233 }
int chanwr_0_(int n__, integer *order, integer *ipitv, integer *irms, integer *irc, integer *ibits, struct lpc10_encoder_state *st)
Definition chanwr.c:132
References chanwr_0_(), NULL, and order.
Referenced by lpc10_decode().
◆ chanwr_()
|
extern |
Definition at line 223 of file chanwr.c.
References chanwr_0_(), and order.
Referenced by lpc10_encode().
◆ chanwr_0_()
|
extern |
Definition at line 132 of file chanwr.c.
135{
136 /* Initialized data */
137
138 integer *isync;
141 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,
142 4,6,1,5,9,8,7,5,6 };
143
144 /* System generated locals */
145 integer i__1;
146
147 /* Local variables */
148 integer itab[13], i__;
149
150/* Arguments */
151/* Parameters/constants */
152/* These arrays are not Fortran PARAMETER's, but they are defined */
153/* by DATA statements below, and their contents are never altered.
154*/
155/* Local variables that need not be saved */
156/* Local state */
157/* ISYNC is only used by CHANWR, not by ENTRY CHANRD. */
158
159 /* Parameter adjustments */
160 --irc;
161 --ibits;
162
163 /* Function Body */
164 switch(n__) {
165 case 1: goto L_chanrd;
166 }
167
168 isync = &(st->isync);
169
170/* ***********************************************************************
171 */
172/* Place quantized parameters into bitstream */
173/* ***********************************************************************
174 */
175/* Place parameters into ITAB */
176 itab[0] = *ipitv;
177 itab[1] = *irms;
178 itab[2] = 0;
179 i__1 = *order;
180 for (i__ = 1; i__ <= i__1; ++i__) {
181 itab[i__ + 2] = irc[*order + 1 - i__] & 32767;
182 }
183/* Put 54 bits into IBITS array */
184 for (i__ = 1; i__ <= 53; ++i__) {
185 ibits[i__] = itab[iblist[i__ - 1] - 1] & 1;
186 itab[iblist[i__ - 1] - 1] /= 2;
187 }
188 ibits[54] = *isync & 1;
189 *isync = 1 - *isync;
190 return 0;
191/* ***********************************************************************
192 */
193/* Reconstruct parameters from bitstream */
194/* ***********************************************************************
195 */
196
197L_chanrd:
198/* Reconstruct ITAB */
199 for (i__ = 1; i__ <= 13; ++i__) {
200 itab[i__ - 1] = 0;
201 }
202 for (i__ = 1; i__ <= 53; ++i__) {
203 itab[iblist[54 - i__ - 1] - 1] = (itab[iblist[54 - i__ - 1] - 1] << 1)
204 + ibits[54 - i__];
205 }
206/* Sign extend RC's */
207 i__1 = *order;
208 for (i__ = 1; i__ <= i__1; ++i__) {
209 if ((itab[i__ + 2] & bit[i__ - 1]) != 0) {
210 itab[i__ + 2] -= bit[i__ - 1] << 1;
211 }
212 }
213/* Restore variables */
214 *ipitv = itab[0];
215 *irms = itab[1];
216 i__1 = *order;
217 for (i__ = 1; i__ <= i__1; ++i__) {
218 irc[i__] = itab[*order + 4 - i__ - 1];
219 }
220 return 0;
221} /* chanwr_ */
References lpc10_encoder_state::isync, and order.
◆ dcbias_()
Definition at line 79 of file dcbias.c.
80{
81 /* System generated locals */
82 integer i__1;
83
84 /* Local variables */
85 real bias;
86 integer i__;
87
88/* Arguments */
89/* Local variables that need not be saved */
90 /* Parameter adjustments */
91 --sigout;
92 --speech;
93
94 /* Function Body */
95 bias = 0.f;
96 i__1 = *len;
97 for (i__ = 1; i__ <= i__1; ++i__) {
98 bias += speech[i__];
99 }
100 bias /= *len;
101 i__1 = *len;
102 for (i__ = 1; i__ <= i__1; ++i__) {
103 sigout[i__] = speech[i__] - bias;
104 }
105 return 0;
106} /* dcbias_ */
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
Definition func_strings.c:1669
References len().
Referenced by analys_().
◆ decode_()
|
extern |
Definition at line 147 of file lpc10/decode.c.
150{
151 /* Initialized data */
152
159 25480,16640,1560,1560,1560,16640,1816,1563,1560,24960,24960,24859,
160 24856,26001,25881,25915,25913,1560,1560,7800,3640,1561,1561,3643,
161 3641 };
163 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,
164 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,
165 3.2f,0.f };
167 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,
168 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,
169 100,104,3,84,92,88,156,80,96,3,3,74,70,72,66,76,68,3,62,3,60,3,64,
170 3,3,1,3,116,132,112,148,152,3,3,140,3,136,3,144,3,3,1,124,120,128,
171 3,3,3,3,1,3,3,3,1,3,1,1,1 };
173 384,352,328,294,270,246,226,206,188,172,158,144,132,120,110,102,
174 92,84,78,70,64,60,54,50,46,42,38,34,32,30,26,24,22,20,18,17,16,15,
175 14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
177 96,101,104,108,111,114,115,117,119,121,122,123,124,125,126,127,
178 127 };
180 .3828f };
181 integer *ivp2h;
183 ;
188 integer *iovoic;
189 integer *iavgp;
190 integer *iptold;
191 integer *erate;
192 integer *drc;
193 integer *dpit;
194 integer *drms;
195
196 /* System generated locals */
197 integer i__1, i__2;
198
199 /* Builtin functions */
201
202 /* Local variables */
204 integer ipit, iout, i__, icorf, index, ivoic, ixcor, i1, i2, i4;
206 integer ishift, errcnt, lsb;
207
208/* $Log$
209 * Revision 1.16 2004/06/26 03:50:14 markster
210 * Merge source cleanups (bug #1911)
211 *
212 * Revision 1.15 2003/09/19 01:20:22 markster
213 * Code cleanups (bug #66)
214 *
215 * Revision 1.2 2003/09/19 01:20:22 markster
216 * Code cleanups (bug #66)
217 *
218 * Revision 1.1.1.1 2003/02/12 13:59:14 matteo
219 * mer feb 12 14:56:57 CET 2003
220 *
221 * Revision 1.2 2000/01/05 08:20:39 markster
222 * Some OSS fixes and a few lpc changes to make it actually work
223 *
224 * Revision 1.2 1996/08/20 20:22:39 jaf
225 * Removed all static local variables that were SAVE'd in the Fortran
226 * code, and put them in struct lpc10_decoder_state that is passed as an
227 * argument.
228 *
229 * Removed init function, since all initialization is now done in
230 * init_lpc10_decoder_state().
231 *
232 * Revision 1.1 1996/08/19 22:32:38 jaf
233 * Initial revision
234 * */
235/* Revision 1.3 1996/03/29 22:03:47 jaf */
236/* Removed definitions for any constants that were no longer used. */
237
238/* Revision 1.2 1996/03/26 19:34:33 jaf */
239/* Added comments indicating which constants are not needed in an */
240/* application that uses the LPC-10 coder. */
241
242/* Revision 1.1 1996/02/07 14:43:51 jaf */
243/* Initial revision */
244
245/* LPC Configuration parameters: */
246/* Frame size, Prediction order, Pitch period */
247/* Arguments */
248/* $Log$
249 * Revision 1.16 2004/06/26 03:50:14 markster
250 * Merge source cleanups (bug #1911)
251 *
252 * Revision 1.15 2003/09/19 01:20:22 markster
253 * Code cleanups (bug #66)
254 *
255 * Revision 1.2 2003/09/19 01:20:22 markster
256 * Code cleanups (bug #66)
257 *
258 * Revision 1.1.1.1 2003/02/12 13:59:14 matteo
259 * mer feb 12 14:56:57 CET 2003
260 *
261 * Revision 1.2 2000/01/05 08:20:39 markster
262 * Some OSS fixes and a few lpc changes to make it actually work
263 *
264 * Revision 1.2 1996/08/20 20:22:39 jaf
265 * Removed all static local variables that were SAVE'd in the Fortran
266 * code, and put them in struct lpc10_decoder_state that is passed as an
267 * argument.
268 *
269 * Removed init function, since all initialization is now done in
270 * init_lpc10_decoder_state().
271 *
272 * Revision 1.1 1996/08/19 22:32:38 jaf
273 * Initial revision
274 * */
275/* Revision 1.3 1996/03/29 22:05:55 jaf */
276/* Commented out the common block variables that are not needed by the */
277/* embedded version. */
278
279/* Revision 1.2 1996/03/26 19:34:50 jaf */
280/* Added comments indicating which constants are not needed in an */
281/* application that uses the LPC-10 coder. */
282
283/* Revision 1.1 1996/02/07 14:44:09 jaf */
284/* Initial revision */
285
286/* LPC Processing control variables: */
287
288/* *** Read-only: initialized in setup */
289
290/* Files for Speech, Parameter, and Bitstream Input & Output, */
291/* and message and debug outputs. */
292
293/* Here are the only files which use these variables: */
294
295/* lpcsim.f setup.f trans.f error.f vqsetup.f */
296
297/* Many files which use fdebug are not listed, since it is only used in */
298/* those other files conditionally, to print trace statements. */
299/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
300/* LPC order, Frame size, Quantization rate, Bits per frame, */
301/* Error correction */
302/* Subroutine SETUP is the only place where order is assigned a value, */
303/* and that value is 10. It could increase efficiency 1% or so to */
304/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
305*/
306/* a variable in a COMMON block, since it is used in many places in the */
307/* core of the coding and decoding routines. Actually, I take that back.
308*/
309/* At least when compiling with f2c, the upper bound of DO loops is */
310/* stored in a local variable before the DO loop begins, and then that is
311*/
312/* compared against on each iteration. */
313/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
314/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
315/* is used in only a few places, and never in the core coding and */
316/* decoding routines, so it could be eliminated entirely. */
317/* nbits is similar to quant, and is given a value of 54 in SETUP. */
318/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
319/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
320/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
321*/
322/* a constant or a variable, since it is only examined once per frame. */
323/* Leaving it as a variable that is set to .TRUE. seems like a good */
324/* idea, since it does enable some error-correction capability for */
325/* unvoiced frames, with no change in the coding rate, and no noticeable
326*/
327/* quality difference in the decoded speech. */
328/* integer quant, nbits */
329/* *** Read/write: variables for debugging, not needed for LPC algorithm
330*/
331
332/* Current frame, Unstable frames, Output clip count, Max onset buffer,
333*/
334/* Debug listing detail level, Line count on listing page */
335
336/* nframe is not needed for an embedded LPC10 at all. */
337/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
338/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
339/* an application, I would recommend removing the call to ERROR in RCCHK,
340*/
341/* and remove ERROR and nunsfm completely. */
342/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
343*/
344/* sread.f. When LPC10 is embedded into an application, one might want */
345/* to cause it to be incremented in a routine that takes the output of */
346/* SYNTHS and sends it to an audio device. It could be optionally */
347/* displayed, for those that might want to know what it is. */
348/* maxosp is never initialized to 0 in SETUP, although it probably should
349*/
350/* be, and it is updated in subroutine ANALYS. I doubt that its value */
351/* would be of much interest to an application in which LPC10 is */
352/* embedded. */
353/* listl and lincnt are not needed for an embedded LPC10 at all. */
354/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
355/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
356/* common /contrl/ quant, nbits */
357/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
358/* Function return value definitions */
359
360/* Parameters/constants */
361
362/* The variables below that are not Fortran PARAMETER's are */
363/* initialized with DATA statements, and then never modified. */
364/* The following are used regardless of CORRP's value. */
365
366/* DETAU, NBIT, QB, DEADD, DETAB7, RMST, DESCL */
367
368/* The following are used only if CORRP is .TRUE. */
369
370/* ETHRS, ETHRS1, ETHRS2, ETHRS3, IVTAB, BIT, CORTH, ZRC */
371
372/* Local variables that need not be saved */
373
374/* The following are used regardless of CORRP's value */
375/* The following are used only if CORRP is .TRUE. */
376
377/* Local state */
378
379/* The following are used regardless of CORRP's value */
380/* The following are used only if CORRP is .TRUE. */
381/* I am guessing the initial values for IVP2H, IOVOIC, DRC, DPIT, */
382/* and DRMS. They should be checked to see if they are reasonable.
383*/
384/* I'm also guessing for ERATE, but I think 0 is the right initial
385*/
386/* value. */
387 /* Parameter adjustments */
388 if (irc) {
389 --irc;
390 }
391 if (voice) {
392 --voice;
393 }
394 if (rc) {
395 --rc;
396 }
397
398 /* Function Body */
399
400 iptold = &(st->iptold);
402 ivp2h = &(st->ivp2h);
403 iovoic = &(st->iovoic);
404 iavgp = &(st->iavgp);
405 erate = &(st->erate);
406 drc = &(st->drc[0]);
407 dpit = &(st->dpit[0]);
408 drms = &(st->drms[0]);
409
410/* DATA statements for "constants" defined above. */
411/* IF (LISTL.GE.3) WRITE(FDEBUG,800) IPITV,IRMS,(IRC(J),J=1,ORDER) */
412/* 800 FORMAT(1X,' <<ERRCOR IN>>',T32,6X,I6,I5,T50,10I8) */
413/* If no error correction, do pitch and voicing then jump to decode */
414 i4 = detau[*ipitv];
416 voice[1] = 1;
417 voice[2] = 1;
418 if (*ipitv <= 1) {
419 voice[1] = 0;
420 }
421 if (*ipitv == 0 || *ipitv == 2) {
422 voice[2] = 0;
423 }
424 *pitch = i4;
425 if (*pitch <= 4) {
426 *pitch = *iptold;
427 }
428 if (voice[1] == 1 && voice[2] == 1) {
429 *iptold = *pitch;
430 }
431 if (voice[1] != voice[2]) {
432 *pitch = *iptold;
433 }
434 goto L900;
435 }
436/* Do error correction pitch and voicing */
437 if (i4 > 4) {
438 dpit[0] = i4;
439 ivoic = 2;
440 *iavgp = (*iavgp * 15 + i4 + 8) / 16;
441 } else {
442 ivoic = i4;
443 dpit[0] = *iavgp;
444 }
445 drms[0] = *irms;
446 i__1 = contrl_1.order;
447 for (i__ = 1; i__ <= i__1; ++i__) {
448 drc[i__ * 3 - 3] = irc[i__];
449 }
450/* Determine index to IVTAB from V/UV decision */
451/* If error rate is high then use alternate table */
452 index = (*ivp2h << 4) + (*iovoic << 2) + ivoic + 1;
453 i1 = ivtab[index - 1];
454 ipit = i1 & 3;
455 icorf = i1 / 8;
456 if (*erate < ethrs) {
457 icorf /= 64;
458 }
459/* Determine error rate: 4=high 1=low */
460 ixcor = 4;
461 if (*erate < ethrs3) {
462 ixcor = 3;
463 }
464 if (*erate < ethrs2) {
465 ixcor = 2;
466 }
467 if (*erate < ethrs1) {
468 ixcor = 1;
469 }
470/* Voice/unvoice decision determined from bits 0 and 1 of IVTAB */
471 voice[1] = icorf / 2 & 1;
472 voice[2] = icorf & 1;
473/* Skip decoding on first frame because present data not yet available */
476/* Assign PITCH a "default" value on the first call, since */
477/* otherwise it would be left uninitialized. The two lines
478*/
479/* below were copied from above, since it seemed like a */
480/* reasonable thing to do for the first call. */
481 *pitch = i4;
482 if (*pitch <= 4) {
483 *pitch = *iptold;
484 }
485 goto L500;
486 }
487/* If bit 4 of ICORF is set then correct RMS and RC(1) - RC(4). */
488/* Determine error rate and correct errors using a Hamming 8,4 code */
489/* during transition or unvoiced frame. If IOUT is negative, */
490/* more than 1 error occurred, use previous frame's parameters. */
491 if ((icorf & bit[3]) != 0) {
492 errcnt = 0;
493 lsb = drms[1] & 1;
494 index = (drc[22] << 4) + drms[1] / 2;
495 ham84_(&index, &iout, &errcnt);
496 drms[1] = drms[2];
497 if (iout >= 0) {
498 drms[1] = (iout << 1) + lsb;
499 }
500 for (i__ = 1; i__ <= 4; ++i__) {
501 if (i__ == 1) {
502 i1 = ((drc[25] & 7) << 1) + (drc[28] & 1);
503 } else {
504 i1 = drc[(9 - i__) * 3 - 2] & 15;
505 }
506 i2 = drc[(5 - i__) * 3 - 2] & 31;
507 lsb = i2 & 1;
508 index = (i1 << 4) + i2 / 2;
509 ham84_(&index, &iout, &errcnt);
510 if (iout >= 0) {
511 iout = (iout << 1) + lsb;
512 if ((iout & 16) == 16) {
513 iout += -32;
514 }
515 } else {
516 iout = drc[(5 - i__) * 3 - 1];
517 }
518 drc[(5 - i__) * 3 - 2] = iout;
519 }
520/* Determine error rate */
521 *erate = (integer)(*erate * .96875f + errcnt * 102);
522 }
523/* Get unsmoothed RMS, RC's, and PITCH */
524 *irms = drms[1];
525 i__1 = contrl_1.order;
526 for (i__ = 1; i__ <= i__1; ++i__) {
527 irc[i__] = drc[i__ * 3 - 2];
528 }
529 if (ipit == 1) {
530 dpit[1] = dpit[2];
531 }
532 if (ipit == 3) {
533 dpit[1] = dpit[0];
534 }
535 *pitch = dpit[1];
536/* If bit 2 of ICORF is set then smooth RMS and RC's, */
537 if ((icorf & bit[1]) != 0) {
540 ixcor + 3]) {
541 *irms = median_(&drms[2], &drms[1], drms);
542 }
543 for (i__ = 1; i__ <= 6; ++i__) {
545 >= corth[ixcor + ((i__ + 2) << 2) - 5] && (i__2 = drc[i__ *
547 ixcor + ((i__ + 2) << 2) - 5]) {
548 irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[
549 i__ * 3 - 3]);
550 }
551 }
552 }
553/* If bit 3 of ICORF is set then smooth pitch */
554 if ((icorf & bit[2]) != 0) {
557 ixcor - 1]) {
558 *pitch = median_(&dpit[2], &dpit[1], dpit);
559 }
560 }
561/* If bit 5 of ICORF is set then RC(5) - RC(10) are loaded with */
562/* values so that after quantization bias is removed in decode */
563/* the values will be zero. */
564L500:
565 if ((icorf & bit[4]) != 0) {
566 i__1 = contrl_1.order;
567 for (i__ = 5; i__ <= i__1; ++i__) {
568 irc[i__] = zrc[i__ - 1];
569 }
570 }
571/* House keeping - one frame delay */
572 *iovoic = ivoic;
573 *ivp2h = voice[2];
574 dpit[2] = dpit[1];
575 dpit[1] = dpit[0];
576 drms[2] = drms[1];
577 drms[1] = drms[0];
578 i__1 = contrl_1.order;
579 for (i__ = 1; i__ <= i__1; ++i__) {
580 drc[i__ * 3 - 1] = drc[i__ * 3 - 2];
581 drc[i__ * 3 - 2] = drc[i__ * 3 - 3];
582 }
583L900:
584/* IF (LISTL.GE.3)WRITE(FDEBUG,801)VOICE,PITCH,IRMS,(IRC(J),J=1,ORDER) */
585/* 801 FORMAT(1X,'<<ERRCOR OUT>>',T32,2I3,I6,I5,T50,10I8) */
586/* Decode RMS */
587 *irms = rmst[(31 - *irms) * 2];
588/* Decode RC(1) and RC(2) from log-area-ratios */
589/* Protect from illegal coded value (-16) caused by bit errors */
590 for (i__ = 1; i__ <= 2; ++i__) {
591 i2 = irc[i__];
592 i1 = 0;
593 if (i2 < 0) {
594 i1 = 1;
595 i2 = -i2;
596 if (i2 > 15) {
597 i2 = 0;
598 }
599 }
600 i2 = detab7[i2 * 2];
601 if (i1 == 1) {
602 i2 = -i2;
603 }
604 ishift = 15 - nbit[i__ - 1];
606 }
607/* Decode RC(3)-RC(10) to sign plus 14 bits */
608 i__1 = contrl_1.order;
609 for (i__ = 3; i__ <= i__1; ++i__) {
610 i2 = irc[i__];
611 ishift = 15 - nbit[i__ - 1];
613 i2 += qb[i__ - 3];
614 irc[i__] = (integer)(i2 * descl[i__ - 3] + deadd[i__ - 3]);
615 }
616/* IF (LISTL.GE.3) WRITE(FDEBUG,811) IRMS, (IRC(I),I=1,ORDER) */
617/* 811 FORMAT(1X,'<<DECODE OUT>>',T45,I4,1X,10I8) */
618/* Scale RMS and RC's to reals */
619 *rms = (real) (*irms);
620 i__1 = contrl_1.order;
621 for (i__ = 1; i__ <= i__1; ++i__) {
622 rc[i__] = irc[i__] / 16384.f;
623 }
624 return 0;
625} /* decode_ */
References abs, c__2, contrl_1, lpc10_decoder_state::dpit, lpc10_decoder_state::drc, lpc10_decoder_state::drms, lpc10_decoder_state::erate, FALSE_, first, lpc10_decoder_state::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().
◆ deemp_()
|
extern |
Definition at line 106 of file deemp.c.
107{
108 /* Initialized data */
109
110 real *dei1;
111 real *dei2;
112 real *deo1;
113 real *deo2;
114 real *deo3;
115
116 /* System generated locals */
117 integer i__1;
118 real r__1;
119
120 /* Local variables */
121 integer k;
122 real dei0;
123
124/* Arguments */
125/* Local variables that need not be saved */
126/* Local state */
127/* All of the locals saved below were not given explicit initial */
128/* values in the original code. I think 0 is a safe choice. */
129 /* Parameter adjustments */
130 if (x) {
131 --x;
132 }
133
134 /* Function Body */
135
136 dei1 = &(st->dei1);
137 dei2 = &(st->dei2);
138 deo1 = &(st->deo1);
139 deo2 = &(st->deo2);
140 deo3 = &(st->deo3);
141
142 i__1 = *n;
143 for (k = 1; k <= i__1; ++k) {
144 dei0 = x[k];
145 r__1 = x[k] - *dei1 * 1.9998f + *dei2;
146 x[k] = r__1 + *deo1 * 2.5f - *deo2 * 2.0925f + *deo3 * .585f;
147 *dei2 = *dei1;
148 *dei1 = dei0;
149 *deo3 = *deo2;
150 *deo2 = *deo1;
151 *deo1 = x[k];
152 }
153 return 0;
154} /* deemp_ */
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_().
◆ difmag_()
|
extern |
Definition at line 90 of file difmag.c.
93{
94 /* System generated locals */
95 integer i__1, i__2;
96 real r__1;
97
98 /* Local variables */
99 integer i__, j, n1, n2;
100 real sum;
101
102/* Arguments */
103/* Local variables that need not be saved */
104/* Local state */
105/* None */
106 /* Parameter adjustments */
107 --amdf;
108 --tau;
109 --speech;
110
111 /* Function Body */
112 *minptr = 1;
113 *maxptr = 1;
114 i__1 = *ltau;
115 for (i__ = 1; i__ <= i__1; ++i__) {
116 n1 = (*maxlag - tau[i__]) / 2 + 1;
117 n2 = n1 + *lpita - 1;
118 sum = 0.f;
119 i__2 = n2;
120 for (j = n1; j <= i__2; j += 4) {
121 sum += (r__1 = speech[j] - speech[j + tau[i__]], abs(r__1));
122 }
123 amdf[i__] = sum;
124 if (amdf[i__] < amdf[*minptr]) {
125 *minptr = i__;
126 }
127 if (amdf[i__] > amdf[*maxptr]) {
128 *maxptr = i__;
129 }
130 }
131 return 0;
132} /* difmag_ */
References abs.
Referenced by tbdm_().
◆ dyptrk_()
|
extern |
Definition at line 129 of file dyptrk.c.
132{
133 /* Initialized data */
134
135 real *s;
136 integer *p;
137 integer *ipoint;
138 real *alphax;
139
140 /* System generated locals */
141 integer i__1;
142
143 /* Local variables */
144 integer pbar;
145 real sbar;
146 integer iptr, i__, j;
147 real alpha, minsc, maxsc;
148
149/* Arguments */
150/* $Log$
151 * Revision 1.15 2004/06/26 03:50:14 markster
152 * Merge source cleanups (bug #1911)
153 *
154 * Revision 1.14 2003/02/12 13:59:15 matteo
155 * mer feb 12 14:56:57 CET 2003
156 *
157 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
158 * mer feb 12 14:56:57 CET 2003
159 *
160 * Revision 1.2 2000/01/05 08:20:39 markster
161 * Some OSS fixes and a few lpc changes to make it actually work
162 *
163 * Revision 1.2 1996/08/20 20:25:29 jaf
164 * Removed all static local variables that were SAVE'd in the Fortran
165 * code, and put them in struct lpc10_encoder_state that is passed as an
166 * argument.
167 *
168 * Removed init function, since all initialization is now done in
169 * init_lpc10_encoder_state().
170 *
171 * Revision 1.1 1996/08/19 22:32:26 jaf
172 * Initial revision
173 * */
174/* Revision 1.3 1996/03/29 22:05:55 jaf */
175/* Commented out the common block variables that are not needed by the */
176/* embedded version. */
177
178/* Revision 1.2 1996/03/26 19:34:50 jaf */
179/* Added comments indicating which constants are not needed in an */
180/* application that uses the LPC-10 coder. */
181
182/* Revision 1.1 1996/02/07 14:44:09 jaf */
183/* Initial revision */
184
185/* LPC Processing control variables: */
186
187/* *** Read-only: initialized in setup */
188
189/* Files for Speech, Parameter, and Bitstream Input & Output, */
190/* and message and debug outputs. */
191
192/* Here are the only files which use these variables: */
193
194/* lpcsim.f setup.f trans.f error.f vqsetup.f */
195
196/* Many files which use fdebug are not listed, since it is only used in */
197/* those other files conditionally, to print trace statements. */
198/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
199/* LPC order, Frame size, Quantization rate, Bits per frame, */
200/* Error correction */
201/* Subroutine SETUP is the only place where order is assigned a value, */
202/* and that value is 10. It could increase efficiency 1% or so to */
203/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
204*/
205/* a variable in a COMMON block, since it is used in many places in the */
206/* core of the coding and decoding routines. Actually, I take that back.
207*/
208/* At least when compiling with f2c, the upper bound of DO loops is */
209/* stored in a local variable before the DO loop begins, and then that is
210*/
211/* compared against on each iteration. */
212/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
213/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
214/* is used in only a few places, and never in the core coding and */
215/* decoding routines, so it could be eliminated entirely. */
216/* nbits is similar to quant, and is given a value of 54 in SETUP. */
217/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
218/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
219/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
220*/
221/* a constant or a variable, since it is only examined once per frame. */
222/* Leaving it as a variable that is set to .TRUE. seems like a good */
223/* idea, since it does enable some error-correction capability for */
224/* unvoiced frames, with no change in the coding rate, and no noticeable
225*/
226/* quality difference in the decoded speech. */
227/* integer quant, nbits */
228/* *** Read/write: variables for debugging, not needed for LPC algorithm
229*/
230
231/* Current frame, Unstable frames, Output clip count, Max onset buffer,
232*/
233/* Debug listing detail level, Line count on listing page */
234
235/* nframe is not needed for an embedded LPC10 at all. */
236/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
237/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
238/* an application, I would recommend removing the call to ERROR in RCCHK,
239*/
240/* and remove ERROR and nunsfm completely. */
241/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
242*/
243/* sread.f. When LPC10 is embedded into an application, one might want */
244/* to cause it to be incremented in a routine that takes the output of */
245/* SYNTHS and sends it to an audio device. It could be optionally */
246/* displayed, for those that might want to know what it is. */
247/* maxosp is never initialized to 0 in SETUP, although it probably should
248*/
249/* be, and it is updated in subroutine ANALYS. I doubt that its value */
250/* would be of much interest to an application in which LPC10 is */
251/* embedded. */
252/* listl and lincnt are not needed for an embedded LPC10 at all. */
253/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
254/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
255/* common /contrl/ quant, nbits */
256/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
257/* Parameters/constants */
258/* Local variables that need not be saved */
259/* Note that PATH is only used for debugging purposes, and can be */
260/* removed. */
261/* Local state */
262/* It would be a bit more "general" to define S(LTAU), if Fortran */
263/* allows the argument of a function to be used as the dimension of
264*/
265/* a local array variable. */
266/* IPOINT is always in the range 0 to DEPTH-1. */
267/* WARNING! */
268
269/* In the original version of this subroutine, IPOINT, ALPHAX, */
270/* every element of S, and potentially any element of P with the */
271/* second index value .NE. IPTR were read without being given */
272/* initial values (all indices of P with second index equal to */
273/* IPTR are all written before being read in this subroutine). */
274
275/* From examining the code carefully, it appears that all of these
276*/
277/* should be saved from one invocation to the next. */
278
279/* I've run lpcsim with the "-l 6" option to see all of the */
280/* debugging information that is printed out by this subroutine */
281/* below, and it appears that S, P, IPOINT, and ALPHAX are all */
282/* initialized to 0 (these initial values would likely be different
283*/
284/* on different platforms, compilers, etc.). Given that the output
285*/
286/* of the coder sounds reasonable, I'm going to initialize these */
287/* variables to 0 explicitly. */
288
289 s = &(st->s[0]);
290 p = &(st->p[0]);
291 ipoint = &(st->ipoint);
292 alphax = &(st->alphax);
293
294
295 /* Parameter adjustments */
296 if (amdf) {
297 --amdf;
298 }
299
300 /* Function Body */
301
302/* Calculate the confidence factor ALPHA, used as a threshold slope in
303*/
304/* SEESAW. If unvoiced, set high slope so that every point in P array
305*/
306/* is marked as a potential pitch frequency. A scaled up version (ALPHAX
307)*/
308/* is used to maintain arithmetic precision. */
309 if (*voice == 1) {
310 *alphax = *alphax * .75f + amdf[*minptr] / 2.f;
311 } else {
312 *alphax *= .984375f;
313 }
314 alpha = *alphax / 16;
315 if (*voice == 0 && *alphax < 128.f) {
316 alpha = 8.f;
317 }
318/* SEESAW: Construct a pitch pointer array and intermediate winner functio
319n*/
320/* Left to right pass: */
321 iptr = *ipoint + 1;
322 p[iptr * 60 - 60] = 1;
323 i__ = 1;
324 pbar = 1;
325 sbar = s[0];
326 i__1 = *ltau;
327 for (i__ = 1; i__ <= i__1; ++i__) {
328 sbar += alpha;
329 if (sbar < s[i__ - 1]) {
330 s[i__ - 1] = sbar;
331 p[i__ + iptr * 60 - 61] = pbar;
332 } else {
333 sbar = s[i__ - 1];
334 p[i__ + iptr * 60 - 61] = i__;
335 pbar = i__;
336 }
337 }
338/* Right to left pass: */
339 i__ = pbar - 1;
340 sbar = s[i__];
341 while(i__ >= 1) {
342 sbar += alpha;
343 if (sbar < s[i__ - 1]) {
344 s[i__ - 1] = sbar;
345 p[i__ + iptr * 60 - 61] = pbar;
346 } else {
347 pbar = p[i__ + iptr * 60 - 61];
348 i__ = pbar;
349 sbar = s[i__ - 1];
350 }
351 --i__;
352 }
353/* Update S using AMDF */
354/* Find maximum, minimum, and location of minimum */
355 s[0] += amdf[1] / 2;
356 minsc = s[0];
357 maxsc = minsc;
358 *midx = 1;
359 i__1 = *ltau;
360 for (i__ = 2; i__ <= i__1; ++i__) {
361 s[i__ - 1] += amdf[i__] / 2;
362 if (s[i__ - 1] > maxsc) {
363 maxsc = s[i__ - 1];
364 }
365 if (s[i__ - 1] < minsc) {
366 *midx = i__;
367 minsc = s[i__ - 1];
368 }
369 }
370/* Subtract MINSC from S to prevent overflow */
371 i__1 = *ltau;
372 for (i__ = 1; i__ <= i__1; ++i__) {
373 s[i__ - 1] -= minsc;
374 }
375 maxsc -= minsc;
376/* Use higher octave pitch if significant null there */
377 j = 0;
378 for (i__ = 20; i__ <= 40; i__ += 10) {
379 if (*midx > i__) {
380 if (s[*midx - i__ - 1] < maxsc / 4) {
381 j = i__;
382 }
383 }
384 }
385 *midx -= j;
386/* TRACE: look back two frames to find minimum cost pitch estimate */
387 j = *ipoint;
388 *pitch = *midx;
389 for (i__ = 1; i__ <= 2; ++i__) {
390 j = j % 2 + 1;
391 *pitch = p[*pitch + j * 60 - 61];
392 }
393
394/* The following statement subtracts one from IPOINT, mod DEPTH. I
395*/
396/* think the author chose to add DEPTH-1, instead of subtracting 1,
397*/
398/* because then it will work even if MOD doesn't work as desired on
399*/
400/* negative arguments. */
401
402 *ipoint = (*ipoint + 1) % 2;
403 return 0;
404} /* dyptrk_ */
References lpc10_encoder_state::alphax, lpc10_encoder_state::ipoint, lpc10_encoder_state::p, and lpc10_encoder_state::s.
Referenced by analys_().
◆ encode_()
|
extern |
Definition at line 111 of file encode.c.
113{
114 /* Initialized data */
115
118 42,43,41,45,37,53,49,51,50,54,52,60,56,58,26,90,88,92,84,86,82,83,
119 81,85,69,77,73,75,74,78,70,71,67,99,97,113,112,114,98,106,104,108,
120 100,101,76 };
123 .0112f };
126 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,
127 9,10,10,11,11,12,13,14,15 };
129 384,352,328,294,270,246,226,206,188,172,158,144,132,120,110,102,
130 92,84,78,70,64,60,54,50,46,42,38,34,32,30,26,24,22,20,18,17,16,15,
131 14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
132
133 /* System generated locals */
134 integer i__1, i__2;
135
136 /* Builtin functions */
138
139 /* Local variables */
140 integer idel, nbit, i__, j, i2, i3, mrk;
141
142/* $Log$
143 * Revision 1.15 2004/06/26 03:50:14 markster
144 * Merge source cleanups (bug #1911)
145 *
146 * Revision 1.14 2003/02/12 13:59:15 matteo
147 * mer feb 12 14:56:57 CET 2003
148 *
149 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
150 * mer feb 12 14:56:57 CET 2003
151 *
152 * Revision 1.2 2000/01/05 08:20:39 markster
153 * Some OSS fixes and a few lpc changes to make it actually work
154 *
155 * Revision 1.1 1996/08/19 22:32:21 jaf
156 * Initial revision
157 * */
158/* Revision 1.3 1996/03/29 22:03:47 jaf */
159/* Removed definitions for any constants that were no longer used. */
160
161/* Revision 1.2 1996/03/26 19:34:33 jaf */
162/* Added comments indicating which constants are not needed in an */
163/* application that uses the LPC-10 coder. */
164
165/* Revision 1.1 1996/02/07 14:43:51 jaf */
166/* Initial revision */
167
168/* LPC Configuration parameters: */
169/* Frame size, Prediction order, Pitch period */
170/* Arguments */
171/* $Log$
172 * Revision 1.15 2004/06/26 03:50:14 markster
173 * Merge source cleanups (bug #1911)
174 *
175 * Revision 1.14 2003/02/12 13:59:15 matteo
176 * mer feb 12 14:56:57 CET 2003
177 *
178 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
179 * mer feb 12 14:56:57 CET 2003
180 *
181 * Revision 1.2 2000/01/05 08:20:39 markster
182 * Some OSS fixes and a few lpc changes to make it actually work
183 *
184 * Revision 1.1 1996/08/19 22:32:21 jaf
185 * Initial revision
186 * */
187/* Revision 1.3 1996/03/29 22:05:55 jaf */
188/* Commented out the common block variables that are not needed by the */
189/* embedded version. */
190
191/* Revision 1.2 1996/03/26 19:34:50 jaf */
192/* Added comments indicating which constants are not needed in an */
193/* application that uses the LPC-10 coder. */
194
195/* Revision 1.1 1996/02/07 14:44:09 jaf */
196/* Initial revision */
197
198/* LPC Processing control variables: */
199
200/* *** Read-only: initialized in setup */
201
202/* Files for Speech, Parameter, and Bitstream Input & Output, */
203/* and message and debug outputs. */
204
205/* Here are the only files which use these variables: */
206
207/* lpcsim.f setup.f trans.f error.f vqsetup.f */
208
209/* Many files which use fdebug are not listed, since it is only used in */
210/* those other files conditionally, to print trace statements. */
211/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
212/* LPC order, Frame size, Quantization rate, Bits per frame, */
213/* Error correction */
214/* Subroutine SETUP is the only place where order is assigned a value, */
215/* and that value is 10. It could increase efficiency 1% or so to */
216/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
217*/
218/* a variable in a COMMON block, since it is used in many places in the */
219/* core of the coding and decoding routines. Actually, I take that back.
220*/
221/* At least when compiling with f2c, the upper bound of DO loops is */
222/* stored in a local variable before the DO loop begins, and then that is
223*/
224/* compared against on each iteration. */
225/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
226/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
227/* is used in only a few places, and never in the core coding and */
228/* decoding routines, so it could be eliminated entirely. */
229/* nbits is similar to quant, and is given a value of 54 in SETUP. */
230/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
231/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
232/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
233*/
234/* a constant or a variable, since it is only examined once per frame. */
235/* Leaving it as a variable that is set to .TRUE. seems like a good */
236/* idea, since it does enable some error-correction capability for */
237/* unvoiced frames, with no change in the coding rate, and no noticeable
238*/
239/* quality difference in the decoded speech. */
240/* integer quant, nbits */
241/* *** Read/write: variables for debugging, not needed for LPC algorithm
242*/
243
244/* Current frame, Unstable frames, Output clip count, Max onset buffer,
245*/
246/* Debug listing detail level, Line count on listing page */
247
248/* nframe is not needed for an embedded LPC10 at all. */
249/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
250/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
251/* an application, I would recommend removing the call to ERROR in RCCHK,
252*/
253/* and remove ERROR and nunsfm completely. */
254/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
255*/
256/* sread.f. When LPC10 is embedded into an application, one might want */
257/* to cause it to be incremented in a routine that takes the output of */
258/* SYNTHS and sends it to an audio device. It could be optionally */
259/* displayed, for those that might want to know what it is. */
260/* maxosp is never initialized to 0 in SETUP, although it probably should
261*/
262/* be, and it is updated in subroutine ANALYS. I doubt that its value */
263/* would be of much interest to an application in which LPC10 is */
264/* embedded. */
265/* listl and lincnt are not needed for an embedded LPC10 at all. */
266/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
267/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
268/* common /contrl/ quant, nbits */
269/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
270/* Parameters/constants */
271/* These arrays are not Fortran PARAMETER's, but they are defined */
272/* by DATA statements below, and their contents are never altered.
273*/
274/* Local variables that need not be saved */
275 /* Parameter adjustments */
276 --irc;
277 --rc;
278 --voice;
279
280 /* Function Body */
281/* Scale RMS and RC's to integers */
282 *irms = (integer)*rms;
283 i__1 = contrl_1.order;
284 for (i__ = 1; i__ <= i__1; ++i__) {
285 irc[i__] = (integer)(rc[i__] * 32768.f);
286 }
287/* IF(LISTL.GE.3)WRITE(FDEBUG,800)VOICE,PITCH,IRMS,(IRC(I),I=1,ORDER) */
288/* 800 FORMAT(1X,/,' <<ENCODE IN>>',T32,2I3,I6,I5,T50,10I8) */
289/* Encode pitch and voicing */
290 if (voice[1] != 0 && voice[2] != 0) {
291 *ipitch = entau[*pitch - 1];
292 } else {
294 *ipitch = 0;
295 if (voice[1] != voice[2]) {
296 *ipitch = 127;
297 }
298 } else {
299 *ipitch = (voice[1] << 1) + voice[2];
300 }
301 }
302/* Encode RMS by binary table search */
303 j = 32;
304 idel = 16;
305 *irms = min(*irms,1023);
306 while(idel > 0) {
307 if (*irms > rmst[j - 1]) {
308 j -= idel;
309 }
310 if (*irms < rmst[j - 1]) {
311 j += idel;
312 }
313 idel /= 2;
314 }
315 if (*irms > rmst[j - 1]) {
316 --j;
317 }
318 *irms = 31 - j / 2;
319/* Encode RC(1) and (2) as log-area-ratios */
320 for (i__ = 1; i__ <= 2; ++i__) {
321 i2 = irc[i__];
322 mrk = 0;
323 if (i2 < 0) {
324 i2 = -i2;
325 mrk = 1;
326 }
327 i2 /= 512;
328 i2 = min(i2,63);
329 i2 = entab6[i2];
330 if (mrk != 0) {
331 i2 = -i2;
332 }
333 irc[i__] = i2;
334 }
335/* Encode RC(3) - (10) linearly, remove bias then scale */
336 i__1 = contrl_1.order;
337 for (i__ = 3; i__ <= i__1; ++i__) {
338 i2 = irc[i__] / 2;
340 contrl_1.order + 1 - i__ - 1]);
341/* Computing MIN */
342 i__2 = max(i2,-127);
343 i2 = min(i__2,127);
344 nbit = enbits[contrl_1.order + 1 - i__ - 1];
345 i3 = 0;
346 if (i2 < 0) {
347 i3 = -1;
348 }
350 if (i3 == -1) {
351 --i2;
352 }
353 irc[i__] = i2;
354 }
355/* Protect the most significant bits of the most */
356/* important parameters during non-voiced frames. */
357/* RC(1) - RC(4) are protected using 20 parity bits */
358/* replacing RC(5) - RC(10). */
360 if (*ipitch == 0 || *ipitch == 127) {
361 irc[5] = enctab[(irc[1] & 30) / 2];
362 irc[6] = enctab[(irc[2] & 30) / 2];
363 irc[7] = enctab[(irc[3] & 30) / 2];
364 irc[8] = enctab[(*irms & 30) / 2];
365 irc[9] = enctab[(irc[4] & 30) / 2] / 2;
366 irc[10] = enctab[(irc[4] & 30) / 2] & 1;
367 }
368 }
369/* IF(LISTL.GE.3)WRITE(FDEBUG,801)VOICE,IPITCH,IRMS,(IRC(J),J=1,ORDER) */
370/* 801 FORMAT(1X,'<<ENCODE OUT>>',T32,2I3,I6,I5,T50,10I8) */
371 return 0;
372} /* encode_ */
References c__2, contrl_1, max, min, and pow_ii().
Referenced by lpc10_encode().
◆ energy_()
Definition at line 78 of file energy.c.
79{
80 /* System generated locals */
81 integer i__1;
82
83 /* Builtin functions */
85
86 /* Local variables */
87 integer i__;
88
89/* Arguments */
90/* Local variables that need not be saved */
91 /* Parameter adjustments */
92 --speech;
93
94 /* Function Body */
95 *rms = 0.f;
96 i__1 = *len;
97 for (i__ = 1; i__ <= i__1; ++i__) {
98 *rms += speech[i__] * speech[i__];
99 }
101 return 0;
102} /* energy_ */
References len().
Referenced by analys_().
◆ ham84_()
Definition at line 85 of file ham84.c.
86{
87 /* Initialized data */
88
90 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,
91 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,
92 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,
93 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,
94 12,15,15,31 };
95
96 integer i__, j, parity;
97
98/* Arguments */
99/* Parameters/constants */
100/* Local variables that need not be saved */
101/* Determine parity of input word */
102 parity = *input & 255;
103 parity ^= parity / 16;
104 parity ^= parity / 4;
105 parity ^= parity / 2;
106 parity &= 1;
107 i__ = dactab[*input & 127];
108 *output = i__ & 15;
109 j = i__ & 16;
110 if (j != 0) {
111/* No errors detected in seven bits */
112 if (parity != 0) {
113 ++(*errcnt);
114 }
115 } else {
116/* One or two errors detected */
117 ++(*errcnt);
118 if (parity == 0) {
119/* Two errors detected */
120 ++(*errcnt);
121 *output = -1;
122 }
123 }
124 return 0;
125} /* ham84_ */
Referenced by decode_().
◆ hp100_()
|
extern |
Definition at line 113 of file hp100.c.
115{
116 /* Temporary local copies of variables in lpc10_encoder_state.
117 I've only created these because it might cause the loop below
118 to execute a bit faster to access local variables, rather than
119 variables in the lpc10_encoder_state structure. It is just a
120 guess that it will be faster. */
121
122 real z11;
123 real z21;
124 real z12;
125 real z22;
126
127 /* System generated locals */
128 integer i__1;
129
130 /* Local variables */
131 integer i__;
132 real si, err;
133
134/* Arguments */
135/* Local variables that need not be saved */
136/* Local state */
137 /* Parameter adjustments */
138 if (speech) {
139 --speech;
140 }
141
142 /* Function Body */
143
144 z11 = st->z11;
145 z21 = st->z21;
146 z12 = st->z12;
147 z22 = st->z22;
148
149 i__1 = *end;
150 for (i__ = *start; i__ <= i__1; ++i__) {
151 si = speech[i__];
152 err = si + z11 * 1.859076f - z21 * .8648249f;
153 si = err - z11 * 2.f + z21;
154 z21 = z11;
155 z11 = err;
156 err = si + z12 * 1.935715f - z22 * .9417004f;
157 si = err - z12 * 2.f + z22;
158 z22 = z12;
159 z12 = err;
160 speech[i__] = si * .902428f;
161 }
162
163 st->z11 = z11;
164 st->z21 = z21;
165 st->z12 = z12;
166 st->z22 = z22;
167
168 return 0;
169} /* hp100_ */
References end, lpc10_encoder_state::z11, lpc10_encoder_state::z12, lpc10_encoder_state::z21, and lpc10_encoder_state::z22.
Referenced by prepro_().
◆ i_nint()
◆ inithp100_()
|
extern |
◆ initlpcdec_()
|
extern |
◆ initlpcenc_()
|
extern |
◆ invert_()
Definition at line 93 of file invert.c.
94{
95 /* System generated locals */
96 unsigned i__2;
97 integer phi_dim1, phi_offset, i__1, i__3;
98 real r__1, r__2;
99
100 /* Local variables */
101 real save;
102 integer i__, j, k;
104
105/* Arguments */
106/* $Log$
107 * Revision 1.15 2004/06/26 03:50:14 markster
108 * Merge source cleanups (bug #1911)
109 *
110 * Revision 1.14 2003/02/12 13:59:15 matteo
111 * mer feb 12 14:56:57 CET 2003
112 *
113 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
114 * mer feb 12 14:56:57 CET 2003
115 *
116 * Revision 1.2 2000/01/05 08:20:39 markster
117 * Some OSS fixes and a few lpc changes to make it actually work
118 *
119 * Revision 1.1 1996/08/19 22:32:00 jaf
120 * Initial revision
121 * */
122/* Revision 1.3 1996/03/29 22:03:47 jaf */
123/* Removed definitions for any constants that were no longer used. */
124
125/* Revision 1.2 1996/03/26 19:34:33 jaf */
126/* Added comments indicating which constants are not needed in an */
127/* application that uses the LPC-10 coder. */
128
129/* Revision 1.1 1996/02/07 14:43:51 jaf */
130/* Initial revision */
131
132/* LPC Configuration parameters: */
133/* Frame size, Prediction order, Pitch period */
134/* Parameters/constants */
135/* Local variables that need not be saved */
136/* Decompose PHI into V * D * V' where V is a triangular matrix whose */
137/* main diagonal elements are all 1, V' is the transpose of V, and */
138/* D is a vector. Here D(n) is stored in location V(n,n). */
139 /* Parameter adjustments */
140 --rc;
141 --psi;
142 phi_dim1 = *order;
143 phi_offset = phi_dim1 + 1;
144 phi -= phi_offset;
145
146 /* Function Body */
147 i__1 = *order;
148 for (j = 1; j <= i__1; ++j) {
149 i__2 = *order;
150 for (i__ = j; i__ <= i__2; ++i__) {
151 v[i__ + j * 10 - 11] = phi[i__ + j * phi_dim1];
152 }
153 i__2 = j - 1;
154 for (k = 1; k <= i__2; ++k) {
155 save = v[j + k * 10 - 11] * v[k + k * 10 - 11];
156 i__3 = *order;
157 for (i__ = j; i__ <= i__3; ++i__) {
158 v[i__ + j * 10 - 11] -= v[i__ + k * 10 - 11] * save;
159 }
160 }
161/* Compute intermediate results, which are similar to RC's */
163 goto L100;
164 }
165 rc[j] = psi[j];
166 i__2 = j - 1;
167 for (k = 1; k <= i__2; ++k) {
168 rc[j] -= rc[k] * v[j + k * 10 - 11];
169 }
170 v[j + j * 10 - 11] = 1.f / v[j + j * 10 - 11];
171 rc[j] *= v[j + j * 10 - 11];
172/* Computing MAX */
173/* Computing MIN */
174 r__2 = rc[j];
175 r__1 = min(r__2,.999f);
176 rc[j] = max(r__1,-.999f);
177 }
178 return 0;
179/* Zero out higher order RC's if algorithm terminated early */
180L100:
181 i__1 = *order;
182 for (i__ = j; i__ <= i__1; ++i__) {
183 rc[i__] = 0.f;
184 }
185/* Back substitute for PC's (if needed) */
186/* 110 DO J = ORDER,1,-1 */
187/* PC(J) = RC(J) */
188/* DO I = 1,J-1 */
189/* PC(J) = PC(J) - PC(I)*V(J,I) */
190/* END DO */
191/* END DO */
192 return 0;
193} /* invert_ */
References abs, max, min, and order.
Referenced by analys_().
◆ irc2pc_()
Definition at line 82 of file irc2pc.c.
84{
85 /* System generated locals */
86 integer i__1, i__2;
87
88 /* Builtin functions */
90
91 /* Local variables */
92 real temp[10];
93 integer i__, j;
94
95/* Arguments */
96/* $Log$
97 * Revision 1.15 2004/06/26 03:50:14 markster
98 * Merge source cleanups (bug #1911)
99 *
100 * Revision 1.14 2003/02/12 13:59:15 matteo
101 * mer feb 12 14:56:57 CET 2003
102 *
103 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
104 * mer feb 12 14:56:57 CET 2003
105 *
106 * Revision 1.2 2000/01/05 08:20:39 markster
107 * Some OSS fixes and a few lpc changes to make it actually work
108 *
109 * Revision 1.1 1996/08/19 22:31:56 jaf
110 * Initial revision
111 * */
112/* Revision 1.3 1996/03/29 22:03:47 jaf */
113/* Removed definitions for any constants that were no longer used. */
114
115/* Revision 1.2 1996/03/26 19:34:33 jaf */
116/* Added comments indicating which constants are not needed in an */
117/* application that uses the LPC-10 coder. */
118
119/* Revision 1.1 1996/02/07 14:43:51 jaf */
120/* Initial revision */
121
122/* LPC Configuration parameters: */
123/* Frame size, Prediction order, Pitch period */
124/* Local variables that need not be saved */
125 /* Parameter adjustments */
126 --pc;
127 --rc;
128
129 /* Function Body */
130 *g2pass = 1.f;
131 i__1 = *order;
132 for (i__ = 1; i__ <= i__1; ++i__) {
133 *g2pass *= 1.f - rc[i__] * rc[i__];
134 }
135 *g2pass = *gprime * (real)sqrt(*g2pass);
136 pc[1] = rc[1];
137 i__1 = *order;
138 for (i__ = 2; i__ <= i__1; ++i__) {
139 i__2 = i__ - 1;
140 for (j = 1; j <= i__2; ++j) {
141 temp[j - 1] = pc[j] - rc[i__] * pc[i__ - j];
142 }
143 i__2 = i__ - 1;
144 for (j = 1; j <= i__2; ++j) {
145 pc[j] = temp[j - 1];
146 }
147 pc[i__] = rc[i__];
148 }
149 return 0;
150} /* irc2pc_ */
References order.
Referenced by synths_().
◆ ivfilt_()
Definition at line 89 of file ivfilt.c.
91{
92 /* System generated locals */
93 integer i__1;
94
95 /* Local variables */
96 integer i__, j, k;
97 real r__[3], pc1, pc2;
98
99/* Arguments */
100/* Local variables that need not be saved */
101/* Local state */
102/* None */
103/* Calculate Autocorrelations */
104 /* Parameter adjustments */
105 --ivbuf;
106 --lpbuf;
107 --ivrc;
108
109 /* Function Body */
110 for (i__ = 1; i__ <= 3; ++i__) {
111 r__[i__ - 1] = 0.f;
112 k = (i__ - 1) << 2;
113 i__1 = *len;
115 r__[i__ - 1] += lpbuf[j] * lpbuf[j - k];
116 }
117 }
118/* Calculate predictor coefficients */
119 pc1 = 0.f;
120 pc2 = 0.f;
121 ivrc[1] = 0.f;
122 ivrc[2] = 0.f;
123 if (r__[0] > 1e-10f) {
124 ivrc[1] = r__[1] / r__[0];
125 ivrc[2] = (r__[2] - ivrc[1] * r__[1]) / (r__[0] - ivrc[1] * r__[1]);
126 pc1 = ivrc[1] - ivrc[1] * ivrc[2];
127 pc2 = ivrc[2];
128 }
129/* Inverse filter LPBUF into IVBUF */
130 i__1 = *len;
132 ivbuf[i__] = lpbuf[i__] - pc1 * lpbuf[i__ - 4] - pc2 * lpbuf[i__ - 8];
133 }
134 return 0;
135} /* ivfilt_ */
References len().
Referenced by analys_().
◆ lpcdec_()
◆ lpcenc_()
◆ lpfilt_()
Definition at line 83 of file lpfilt.c.
85{
86 /* System generated locals */
87 integer i__1;
88
89 /* Local variables */
90 integer j;
91 real t;
92
93/* Arguments */
94/* Parameters/constants */
95/* Local variables that need not be saved */
96/* Local state */
97/* None */
98 /* Parameter adjustments */
99 --lpbuf;
100 --inbuf;
101
102 /* Function Body */
103 i__1 = *len;
120 t += inbuf[j - 15] * .250535965f;
121 lpbuf[j] = t;
122 }
123 return 0;
124} /* lpfilt_ */
static int inbuf(struct baseio *bio, FILE *fi)
utility used by inchar(), for base_encode()
Definition utils.c:590
References inbuf(), and len().
Referenced by analys_().
◆ median_()
Definition at line 69 of file median.c.
70{
71 /* System generated locals */
72 integer ret_val;
73
74/* Arguments */
75 ret_val = *d2;
76 if (*d2 > *d1 && *d2 > *d3) {
77 ret_val = *d1;
78 if (*d3 > *d1) {
79 ret_val = *d3;
80 }
81 } else if (*d2 < *d1 && *d2 < *d3) {
82 ret_val = *d1;
83 if (*d3 < *d1) {
84 ret_val = *d3;
85 }
86 }
87 return ret_val;
88} /* median_ */
Referenced by decode_().
◆ mload_()
|
extern |
Definition at line 99 of file mload.c.
101{
102 /* System generated locals */
103 integer phi_dim1, phi_offset, i__1, i__2;
104
105 /* Local variables */
106 integer c__, i__, r__, start;
107
108/* Arguments */
109/* Local variables that need not be saved */
110/* Load first column of triangular covariance matrix PHI */
111 /* Parameter adjustments */
112 --psi;
113 phi_dim1 = *order;
114 phi_offset = phi_dim1 + 1;
115 phi -= phi_offset;
116 --speech;
117
118 /* Function Body */
119 start = *awins + *order;
120 i__1 = *order;
121 for (r__ = 1; r__ <= i__1; ++r__) {
122 phi[r__ + phi_dim1] = 0.f;
123 i__2 = *awinf;
124 for (i__ = start; i__ <= i__2; ++i__) {
125 phi[r__ + phi_dim1] += speech[i__ - 1] * speech[i__ - r__];
126 }
127 }
128/* Load last element of vector PSI */
129 psi[*order] = 0.f;
130 i__1 = *awinf;
131 for (i__ = start; i__ <= i__1; ++i__) {
133 }
134/* End correct to get additional columns of PHI */
135 i__1 = *order;
136 for (r__ = 2; r__ <= i__1; ++r__) {
137 i__2 = r__;
138 for (c__ = 2; c__ <= i__2; ++c__) {
139 phi[r__ + c__ * phi_dim1] = phi[r__ - 1 + (c__ - 1) * phi_dim1] -
140 speech[*awinf + 1 - r__] * speech[*awinf + 1 - c__] +
141 speech[start - r__] * speech[start - c__];
142 }
143 }
144/* End correct to get additional elements of PSI */
145 i__1 = *order - 1;
146 for (c__ = 1; c__ <= i__1; ++c__) {
147 psi[c__] = phi[c__ + 1 + phi_dim1] - speech[start - 1] * speech[start
148 - 1 - c__] + speech[*awinf] * speech[*awinf - c__];
149 }
150/* Copy lower triangular section into upper (why bother?) */
151/* I'm commenting this out, since the upper triangular half of PHI
152*/
153/* is never used by later code, unless a sufficiently high level of
154*/
155/* tracing is turned on. */
156/* DO R = 1,ORDER */
157/* DO C = 1,R-1 */
158/* PHI(C,R) = PHI(R,C) */
159/* END DO */
160/* END DO */
161 return 0;
162} /* mload_ */
References order.
Referenced by analys_().
◆ onset_()
|
extern |
Definition at line 129 of file onset.c.
132{
133 /* Initialized data */
134
135 real *n;
136 real *d__;
137 real *l2buf;
138 real *l2sum1;
139 integer *l2ptr1;
140 integer *l2ptr2;
141 logical *hyst;
142
143 /* System generated locals */
144 integer pebuf_offset, i__1;
145 real r__1;
146
147 /* Builtin functions */
149
150 /* Local variables */
151 integer i__;
152 integer *lasti;
153 real l2sum2;
154 real *fpc;
155
156/* Arguments */
157/* $Log$
158 * Revision 1.15 2004/06/26 03:50:14 markster
159 * Merge source cleanups (bug #1911)
160 *
161 * Revision 1.14 2003/02/12 13:59:15 matteo
162 * mer feb 12 14:56:57 CET 2003
163 *
164 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
165 * mer feb 12 14:56:57 CET 2003
166 *
167 * Revision 1.2 2000/01/05 08:20:39 markster
168 * Some OSS fixes and a few lpc changes to make it actually work
169 *
170 * Revision 1.2 1996/08/20 20:37:55 jaf
171 * Removed all static local variables that were SAVE'd in the Fortran
172 * code, and put them in struct lpc10_encoder_state that is passed as an
173 * argument.
174 *
175 * Removed init function, since all initialization is now done in
176 * init_lpc10_encoder_state().
177 *
178 * Revision 1.1 1996/08/19 22:31:18 jaf
179 * Initial revision
180 * */
181/* Revision 1.3 1996/03/29 22:03:47 jaf */
182/* Removed definitions for any constants that were no longer used. */
183
184/* Revision 1.2 1996/03/26 19:34:33 jaf */
185/* Added comments indicating which constants are not needed in an */
186/* application that uses the LPC-10 coder. */
187
188/* Revision 1.1 1996/02/07 14:43:51 jaf */
189/* Initial revision */
190
191/* LPC Configuration parameters: */
192/* Frame size, Prediction order, Pitch period */
193/* Parameters/constants */
194/* Parameters for onset detection algorithm: */
195/* L2 Threshold for filtered slope of FPC (function of L2WID!) */
196/* L2LAG Lag due to both filters which compute filtered slope of FPC */
197/* L2WID Width of the filter which computes the slope of FPC */
198/* OSHYST The number of samples of slope(FPC) which must be below */
199/* the threshold before a new onset may be declared. */
200/* Local variables that need not be saved */
201/* Local state */
202/* Variables */
203/* N, D Numerator and denominator of prediction filters */
204/* FPC Current prediction coefs */
205/* L2BUF, L2SUM1, L2SUM2 State of slope filter */
206/* The only "significant" change I've made is to change L2SUM2 out
207*/
208/* of the list of local variables that need to be saved, since it */
209/* didn't need to be. */
210/* L2SUM1 need not be, but avoiding saving it would require a small
211*/
212/* change to the body of the code. See comments below for an */
213/* example of how the code could be changed to avoid saving L2SUM1.
214*/
215/* FPC and LASTI are saved from one invocation to the next, but */
216/* they are not given initial values. This is acceptable, because
217*/
218/* FPC will be assigned a value the first time that this function */
219/* is called after D is initialized to 1, since the formula to */
220/* change D will not change it to 0 in one step, and the IF (D */
221/* .NE. 0) statement will execute its THEN part, initializing FPC.
222*/
223
224/* LASTI's value will not be used until HYST is .TRUE., and */
225/* whenever HYST is changed from its initial value of .FALSE., */
226/* LASTI is assigned a value. */
227/* In a C version of this coder, it would be nice if all of these */
228/* saved things, in this and all other subroutines, could be stored
229*/
230/* in a single struct lpc10_coder_state_t, initialized with a call
231*/
232/* to a function like lpc10_init(&lpc10_coder_state). In this way,
233*/
234/* a program that used these functions could conveniently alternate
235*/
236/* coding more than one distinct audio stream. */
237
238 n = &(st->n);
239 d__ = &(st->d__);
240 fpc = &(st->fpc);
241 l2buf = &(st->l2buf[0]);
242 l2sum1 = &(st->l2sum1);
243 l2ptr1 = &(st->l2ptr1);
244 l2ptr2 = &(st->l2ptr2);
245 lasti = &(st->lasti);
246 hyst = &(st->hyst);
247
248 /* Parameter adjustments */
249 if (osbuf) {
250 --osbuf;
251 }
252 if (pebuf) {
253 pebuf_offset = *sbufl;
254 pebuf -= pebuf_offset;
255 }
256
257 /* Function Body */
258
259/* The following line subtracted a hard-coded "180" from LASTI, */
260/* instead of using a variable like LFRAME or a constant like */
261/* MAXFRM. I changed it to LFRAME, for "generality". */
262 if (*hyst) {
263 *lasti -= *lframe;
264 }
265 i__1 = *sbufh;
267/* Compute FPC; Use old FPC on divide by zero; Clamp FPC to +/- 1.
268*/
269 *n = (pebuf[i__] * pebuf[i__ - 1] + (*n) * 63.f) / 64.f;
270/* Computing 2nd power */
271 r__1 = pebuf[i__ - 1];
272 *d__ = (r__1 * r__1 + (*d__) * 63.f) / 64.f;
273 if ((*d__) != 0.f) {
276 } else {
277 *fpc = (*n) / (*d__);
278 }
279 }
280/* Filter FPC */
281/* In order to allow L2SUM1 not to be saved from one invocation
282of */
283/* this subroutine to the next, one could change the sequence of
284 */
285/* assignments below, up to the IF statement, to the following.
286 In */
287/* addition, the initial value of L2PTR2 should be changed to */
288/* L2WID/2 instead of L2WID/2+1. */
289
290/* L2SUM1 = L2BUF(L2PTR2) */
291/* L2PTR2 = MOD(L2PTR2,L2WID)+1 */
292/* L2SUM1 = L2SUM1 - L2BUF(L2PTR2) + FPC */
293/* L2BUF(L2PTR2) = L2SUM1 */
294
295/* * The following lines didn't change from the original: */
296/* L2SUM2 = L2BUF(L2PTR1) */
297/* L2BUF(L2PTR1) = FPC */
298/* L2PTR1 = MOD(L2PTR1,L2WID)+1 */
299
300 l2sum2 = l2buf[*l2ptr1 - 1];
301 *l2sum1 = *l2sum1 - l2buf[*l2ptr2 - 1] + *fpc;
302 l2buf[*l2ptr2 - 1] = *l2sum1;
303 l2buf[*l2ptr1 - 1] = *fpc;
304 *l2ptr1 = *l2ptr1 % 16 + 1;
305 *l2ptr2 = *l2ptr2 % 16 + 1;
307 if (! (*hyst)) {
308/* Ignore if buffer full */
309 if (*osptr <= *oslen) {
310 osbuf[*osptr] = i__ - 9;
311 ++(*osptr);
312 }
313 *hyst = TRUE_;
314 }
315 *lasti = i__;
316/* After one onset detection, at least OSHYST sample times m
317ust go */
318/* by before another is allowed to occur. */
319 } else if ((*hyst) && i__ - *lasti >= 10) {
320 *hyst = FALSE_;
321 }
322 }
323 return 0;
324} /* onset_ */
References abs, c_b2, lpc10_encoder_state::d__, FALSE_, lpc10_encoder_state::fpc, lpc10_encoder_state::hyst, lpc10_encoder_state::l2buf, lpc10_encoder_state::l2ptr1, lpc10_encoder_state::l2ptr2, lpc10_encoder_state::l2sum1, lpc10_encoder_state::lasti, lframe, lpc10_encoder_state::n, r_sign(), and TRUE_.
Referenced by analys_().
◆ pitsyn_()
|
extern |
Definition at line 132 of file pitsyn.c.
136{
137 /* Initialized data */
138
139 real *rmso;
141
142 /* System generated locals */
143 integer rci_dim1 = 0, rci_offset, i__1, i__2;
144 real r__1;
145
146 /* Builtin functions */
148
149 /* Local variables */
150 real alrn, alro, yarc[10], prop;
151 integer i__, j, vflag, jused, lsamp;
152 integer *jsamp;
153 real slope;
154 integer *ipito;
155 real uvpit;
156 integer ip, nl, ivoice;
157 integer *ivoico;
158 integer istart;
159 real *rco;
160 real xxy;
161
162/* Arguments */
163/* $Log$
164 * Revision 1.16 2004/06/26 03:50:14 markster
165 * Merge source cleanups (bug #1911)
166 *
167 * Revision 1.15 2003/11/23 22:14:32 markster
168 * Various warning cleanups
169 *
170 * Revision 1.14 2003/02/12 13:59:15 matteo
171 * mer feb 12 14:56:57 CET 2003
172 *
173 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
174 * mer feb 12 14:56:57 CET 2003
175 *
176 * Revision 1.2 2000/01/05 08:20:39 markster
177 * Some OSS fixes and a few lpc changes to make it actually work
178 *
179 * Revision 1.2 1996/08/20 20:40:12 jaf
180 * Removed all static local variables that were SAVE'd in the Fortran
181 * code, and put them in struct lpc10_decoder_state that is passed as an
182 * argument.
183 *
184 * Removed init function, since all initialization is now done in
185 * init_lpc10_decoder_state().
186 *
187 * Revision 1.1 1996/08/19 22:31:12 jaf
188 * Initial revision
189 * */
190/* Revision 1.3 1996/03/29 22:03:47 jaf */
191/* Removed definitions for any constants that were no longer used. */
192
193/* Revision 1.2 1996/03/26 19:34:33 jaf */
194/* Added comments indicating which constants are not needed in an */
195/* application that uses the LPC-10 coder. */
196
197/* Revision 1.1 1996/02/07 14:43:51 jaf */
198/* Initial revision */
199
200/* LPC Configuration parameters: */
201/* Frame size, Prediction order, Pitch period */
202/* Local variables that need not be saved */
203/* LSAMP is initialized in the IF (FIRST) THEN clause, but it is */
204/* not used the first time through, and it is given a value before
205*/
206/* use whenever FIRST is .FALSE., so it appears unnecessary to */
207/* assign it a value when FIRST is .TRUE. */
208/* Local state */
209/* FIRST - .TRUE. only on first call to PITSYN. */
210/* IVOICO - Previous VOICE(2) value. */
211/* IPITO - Previous PITCH value. */
212/* RMSO - Previous RMS value. */
213/* RCO - Previous RC values. */
214
215/* JSAMP - If this routine is called N times with identical values of */
216/* LFRAME, then the total length of all pitch periods returned */
217/* is always N*LFRAME-JSAMP, and JSAMP is always in the range 0
218*/
219/* to MAXPIT-1 (see below for why this is so). Thus JSAMP is */
220/* the number of samples "left over" from the previous call to */
221/* PITSYN, that haven't been "used" in a pitch period returned */
222/* from this subroutine. Every time this subroutine is called,
223*/
224/* it returns pitch periods with a total length of at most */
225/* LFRAME+JSAMP. */
226
227/* IVOICO, IPITO, RCO, and JSAMP need not be assigned an initial value */
228/* with a DATA statement, because they are always initialized on the */
229/* first call to PITSYN. */
230
231/* FIRST and RMSO should be initialized with DATA statements, because */
232/* even on the first call, they are used before being initialized. */
233 /* Parameter adjustments */
234 if (rc) {
235 --rc;
236 }
237 if (rci) {
238 rci_dim1 = *order;
239 rci_offset = rci_dim1 + 1;
240 rci -= rci_offset;
241 }
242 if (voice) {
243 --voice;
244 }
245 if (ivuv) {
246 --ivuv;
247 }
248 if (ipiti) {
249 --ipiti;
250 }
251 if (rmsi) {
252 --rmsi;
253 }
254
255 /* Function Body */
256 ivoico = &(st->ivoico);
257 ipito = &(st->ipito);
258 rmso = &(st->rmso);
259 rco = &(st->rco[0]);
260 jsamp = &(st->jsamp);
262
263 if (*rms < 1.f) {
264 *rms = 1.f;
265 }
266 if (*rmso < 1.f) {
267 *rmso = 1.f;
268 }
269 uvpit = 0.f;
270 *ratio = *rms / (*rmso + 8.f);
272 lsamp = 0;
273 ivoice = voice[2];
274 if (ivoice == 0) {
275 *pitch = *lframe / 4;
276 }
277 *nout = *lframe / *pitch;
278 *jsamp = *lframe - *nout * *pitch;
279
280/* SYNTHS only calls this subroutine with PITCH in the range
28120 */
282/* to 156. LFRAME = MAXFRM = 180, so NOUT is somewhere in th
283e */
284/* range 1 to 9. */
285
286/* JSAMP is "LFRAME mod PITCH", so it is in the range 0 to */
287/* (PITCH-1), or 0 to MAXPIT-1=155, after the first call. */
288
289 i__1 = *nout;
290 for (i__ = 1; i__ <= i__1; ++i__) {
291 i__2 = *order;
292 for (j = 1; j <= i__2; ++j) {
293 rci[j + i__ * rci_dim1] = rc[j];
294 }
295 ivuv[i__] = ivoice;
296 ipiti[i__] = *pitch;
297 rmsi[i__] = *rms;
298 }
300 } else {
301 vflag = 0;
302 lsamp = *lframe + *jsamp;
303 slope = (*pitch - *ipito) / (real) lsamp;
304 *nout = 0;
305 jused = 0;
306 istart = 1;
307 if (voice[1] == *ivoico && voice[2] == voice[1]) {
308 if (voice[2] == 0) {
309/* SSUV - - 0 , 0 , 0 */
310 *pitch = *lframe / 4;
311 *ipito = *pitch;
312 if (*ratio > 8.f) {
313 *rmso = *rms;
314 }
315 }
316/* SSVC - - 1 , 1 , 1 */
317 slope = (*pitch - *ipito) / (real) lsamp;
318 ivoice = voice[2];
319 } else {
320 if (*ivoico != 1) {
321 if (*ivoico == voice[1]) {
322/* UV2VC2 - - 0 , 0 , 1 */
323 nl = lsamp - *lframe / 4;
324 } else {
325/* UV2VC1 - - 0 , 1 , 1 */
326 nl = lsamp - *lframe * 3 / 4;
327 }
328 ipiti[1] = nl / 2;
329 ipiti[2] = nl - ipiti[1];
330 ivuv[1] = 0;
331 ivuv[2] = 0;
332 rmsi[1] = *rmso;
333 rmsi[2] = *rmso;
334 i__1 = *order;
335 for (i__ = 1; i__ <= i__1; ++i__) {
336 rci[i__ + rci_dim1] = rco[i__ - 1];
337 rci[i__ + (rci_dim1 << 1)] = rco[i__ - 1];
338 rco[i__ - 1] = rc[i__];
339 }
340 slope = 0.f;
341 *nout = 2;
342 *ipito = *pitch;
343 jused = nl;
344 istart = nl + 1;
345 ivoice = 1;
346 } else {
347 if (*ivoico != voice[1]) {
348/* VC2UV1 - - 1 , 0 , 0 */
349 lsamp = *lframe / 4 + *jsamp;
350 } else {
351/* VC2UV2 - - 1 , 1 , 0 */
352 lsamp = *lframe * 3 / 4 + *jsamp;
353 }
354 i__1 = *order;
355 for (i__ = 1; i__ <= i__1; ++i__) {
356 yarc[i__ - 1] = rc[i__];
357 rc[i__] = rco[i__ - 1];
358 }
359 ivoice = 1;
360 slope = 0.f;
361 vflag = 1;
362 }
363 }
364/* Here is the value of most variables that are used below, depending
365on */
366/* the values of IVOICO, VOICE(1), and VOICE(2). VOICE(1) and VOICE(2
367) */
368/* are input arguments, and IVOICO is the value of VOICE(2) on the */
369/* previous call (see notes for the IF (NOUT .NE. 0) statement near th
370e */
371/* end). Each of these three values is either 0 or 1. These three */
372/* values below are given as 3-bit long strings, in the order IVOICO,
373*/
374/* VOICE(1), and VOICE(2). It appears that the code above assumes tha
375t */
376/* the bit sequences 010 and 101 never occur, but I wonder whether a
377*/
378/* large enough number of bit errors in the channel could cause such a
379 */
380/* thing to happen, and if so, could that cause NOUT to ever go over 1
3811? */
382
383/* Note that all of the 180 values in the table are really LFRAME, but
384 */
385/* 180 has fewer characters, and it makes the table a little more */
386/* concrete. If LFRAME is ever changed, keep this in mind. Similarly
387, */
388/* 135's are 3*LFRAME/4, and 45's are LFRAME/4. If LFRAME is not a */
389/* multiple of 4, then the 135 for NL-JSAMP is actually LFRAME-LFRAME/
3904, */
391/* and the 45 for NL-JSAMP is actually LFRAME-3*LFRAME/4. */
392
393/* Note that LSAMP-JSAMP is given as the variable. This was just for
394*/
395/* brevity, to avoid adding "+JSAMP" to all of the column entries. */
396/* Similarly for NL-JSAMP. */
397
398/* Variable | 000 001 011,010 111 110 100,101 */
399/* ------------+-------------------------------------------------- */
400/* ISTART | 1 NL+1 NL+1 1 1 1 */
401/* LSAMP-JSAMP | 180 180 180 180 135 45 */
402/* IPITO | 45 PITCH PITCH oldPITCH oldPITCH oldPITCH */
403/* SLOPE | 0 0 0 seebelow 0 0 */
404/* JUSED | 0 NL NL 0 0 0 */
405/* PITCH | 45 PITCH PITCH PITCH PITCH PITCH */
406/* NL-JSAMP | -- 135 45 -- -- -- */
407/* VFLAG | 0 0 0 0 1 1 */
408/* NOUT | 0 2 2 0 0 0 */
409/* IVOICE | 0 1 1 1 1 1 */
410
411/* while_loop | once once once once twice twice */
412
413/* ISTART | -- -- -- -- JUSED+1 JUSED+1 */
414/* LSAMP-JSAMP | -- -- -- -- 180 180 */
415/* IPITO | -- -- -- -- oldPITCH oldPITCH */
416/* SLOPE | -- -- -- -- 0 0 */
417/* JUSED | -- -- -- -- ?? ?? */
418/* PITCH | -- -- -- -- PITCH PITCH */
419/* NL-JSAMP | -- -- -- -- -- -- */
420/* VFLAG | -- -- -- -- 0 0 */
421/* NOUT | -- -- -- -- ?? ?? */
422/* IVOICE | -- -- -- -- 0 0 */
423
424
425/* UVPIT is always 0.0 on the first pass through the DO WHILE (.TRUE.)
426 */
427/* loop below. */
428
429/* The only possible non-0 value of SLOPE (in column 111) is */
430/* (PITCH-IPITO)/FLOAT(LSAMP) */
431
432/* Column 101 is identical to 100. Any good properties we can prove
433*/
434/* for 100 will also hold for 101. Similarly for 010 and 011. */
435
436/* SYNTHS calls this subroutine with PITCH restricted to the range 20
437to */
438/* 156. IPITO is similarly restricted to this range, after the first
439*/
440/* call. IP below is also restricted to this range, given the */
441/* definitions of IPITO, SLOPE, UVPIT, and that I is in the range ISTA
442RT */
443/* to LSAMP. */
444
446
447/* JUSED is the total length of all pitch periods curr
448ently */
449/* in the output arrays, in samples. */
450
451/* An invariant of the DO I = ISTART,LSAMP loop below,
452 under */
453/* the condition that IP is always in the range 1 thro
454ugh */
455/* MAXPIT, is: */
456
457/* (I - MAXPIT) .LE. JUSED .LE. (I-1) */
458
459/* Note that the final value of I is LSAMP+1, so that
460after */
461/* the DO loop is complete, we know: */
462
463/* (LSAMP - MAXPIT + 1) .LE. JUSED .LE. LSAMP */
464
465 i__1 = lsamp;
466 for (i__ = istart; i__ <= i__1; ++i__) {
467 r__1 = *ipito + slope * i__;
468 ip = (integer)(r__1 + .5f);
469 if (uvpit != 0.f) {
470 ip = (integer)uvpit;
471 }
472 if (ip <= i__ - jused) {
473 ++(*nout);
474
475/* The following check is no longer nece
476ssary, now that */
477/* we can prove that NOUT will never go
478over 16. */
479
480/* IF (NOUT .GT. 16) STOP 'PITSYN: too many epochs'
481*/
482
483 ipiti[*nout] = ip;
484 *pitch = ip;
485 ivuv[*nout] = ivoice;
486 jused += ip;
487 prop = (jused - ip / 2) / (real) lsamp;
488 i__2 = *order;
489 for (j = 1; j <= i__2; ++j) {
490 alro = (real)log((rco[j - 1] + 1) / (1 - rco[j - 1]));
491 alrn = (real)log((rc[j] + 1) / (1 - rc[j]));
492 xxy = alro + prop * (alrn - alro);
493 xxy = (real)exp(xxy);
494 rci[j + *nout * rci_dim1] = (xxy - 1) / (xxy + 1);
495 }
496 rmsi[*nout] = (real)(log(*rmso) + prop * (log(*rms) - log(*rmso)));
497 rmsi[*nout] = (real)exp(rmsi[*nout]);
498 }
499 }
500 if (vflag != 1) {
501 goto L100;
502 }
503
504/* I want to prove what range UVPIT must lie in after
505the */
506/* assignments to it below. To do this, I must determ
507ine */
508/* what range (LSAMP-ISTART) must lie in, after the */
509/* assignments to ISTART and LSAMP below. */
510
511/* Let oldLSAMP be the value of LSAMP at this point in
512 the */
513/* execution. This is 135+JSAMP in state 110, or 45+J
514SAMP in */
515/* states 100 or 101. */
516
517/* Given the loop invariant on JUSED above, we know th
518at: */
519
520/* (oldLSAMP - MAXPIT + 1) .LE. JUSED .LE. oldLSAMP */
521
522/* ISTART is one more than this. */
523
524/* Let newLSAMP be the value assigned to LSAMP below.
525 This */
526/* is 180+JSAMP. Thus (newLSAMP-oldLSAMP) is either 4
5275 or */
528/* 135, depending on the state. */
529
530/* Thus, the range of newLSAMP-ISTART is: */
531
532/* (newLSAMP-(oldLSAMP+1)) .LE. newLSAMP-ISTART */
533/* .LE. (newLSAMP-(oldLSAMP - MAXPIT + 2)) */
534
535/* or: */
536
537/* 46 .LE. newLSAMP-ISTART .LE. 133+MAXPIT .EQ. 289 */
538
539/* Therefore, UVPIT is in the range 23 to 144 after th
540e first */
541/* assignment to UVPIT below, and after the conditional
542l */
543/* assignment, it is in the range 23 to 90. */
544
545/* The important thing is that it is in the range 20 t
546o 156, */
547/* so that in the loop above, IP is always in this ran
548ge. */
549
550 vflag = 0;
551 istart = jused + 1;
552 lsamp = *lframe + *jsamp;
553 slope = 0.f;
554 ivoice = 0;
555 uvpit = (real) ((lsamp - istart) / 2);
556 if (uvpit > 90.f) {
557 uvpit /= 2;
558 }
559 *rmso = *rms;
560 i__1 = *order;
561 for (i__ = 1; i__ <= i__1; ++i__) {
562 rc[i__] = yarc[i__ - 1];
563 rco[i__ - 1] = yarc[i__ - 1];
564 }
565 }
566L100:
567 *jsamp = lsamp - jused;
568 }
569/* Given that the maximum pitch period MAXPIT .LT. LFRAME (this is
570*/
571/* currently true on every call, since SYNTHS always sets */
572/* LFRAME=180), NOUT will always be .GE. 1 at this point. */
573 if (*nout != 0) {
574 *ivoico = voice[2];
575 *ipito = *pitch;
576 *rmso = *rms;
577 i__1 = *order;
578 for (i__ = 1; i__ <= i__1; ++i__) {
579 rco[i__ - 1] = rc[i__];
580 }
581 }
582 return 0;
583} /* pitsyn_ */
References FALSE_, first, lpc10_decoder_state::first_pitsyn, lpc10_decoder_state::ipito, lpc10_decoder_state::ivoico, lpc10_decoder_state::jsamp, lframe, order, lpc10_decoder_state::rco, lpc10_decoder_state::rmso, and TRUE_.
Referenced by synths_().
◆ placea_()
|
extern |
Definition at line 116 of file placea.c.
119{
120 /* System generated locals */
121 real r__1;
122
123 /* Builtin functions */
125
126 /* Local variables */
127 logical allv, winv;
128 integer i__, j, k, l, hrange;
129 logical ephase;
130 integer lrange;
131
132/* Arguments */
133/* Local variables that need not be saved */
134 /* Parameter adjustments */
135 ewin -= 3;
136 awin -= 3;
137 vwin -= 3;
138 --voibuf;
139
140 /* Function Body */
141 lrange = (*af - 2) * *lframe + 1;
142 hrange = *af * *lframe;
143/* Place the Analysis window based on the voicing window */
144/* placement, onsets, tentative voicing decision, and pitch. */
145
146/* Case 1: Sustained Voiced Speech */
147/* If the five most recent voicing decisions are */
148/* voiced, then the window is placed phase-synchronously with the */
149/* previous window, as close to the present voicing window if possible.
150*/
151/* If onsets bound the voicing window, then preference is given to */
152/* a phase-synchronous placement which does not overlap these onsets. */
153
154/* Case 2: Voiced Transition */
155/* If at least one voicing decision in AF is voiced, and there are no
156*/
157/* onsets, then the window is placed as in case 1. */
158
159/* Case 3: Unvoiced Speech or Onsets */
160/* If both voicing decisions in AF are unvoiced, or there are onsets, */
161/* then the window is placed coincident with the voicing window. */
162
163/* Note: During phase-synchronous placement of windows, the length */
164/* is not altered from MAXWIN, since this would defeat the purpose */
165/* of phase-synchronous placement. */
166/* Check for case 1 and case 2 */
167 allv = voibuf[((*af - 2) << 1) + 2] == 1;
168 allv = allv && voibuf[((*af - 1) << 1) + 1] == 1;
169 allv = allv && voibuf[((*af - 1) << 1) + 2] == 1;
170 allv = allv && voibuf[(*af << 1) + 1] == 1;
171 allv = allv && voibuf[(*af << 1) + 2] == 1;
172 winv = voibuf[(*af << 1) + 1] == 1 || voibuf[(*af << 1) + 2] == 1;
173 if (allv || (winv && *obound == 0)) {
174/* APHASE: Phase synchronous window placement. */
175/* Get minimum lower index of the window. */
176 i__ = (lrange + *ipitch - 1 - awin[((*af - 1) << 1) + 1]) / *ipitch;
177 i__ *= *ipitch;
178 i__ += awin[((*af - 1) << 1) + 1];
179/* L = the actual length of this frame's analysis window. */
180 l = *maxwin;
181/* Calculate the location where a perfectly centered window would star
182t. */
183 k = (vwin[(*af << 1) + 1] + vwin[(*af << 1) + 2] + 1 - l) / 2;
184/* Choose the actual location to be the pitch multiple closest to this
185. */
186 r__1 = (real) (k - i__) / *ipitch;
187 awin[(*af << 1) + 1] = i__ + i_nint(&r__1) * *ipitch;
188 awin[(*af << 1) + 2] = awin[(*af << 1) + 1] + l - 1;
189/* If there is an onset bounding the right of the voicing window and t
190he */
191/* analysis window overlaps that, then move the analysis window backwa
192rd */
193/* to avoid this onset. */
194 if (*obound >= 2 && awin[(*af << 1) + 2] > vwin[(*af << 1) + 2]) {
195 awin[(*af << 1) + 1] -= *ipitch;
196 awin[(*af << 1) + 2] -= *ipitch;
197 }
198/* Similarly for the left of the voicing window. */
199 if ((*obound == 1 || *obound == 3) && awin[(*af << 1) + 1] < vwin[(*
200 af << 1) + 1]) {
201 awin[(*af << 1) + 1] += *ipitch;
202 awin[(*af << 1) + 2] += *ipitch;
203 }
204/* If this placement puts the analysis window above HRANGE, then */
205/* move it backward an integer number of pitch periods. */
206 while(awin[(*af << 1) + 2] > hrange) {
207 awin[(*af << 1) + 1] -= *ipitch;
208 awin[(*af << 1) + 2] -= *ipitch;
209 }
210/* Similarly if the placement puts the analysis window below LRANGE.
211*/
212 while(awin[(*af << 1) + 1] < lrange) {
213 awin[(*af << 1) + 1] += *ipitch;
214 awin[(*af << 1) + 2] += *ipitch;
215 }
216/* Make Energy window be phase-synchronous. */
217 ephase = TRUE_;
218/* Case 3 */
219 } else {
220 awin[(*af << 1) + 1] = vwin[(*af << 1) + 1];
221 awin[(*af << 1) + 2] = vwin[(*af << 1) + 2];
222 ephase = FALSE_;
223 }
224/* RMS is computed over an integer number of pitch periods in the analysis
225 */
226/*window. When it is not placed phase-synchronously, it is placed as clos
227e*/
228/* as possible to onsets. */
229 j = (awin[(*af << 1) + 2] - awin[(*af << 1) + 1] + 1) / *ipitch * *ipitch;
230 if (j == 0 || ! winv) {
231 ewin[(*af << 1) + 1] = vwin[(*af << 1) + 1];
232 ewin[(*af << 1) + 2] = vwin[(*af << 1) + 2];
233 } else if (! ephase && *obound == 2) {
234 ewin[(*af << 1) + 1] = awin[(*af << 1) + 2] - j + 1;
235 ewin[(*af << 1) + 2] = awin[(*af << 1) + 2];
236 } else {
237 ewin[(*af << 1) + 1] = awin[(*af << 1) + 1];
238 ewin[(*af << 1) + 2] = awin[(*af << 1) + 1] + j - 1;
239 }
240 return 0;
241} /* placea_ */
References FALSE_, i_nint(), lframe, and TRUE_.
Referenced by analys_().
◆ placev_()
|
extern |
Definition at line 112 of file placev.c.
115{
116 /* System generated locals */
117 integer i__1, i__2;
118
119 /* Local variables */
120 logical crit;
121 integer i__, q, osptr1, hrange, lrange;
122
123/* Arguments */
124/* Local variables that need not be saved */
125/* Variables */
126/* LRANGE, HRANGE Range in which window is placed */
127/* OSPTR1 OSPTR excluding samples in 3F */
128/* Local state */
129/* None */
130/* Voicing Window Placement */
131
132/* __________________ __________________ ______________ */
133/* | | | */
134/* | 1F | 2F | 3F ... */
135/* |__________________|__________________|______________ */
136
137/* Previous | */
138/* Window | */
139/* ...________| */
140
141/* | | */
142/* ------>| This window's placement range |<------ */
143/* | | */
144
145/* There are three cases. Note that these are different from those */
146/* given in the LPC-10e phase 1 report. */
147
148/* 1. If there are no onsets in this range, then the voicing window */
149/* is centered in the pitch window. If such a placement is not within
150*/
151/* the window's placement range, then the window is placed in the left-
152*/
153/* most portion of the placement range. Its length is always MAXWIN. */
154
155/* 2. If the first onset is in 2F and there is sufficient room to place
156 */
157/* the window immediately before this onset, then the window is placed
158*/
159/* there, and its length is set to the maximum possible under these */
160/* constraints. */
161
162/* "Critical Region Exception": If there is another onset in 2F */
163/* such that a window can be placed between the two onsets, the */
164/* window is placed there (ie, as in case 3). */
165
166/* 3. Otherwise, the window is placed immediately after the onset. The
167 */
168/* window's length */
169/* is the longest length that can fit in the range under these constraint
170s,*/
171/* except that the window may be shortened even further to avoid overlapp
172ing*/
173/* other onsets in the placement range. In any case, the window's length
174*/
175/* is at least MINWIN. */
176
177/* Note that the values of MINWIN and LFRAME must be chosen such */
178/* that case 2 = false implies case 3 = true. This means that */
179/* MINWIN <= LFRAME/2. If this were not the case, then a fourth case */
180/* would have to be added for when the window cannot fit either before
181*/
182/* or after the onset. */
183
184/* Note also that onsets which weren't in 2F last time may be in 1F this
185 */
186/* time, due to the filter delays in computing onsets. The result is tha
187t*/
188/* occasionally a voicing window will overlap that onset. The only way
189*/
190/* to circumvent this problem is to add more delay in processing input
191*/
192/* speech. In the trade-off between delay and window-placement, window
193*/
194/* placement lost. */
195/* Compute the placement range */
196 /* Parameter adjustments */
197 --osbuf;
198 vwin -= 3;
199
200 /* Function Body */
201/* Computing MAX */
202 i__1 = vwin[((*af - 1) << 1) + 2] + 1, i__2 = (*af - 2) * *lframe + 1;
203 lrange = max(i__1,i__2);
204 hrange = *af * *lframe;
205/* Compute OSPTR1, so the following code only looks at relevant onsets. */
206 for (osptr1 = *osptr - 1; osptr1 >= 1; --osptr1) {
207 if (osbuf[osptr1] <= hrange) {
208 goto L90;
209 }
210 }
211L90:
212 ++osptr1;
213/* Check for case 1 first (fast case): */
214 if (osptr1 <= 1 || osbuf[osptr1 - 1] < lrange) {
215/* Computing MAX */
216 i__1 = vwin[((*af - 1) << 1) + 2] + 1;
217 vwin[(*af << 1) + 1] = max(i__1,*dvwinl);
218 vwin[(*af << 1) + 2] = vwin[(*af << 1) + 1] + *maxwin - 1;
219 *obound = 0;
220 } else {
221/* Search backward in OSBUF for first onset in range. */
222/* This code relies on the above check being performed first. */
223 for (q = osptr1 - 1; q >= 1; --q) {
224 if (osbuf[q] < lrange) {
225 goto L100;
226 }
227 }
228L100:
229 ++q;
230/* Check for case 2 (placement before onset): */
231/* Check for critical region exception: */
232 i__1 = osptr1 - 1;
233 for (i__ = q + 1; i__ <= i__1; ++i__) {
234 if (osbuf[i__] - osbuf[q] >= *minwin) {
235 crit = TRUE_;
236 goto L105;
237 }
238 }
239 crit = FALSE_;
240L105:
241/* Computing MAX */
242 i__1 = (*af - 1) * *lframe, i__2 = lrange + *minwin - 1;
244 vwin[(*af << 1) + 2] = osbuf[q] - 1;
245/* Computing MAX */
246 i__1 = lrange, i__2 = vwin[(*af << 1) + 2] - *maxwin + 1;
247 vwin[(*af << 1) + 1] = max(i__1,i__2);
248 *obound = 2;
249/* Case 3 (placement after onset) */
250 } else {
251 vwin[(*af << 1) + 1] = osbuf[q];
252L110:
253 ++q;
254 if (q >= osptr1) {
255 goto L120;
256 }
257 if (osbuf[q] > vwin[(*af << 1) + 1] + *maxwin) {
258 goto L120;
259 }
260 if (osbuf[q] < vwin[(*af << 1) + 1] + *minwin) {
261 goto L110;
262 }
263 vwin[(*af << 1) + 2] = osbuf[q] - 1;
264 *obound = 3;
265 return 0;
266L120:
267/* Computing MIN */
268 i__1 = vwin[(*af << 1) + 1] + *maxwin - 1;
269 vwin[(*af << 1) + 2] = min(i__1,hrange);
270 *obound = 1;
271 }
272 }
273 return 0;
274} /* placev_ */
References FALSE_, lframe, max, min, and TRUE_.
Referenced by analys_().
◆ pow_ii()
Definition at line 30 of file f2clib.c.
32{
33 integer pow, x, n;
34 unsigned long u;
35
36 x = *ap;
37 n = *bp;
38
39 if (n <= 0) {
40 if (n == 0 || x == 1)
41 return 1;
42 if (x != -1)
43 return x == 0 ? 0 : 1/x;
44 n = -n;
45 }
46 u = n;
47 for(pow = 1; ; )
48 {
49 if(u & 01)
50 pow *= x;
51 if(u >>= 1)
52 x *= x;
53 else
54 break;
55 }
56 return(pow);
57 }
◆ preemp_()
Definition at line 82 of file preemp.c.
84{
85 /* System generated locals */
86 integer i__1;
87
88 /* Local variables */
89 real temp;
90 integer i__;
91
92/* Arguments */
93/* Local variables */
94
95/* None of these need to have their values saved from one */
96/* invocation to the next. */
97
98/* Logically, this subroutine computes the output sequence */
99/* pebuf(1:nsamp) defined by: */
100
101/* pebuf(i) = inbuf(i) - coef * inbuf(i-1) */
102
103/* where inbuf(0) is defined by the value of z given as input to */
104/* this subroutine. */
105
106/* What is this filter's frequency response and phase response? */
107
108/* Why is this filter applied to the speech? */
109
110/* Could it be more efficient to apply multiple filters */
111/* simultaneously, by combining them into one equivalent filter? */
112
113/* Are there ever cases when "factoring" one high-order filter into
114*/
115/* multiple smaller-order filter actually reduces the number of */
116/* arithmetic operations needed to perform them? */
117/* When I first read this subroutine, I didn't understand why the */
118/* variable temp was used. It seemed that the statements in the do
119*/
120/* loop could be replaced with the following: */
121
122/* pebuf(i) = inbuf(i) - coef * z */
123/* z = inbuf(i) */
124
125/* The reason for temp is so that even if pebuf and inbuf are the */
126/* same arrays in memory (i.e., they are aliased), then this */
127/* subroutine will still work correctly. I didn't realize this */
128/* until seeing the comment after PEBUF above that says "(can be */
129/* equal to INBUF)". */
130 /* Parameter adjustments */
131 --pebuf;
132 --inbuf;
133
134 /* Function Body */
135 i__1 = *nsamp;
136 for (i__ = 1; i__ <= i__1; ++i__) {
137 temp = inbuf[i__] - *coef * *z__;
138 *z__ = inbuf[i__];
139 pebuf[i__] = temp;
140/* L10: */
141 }
142 return 0;
143} /* preemp_ */
References inbuf().
Referenced by analys_().
◆ prepro_()
|
extern |
Definition at line 101 of file prepro.c.
103{
105
106/* Arguments */
107/* High Pass Filter at 100 Hz */
108 /* Parameter adjustments */
109 if (speech) {
110 --speech;
111 }
112
113 /* Function Body */
115 return 0;
116} /* prepro_ */
int hp100_(real *speech, integer *start, integer *end, struct lpc10_encoder_state *st)
Definition hp100.c:113
Definition lpc10.h:84
References c__1, and hp100_().
Referenced by lpc10_encode().
◆ r_sign()
◆ random_()
|
extern |
Definition at line 93 of file random.c.
94{
95 /* Initialized data */
96
97 integer *j;
98 integer *k;
99 shortint *y;
100
101 /* System generated locals */
102 integer ret_val;
103
104/* Parameters/constants */
105/* Local state */
106/* The following is a 16 bit 2's complement addition, */
107/* with overflow checking disabled */
108
109 j = &(st->j);
110 k = &(st->k);
111 y = &(st->y[0]);
112
113 y[*k - 1] += y[*j - 1];
114 ret_val = y[*k - 1];
115 --(*k);
116 if (*k <= 0) {
117 *k = 5;
118 }
119 --(*j);
120 if (*j <= 0) {
121 *j = 5;
122 }
123 return ret_val;
124} /* random_ */
References lpc10_decoder_state::j, lpc10_decoder_state::k, and lpc10_decoder_state::y.
Referenced by bsynz_().
◆ rcchk_()
Definition at line 82 of file rcchk.c.
83{
84 /* System generated locals */
85 integer i__1;
86 real r__1;
87
88 /* Local variables */
89 integer i__;
90
91/* Arguments */
92/* Local variables that need not be saved */
93 /* Parameter adjustments */
94 --rc2f;
95 --rc1f;
96
97 /* Function Body */
98 i__1 = *order;
99 for (i__ = 1; i__ <= i__1; ++i__) {
101 goto L10;
102 }
103 }
104 return 0;
105/* Note: In version embedded in other software, all calls to ERROR
106*/
107/* should probably be removed. */
108L10:
109
110/* This call to ERROR is only needed for debugging purposes. */
111
112/* CALL ERROR('RCCHK',2,I) */
113 i__1 = *order;
114 for (i__ = 1; i__ <= i__1; ++i__) {
115 rc2f[i__] = rc1f[i__];
116 }
117 return 0;
118} /* rcchk_ */
Referenced by analys_().
◆ synths_()
|
extern |
Definition at line 170 of file synths.c.
172{
173 /* Initialized data */
174
176 integer *buflen;
177
178 /* System generated locals */
179 integer i__1;
180 real r__1, r__2;
181
182 /* Local variables */
183 real rmsi[16];
184 integer nout, ivuv[16], i__, j;
186 real ratio;
187 integer ipiti[16];
188 real g2pass;
189 real pc[10];
194
195/* $Log$
196 * Revision 1.16 2004/06/26 03:50:14 markster
197 * Merge source cleanups (bug #1911)
198 *
199 * Revision 1.15 2003/09/27 02:45:37 markster
200 * Fix various compiler warnings (bug #322)
201 *
202 * Revision 1.2 2003/09/27 02:45:37 markster
203 * Fix various compiler warnings (bug #322)
204 *
205 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
206 * mer feb 12 14:56:57 CET 2003
207 *
208 * Revision 1.2 2000/01/05 08:20:39 markster
209 * Some OSS fixes and a few lpc changes to make it actually work
210 *
211 * Revision 1.2 1996/08/20 20:42:59 jaf
212 * Removed all static local variables that were SAVE'd in the Fortran
213 * code, and put them in struct lpc10_decoder_state that is passed as an
214 * argument.
215 *
216 * Removed init function, since all initialization is now done in
217 * init_lpc10_decoder_state().
218 *
219 * Revision 1.1 1996/08/19 22:30:33 jaf
220 * Initial revision
221 * */
222/* Revision 1.3 1996/03/29 22:03:47 jaf */
223/* Removed definitions for any constants that were no longer used. */
224
225/* Revision 1.2 1996/03/26 19:34:33 jaf */
226/* Added comments indicating which constants are not needed in an */
227/* application that uses the LPC-10 coder. */
228
229/* Revision 1.1 1996/02/07 14:43:51 jaf */
230/* Initial revision */
231
232/* LPC Configuration parameters: */
233/* Frame size, Prediction order, Pitch period */
234/* Arguments */
235/* $Log$
236 * Revision 1.16 2004/06/26 03:50:14 markster
237 * Merge source cleanups (bug #1911)
238 *
239 * Revision 1.15 2003/09/27 02:45:37 markster
240 * Fix various compiler warnings (bug #322)
241 *
242 * Revision 1.2 2003/09/27 02:45:37 markster
243 * Fix various compiler warnings (bug #322)
244 *
245 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
246 * mer feb 12 14:56:57 CET 2003
247 *
248 * Revision 1.2 2000/01/05 08:20:39 markster
249 * Some OSS fixes and a few lpc changes to make it actually work
250 *
251 * Revision 1.2 1996/08/20 20:42:59 jaf
252 * Removed all static local variables that were SAVE'd in the Fortran
253 * code, and put them in struct lpc10_decoder_state that is passed as an
254 * argument.
255 *
256 * Removed init function, since all initialization is now done in
257 * init_lpc10_decoder_state().
258 *
259 * Revision 1.1 1996/08/19 22:30:33 jaf
260 * Initial revision
261 * */
262/* Revision 1.3 1996/03/29 22:05:55 jaf */
263/* Commented out the common block variables that are not needed by the */
264/* embedded version. */
265
266/* Revision 1.2 1996/03/26 19:34:50 jaf */
267/* Added comments indicating which constants are not needed in an */
268/* application that uses the LPC-10 coder. */
269
270/* Revision 1.1 1996/02/07 14:44:09 jaf */
271/* Initial revision */
272
273/* LPC Processing control variables: */
274
275/* *** Read-only: initialized in setup */
276
277/* Files for Speech, Parameter, and Bitstream Input & Output, */
278/* and message and debug outputs. */
279
280/* Here are the only files which use these variables: */
281
282/* lpcsim.f setup.f trans.f error.f vqsetup.f */
283
284/* Many files which use fdebug are not listed, since it is only used in */
285/* those other files conditionally, to print trace statements. */
286/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
287/* LPC order, Frame size, Quantization rate, Bits per frame, */
288/* Error correction */
289/* Subroutine SETUP is the only place where order is assigned a value, */
290/* and that value is 10. It could increase efficiency 1% or so to */
291/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
292*/
293/* a variable in a COMMON block, since it is used in many places in the */
294/* core of the coding and decoding routines. Actually, I take that back.
295*/
296/* At least when compiling with f2c, the upper bound of DO loops is */
297/* stored in a local variable before the DO loop begins, and then that is
298*/
299/* compared against on each iteration. */
300/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
301/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
302/* is used in only a few places, and never in the core coding and */
303/* decoding routines, so it could be eliminated entirely. */
304/* nbits is similar to quant, and is given a value of 54 in SETUP. */
305/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
306/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
307/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
308*/
309/* a constant or a variable, since it is only examined once per frame. */
310/* Leaving it as a variable that is set to .TRUE. seems like a good */
311/* idea, since it does enable some error-correction capability for */
312/* unvoiced frames, with no change in the coding rate, and no noticeable
313*/
314/* quality difference in the decoded speech. */
315/* integer quant, nbits */
316/* *** Read/write: variables for debugging, not needed for LPC algorithm
317*/
318
319/* Current frame, Unstable frames, Output clip count, Max onset buffer,
320*/
321/* Debug listing detail level, Line count on listing page */
322
323/* nframe is not needed for an embedded LPC10 at all. */
324/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
325/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
326/* an application, I would recommend removing the call to ERROR in RCCHK,
327*/
328/* and remove ERROR and nunsfm completely. */
329/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
330*/
331/* sread.f. When LPC10 is embedded into an application, one might want */
332/* to cause it to be incremented in a routine that takes the output of */
333/* SYNTHS and sends it to an audio device. It could be optionally */
334/* displayed, for those that might want to know what it is. */
335/* maxosp is never initialized to 0 in SETUP, although it probably should
336*/
337/* be, and it is updated in subroutine ANALYS. I doubt that its value */
338/* would be of much interest to an application in which LPC10 is */
339/* embedded. */
340/* listl and lincnt are not needed for an embedded LPC10 at all. */
341/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
342/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
343/* common /contrl/ quant, nbits */
344/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
345/* Parameters/constants */
346/* Local variables that need not be saved */
347/* Local state */
348/* BUF is a buffer of speech samples that would have been returned
349*/
350/* by the older version of SYNTHS, but the newer version doesn't, */
351/* so that the newer version can always return MAXFRM samples on */
352/* every call. This has the effect of delaying the return of */
353/* samples for one additional frame time. */
354
355/* Indices 1 through BUFLEN contain samples that are left over from
356*/
357/* the last call to SYNTHS. Given the way that PITSYN works, */
358/* BUFLEN should always be in the range MAXFRM-MAXPIT+1 through */
359/* MAXFRM, inclusive, after a call to SYNTHS is complete. */
360
361/* On the first call to SYNTHS (or the first call after */
362/* reinitializing with the entry INITSYNTHS), BUFLEN is MAXFRM, and
363*/
364/* a frame of silence is always returned. */
365 /* Parameter adjustments */
366 if (voice) {
367 --voice;
368 }
369 if (rc) {
370 --rc;
371 }
372 if (speech) {
373 --speech;
374 }
375
376 /* Function Body */
378 buflen = &(st->buflen);
379
380/* Computing MAX */
381 i__1 = min(*pitch,156);
382 *pitch = max(i__1,20);
383 i__1 = contrl_1.order;
384 for (i__ = 1; i__ <= i__1; ++i__) {
385/* Computing MAX */
386/* Computing MIN */
387 r__2 = rc[i__];
388 r__1 = min(r__2,.99f);
389 rc[i__] = max(r__1,-.99f);
390 }
392 ivuv, ipiti, rmsi, rci, &nout, &ratio, st);
393 if (nout > 0) {
394 i__1 = nout;
395 for (j = 1; j <= i__1; ++j) {
396
397/* Add synthesized speech for pitch period J to the en
398d of */
399/* BUF. */
400
403 , &ratio, &g2pass, st);
405 *buflen += ipiti[j - 1];
406 }
407
408/* Copy first MAXFRM samples from BUF to output array SPEECH
409*/
410/* (scaling them), and then remove them from the beginning of
411 */
412/* BUF. */
413
414 for (i__ = 1; i__ <= 180; ++i__) {
415 speech[i__] = buf[i__ - 1] / 4096.f;
416 }
417 *k = 180;
418 *buflen += -180;
419 i__1 = *buflen;
420 for (i__ = 1; i__ <= i__1; ++i__) {
422 }
423 }
424 return 0;
425} /* synths_ */
int bsynz_(real *coef, integer *ip, integer *iv, real *sout, real *rms, real *ratio, real *g2pass, struct lpc10_decoder_state *st)
Definition bsynz.c:122
int irc2pc_(real *rc, real *pc, integer *order, real *gprime, real *g2pass)
Definition irc2pc.c:82
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 pitsyn.c:132
References bsynz_(), lpc10_decoder_state::buf, buf, lpc10_decoder_state::buflen, c_b2, contrl_1, deemp_(), irc2pc_(), max, min, and pitsyn_().
Referenced by lpc10_decode().
◆ tbdm_()
|
extern |
Definition at line 94 of file tbdm.c.
97{
98 /* System generated locals */
99 integer i__1, i__2, i__3, i__4;
100
101 /* Local variables */
102 real amdf2[6];
103 integer minp2, ltau2, maxp2, i__;
106 integer minamd, ptr, tau2[6];
107
108/* Arguments */
109/* REAL SPEECH(LPITA+TAU(LTAU)), AMDF(LTAU) */
110/* Stupid TOAST doesn't understand expressions */
111/* Local variables that need not be saved */
112/* Local state */
113/* None */
114/* Compute full AMDF using log spaced lags, find coarse minimum */
115 /* Parameter adjustments */
116 --speech;
117 --amdf;
118 --tau;
119
120 /* Function Body */
121 difmag_(&speech[1], lpita, &tau[1], ltau, &tau[*ltau], &amdf[1], minptr,
122 maxptr);
123 *mintau = tau[*minptr];
124 minamd = (integer)amdf[*minptr];
125/* Build table containing all lags within +/- 3 of the AMDF minimum */
126/* excluding all that have already been computed */
127 ltau2 = 0;
128 ptr = *minptr - 2;
129/* Computing MAX */
130 i__1 = *mintau - 3;
131/* Computing MIN */
132 i__3 = *mintau + 3, i__4 = tau[*ltau] - 1;
133 i__2 = min(i__3,i__4);
135 while(tau[ptr] < i__) {
136 ++ptr;
137 }
138 if (tau[ptr] != i__) {
139 ++ltau2;
140 tau2[ltau2 - 1] = i__;
141 }
142 }
143/* Compute AMDF of the new lags, if there are any, and choose one */
144/* if it is better than the coarse minimum */
145 if (ltau2 > 0) {
146 difmag_(&speech[1], lpita, tau2, <au2, &tau[*ltau], amdf2, &minp2, &
147 maxp2);
149 *mintau = tau2[minp2 - 1];
150 minamd = (integer)amdf2[minp2 - 1];
151 }
152 }
153/* Check one octave up, if there are any lags not yet computed */
154 if (*mintau >= 80) {
155 i__ = *mintau / 2;
156 if ((i__ & 1) == 0) {
157 ltau2 = 2;
158 tau2[0] = i__ - 1;
159 tau2[1] = i__ + 1;
160 } else {
161 ltau2 = 1;
162 tau2[0] = i__;
163 }
164 difmag_(&speech[1], lpita, tau2, <au2, &tau[*ltau], amdf2, &minp2, &
165 maxp2);
167 *mintau = tau2[minp2 - 1];
168 minamd = (integer)amdf2[minp2 - 1];
169 *minptr += -20;
170 }
171 }
172/* Force minimum of the AMDF array to the high resolution minimum */
173 amdf[*minptr] = (real) minamd;
174/* Find maximum of AMDF within 1/2 octave of minimum */
175/* Computing MAX */
176 i__2 = *minptr - 5;
177 *maxptr = max(i__2,1);
178/* Computing MIN */
179 i__1 = *minptr + 5;
180 i__2 = min(i__1,*ltau);
181 for (i__ = *maxptr + 1; i__ <= i__2; ++i__) {
182 if (amdf[i__] > amdf[*maxptr]) {
183 *maxptr = i__;
184 }
185 }
186 return 0;
187} /* tbdm_ */
int difmag_(real *speech, integer *lpita, integer *tau, integer *ltau, integer *maxlag, real *amdf, integer *minptr, integer *maxptr)
Definition difmag.c:90
References difmag_(), max, and min.
Referenced by analys_().
◆ voicin_()
|
extern |
Definition at line 258 of file voicin.c.
262{
263 /* Initialized data */
264
265 real *dither;
267 334.f,-4096.f,-654.f,3752.f,3769.f,0.f,1181.f,0.f,874.f,-97.f,
268 300.f,-4096.f,-1021.f,2451.f,2527.f,0.f,-500.f,0.f,510.f,-70.f,
269 250.f,-4096.f,-1270.f,2194.f,2491.f,0.f,-1500.f,0.f,500.f,-10.f,
270 200.f,-4096.f,-1300.f,2e3f,2e3f,0.f,-2e3f,0.f,500.f,0.f,0.f,
271 -4096.f,-1300.f,2e3f,2e3f,0.f,-2500.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,
272 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,
273 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,
274 0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f };
277 ;
278
279 /* System generated locals */
280 integer inbuf_offset = 0, lpbuf_offset = 0, i__1, i__2;
281 real r__1, r__2;
282
283 /* Builtin functions */
286
287 /* Local variables */
288 real ar_b__, ar_f__;
289 integer *lbve, *lbue, *fbve, *fbue;
290 integer snrl, i__;
291 integer *ofbue, *sfbue;
292 real *voice;
293 integer *olbue, *slbue;
295 integer zc;
296 logical ot;
297 real qs;
298 real *maxmin;
299 integer vstate;
300 real rc1;
304 integer fbe, lbe;
305 real *snr;
306 real snr2;
307
308/* Global Variables: */
309/* Arguments */
310/* $Log$
311 * Revision 1.16 2004/06/26 03:50:14 markster
312 * Merge source cleanups (bug #1911)
313 *
314 * Revision 1.15 2003/11/23 22:14:32 markster
315 * Various warning cleanups
316 *
317 * Revision 1.14 2003/02/12 13:59:15 matteo
318 * mer feb 12 14:56:57 CET 2003
319 *
320 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
321 * mer feb 12 14:56:57 CET 2003
322 *
323 * Revision 1.2 2000/01/05 08:20:40 markster
324 * Some OSS fixes and a few lpc changes to make it actually work
325 *
326 * Revision 1.2 1996/08/20 20:45:00 jaf
327 * Removed all static local variables that were SAVE'd in the Fortran
328 * code, and put them in struct lpc10_encoder_state that is passed as an
329 * argument.
330 *
331 * Removed init function, since all initialization is now done in
332 * init_lpc10_encoder_state().
333 *
334 * Revision 1.1 1996/08/19 22:30:14 jaf
335 * Initial revision
336 * */
337/* Revision 1.3 1996/03/29 22:05:55 jaf */
338/* Commented out the common block variables that are not needed by the */
339/* embedded version. */
340
341/* Revision 1.2 1996/03/26 19:34:50 jaf */
342/* Added comments indicating which constants are not needed in an */
343/* application that uses the LPC-10 coder. */
344
345/* Revision 1.1 1996/02/07 14:44:09 jaf */
346/* Initial revision */
347
348/* LPC Processing control variables: */
349
350/* *** Read-only: initialized in setup */
351
352/* Files for Speech, Parameter, and Bitstream Input & Output, */
353/* and message and debug outputs. */
354
355/* Here are the only files which use these variables: */
356
357/* lpcsim.f setup.f trans.f error.f vqsetup.f */
358
359/* Many files which use fdebug are not listed, since it is only used in */
360/* those other files conditionally, to print trace statements. */
361/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
362/* LPC order, Frame size, Quantization rate, Bits per frame, */
363/* Error correction */
364/* Subroutine SETUP is the only place where order is assigned a value, */
365/* and that value is 10. It could increase efficiency 1% or so to */
366/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
367*/
368/* a variable in a COMMON block, since it is used in many places in the */
369/* core of the coding and decoding routines. Actually, I take that back.
370*/
371/* At least when compiling with f2c, the upper bound of DO loops is */
372/* stored in a local variable before the DO loop begins, and then that is
373*/
374/* compared against on each iteration. */
375/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
376/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
377/* is used in only a few places, and never in the core coding and */
378/* decoding routines, so it could be eliminated entirely. */
379/* nbits is similar to quant, and is given a value of 54 in SETUP. */
380/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
381/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
382/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
383*/
384/* a constant or a variable, since it is only examined once per frame. */
385/* Leaving it as a variable that is set to .TRUE. seems like a good */
386/* idea, since it does enable some error-correction capability for */
387/* unvoiced frames, with no change in the coding rate, and no noticeable
388*/
389/* quality difference in the decoded speech. */
390/* integer quant, nbits */
391/* *** Read/write: variables for debugging, not needed for LPC algorithm
392*/
393
394/* Current frame, Unstable frames, Output clip count, Max onset buffer,
395*/
396/* Debug listing detail level, Line count on listing page */
397
398/* nframe is not needed for an embedded LPC10 at all. */
399/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
400/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
401/* an application, I would recommend removing the call to ERROR in RCCHK,
402*/
403/* and remove ERROR and nunsfm completely. */
404/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
405*/
406/* sread.f. When LPC10 is embedded into an application, one might want */
407/* to cause it to be incremented in a routine that takes the output of */
408/* SYNTHS and sends it to an audio device. It could be optionally */
409/* displayed, for those that might want to know what it is. */
410/* maxosp is never initialized to 0 in SETUP, although it probably should
411*/
412/* be, and it is updated in subroutine ANALYS. I doubt that its value */
413/* would be of much interest to an application in which LPC10 is */
414/* embedded. */
415/* listl and lincnt are not needed for an embedded LPC10 at all. */
416/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
417/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
418/* common /contrl/ quant, nbits */
419/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
420/* Parameters/constants */
421/* Voicing coefficient and Linear Discriminant Analysis variables:
422*/
423/* Max number of VDC's and VDC levels */
424/* The following are not Fortran PARAMETER's, but they are */
425/* initialized with DATA statements, and never modified. */
426/* Actual number of VDC's and levels */
427/* Local variables that need not be saved */
428/* Note: */
429
430/* VALUE(1) through VALUE(8) are assigned values, but VALUE(9) */
431/* never is. Yet VALUE(9) is read in the loop that begins "DO I =
432*/
433/* 1, 9" below. I believe that this doesn't cause any problems in
434*/
435/* this subroutine, because all VDC(9,*) array elements are 0, and
436*/
437/* this is what is multiplied by VALUE(9) in all cases. Still, it
438*/
439/* would save a multiplication to change the loop to "DO I = 1, 8".
440*/
441/* Local state */
442/* WARNING! */
443
444/* VOICE, SFBUE, and SLBUE should be saved from one invocation to */
445/* the next, but they are never given an initial value. */
446
447/* Does Fortran 77 specify some default initial value, like 0, or */
448/* is it undefined? If it is undefined, then this code should be */
449/* corrected to specify an initial value. */
450
451/* For VOICE, note that it is "shifted" in the statement that */
452/* begins "IF (HALF .EQ. 1) THEN" below. Also, uninitialized */
453/* values in the VOICE array can only affect entries in the VOIBUF
454*/
455/* array that are for the same frame, or for an older frame. Thus
456*/
457/* the effects of uninitialized values in VOICE cannot linger on */
458/* for more than 2 or 3 frame times. */
459
460/* For SFBUE and SLBUE, the effects of uninitialized values can */
461/* linger on for many frame times, because their previous values */
462/* are exponentially decayed. Thus it is more important to choose
463*/
464/* initial values for these variables. I would guess that a */
465/* reasonable initial value for SFBUE is REF/16, the same as used */
466/* for FBUE and OFBUE. Similarly, SLBUE can be initialized to */
467/* REF/32, the same as for LBUE and OLBUE. */
468
469/* These guessed initial values should be validated by re-running */
470/* the modified program on some audio samples. */
471
472/* Declare and initialize filters: */
473
474 dither = (&st->dither);
475 snr = (&st->snr);
476 maxmin = (&st->maxmin);
477 voice = (&st->voice[0]);
478 lbve = (&st->lbve);
479 lbue = (&st->lbue);
480 fbve = (&st->fbve);
481 fbue = (&st->fbue);
482 ofbue = (&st->ofbue);
483 olbue = (&st->olbue);
484 sfbue = (&st->sfbue);
485 slbue = (&st->slbue);
486
487 /* Parameter adjustments */
488 if (vwin) {
489 --vwin;
490 }
491 if (buflim) {
492 --buflim;
493 }
495 inbuf_offset = buflim[1];
496 inbuf -= inbuf_offset;
497 }
498 if (lpbuf) {
499 lpbuf_offset = buflim[3];
500 lpbuf -= lpbuf_offset;
501 }
502 if (ivrc) {
503 --ivrc;
504 }
505 if (obound) {
506 --obound;
507 }
508 if (voibuf) {
509 --voibuf;
510 }
511
512 /* Function Body */
513
514/* The following variables are saved from one invocation to the */
515/* next, but are not initialized with DATA statements. This is */
516/* acceptable, because FIRST is initialized ot .TRUE., and the */
517/* first time that this subroutine is then called, they are all */
518/* given initial values. */
519
520/* SNR */
521/* LBVE, LBUE, FBVE, FBUE, OFBUE, OLBUE */
522
523/* MAXMIN is initialized on the first call, assuming that HALF */
524/* .EQ. 1 on first call. This is how ANALYS calls this subroutine.
525*/
526
527/* Voicing Decision Parameter vector (* denotes zero coefficient): */
528
529/* * MAXMIN */
530/* LBE/LBVE */
531/* ZC */
532/* RC1 */
533/* QS */
534/* IVRC2 */
535/* aR_B */
536/* aR_F */
537/* * LOG(LBE/LBVE) */
538/* Define 2-D voicing decision coefficient vector according to the voicin
539g*/
540/* parameter order above. Each row (VDC vector) is optimized for a speci
541fic*/
542/* SNR. The last element of the vector is the constant. */
543/* E ZC RC1 Qs IVRC2 aRb aRf c */
544
545/* The VOICE array contains the result of the linear discriminant functio
546n*/
547/* (analog values). The VOIBUF array contains the hard-limited binary
548*/
549/* voicing decisions. The VOICE and VOIBUF arrays, according to FORTRAN
550 */
551/* memory allocation, are addressed as: */
552
553/* (half-frame number, future-frame number) */
554
555/* | Past | Present | Future1 | Future2 | */
556/* | 1,0 | 2,0 | 1,1 | 2,1 | 1,2 | 2,2 | 1,3 | 2,3 | ---> time */
557
558/* Update linear discriminant function history each frame: */
559 if (*half == 1) {
560 voice[0] = voice[2];
561 voice[1] = voice[3];
562 voice[2] = voice[4];
563 voice[3] = voice[5];
564 *maxmin = *maxamd / max(*minamd,1.f);
565 }
566/* Calculate voicing parameters twice per frame: */
568 half, dither, mintau, &zc, &lbe, &fbe, &qs, &rc1, &ar_b__, &
569 ar_f__);
570/* Estimate signal-to-noise ratio to select the appropriate VDC vector.
571*/
572/* The SNR is estimated as the running average of the ratio of the */
573/* running average full-band voiced energy to the running average */
574/* full-band unvoiced energy. SNR filter has gain of 63. */
577 snr2 = *snr * *fbue / max(*lbue,1);
578/* Quantize SNR to SNRL according to VDCL thresholds. */
579 snrl = 1;
580 i__1 = nvdcl - 1;
581 for (snrl = 1; snrl <= i__1; ++snrl) {
582 if (snr2 > vdcl[snrl - 1]) {
583 goto L69;
584 }
585 }
586/* (Note: SNRL = NVDCL here) */
587L69:
588/* Linear discriminant voicing parameters: */
589 value[0] = *maxmin;
592 value[3] = rc1;
593 value[4] = qs;
594 value[5] = ivrc[2];
595 value[6] = ar_b__;
596 value[7] = ar_f__;
597/* Evaluation of linear discriminant function: */
598 voice[*half + 3] = vdc[snrl * 10 - 1];
599 for (i__ = 1; i__ <= 8; ++i__) {
600 voice[*half + 3] += vdc[i__ + snrl * 10 - 11] * value[i__ - 1];
601 }
602/* Classify as voiced if discriminant > 0, otherwise unvoiced */
603/* Voicing decision for current half-frame: 1 = Voiced; 0 = Unvoiced */
604 if (voice[*half + 3] > 0.f) {
605 voibuf[*half + 6] = 1;
606 } else {
607 voibuf[*half + 6] = 0;
608 }
609/* Skip voicing decision smoothing in first half-frame: */
610/* Give a value to VSTATE, so that trace statements below will print
611*/
612/* a consistent value from one call to the next when HALF .EQ. 1. */
613/* The value of VSTATE is not used for any other purpose when this is
614*/
615/* true. */
616 vstate = -1;
617 if (*half == 1) {
618 goto L99;
619 }
620/* Voicing decision smoothing rules (override of linear combination): */
621
622/* Unvoiced half-frames: At least two in a row. */
623/* -------------------- */
624
625/* Voiced half-frames: At least two in a row in one frame. */
626/* ------------------- Otherwise at least three in a row. */
627/* (Due to the way transition frames are encoded) */
628
629/* In many cases, the discriminant function determines how to smooth. */
630/* In the following chart, the decisions marked with a * may be overridden
631.*/
632
633/* Voicing override of transitions at onsets: */
634/* If a V/UV or UV/V voicing decision transition occurs within one-half
635*/
636/* frame of an onset bounding a voicing window, then the transition is */
637/* moved to occur at the onset. */
638
639/* P 1F */
640/* ----- ----- */
641/* 0 0 0 0 */
642/* 0 0 0* 1 (If there is an onset there) */
643/* 0 0 1* 0* (Based on 2F and discriminant distance) */
644/* 0 0 1 1 */
645/* 0 1* 0 0 (Always) */
646/* 0 1* 0* 1 (Based on discriminant distance) */
647/* 0* 1 1 0* (Based on past, 2F, and discriminant distance) */
648/* 0 1* 1 1 (If there is an onset there) */
649/* 1 0* 0 0 (If there is an onset there) */
650/* 1 0 0 1 */
651/* 1 0* 1* 0 (Based on discriminant distance) */
652/* 1 0* 1 1 (Always) */
653/* 1 1 0 0 */
654/* 1 1 0* 1* (Based on 2F and discriminant distance) */
655/* 1 1 1* 0 (If there is an onset there) */
656/* 1 1 1 1 */
657
658/* Determine if there is an onset transition between P and 1F. */
659/* OT (Onset Transition) is true if there is an onset between */
660/* P and 1F but not after 1F. */
661 ot = ((obound[1] & 2) != 0 || obound[2] == 1) && (obound[3] & 1) == 0;
662/* Multi-way dispatch on voicing decision history: */
663 vstate = (voibuf[3] << 3) + (voibuf[4] << 2) + (voibuf[5] << 1) + voibuf[
664 6];
665 switch (vstate + 1) {
666 case 1: goto L99;
667 case 2: goto L1;
668 case 3: goto L2;
669 case 4: goto L99;
670 case 5: goto L4;
671 case 6: goto L5;
672 case 7: goto L6;
673 case 8: goto L7;
674 case 9: goto L8;
675 case 10: goto L99;
676 case 11: goto L10;
677 case 12: goto L11;
678 case 13: goto L99;
679 case 14: goto L13;
680 case 15: goto L14;
681 case 16: goto L99;
682 }
683L1:
684 if (ot && voibuf[7] == 1) {
685 voibuf[5] = 1;
686 }
687 goto L99;
688L2:
689 if (voibuf[7] == 0 || voice[2] < -voice[3]) {
690 voibuf[5] = 0;
691 } else {
692 voibuf[6] = 1;
693 }
694 goto L99;
695L4:
696 voibuf[4] = 0;
697 goto L99;
698L5:
699 if (voice[1] < -voice[2]) {
700 voibuf[4] = 0;
701 } else {
702 voibuf[5] = 1;
703 }
704 goto L99;
705/* VOIBUF(2,0) must be 0 */
706L6:
707 if (voibuf[1] == 1 || voibuf[7] == 1 || voice[3] > voice[0]) {
708 voibuf[6] = 1;
709 } else {
710 voibuf[3] = 1;
711 }
712 goto L99;
713L7:
714 if (ot) {
715 voibuf[4] = 0;
716 }
717 goto L99;
718L8:
719 if (ot) {
720 voibuf[4] = 1;
721 }
722 goto L99;
723L10:
724 if (voice[2] < -voice[1]) {
725 voibuf[5] = 0;
726 } else {
727 voibuf[4] = 1;
728 }
729 goto L99;
730L11:
731 voibuf[4] = 1;
732 goto L99;
733L13:
734 if (voibuf[7] == 0 && voice[3] < -voice[2]) {
735 voibuf[6] = 0;
736 } else {
737 voibuf[5] = 1;
738 }
739 goto L99;
740L14:
741 if (ot && voibuf[7] == 0) {
742 voibuf[5] = 0;
743 }
744/* GOTO 99 */
745L99:
746/* Now update parameters: */
747/* ---------------------- */
748
749/* During unvoiced half-frames, update the low band and full band unvoice
750d*/
751/* energy estimates (LBUE and FBUE) and also the zero crossing */
752/* threshold (DITHER). (The input to the unvoiced energy filters is */
753/* restricted to be less than 10dB above the previous inputs of the */
754/* filters.) */
755/* During voiced half-frames, update the low-pass (LBVE) and all-pass */
756/* (FBVE) voiced energy estimates. */
757 if (voibuf[*half + 6] == 0) {
758/* Computing MIN */
759 i__1 = fbe, i__2 = *ofbue * 3;
760 r__1 = (*sfbue * 63 + (min(i__1,i__2) << 3)) / 64.f;
761 *sfbue = i_nint(&r__1);
762 *fbue = *sfbue / 8;
763 *ofbue = fbe;
764/* Computing MIN */
765 i__1 = lbe, i__2 = *olbue * 3;
766 r__1 = (*slbue * 63 + (min(i__1,i__2) << 3)) / 64.f;
767 *slbue = i_nint(&r__1);
768 *lbue = *slbue / 8;
769 *olbue = lbe;
770 } else {
771 r__1 = (*lbve * 63 + lbe) / 64.f;
772 *lbve = i_nint(&r__1);
773 r__1 = (*fbve * 63 + fbe) / 64.f;
774 *fbve = i_nint(&r__1);
775 }
776/* Set dither threshold to yield proper zero crossing rates in the */
777/* presence of low frequency noise and low level signal input. */
778/* NOTE: The divisor is a function of REF, the expected energies. */
779/* Computing MIN */
780/* Computing MAX */
782 r__1 = max(r__2,1.f);
783 *dither = min(r__1,20.f);
784/* Voicing decisions are returned in VOIBUF. */
785 return 0;
786} /* voicin_ */
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 vparms.c:134
References lpc10_encoder_state::dither, lpc10_encoder_state::fbue, lpc10_encoder_state::fbve, i_nint(), inbuf(), 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_().
◆ vparms_()
|
extern |
Definition at line 134 of file vparms.c.
138{
139 /* System generated locals */
140 integer inbuf_offset, lpbuf_offset, i__1;
141 real r__1, r__2;
142
143 /* Builtin functions */
146
147 /* Local variables */
149 real e_pre__;
150 integer start;
151 real ap_rms__, e_0__, oldsgn, lp_rms__, e_b__, e_f__, r_b__, r_f__, e0ap;
152
153/* Arguments */
154/* Local variables that need not be saved */
155/* Calculate zero crossings (ZC) and several energy and correlation */
156/* measures on low band and full band speech. Each measure is taken */
157/* over either the first or the second half of the voicing window, */
158/* depending on the variable HALF. */
159 /* Parameter adjustments */
160 --vwin;
161 --buflim;
162 lpbuf_offset = buflim[3];
163 lpbuf -= lpbuf_offset;
164 inbuf_offset = buflim[1];
165 inbuf -= inbuf_offset;
166
167 /* Function Body */
168 lp_rms__ = 0.f;
169 ap_rms__ = 0.f;
170 e_pre__ = 0.f;
171 e0ap = 0.f;
172 *rc1 = 0.f;
173 e_0__ = 0.f;
174 e_b__ = 0.f;
175 e_f__ = 0.f;
176 r_f__ = 0.f;
177 r_b__ = 0.f;
178 *zc = 0;
179 vlen = vwin[2] - vwin[1] + 1;
180 start = vwin[1] + (*half - 1) * vlen / 2 + 1;
181 stop = start + vlen / 2 - 1;
182
183/* I'll use the symbol HVL in the table below to represent the value */
184/* VLEN/2. Note that if VLEN is odd, then HVL should be rounded down, */
185/* i.e., HVL = (VLEN-1)/2. */
186
187/* HALF START STOP */
188
189/* 1 VWIN(1)+1 VWIN(1)+HVL */
190/* 2 VWIN(1)+HVL+1 VWIN(1)+2*HVL */
191
192/* Note that if VLEN is even and HALF is 2, then STOP will be */
193/* VWIN(1)+VLEN = VWIN(2)+1. That could be bad, if that index of INBUF */
194/* is undefined. */
195
196 r__1 = inbuf[start - 1] - *dither;
198 i__1 = stop;
199 for (i__ = start; i__ <= i__1; ++i__) {
200 lp_rms__ += (r__1 = lpbuf[i__], abs(r__1));
203/* Computing 2nd power */
204 r__1 = inbuf[i__];
205 e0ap += r__1 * r__1;
207/* Computing 2nd power */
208 r__1 = lpbuf[i__];
209 e_0__ += r__1 * r__1;
210/* Computing 2nd power */
211 r__1 = lpbuf[i__ - *mintau];
212 e_b__ += r__1 * r__1;
213/* Computing 2nd power */
214 r__1 = lpbuf[i__ + *mintau];
215 e_f__ += r__1 * r__1;
216 r_f__ += lpbuf[i__] * lpbuf[i__ + *mintau];
217 r_b__ += lpbuf[i__] * lpbuf[i__ - *mintau];
218 r__1 = inbuf[i__] + *dither;
220 ++(*zc);
221 oldsgn = -oldsgn;
222 }
223 *dither = -(*dither);
224 }
225/* Normalized short-term autocovariance coefficient at unit sample delay
226 */
227 *rc1 /= max(e0ap,1.f);
228/* Ratio of the energy of the first difference signal (6 dB/oct preemphas
229is)*/
230/* to the energy of the full band signal */
231/* Computing MAX */
232 r__1 = ap_rms__ * 2.f;
233 *qs = e_pre__ / max(r__1,1.f);
234/* aR_b is the product of the forward and reverse prediction gains, */
235/* looking backward in time (the causal case). */
237/* aR_f is the same as aR_b, but looking forward in time (non causal case
238).*/
240/* Normalize ZC, LBE, and FBE to old fixed window length of 180. */
241/* (The fraction 90/VLEN has a range of .58 to 1) */
242 r__2 = (real) (*zc << 1);
243 r__1 = r__2 * (90.f / vlen);
244 *zc = i_nint(&r__1);
245/* Computing MIN */
246 r__1 = lp_rms__ / 4 * (90.f / vlen);
247 i__1 = i_nint(&r__1);
248 *lbe = min(i__1,32767);
249/* Computing MIN */
250 r__1 = ap_rms__ / 4 * (90.f / vlen);
251 i__1 = i_nint(&r__1);
252 *fbe = min(i__1,32767);
253 return 0;
254} /* vparms_ */
References abs, c_b2, i_nint(), inbuf(), max, min, r_sign(), and stop.
Referenced by voicin_().
