pitsyn.c File Reference

#include "f2c.h"

Include dependency graph for pitsyn.c:

Go to the source code of this file.

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

Function Documentation

pitsyn_()

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

Definition at line 132 of file pitsyn.c.

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

Referenced by synths_().

{
 /* Initialized data */

 real *rmso;
 logical *first;

 /* System generated locals */
 integer rci_dim1 = 0, rci_offset, i__1, i__2;
 real r__1;

 /* Builtin functions */
 double log(doublereal), exp(doublereal);

 /* Local variables */
 real alrn, alro, yarc[10], prop;
 integer i__, j, vflag, jused, lsamp;
 integer *jsamp;
 real slope;
 integer *ipito;
 real uvpit;
 integer ip, nl, ivoice;
 integer *ivoico;
 integer istart;
 real *rco;
 real xxy;

/* Arguments */
/* $Log$
 * Revision 1.16 2004/06/26 03:50:14 markster
 * Merge source cleanups (bug #1911)
 *
 * Revision 1.15 2003/11/23 22:14:32 markster
 * Various warning cleanups
 *
 * Revision 1.14 2003/02/12 13:59:15 matteo
 * mer feb 12 14:56:57 CET 2003
 *
 * Revision 1.1.1.1 2003/02/12 13:59:15 matteo
 * mer feb 12 14:56:57 CET 2003
 *
 * Revision 1.2 2000/01/05 08:20:39 markster
 * Some OSS fixes and a few lpc changes to make it actually work
 *
 * Revision 1.2 1996/08/20 20:40:12 jaf
 * Removed all static local variables that were SAVE'd in the Fortran
 * code, and put them in struct lpc10_decoder_state that is passed as an
 * argument.
 *
 * Removed init function, since all initialization is now done in
 * init_lpc10_decoder_state().
 *
 * Revision 1.1 1996/08/19 22:31:12 jaf
 * Initial revision
 * */
/* Revision 1.3 1996/03/29 22:03:47 jaf */
/* Removed definitions for any constants that were no longer used. */

/* Revision 1.2 1996/03/26 19:34:33 jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */

/* Revision 1.1 1996/02/07 14:43:51 jaf */
/* Initial revision */

/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Local variables that need not be saved */
/* LSAMP is initialized in the IF (FIRST) THEN clause, but it is */
/* not used the first time through, and it is given a value before
*/
/* use whenever FIRST is .FALSE., so it appears unnecessary to */
/* assign it a value when FIRST is .TRUE. */
/* Local state */
/* FIRST - .TRUE. only on first call to PITSYN. */
/* IVOICO - Previous VOICE(2) value. */
/* IPITO - Previous PITCH value. */
/* RMSO - Previous RMS value. */
/* RCO - Previous RC values. */

/* JSAMP - If this routine is called N times with identical values of */
/* LFRAME, then the total length of all pitch periods returned */
/* is always N*LFRAME-JSAMP, and JSAMP is always in the range 0
*/
/* to MAXPIT-1 (see below for why this is so). Thus JSAMP is */
/* the number of samples "left over" from the previous call to */
/* PITSYN, that haven't been "used" in a pitch period returned */
/* from this subroutine. Every time this subroutine is called,
*/
/* it returns pitch periods with a total length of at most */
/* LFRAME+JSAMP. */

/* IVOICO, IPITO, RCO, and JSAMP need not be assigned an initial value */
/* with a DATA statement, because they are always initialized on the */
/* first call to PITSYN. */

/* FIRST and RMSO should be initialized with DATA statements, because */
/* even on the first call, they are used before being initialized. */
 /* Parameter adjustments */
 if (rc) {
 --rc;
 }
 if (rci) {
 rci_dim1 = *order;
 rci_offset = rci_dim1 + 1;
 rci -= rci_offset;
 }
 if (voice) {
 --voice;
 }
 if (ivuv) {
 --ivuv;
 }
 if (ipiti) {
 --ipiti;
 }
 if (rmsi) {
 --rmsi;
 }

 /* Function Body */
 ivoico = &(st->ivoico);
 ipito = &(st->ipito);
 rmso = &(st->rmso);
 rco = &(st->rco[0]);
 jsamp = &(st->jsamp);
 first = &(st->first_pitsyn);

 if (*rms < 1.f) {
 *rms = 1.f;
 }
 if (*rmso < 1.f) {
 *rmso = 1.f;
 }
 uvpit = 0.f;
 *ratio = *rms / (*rmso + 8.f);
 if (*first) {
 lsamp = 0;
 ivoice = voice[2];
 if (ivoice == 0) {
 *pitch = *lframe / 4;
 }
 *nout = *lframe / *pitch;
 *jsamp = *lframe - *nout * *pitch;

/* SYNTHS only calls this subroutine with PITCH in the range
20 */
/* to 156. LFRAME = MAXFRM = 180, so NOUT is somewhere in th
e */
/* range 1 to 9. */

/* JSAMP is "LFRAME mod PITCH", so it is in the range 0 to */
/* (PITCH-1), or 0 to MAXPIT-1=155, after the first call. */

 i__1 = *nout;
 for (i__ = 1; i__ <= i__1; ++i__) {
 i__2 = *order;
 for (j = 1; j <= i__2; ++j) {
 rci[j + i__ * rci_dim1] = rc[j];
 }
 ivuv[i__] = ivoice;
 ipiti[i__] = *pitch;
 rmsi[i__] = *rms;
 }
 *first = FALSE_;
 } else {
 vflag = 0;
 lsamp = *lframe + *jsamp;
 slope = (*pitch - *ipito) / (real) lsamp;
 *nout = 0;
 jused = 0;
 istart = 1;
 if (voice[1] == *ivoico && voice[2] == voice[1]) {
 if (voice[2] == 0) {
/* SSUV - - 0 , 0 , 0 */
 *pitch = *lframe / 4;
 *ipito = *pitch;
 if (*ratio > 8.f) {
 *rmso = *rms;
 }
 }
/* SSVC - - 1 , 1 , 1 */
 slope = (*pitch - *ipito) / (real) lsamp;
 ivoice = voice[2];
 } else {
 if (*ivoico != 1) {
 if (*ivoico == voice[1]) {
/* UV2VC2 - - 0 , 0 , 1 */
 nl = lsamp - *lframe / 4;
 } else {
/* UV2VC1 - - 0 , 1 , 1 */
 nl = lsamp - *lframe * 3 / 4;
 }
 ipiti[1] = nl / 2;
 ipiti[2] = nl - ipiti[1];
 ivuv[1] = 0;
 ivuv[2] = 0;
 rmsi[1] = *rmso;
 rmsi[2] = *rmso;
 i__1 = *order;
 for (i__ = 1; i__ <= i__1; ++i__) {
 rci[i__ + rci_dim1] = rco[i__ - 1];
 rci[i__ + (rci_dim1 << 1)] = rco[i__ - 1];
 rco[i__ - 1] = rc[i__];
 }
 slope = 0.f;
 *nout = 2;
 *ipito = *pitch;
 jused = nl;
 istart = nl + 1;
 ivoice = 1;
 } else {
 if (*ivoico != voice[1]) {
/* VC2UV1 - - 1 , 0 , 0 */
 lsamp = *lframe / 4 + *jsamp;
 } else {
/* VC2UV2 - - 1 , 1 , 0 */
 lsamp = *lframe * 3 / 4 + *jsamp;
 }
 i__1 = *order;
 for (i__ = 1; i__ <= i__1; ++i__) {
 yarc[i__ - 1] = rc[i__];
 rc[i__] = rco[i__ - 1];
 }
 ivoice = 1;
 slope = 0.f;
 vflag = 1;
 }
 }
/* Here is the value of most variables that are used below, depending
on */
/* the values of IVOICO, VOICE(1), and VOICE(2). VOICE(1) and VOICE(2
) */
/* are input arguments, and IVOICO is the value of VOICE(2) on the */
/* previous call (see notes for the IF (NOUT .NE. 0) statement near th
e */
/* end). Each of these three values is either 0 or 1. These three */
/* values below are given as 3-bit long strings, in the order IVOICO,
*/
/* VOICE(1), and VOICE(2). It appears that the code above assumes tha
t */
/* the bit sequences 010 and 101 never occur, but I wonder whether a
*/
/* large enough number of bit errors in the channel could cause such a
 */
/* thing to happen, and if so, could that cause NOUT to ever go over 1
1? */

/* Note that all of the 180 values in the table are really LFRAME, but
 */
/* 180 has fewer characters, and it makes the table a little more */
/* concrete. If LFRAME is ever changed, keep this in mind. Similarly
, */
/* 135's are 3*LFRAME/4, and 45's are LFRAME/4. If LFRAME is not a */
/* multiple of 4, then the 135 for NL-JSAMP is actually LFRAME-LFRAME/
4, */
/* and the 45 for NL-JSAMP is actually LFRAME-3*LFRAME/4. */

/* Note that LSAMP-JSAMP is given as the variable. This was just for
*/
/* brevity, to avoid adding "+JSAMP" to all of the column entries. */
/* Similarly for NL-JSAMP. */

/* Variable | 000 001 011,010 111 110 100,101 */
/* ------------+-------------------------------------------------- */
/* ISTART | 1 NL+1 NL+1 1 1 1 */
/* LSAMP-JSAMP | 180 180 180 180 135 45 */
/* IPITO | 45 PITCH PITCH oldPITCH oldPITCH oldPITCH */
/* SLOPE | 0 0 0 seebelow 0 0 */
/* JUSED | 0 NL NL 0 0 0 */
/* PITCH | 45 PITCH PITCH PITCH PITCH PITCH */
/* NL-JSAMP | -- 135 45 -- -- -- */
/* VFLAG | 0 0 0 0 1 1 */
/* NOUT | 0 2 2 0 0 0 */
/* IVOICE | 0 1 1 1 1 1 */

/* while_loop | once once once once twice twice */

/* ISTART | -- -- -- -- JUSED+1 JUSED+1 */
/* LSAMP-JSAMP | -- -- -- -- 180 180 */
/* IPITO | -- -- -- -- oldPITCH oldPITCH */
/* SLOPE | -- -- -- -- 0 0 */
/* JUSED | -- -- -- -- ?? ?? */
/* PITCH | -- -- -- -- PITCH PITCH */
/* NL-JSAMP | -- -- -- -- -- -- */
/* VFLAG | -- -- -- -- 0 0 */
/* NOUT | -- -- -- -- ?? ?? */
/* IVOICE | -- -- -- -- 0 0 */


/* UVPIT is always 0.0 on the first pass through the DO WHILE (.TRUE.)
 */
/* loop below. */

/* The only possible non-0 value of SLOPE (in column 111) is */
/* (PITCH-IPITO)/FLOAT(LSAMP) */

/* Column 101 is identical to 100. Any good properties we can prove
*/
/* for 100 will also hold for 101. Similarly for 010 and 011. */

/* SYNTHS calls this subroutine with PITCH restricted to the range 20
to */
/* 156. IPITO is similarly restricted to this range, after the first
*/
/* call. IP below is also restricted to this range, given the */
/* definitions of IPITO, SLOPE, UVPIT, and that I is in the range ISTA
RT */
/* to LSAMP. */

 while(TRUE_) {

/* JUSED is the total length of all pitch periods curr
ently */
/* in the output arrays, in samples. */

/* An invariant of the DO I = ISTART,LSAMP loop below,
 under */
/* the condition that IP is always in the range 1 thro
ugh */
/* MAXPIT, is: */

/* (I - MAXPIT) .LE. JUSED .LE. (I-1) */

/* Note that the final value of I is LSAMP+1, so that
after */
/* the DO loop is complete, we know: */

/* (LSAMP - MAXPIT + 1) .LE. JUSED .LE. LSAMP */

 i__1 = lsamp;
 for (i__ = istart; i__ <= i__1; ++i__) {
 r__1 = *ipito + slope * i__;
 ip = (integer)(r__1 + .5f);
 if (uvpit != 0.f) {
 ip = (integer)uvpit;
 }
 if (ip <= i__ - jused) {
 ++(*nout);

/* The following check is no longer nece
ssary, now that */
/* we can prove that NOUT will never go
over 16. */

/* IF (NOUT .GT. 16) STOP 'PITSYN: too many epochs'
*/

 ipiti[*nout] = ip;
 *pitch = ip;
 ivuv[*nout] = ivoice;
 jused += ip;
 prop = (jused - ip / 2) / (real) lsamp;
 i__2 = *order;
 for (j = 1; j <= i__2; ++j) {
 alro = (real)log((rco[j - 1] + 1) / (1 - rco[j - 1]));
 alrn = (real)log((rc[j] + 1) / (1 - rc[j]));
 xxy = alro + prop * (alrn - alro);
 xxy = (real)exp(xxy);
 rci[j + *nout * rci_dim1] = (xxy - 1) / (xxy + 1);
 }
 rmsi[*nout] = (real)(log(*rmso) + prop * (log(*rms) - log(*rmso)));
 rmsi[*nout] = (real)exp(rmsi[*nout]);
 }
 }
 if (vflag != 1) {
 goto L100;
 }

/* I want to prove what range UVPIT must lie in after
the */
/* assignments to it below. To do this, I must determ
ine */
/* what range (LSAMP-ISTART) must lie in, after the */
/* assignments to ISTART and LSAMP below. */

/* Let oldLSAMP be the value of LSAMP at this point in
 the */
/* execution. This is 135+JSAMP in state 110, or 45+J
SAMP in */
/* states 100 or 101. */

/* Given the loop invariant on JUSED above, we know th
at: */

/* (oldLSAMP - MAXPIT + 1) .LE. JUSED .LE. oldLSAMP */

/* ISTART is one more than this. */

/* Let newLSAMP be the value assigned to LSAMP below.
 This */
/* is 180+JSAMP. Thus (newLSAMP-oldLSAMP) is either 4
5 or */
/* 135, depending on the state. */

/* Thus, the range of newLSAMP-ISTART is: */

/* (newLSAMP-(oldLSAMP+1)) .LE. newLSAMP-ISTART */
/* .LE. (newLSAMP-(oldLSAMP - MAXPIT + 2)) */

/* or: */

/* 46 .LE. newLSAMP-ISTART .LE. 133+MAXPIT .EQ. 289 */

/* Therefore, UVPIT is in the range 23 to 144 after th
e first */
/* assignment to UVPIT below, and after the conditiona
l */
/* assignment, it is in the range 23 to 90. */

/* The important thing is that it is in the range 20 t
o 156, */
/* so that in the loop above, IP is always in this ran
ge. */

 vflag = 0;
 istart = jused + 1;
 lsamp = *lframe + *jsamp;
 slope = 0.f;
 ivoice = 0;
 uvpit = (real) ((lsamp - istart) / 2);
 if (uvpit > 90.f) {
 uvpit /= 2;
 }
 *rmso = *rms;
 i__1 = *order;
 for (i__ = 1; i__ <= i__1; ++i__) {
 rc[i__] = yarc[i__ - 1];
 rco[i__ - 1] = yarc[i__ - 1];
 }
 }
L100:
 *jsamp = lsamp - jused;
 }
/* Given that the maximum pitch period MAXPIT .LT. LFRAME (this is
*/
/* currently true on every call, since SYNTHS always sets */
/* LFRAME=180), NOUT will always be .GE. 1 at this point. */
 if (*nout != 0) {
 *ivoico = voice[2];
 *ipito = *pitch;
 *rmso = *rms;
 i__1 = *order;
 for (i__ = 1; i__ <= i__1; ++i__) {
 rco[i__ - 1] = rc[i__];
 }
 }
 return 0;
} /* pitsyn_ */