Think both encoder and decoder for SB-CELP work...
[speexdsp.git] / libspeex / speex.c
1 /* Copyright (C) 2002 Jean-Marc Valin 
2    File: speex.c
3
4    This library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8    
9    This library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13    
14    You should have received a copy of the GNU Lesser General Public
15    License along with this library; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <math.h>
23 #include "speex.h"
24 #include "lpc.h"
25 #include "lsp.h"
26 #include "ltp.h"
27 #include "quant_lsp.h"
28 #include "cb_search.h"
29 #include "filters.h"
30 #include "stack_alloc.h"
31
32 #ifndef M_PI
33 #define M_PI           3.14159265358979323846  /* pi */
34 #endif
35
36 #define sqr(x) ((x)*(x))
37 #define min(a,b) ((a) < (b) ? (a) : (b))
38
39 void encoder_init(EncState *st, SpeexMode *mode)
40 {
41    int i;
42    float tmp;
43    /* Codec parameters, should eventually have several "modes"*/
44    st->frameSize = mode->frameSize;
45    st->windowSize = mode->windowSize;
46    st->nbSubframes=mode->frameSize/mode->subframeSize;
47    st->subframeSize=mode->subframeSize;
48    st->lpcSize = mode->lpcSize;
49    st->bufSize = mode->bufSize;
50    st->gamma1=mode->gamma1;
51    st->gamma2=mode->gamma2;
52    st->min_pitch=mode->pitchStart;
53    st->max_pitch=mode->pitchEnd;
54    st->lag_factor=mode->lag_factor;
55    st->lpc_floor = mode->lpc_floor;
56    st->preemph = mode->preemph;
57   
58
59    st->lsp_quant = mode->lsp_quant;
60    st->ltp_quant = mode->ltp_quant;
61    st->ltp_params = mode->ltp_params;
62    st->innovation_quant = mode->innovation_quant;
63    st->innovation_params = mode->innovation_params;
64
65    st->pre_mem=0;
66    st->pre_mem2=0;
67
68    /* Over-sampling filter (fractional pitch)*/
69    st->os_fact=4;
70    st->os_filt_ord2=4*st->os_fact;
71    st->os_filt = malloc((1+2*st->os_filt_ord2)*sizeof(float));
72    st->os_filt[st->os_filt_ord2] = 1;
73    for (i=1;i<=st->os_filt_ord2;i++)
74    {
75       float x=M_PI*i/st->os_fact;
76       st->os_filt[st->os_filt_ord2-i] = st->os_filt[st->os_filt_ord2+i]=sin(x)/x*(.5+.5*cos(M_PI*i/st->os_filt_ord2));
77    }
78    /* Normalizing the over-sampling filter */
79    tmp=0;
80    for (i=0;i<2*st->os_filt_ord2+1;i++)
81       tmp += st->os_filt[i];
82    tmp=1/tmp;
83    for (i=0;i<2*st->os_filt_ord2+1;i++)
84       st->os_filt[i] *= tmp;
85
86    /*for (i=0;i<2*st->os_filt_ord2+1;i++)
87       printf ("%f ", st->os_filt[i]);
88       printf ("\n");*/
89
90    /* Allocating input buffer */
91    st->inBuf = calloc(st->bufSize,sizeof(float));
92    st->frame = st->inBuf + st->bufSize - st->windowSize;
93    /* Allocating excitation buffer */
94    st->excBuf = calloc(st->bufSize,sizeof(float));
95    st->exc = st->excBuf + st->bufSize - st->windowSize;
96    st->swBuf = calloc(st->bufSize,sizeof(float));
97    st->sw = st->swBuf + st->bufSize - st->windowSize;
98
99    /* Hanning window */
100    st->window = malloc(st->windowSize*sizeof(float));
101    for (i=0;i<st->windowSize;i++)
102       st->window[i]=.5*(1-cos(2*M_PI*i/st->windowSize));
103
104    /* Create the window for autocorrelation (lag-windowing) */
105    st->lagWindow = malloc((st->lpcSize+1)*sizeof(float));
106    for (i=0;i<st->lpcSize+1;i++)
107       st->lagWindow[i]=exp(-.5*sqr(2*M_PI*st->lag_factor*i));
108
109    st->autocorr = malloc((st->lpcSize+1)*sizeof(float));
110
111    st->stack = calloc(20000, sizeof(float));
112
113    st->buf2 = malloc(st->windowSize*sizeof(float));
114
115    st->lpc = malloc((st->lpcSize+1)*sizeof(float));
116    st->interp_lpc = malloc((st->lpcSize+1)*sizeof(float));
117    st->interp_qlpc = malloc((st->lpcSize+1)*sizeof(float));
118    st->bw_lpc1 = malloc((st->lpcSize+1)*sizeof(float));
119    st->bw_lpc2 = malloc((st->lpcSize+1)*sizeof(float));
120
121    st->lsp = malloc(st->lpcSize*sizeof(float));
122    st->qlsp = malloc(st->lpcSize*sizeof(float));
123    st->old_lsp = malloc(st->lpcSize*sizeof(float));
124    st->old_qlsp = malloc(st->lpcSize*sizeof(float));
125    st->interp_lsp = malloc(st->lpcSize*sizeof(float));
126    st->interp_qlsp = malloc(st->lpcSize*sizeof(float));
127    st->rc = malloc(st->lpcSize*sizeof(float));
128    st->first = 1;
129    
130    st->mem_sp = calloc(st->lpcSize, sizeof(float));
131    st->mem_sw = calloc(st->lpcSize, sizeof(float));
132
133    st->pi_gain = calloc(st->nbSubframes, sizeof(float));
134
135 }
136
137 void encoder_destroy(EncState *st)
138 {
139    /* Free all allocated memory */
140    free(st->inBuf);
141    free(st->excBuf);
142    free(st->swBuf);
143    
144    free(st->stack);
145
146    free(st->window);
147    free(st->buf2);
148    free(st->lpc);
149    free(st->interp_lpc);
150    free(st->interp_qlpc);
151
152    free(st->bw_lpc1);
153    free(st->bw_lpc2);
154    free(st->autocorr);
155    free(st->lagWindow);
156    free(st->lsp);
157    free(st->qlsp);
158    free(st->old_lsp);
159    free(st->interp_lsp);
160    free(st->old_qlsp);
161    free(st->interp_qlsp);
162    free(st->rc);
163
164    free(st->mem_sp);
165    free(st->mem_sw);
166    free(st->pi_gain);
167 }
168
169
170 void encode(EncState *st, float *in, FrameBits *bits)
171 {
172    int i, sub, roots;
173    float error;
174
175    /* Copy new data in input buffer */
176    memmove(st->inBuf, st->inBuf+st->frameSize, (st->bufSize-st->frameSize)*sizeof(float));
177    st->inBuf[st->bufSize-st->frameSize] = in[0] - st->preemph*st->pre_mem;
178    for (i=1;i<st->frameSize;i++)
179       st->inBuf[st->bufSize-st->frameSize+i] = in[i] - st->preemph*in[i-1];
180    st->pre_mem = in[st->frameSize-1];
181
182    memmove(st->excBuf, st->excBuf+st->frameSize, (st->bufSize-st->frameSize)*sizeof(float));
183    memmove(st->swBuf, st->swBuf+st->frameSize, (st->bufSize-st->frameSize)*sizeof(float));
184
185    /* Window for analysis */
186    for (i=0;i<st->windowSize;i++)
187       st->buf2[i] = st->frame[i] * st->window[i];
188
189    /* Compute auto-correlation */
190    autocorr(st->buf2, st->autocorr, st->lpcSize+1, st->windowSize);
191
192    st->autocorr[0] += 1;        /* prevents NANs */
193    st->autocorr[0] *= st->lpc_floor; /* Noise floor in auto-correlation domain */
194    /* Lag windowing: equivalent to filtering in the power-spectrum domain */
195    for (i=0;i<st->lpcSize+1;i++)
196       st->autocorr[i] *= st->lagWindow[i];
197
198    /* Levinson-Durbin */
199    error = wld(st->lpc+1, st->autocorr, st->rc, st->lpcSize);
200    st->lpc[0]=1;
201
202    /* LPC to LSPs (x-domain) transform */
203    roots=lpc_to_lsp (st->lpc, st->lpcSize, st->lsp, 6, 0.002, st->stack);
204    if (roots!=st->lpcSize)
205    {
206       fprintf (stderr, "roots!=st->lpcSize (found only %d roots)\n", roots);
207       exit(1);
208    }
209
210    /* x-domain to angle domain*/
211    for (i=0;i<st->lpcSize;i++)
212       st->lsp[i] = acos(st->lsp[i]);
213    
214    /* LSP Quantization */
215    st->lsp_quant(st->lsp, st->qlsp, st->lpcSize, bits);
216    /*for (i=0;i<st->lpcSize;i++)
217      st->qlsp[i]=st->lsp[i];*/
218    /*printf ("LSP ");
219    for (i=0;i<st->lpcSize;i++)
220       printf ("%f ", st->lsp[i]);
221    printf ("\n");
222    printf ("QLSP ");
223    for (i=0;i<st->lpcSize;i++)
224       printf ("%f ", st->qlsp[i]);
225    printf ("\n");*/
226    /* Special case for first frame */
227    if (st->first)
228    {
229       for (i=0;i<st->lpcSize;i++)
230          st->old_lsp[i] = st->lsp[i];
231       for (i=0;i<st->lpcSize;i++)
232          st->old_qlsp[i] = st->qlsp[i];
233    }
234
235    /* Loop on sub-frames */
236    for (sub=0;sub<st->nbSubframes;sub++)
237    {
238       float esig, enoise, snr, tmp;
239       int   offset;
240       float *sp, *sw, *res, *exc, *target, *mem;
241       
242       /* Offset relative to start of frame */
243       offset = st->subframeSize*sub;
244       /* Original signal */
245       sp=st->frame+offset;
246       /* Excitation */
247       exc=st->exc+offset;
248       /* Weighted signal */
249       sw=st->sw+offset;
250       /* Filter response */
251       res = PUSH(st->stack, st->subframeSize);
252       /* Target signal */
253       target = PUSH(st->stack, st->subframeSize);
254       mem = PUSH(st->stack, st->lpcSize);
255
256       /* LSP interpolation (quantized and unquantized) */
257       tmp = (.5 + sub)/st->nbSubframes;
258       for (i=0;i<st->lpcSize;i++)
259          st->interp_lsp[i] = (1-tmp)*st->old_lsp[i] + tmp*st->lsp[i];
260       for (i=0;i<st->lpcSize;i++)
261          st->interp_qlsp[i] = (1-tmp)*st->old_qlsp[i] + tmp*st->qlsp[i];
262
263       /* Compute interpolated LPCs (quantized and unquantized) */
264       for (i=0;i<st->lpcSize;i++)
265          st->interp_lsp[i] = cos(st->interp_lsp[i]);
266       lsp_to_lpc(st->interp_lsp, st->interp_lpc, st->lpcSize,st->stack);
267
268       for (i=0;i<st->lpcSize;i++)
269          st->interp_qlsp[i] = cos(st->interp_qlsp[i]);
270       lsp_to_lpc(st->interp_qlsp, st->interp_qlpc, st->lpcSize, st->stack);
271
272       tmp=1;
273       st->pi_gain[sub]=0;
274       for (i=0;i<=st->lpcSize;i++)
275       {
276          st->pi_gain[sub] += tmp*st->interp_qlpc[i];
277          tmp = -tmp;
278       }
279      
280
281       /* Compute bandwidth-expanded (unquantized) LPCs for perceptual weighting */
282       bw_lpc(st->gamma1, st->interp_lpc, st->bw_lpc1, st->lpcSize);
283       if (st->gamma2>=0)
284          bw_lpc(st->gamma2, st->interp_lpc, st->bw_lpc2, st->lpcSize);
285       else
286       {
287          st->bw_lpc2[0]=1;
288          st->bw_lpc2[1]=-st->preemph;
289          for (i=2;i<=st->lpcSize;i++)
290             st->bw_lpc2[i]=0;
291       }
292 #ifdef DEBUG
293       printf ("\nlpc0 ");
294       for (i=0;i<=st->lpcSize;i++)
295          printf ("%f ", st->interp_lpc[i]);
296       printf ("\nlpc1 ");
297       for (i=0;i<=st->lpcSize;i++)
298          printf ("%f ", st->bw_lpc1[i]);
299       printf ("\nlpc2 ");
300       for (i=0;i<=st->lpcSize;i++)
301          printf ("%f ", st->bw_lpc2[i]);
302       printf ("\n\n");
303 #endif
304       /* Reset excitation */
305       for (i=0;i<st->subframeSize;i++)
306          exc[i]=0;
307
308       /* Compute zero response of A(z/g1) / ( A(z/g2) * Aq(z) ) */
309       for (i=0;i<st->lpcSize;i++)
310          mem[i]=st->mem_sp[i];
311       syn_filt_mem(exc, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, mem);
312       for (i=0;i<st->lpcSize;i++)
313          mem[i]=st->mem_sp[i];
314       residue_mem(exc, st->bw_lpc1, res, st->subframeSize, st->lpcSize, mem);
315       for (i=0;i<st->lpcSize;i++)
316          mem[i]=st->mem_sw[i];
317       syn_filt_mem(res, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);
318
319       /* Compute weighted signal */
320       for (i=0;i<st->lpcSize;i++)
321          mem[i]=st->mem_sp[i];
322       residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
323       for (i=0;i<st->lpcSize;i++)
324          mem[i]=st->mem_sw[i];
325       syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, mem);
326       
327       esig=0;
328       for (i=0;i<st->subframeSize;i++)
329          esig+=sw[i]*sw[i];
330       
331       /* Compute target signal */
332       for (i=0;i<st->subframeSize;i++)
333          target[i]=sw[i]-res[i];
334
335       for (i=0;i<st->subframeSize;i++)
336          exc[i]=0;
337
338       /* Long-term prediction */
339 #if 1
340       st->ltp_quant(target, st->interp_qlpc, st->bw_lpc1, st->bw_lpc2,
341                     exc, st->ltp_params, st->min_pitch, st->max_pitch, 
342                     st->lpcSize, st->subframeSize, bits, st->stack);
343 #else
344       {
345          float gain[3];
346          int pitch;
347          closed_loop_fractional_pitch(target, st->interp_qlpc, st->bw_lpc1, st->bw_lpc2,                                      exc, st->os_filt, st->os_filt_ord2, st->os_fact, 35, 290,                                      &gain[0], &pitch, st->lpcSize,                                      st->subframeSize, st->stack);
348       }
349 #endif
350       /* Update target for adaptive codebook contribution */
351       residue_zero(exc, st->bw_lpc1, res, st->subframeSize, st->lpcSize);
352       syn_filt_zero(res, st->interp_qlpc, res, st->subframeSize, st->lpcSize);
353       syn_filt_zero(res, st->bw_lpc2, res, st->subframeSize, st->lpcSize);
354       for (i=0;i<st->subframeSize;i++)
355         target[i]-=res[i];
356
357       /* Compute noise energy and SNR */
358       enoise=0;
359       for (i=0;i<st->subframeSize;i++)
360          enoise += target[i]*target[i];
361       snr = 10*log10((esig+1)/(enoise+1));
362 #ifdef DEBUG
363       printf ("pitch SNR = %f\n", snr);
364 #endif
365
366 #if 0 /*If set to 1, compute "real innovation" i.e. cheat to get perfect reconstruction*/
367       syn_filt_zero(target, st->bw_lpc1, res, st->subframeSize, st->lpcSize);
368       residue_zero(res, st->interp_qlpc, st->buf2, st->subframeSize, st->lpcSize);
369       residue_zero(st->buf2, st->bw_lpc2, st->buf2, st->subframeSize, st->lpcSize);
370       if (1||(snr>9 && (rand()%6==0)))
371       {
372          float ener=0;
373          printf ("exc ");
374          for (i=0;i<st->subframeSize;i++)
375          {
376             ener+=st->buf2[i]*st->buf2[i];
377             if (i && i%5==0)
378                printf ("\nexc ");
379             printf ("%f ", st->buf2[i]);
380          }
381          printf ("\n");
382       printf ("innovation_energy = %f\n", ener);
383       }
384       for (i=0;i<st->subframeSize;i++)
385          exc[i]+=st->buf2[i];
386 #else
387       /* Perform a split-codebook search */
388       st->innovation_quant(target, st->interp_qlpc, st->bw_lpc1, st->bw_lpc2,
389                            st->innovation_params, st->lpcSize,
390                            st->subframeSize, exc, bits, st->stack);
391
392 #endif
393       /* Compute weighted noise energy and SNR */
394       enoise=0;
395       for (i=0;i<st->subframeSize;i++)
396          enoise += target[i]*target[i];
397       snr = 10*log10((esig+1)/(enoise+1));
398 #ifdef DEBUG
399       printf ("seg SNR = %f\n", snr);
400 #endif
401       /*Keep the previous memory*/
402       for (i=0;i<st->lpcSize;i++)
403          mem[i]=st->mem_sp[i];
404       /* Final signal synthesis from excitation */
405       syn_filt_mem(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
406
407       /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
408       residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
409       syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw);
410
411       POP(st->stack);
412       POP(st->stack);
413       POP(st->stack);
414    }
415
416    /* Store the LSPs for interpolation in the next frame */
417    for (i=0;i<st->lpcSize;i++)
418       st->old_lsp[i] = st->lsp[i];
419    for (i=0;i<st->lpcSize;i++)
420       st->old_qlsp[i] = st->qlsp[i];
421
422    /* The next frame will not be the first (Duh!) */
423    st->first = 0;
424
425    /* Replace input by synthesized speech */
426    in[0] = st->frame[0] + st->preemph*st->pre_mem2;
427    for (i=1;i<st->frameSize;i++)
428      in[i]=st->frame[i] + st->preemph*in[i-1];
429    st->pre_mem2=in[st->frameSize-1];
430 }
431
432
433 void decoder_init(DecState *st, SpeexMode *mode)
434 {
435    int i;
436    st->first=1;
437    /* Codec parameters, should eventually have several "modes"*/
438    st->frameSize = mode->frameSize;
439    st->windowSize = mode->windowSize;
440    st->nbSubframes=mode->frameSize/mode->subframeSize;
441    st->subframeSize=mode->subframeSize;
442    st->lpcSize = mode->lpcSize;
443    st->bufSize = mode->bufSize;
444    st->gamma1=mode->gamma1;
445    st->gamma2=mode->gamma2;
446    st->min_pitch=mode->pitchStart;
447    st->max_pitch=mode->pitchEnd;
448    st->preemph = mode->preemph;
449
450    st->pre_mem=0;
451    st->lsp_unquant = mode->lsp_unquant;
452    st->ltp_unquant = mode->ltp_unquant;
453    st->ltp_params = mode->ltp_params;
454
455    st->innovation_unquant = mode->innovation_unquant;
456    st->innovation_params = mode->innovation_params;
457
458    st->stack = calloc(10000, sizeof(float));
459
460    st->inBuf = malloc(st->bufSize*sizeof(float));
461    st->frame = st->inBuf + st->bufSize - st->windowSize;
462    st->excBuf = malloc(st->bufSize*sizeof(float));
463    st->exc = st->excBuf + st->bufSize - st->windowSize;
464    for (i=0;i<st->bufSize;i++)
465       st->inBuf[i]=0;
466    for (i=0;i<st->bufSize;i++)
467       st->excBuf[i]=0;
468
469    st->interp_qlpc = malloc((st->lpcSize+1)*sizeof(float));
470    st->qlsp = malloc(st->lpcSize*sizeof(float));
471    st->old_qlsp = malloc(st->lpcSize*sizeof(float));
472    st->interp_qlsp = malloc(st->lpcSize*sizeof(float));
473    st->mem_sp = calloc(st->lpcSize, sizeof(float));
474
475    st->pi_gain = calloc(st->nbSubframes, sizeof(float));
476
477 }
478
479 void decoder_destroy(DecState *st)
480 {
481    free(st->inBuf);
482    free(st->excBuf);
483    free(st->interp_qlpc);
484    free(st->qlsp);
485    free(st->old_qlsp);
486    free(st->interp_qlsp);
487    free(st->stack);
488    free(st->mem_sp);
489    free(st->pi_gain);
490 }
491
492 void decode(DecState *st, FrameBits *bits, float *out)
493 {
494    int i, sub;
495
496    memmove(st->inBuf, st->inBuf+st->frameSize, (st->bufSize-st->frameSize)*sizeof(float));
497    memmove(st->excBuf, st->excBuf+st->frameSize, (st->bufSize-st->frameSize)*sizeof(float));
498
499
500    st->lsp_unquant(st->qlsp, st->lpcSize, bits);
501    if (st->first)
502    {
503       for (i=0;i<st->lpcSize;i++)
504          st->old_qlsp[i] = st->qlsp[i];
505    }
506
507    /*Loop on subframes */
508    for (sub=0;sub<st->nbSubframes;sub++)
509    {
510       int offset;
511       float *sp, *exc, tmp;
512       
513       /* Offset relative to start of frame */
514       offset = st->subframeSize*sub;
515       /* Original signal */
516       sp=st->frame+offset;
517       /* Excitation */
518       exc=st->exc+offset;
519
520       /* LSP interpolation (quantized and unquantized) */
521       tmp = (.5 + sub)/st->nbSubframes;
522       for (i=0;i<st->lpcSize;i++)
523          st->interp_qlsp[i] = (1-tmp)*st->old_qlsp[i] + tmp*st->qlsp[i];
524
525       printf ("decode lsp:");
526       for (i=0;i<st->lpcSize;i++)
527          printf (" %f", st->interp_qlsp[i]);
528       printf ("\n");
529
530       /* Compute interpolated LPCs (unquantized) */
531       for (i=0;i<st->lpcSize;i++)
532          st->interp_qlsp[i] = cos(st->interp_qlsp[i]);
533       lsp_to_lpc(st->interp_qlsp, st->interp_qlpc, st->lpcSize, st->stack);
534
535       printf ("decode lpc:");
536       for (i=0;i<=st->lpcSize;i++)
537          printf (" %f", st->interp_qlpc[i]);
538       printf ("\n");
539
540       tmp=1;
541       st->pi_gain[sub]=0;
542       for (i=0;i<=st->lpcSize;i++)
543       {
544          st->pi_gain[sub] += tmp*st->interp_qlpc[i];
545          tmp = -tmp;
546       }
547
548       /* Reset excitation */
549       for (i=0;i<st->subframeSize;i++)
550          exc[i]=0;
551
552       /*Adaptive codebook contribution*/
553       st->ltp_unquant(exc, st->min_pitch, st->max_pitch, st->ltp_params, st->subframeSize, bits, st->stack);
554        
555       /*Fixed codebook contribution*/
556       st->innovation_unquant(exc, st->innovation_params, st->subframeSize, bits, st->stack);
557
558       /*Compute decoded signal*/
559       syn_filt_mem(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
560
561    }
562    
563    /*Copy output signal*/
564    for (i=0;i<st->frameSize;i++)
565       out[i]=st->frame[i];
566
567    out[0] = st->frame[0] + st->preemph*st->pre_mem;
568    for (i=1;i<st->frameSize;i++)
569      out[i]=st->frame[i] + st->preemph*out[i-1];
570    st->pre_mem=out[st->frameSize-1];
571
572
573    /* Store the LSPs for interpolation in the next frame */
574    for (i=0;i<st->lpcSize;i++)
575       st->old_qlsp[i] = st->qlsp[i];
576
577    /* The next frame will not be the first (Duh!) */
578    st->first = 0;
579
580 }