Various warning cleanups
[asterisk/asterisk.git] / codecs / lpc10 / pitsyn.c
1 /*
2
3 $Log$
4 Revision 1.15  2003/11/23 22:14:32  markster
5 Various warning cleanups
6
7 Revision 1.14  2003/02/12 13:59:15  matteo
8 mer feb 12 14:56:57 CET 2003
9
10 Revision 1.1.1.1  2003/02/12 13:59:15  matteo
11 mer feb 12 14:56:57 CET 2003
12
13 Revision 1.2  2000/01/05 08:20:39  markster
14 Some OSS fixes and a few lpc changes to make it actually work
15
16  * Revision 1.2  1996/08/20  20:40:12  jaf
17  * Removed all static local variables that were SAVE'd in the Fortran
18  * code, and put them in struct lpc10_decoder_state that is passed as an
19  * argument.
20  *
21  * Removed init function, since all initialization is now done in
22  * init_lpc10_decoder_state().
23  *
24  * Revision 1.1  1996/08/19  22:31:12  jaf
25  * Initial revision
26  *
27
28 */
29
30 #ifdef P_R_O_T_O_T_Y_P_E_S
31 extern 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);
32 #endif
33
34 /*  -- translated by f2c (version 19951025).
35    You must link the resulting object file with the libraries:
36         -lf2c -lm   (in that order)
37 */
38
39 #include "f2c.h"
40
41 /* ***************************************************************** */
42
43 /*      PITSYN Version 53 */
44
45 /* $Log$
46  * Revision 1.15  2003/11/23 22:14:32  markster
47  * Various warning cleanups
48  *
49 /* Revision 1.14  2003/02/12 13:59:15  matteo
50 /* mer feb 12 14:56:57 CET 2003
51 /*
52 /* Revision 1.1.1.1  2003/02/12 13:59:15  matteo
53 /* mer feb 12 14:56:57 CET 2003
54 /*
55 /* Revision 1.2  2000/01/05 08:20:39  markster
56 /* Some OSS fixes and a few lpc changes to make it actually work
57 /*
58  * Revision 1.2  1996/08/20  20:40:12  jaf
59  * Removed all static local variables that were SAVE'd in the Fortran
60  * code, and put them in struct lpc10_decoder_state that is passed as an
61  * argument.
62  *
63  * Removed init function, since all initialization is now done in
64  * init_lpc10_decoder_state().
65  *
66  * Revision 1.1  1996/08/19  22:31:12  jaf
67  * Initial revision
68  * */
69 /* Revision 1.2  1996/03/25  18:49:07  jaf */
70 /* Added commments about which indices of array arguments are read or */
71 /* written. */
72
73 /* Rearranged local variable declarations to indicate which need to be */
74 /* saved from one invocation to the next.  Added entry INITPITSYN to */
75 /* reinitialize local state variables, if desired. */
76
77 /* Added lots of comments about proving that the maximum number of pitch */
78 /* periods (NOUT) that can be returned is 16.  The call to STOP that */
79 /* could happen if NOUT got too large was removed as a result. */
80
81 /* Also proved that the total number of samples returned from N calls, */
82 /* each with identical values of LFRAME, will always be in the range */
83 /* N*LFRAME-MAXPIT+1 to N*LFRAME. */
84
85 /* Revision 1.1  1996/02/07 14:48:18  jaf */
86 /* Initial revision */
87
88
89 /* ***************************************************************** */
90
91 /*   Synthesize a single pitch epoch */
92
93 /* Input: */
94 /*  ORDER  - Synthesis order (number of RC's) */
95 /*  VOICE  - Half frame voicing decisions */
96 /*           Indices 1 through 2 read. */
97 /*  LFRAME - Length of speech buffer */
98 /* Input/Output: */
99 /*  PITCH  - Pitch */
100 /*           This value should be in the range MINPIT (20) to MAXPIT */
101 /*           (156), inclusive. */
102 /*           PITCH can be modified under some conditions. */
103 /*  RMS    - Energy  (can be modified) */
104 /*           RMS is changed to 1 if the value passed in is less than 1. */
105 /*  RC     - Reflection coefficients */
106 /*           Indices 1 through ORDER can be temporarily overwritten with */
107 /*           RCO, and then replaced with original values, under some */
108 /*           conditions. */
109 /* Output: */
110 /*  IVUV   - Pitch epoch voicing decisions */
111 /*           Indices (I) of IVUV, IPITI, and RMSI are written, */
112 /*           and indices (J,I) of RCI are written, */
113 /*           where I ranges from 1 to NOUT, and J ranges from 1 to ORDER. */
114 /*  IPITI  - Pitch epoch length */
115 /*  RMSI   - Pitch epoch energy */
116 /*  RCI    - Pitch epoch RC's */
117 /*  NOUT   - Number of pitch periods in this frame */
118 /*           This is at least 0, at least 1 if MAXPIT .LT. LFRAME (this */
119 /*           is currently true on every call), and can never be more than */
120 /*           (LFRAME+MAXPIT-1)/PITCH, which is currently 16 with */
121 /*           LFRAME=180, MAXPIT=156, and PITCH .GE. 20, as SYNTHS */
122 /*           guarantees when it calls this subroutine. */
123 /*  RATIO  - Previous to present energy ratio */
124 /*           Always assigned a value. */
125
126 /* Subroutine */ int pitsyn_(integer *order, integer *voice, 
127         integer *pitch, real *rms, real *rc, integer *lframe, integer *ivuv, 
128         integer *ipiti, real *rmsi, real *rci, integer *nout, real *ratio,
129                                struct lpc10_decoder_state *st)
130 {
131     /* Initialized data */
132
133     real *rmso;
134     logical *first;
135
136     /* System generated locals */
137     integer rci_dim1 = 0, rci_offset, i__1, i__2;
138     real r__1;
139
140     /* Builtin functions */
141     double log(doublereal), exp(doublereal);
142
143     /* Local variables */
144     real alrn, alro, yarc[10], prop;
145     integer i__, j, vflag, jused, lsamp;
146     integer *jsamp;
147     real slope;
148     integer *ipito;
149     real uvpit;
150     integer ip, nl, ivoice;
151     integer *ivoico;
152     integer istart;
153     real *rco;
154     real xxy;
155
156 /*       Arguments */
157 /* $Log$
158  * Revision 1.15  2003/11/23 22:14:32  markster
159  * Various warning cleanups
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:40:12  jaf
171  * Removed all static local variables that were SAVE'd in the Fortran
172  * code, and put them in struct lpc10_decoder_state that is passed as an
173  * argument.
174  *
175  * Removed init function, since all initialization is now done in
176  * init_lpc10_decoder_state().
177  *
178  * Revision 1.1  1996/08/19  22:31:12  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 /*       Local variables that need not be saved */
194 /*       LSAMP is initialized in the IF (FIRST) THEN clause, but it is */
195 /*       not used the first time through, and it is given a value before 
196 */
197 /*       use whenever FIRST is .FALSE., so it appears unnecessary to */
198 /*       assign it a value when FIRST is .TRUE. */
199 /*       Local state */
200 /* FIRST  - .TRUE. only on first call to PITSYN. */
201 /* IVOICO - Previous VOICE(2) value. */
202 /* IPITO  - Previous PITCH value. */
203 /* RMSO   - Previous RMS value. */
204 /* RCO    - Previous RC values. */
205
206 /* JSAMP  - If this routine is called N times with identical values of */
207 /*          LFRAME, then the total length of all pitch periods returned */
208 /*          is always N*LFRAME-JSAMP, and JSAMP is always in the range 0 
209 */
210 /*          to MAXPIT-1 (see below for why this is so).  Thus JSAMP is */
211 /*          the number of samples "left over" from the previous call to */
212 /*          PITSYN, that haven't been "used" in a pitch period returned */
213 /*          from this subroutine.  Every time this subroutine is called, 
214 */
215 /*          it returns pitch periods with a total length of at most */
216 /*          LFRAME+JSAMP. */
217
218 /* IVOICO, IPITO, RCO, and JSAMP need not be assigned an initial value */
219 /* with a DATA statement, because they are always initialized on the */
220 /* first call to PITSYN. */
221
222 /* FIRST and RMSO should be initialized with DATA statements, because */
223 /* even on the first call, they are used before being initialized. */
224     /* Parameter adjustments */
225     if (rc) {
226         --rc;
227         }
228     if (rci) {
229         rci_dim1 = *order;
230         rci_offset = rci_dim1 + 1;
231         rci -= rci_offset;
232         }
233     if (voice) {
234         --voice;
235         }
236     if (ivuv) {
237         --ivuv;
238         }
239     if (ipiti) {
240         --ipiti;
241         }
242     if (rmsi) {
243         --rmsi;
244         }
245
246     /* Function Body */
247     ivoico = &(st->ivoico);
248     ipito = &(st->ipito);
249     rmso = &(st->rmso);
250     rco = &(st->rco[0]);
251     jsamp = &(st->jsamp);
252     first = &(st->first_pitsyn);
253
254     if (*rms < 1.f) {
255         *rms = 1.f;
256     }
257     if (*rmso < 1.f) {
258         *rmso = 1.f;
259     }
260     uvpit = 0.f;
261     *ratio = *rms / (*rmso + 8.f);
262     if (*first) {
263         lsamp = 0;
264         ivoice = voice[2];
265         if (ivoice == 0) {
266             *pitch = *lframe / 4;
267         }
268         *nout = *lframe / *pitch;
269         *jsamp = *lframe - *nout * *pitch;
270
271 /*          SYNTHS only calls this subroutine with PITCH in the range 
272 20 */
273 /*          to 156.  LFRAME = MAXFRM = 180, so NOUT is somewhere in th
274 e */
275 /*          range 1 to 9. */
276
277 /*          JSAMP is "LFRAME mod PITCH", so it is in the range 0 to */
278 /*          (PITCH-1), or 0 to MAXPIT-1=155, after the first call. */
279
280         i__1 = *nout;
281         for (i__ = 1; i__ <= i__1; ++i__) {
282             i__2 = *order;
283             for (j = 1; j <= i__2; ++j) {
284                 rci[j + i__ * rci_dim1] = rc[j];
285             }
286             ivuv[i__] = ivoice;
287             ipiti[i__] = *pitch;
288             rmsi[i__] = *rms;
289         }
290         *first = FALSE_;
291     } else {
292         vflag = 0;
293         lsamp = *lframe + *jsamp;
294         slope = (*pitch - *ipito) / (real) lsamp;
295         *nout = 0;
296         jused = 0;
297         istart = 1;
298         if (voice[1] == *ivoico && voice[2] == voice[1]) {
299             if (voice[2] == 0) {
300 /* SSUV - -   0  ,  0  ,  0 */
301                 *pitch = *lframe / 4;
302                 *ipito = *pitch;
303                 if (*ratio > 8.f) {
304                     *rmso = *rms;
305                 }
306             }
307 /* SSVC - -   1  ,  1  ,  1 */
308             slope = (*pitch - *ipito) / (real) lsamp;
309             ivoice = voice[2];
310         } else {
311             if (*ivoico != 1) {
312                 if (*ivoico == voice[1]) {
313 /* UV2VC2 - -  0  ,  0  ,  1 */
314                     nl = lsamp - *lframe / 4;
315                 } else {
316 /* UV2VC1 - -  0  ,  1  ,  1 */
317                     nl = lsamp - *lframe * 3 / 4;
318                 }
319                 ipiti[1] = nl / 2;
320                 ipiti[2] = nl - ipiti[1];
321                 ivuv[1] = 0;
322                 ivuv[2] = 0;
323                 rmsi[1] = *rmso;
324                 rmsi[2] = *rmso;
325                 i__1 = *order;
326                 for (i__ = 1; i__ <= i__1; ++i__) {
327                     rci[i__ + rci_dim1] = rco[i__ - 1];
328                     rci[i__ + (rci_dim1 << 1)] = rco[i__ - 1];
329                     rco[i__ - 1] = rc[i__];
330                 }
331                 slope = 0.f;
332                 *nout = 2;
333                 *ipito = *pitch;
334                 jused = nl;
335                 istart = nl + 1;
336                 ivoice = 1;
337             } else {
338                 if (*ivoico != voice[1]) {
339 /* VC2UV1 - -   1  ,  0  ,  0 */
340                     lsamp = *lframe / 4 + *jsamp;
341                 } else {
342 /* VC2UV2 - -   1  ,  1  ,  0 */
343                     lsamp = *lframe * 3 / 4 + *jsamp;
344                 }
345                 i__1 = *order;
346                 for (i__ = 1; i__ <= i__1; ++i__) {
347                     yarc[i__ - 1] = rc[i__];
348                     rc[i__] = rco[i__ - 1];
349                 }
350                 ivoice = 1;
351                 slope = 0.f;
352                 vflag = 1;
353             }
354         }
355 /* Here is the value of most variables that are used below, depending 
356 on */
357 /* the values of IVOICO, VOICE(1), and VOICE(2).  VOICE(1) and VOICE(2
358 ) */
359 /* are input arguments, and IVOICO is the value of VOICE(2) on the */
360 /* previous call (see notes for the IF (NOUT .NE. 0) statement near th
361 e */
362 /* end).  Each of these three values is either 0 or 1.  These three */
363 /* values below are given as 3-bit long strings, in the order IVOICO, 
364 */
365 /* VOICE(1), and VOICE(2).  It appears that the code above assumes tha
366 t */
367 /* the bit sequences 010 and 101 never occur, but I wonder whether a 
368 */
369 /* large enough number of bit errors in the channel could cause such a
370  */
371 /* thing to happen, and if so, could that cause NOUT to ever go over 1
372 1? */
373
374 /* Note that all of the 180 values in the table are really LFRAME, but
375  */
376 /* 180 has fewer characters, and it makes the table a little more */
377 /* concrete.  If LFRAME is ever changed, keep this in mind.  Similarly
378 , */
379 /* 135's are 3*LFRAME/4, and 45's are LFRAME/4.  If LFRAME is not a */
380 /* multiple of 4, then the 135 for NL-JSAMP is actually LFRAME-LFRAME/
381 4, */
382 /* and the 45 for NL-JSAMP is actually LFRAME-3*LFRAME/4. */
383
384 /* Note that LSAMP-JSAMP is given as the variable.  This was just for 
385 */
386 /* brevity, to avoid adding "+JSAMP" to all of the column entries. */
387 /* Similarly for NL-JSAMP. */
388
389 /* Variable    | 000  001    011,010  111       110       100,101 */
390 /* ------------+-------------------------------------------------- */
391 /* ISTART      | 1    NL+1   NL+1     1         1         1 */
392 /* LSAMP-JSAMP | 180  180    180      180       135       45 */
393 /* IPITO       | 45   PITCH  PITCH    oldPITCH  oldPITCH  oldPITCH */
394 /* SLOPE       | 0    0      0        seebelow  0         0 */
395 /* JUSED       | 0    NL     NL       0         0         0 */
396 /* PITCH       | 45   PITCH  PITCH    PITCH     PITCH     PITCH */
397 /* NL-JSAMP    | --   135    45       --        --        -- */
398 /* VFLAG       | 0    0      0        0         1         1 */
399 /* NOUT        | 0    2      2        0         0         0 */
400 /* IVOICE      | 0    1      1        1         1         1 */
401
402 /* while_loop  | once once   once     once      twice     twice */
403
404 /* ISTART      | --   --     --       --        JUSED+1   JUSED+1 */
405 /* LSAMP-JSAMP | --   --     --       --        180       180 */
406 /* IPITO       | --   --     --       --        oldPITCH  oldPITCH */
407 /* SLOPE       | --   --     --       --        0         0 */
408 /* JUSED       | --   --     --       --        ??        ?? */
409 /* PITCH       | --   --     --       --        PITCH     PITCH */
410 /* NL-JSAMP    | --   --     --       --        --        -- */
411 /* VFLAG       | --   --     --       --        0         0 */
412 /* NOUT        | --   --     --       --        ??        ?? */
413 /* IVOICE      | --   --     --       --        0         0 */
414
415
416 /* UVPIT is always 0.0 on the first pass through the DO WHILE (.TRUE.)
417  */
418 /* loop below. */
419
420 /* The only possible non-0 value of SLOPE (in column 111) is */
421 /* (PITCH-IPITO)/FLOAT(LSAMP) */
422
423 /* Column 101 is identical to 100.  Any good properties we can prove 
424 */
425 /* for 100 will also hold for 101.  Similarly for 010 and 011. */
426
427 /* SYNTHS calls this subroutine with PITCH restricted to the range 20 
428 to */
429 /* 156.  IPITO is similarly restricted to this range, after the first 
430 */
431 /* call.  IP below is also restricted to this range, given the */
432 /* definitions of IPITO, SLOPE, UVPIT, and that I is in the range ISTA
433 RT */
434 /* to LSAMP. */
435
436         while(TRUE_) {
437
438 /*             JUSED is the total length of all pitch periods curr
439 ently */
440 /*             in the output arrays, in samples. */
441
442 /*             An invariant of the DO I = ISTART,LSAMP loop below,
443  under */
444 /*             the condition that IP is always in the range 1 thro
445 ugh */
446 /*             MAXPIT, is: */
447
448 /*             (I - MAXPIT) .LE. JUSED .LE. (I-1) */
449
450 /*             Note that the final value of I is LSAMP+1, so that 
451 after */
452 /*             the DO loop is complete, we know: */
453
454 /*             (LSAMP - MAXPIT + 1) .LE. JUSED .LE. LSAMP */
455
456             i__1 = lsamp;
457             for (i__ = istart; i__ <= i__1; ++i__) {
458                 r__1 = *ipito + slope * i__;
459                 ip = r__1 + .5f;
460                 if (uvpit != 0.f) {
461                     ip = uvpit;
462                 }
463                 if (ip <= i__ - jused) {
464                     ++(*nout);
465
466 /*                   The following check is no longer nece
467 ssary, now that */
468 /*                   we can prove that NOUT will never go 
469 over 16. */
470
471 /*                  IF (NOUT .GT. 16) STOP 'PITSYN: too many epochs' 
472 */
473
474                     ipiti[*nout] = ip;
475                     *pitch = ip;
476                     ivuv[*nout] = ivoice;
477                     jused += ip;
478                     prop = (jused - ip / 2) / (real) lsamp;
479                     i__2 = *order;
480                     for (j = 1; j <= i__2; ++j) {
481                         alro = log((rco[j - 1] + 1) / (1 - rco[j - 1]));
482                         alrn = log((rc[j] + 1) / (1 - rc[j]));
483                         xxy = alro + prop * (alrn - alro);
484                         xxy = exp(xxy);
485                         rci[j + *nout * rci_dim1] = (xxy - 1) / (xxy + 1);
486                     }
487                     rmsi[*nout] = log(*rmso) + prop * (log(*rms) - log(*rmso));
488                     rmsi[*nout] = exp(rmsi[*nout]);
489                 }
490             }
491             if (vflag != 1) {
492                 goto L100;
493             }
494
495 /*             I want to prove what range UVPIT must lie in after 
496 the */
497 /*             assignments to it below.  To do this, I must determ
498 ine */
499 /*             what range (LSAMP-ISTART) must lie in, after the */
500 /*             assignments to ISTART and LSAMP below. */
501
502 /*             Let oldLSAMP be the value of LSAMP at this point in
503  the */
504 /*             execution.  This is 135+JSAMP in state 110, or 45+J
505 SAMP in */
506 /*             states 100 or 101. */
507
508 /*             Given the loop invariant on JUSED above, we know th
509 at: */
510
511 /*             (oldLSAMP - MAXPIT + 1) .LE. JUSED .LE. oldLSAMP */
512
513 /*             ISTART is one more than this. */
514
515 /*             Let newLSAMP be the value assigned to LSAMP below. 
516  This */
517 /*             is 180+JSAMP.  Thus (newLSAMP-oldLSAMP) is either 4
518 5 or */
519 /*             135, depending on the state. */
520
521 /*             Thus, the range of newLSAMP-ISTART is: */
522
523 /*             (newLSAMP-(oldLSAMP+1)) .LE. newLSAMP-ISTART */
524 /*             .LE. (newLSAMP-(oldLSAMP - MAXPIT + 2)) */
525
526 /*             or: */
527
528 /*             46 .LE. newLSAMP-ISTART .LE. 133+MAXPIT .EQ. 289 */
529
530 /*             Therefore, UVPIT is in the range 23 to 144 after th
531 e first */
532 /*             assignment to UVPIT below, and after the conditiona
533 l */
534 /*             assignment, it is in the range 23 to 90. */
535
536 /*             The important thing is that it is in the range 20 t
537 o 156, */
538 /*             so that in the loop above, IP is always in this ran
539 ge. */
540
541             vflag = 0;
542             istart = jused + 1;
543             lsamp = *lframe + *jsamp;
544             slope = 0.f;
545             ivoice = 0;
546             uvpit = (real) ((lsamp - istart) / 2);
547             if (uvpit > 90.f) {
548                 uvpit /= 2;
549             }
550             *rmso = *rms;
551             i__1 = *order;
552             for (i__ = 1; i__ <= i__1; ++i__) {
553                 rc[i__] = yarc[i__ - 1];
554                 rco[i__ - 1] = yarc[i__ - 1];
555             }
556         }
557 L100:
558         *jsamp = lsamp - jused;
559     }
560 /*       Given that the maximum pitch period MAXPIT .LT. LFRAME (this is 
561 */
562 /*       currently true on every call, since SYNTHS always sets */
563 /*       LFRAME=180), NOUT will always be .GE. 1 at this point. */
564     if (*nout != 0) {
565         *ivoico = voice[2];
566         *ipito = *pitch;
567         *rmso = *rms;
568         i__1 = *order;
569         for (i__ = 1; i__ <= i__1; ++i__) {
570             rco[i__ - 1] = rc[i__];
571         }
572     }
573     return 0;
574 } /* pitsyn_ */