← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/ilbc/iLBC_encode.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/ilbc/iLBC_encode.c
1
 
 
2
 
   /******************************************************************
3
 
 
4
 
       iLBC Speech Coder ANSI-C Source Code
5
 
 
6
 
       iLBC_encode.c
7
 
 
8
 
       Copyright (C) The Internet Society (2004).
9
 
       All Rights Reserved.
10
 
 
11
 
   ******************************************************************/
12
 
 
13
 
   #include <math.h>
14
 
   #include <stdlib.h>
15
 
   #include <string.h>
16
 
 
17
 
   #include "iLBC_define.h"
18
 
   #include "LPCencode.h"
19
 
   #include "FrameClassify.h"
20
 
   #include "StateSearchW.h"
21
 
   #include "StateConstructW.h"
22
 
   #include "helpfun.h"
23
 
   #include "constants.h"
24
 
   #include "packing.h"
25
 
   #include "iCBSearch.h"
26
 
   #include "iCBConstruct.h"
27
 
   #include "hpInput.h"
28
 
   #include "anaFilter.h"
29
 
   #include "syntFilter.h"
30
 
 
31
 
   /*----------------------------------------------------------------*
32
 
    *  Initiation of encoder instance.
33
 
    *---------------------------------------------------------------*/
34
 
 
35
 
   short initEncode(                   /* (o) Number of bytes
36
 
                                              encoded */
37
 
       iLBC_Enc_Inst_t *iLBCenc_inst,  /* (i/o) Encoder instance */
38
 
       int mode                    /* (i) frame size mode */
39
 
   ){
40
 
       iLBCenc_inst->mode = mode;
41
 
       if (mode==30) {
42
 
           iLBCenc_inst->blockl = BLOCKL_30MS;
43
 
           iLBCenc_inst->nsub = NSUB_30MS;
44
 
           iLBCenc_inst->nasub = NASUB_30MS;
45
 
           iLBCenc_inst->lpc_n = LPC_N_30MS;
46
 
           iLBCenc_inst->no_of_bytes = NO_OF_BYTES_30MS;
47
 
           iLBCenc_inst->no_of_words = NO_OF_WORDS_30MS;
48
 
 
49
 
 
50
 
 
51
 
 
52
 
 
53
 
           iLBCenc_inst->state_short_len=STATE_SHORT_LEN_30MS;
54
 
           /* ULP init */
55
 
           iLBCenc_inst->ULP_inst=&ULP_30msTbl;
56
 
       }
57
 
       else if (mode==20) {
58
 
           iLBCenc_inst->blockl = BLOCKL_20MS;
59
 
           iLBCenc_inst->nsub = NSUB_20MS;
60
 
           iLBCenc_inst->nasub = NASUB_20MS;
61
 
           iLBCenc_inst->lpc_n = LPC_N_20MS;
62
 
           iLBCenc_inst->no_of_bytes = NO_OF_BYTES_20MS;
63
 
           iLBCenc_inst->no_of_words = NO_OF_WORDS_20MS;
64
 
           iLBCenc_inst->state_short_len=STATE_SHORT_LEN_20MS;
65
 
           /* ULP init */
66
 
           iLBCenc_inst->ULP_inst=&ULP_20msTbl;
67
 
       }
68
 
       else {
69
 
           exit(2);
70
 
       }
71
 
 
72
 
       memset((*iLBCenc_inst).anaMem, 0,
73
 
           LPC_FILTERORDER*sizeof(float));
74
 
       memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl,
75
 
           LPC_FILTERORDER*sizeof(float));
76
 
       memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl,
77
 
           LPC_FILTERORDER*sizeof(float));
78
 
       memset((*iLBCenc_inst).lpc_buffer, 0,
79
 
           (LPC_LOOKBACK+BLOCKL_MAX)*sizeof(float));
80
 
       memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float));
81
 
 
82
 
       return (short)(iLBCenc_inst->no_of_bytes);
83
 
   }
84
 
 
85
 
   /*----------------------------------------------------------------*
86
 
    *  main encoder function
87
 
    *---------------------------------------------------------------*/
88
 
 
89
 
   void iLBC_encode(
90
 
       unsigned char *bytes,           /* (o) encoded data bits iLBC */
91
 
       float *block,                   /* (o) speech vector to
92
 
                                              encode */
93
 
       iLBC_Enc_Inst_t *iLBCenc_inst   /* (i/o) the general encoder
94
 
                                              state */
95
 
   ){
96
 
 
97
 
       float data[BLOCKL_MAX];
98
 
       float residual[BLOCKL_MAX], reverseResidual[BLOCKL_MAX];
99
 
 
100
 
       int start, idxForMax, idxVec[STATE_LEN];
101
 
 
102
 
 
103
 
 
104
 
 
105
 
 
106
 
       float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML];
107
 
       int n, k, meml_gotten, Nfor, Nback, i, pos;
108
 
       int gain_index[CB_NSTAGES*NASUB_MAX],
109
 
           extra_gain_index[CB_NSTAGES];
110
 
       int cb_index[CB_NSTAGES*NASUB_MAX],extra_cb_index[CB_NSTAGES];
111
 
       int lsf_i[LSF_NSPLIT*LPC_N_MAX];
112
 
       unsigned char *pbytes;
113
 
       int diff, start_pos, state_first;
114
 
       float en1, en2;
115
 
       int index, ulp, firstpart;
116
 
       int subcount, subframe;
117
 
       float weightState[LPC_FILTERORDER];
118
 
       float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)];
119
 
       float weightdenum[NSUB_MAX*(LPC_FILTERORDER+1)];
120
 
       float decresidual[BLOCKL_MAX];
121
 
 
122
 
       /* high pass filtering of input signal if such is not done
123
 
              prior to calling this function */
124
 
 
125
 
       hpInput(block, iLBCenc_inst->blockl,
126
 
                   data, (*iLBCenc_inst).hpimem);
127
 
 
128
 
       /* otherwise simply copy */
129
 
 
130
 
       /*memcpy(data,block,iLBCenc_inst->blockl*sizeof(float));*/
131
 
 
132
 
       /* LPC of hp filtered input data */
133
 
 
134
 
       LPCencode(syntdenum, weightdenum, lsf_i, data, iLBCenc_inst);
135
 
 
136
 
 
137
 
       /* inverse filter to get residual */
138
 
 
139
 
       for (n=0; n<iLBCenc_inst->nsub; n++) {
140
 
           anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)],
141
 
               SUBL, &residual[n*SUBL], iLBCenc_inst->anaMem);
142
 
       }
143
 
 
144
 
       /* find state location */
145
 
 
146
 
       start = FrameClassify(iLBCenc_inst, residual);
147
 
 
148
 
       /* check if state should be in first or last part of the
149
 
       two subframes */
150
 
 
151
 
       diff = STATE_LEN - iLBCenc_inst->state_short_len;
152
 
       en1 = 0;
153
 
       index = (start-1)*SUBL;
154
 
 
155
 
 
156
 
 
157
 
 
158
 
 
159
 
       for (i = 0; i < iLBCenc_inst->state_short_len; i++) {
160
 
           en1 += residual[index+i]*residual[index+i];
161
 
       }
162
 
       en2 = 0;
163
 
       index = (start-1)*SUBL+diff;
164
 
       for (i = 0; i < iLBCenc_inst->state_short_len; i++) {
165
 
           en2 += residual[index+i]*residual[index+i];
166
 
       }
167
 
 
168
 
 
169
 
       if (en1 > en2) {
170
 
           state_first = 1;
171
 
           start_pos = (start-1)*SUBL;
172
 
       } else {
173
 
           state_first = 0;
174
 
           start_pos = (start-1)*SUBL + diff;
175
 
       }
176
 
 
177
 
       /* scalar quantization of state */
178
 
 
179
 
       StateSearchW(iLBCenc_inst, &residual[start_pos],
180
 
           &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
181
 
           &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax,
182
 
           idxVec, iLBCenc_inst->state_short_len, state_first);
183
 
 
184
 
       StateConstructW(idxForMax, idxVec,
185
 
           &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
186
 
           &decresidual[start_pos], iLBCenc_inst->state_short_len);
187
 
 
188
 
       /* predictive quantization in state */
189
 
 
190
 
       if (state_first) { /* put adaptive part in the end */
191
 
 
192
 
           /* setup memory */
193
 
 
194
 
           memset(mem, 0,
195
 
               (CB_MEML-iLBCenc_inst->state_short_len)*sizeof(float));
196
 
           memcpy(mem+CB_MEML-iLBCenc_inst->state_short_len,
197
 
               decresidual+start_pos,
198
 
               iLBCenc_inst->state_short_len*sizeof(float));
199
 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
200
 
 
201
 
           /* encode sub-frames */
202
 
 
203
 
           iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index,
204
 
               &residual[start_pos+iLBCenc_inst->state_short_len],
205
 
               mem+CB_MEML-stMemLTbl,
206
 
               stMemLTbl, diff, CB_NSTAGES,
207
 
 
208
 
 
209
 
 
210
 
 
211
 
 
212
 
               &weightdenum[start*(LPC_FILTERORDER+1)],
213
 
               weightState, 0);
214
 
 
215
 
           /* construct decoded vector */
216
 
 
217
 
           iCBConstruct(
218
 
               &decresidual[start_pos+iLBCenc_inst->state_short_len],
219
 
               extra_cb_index, extra_gain_index,
220
 
               mem+CB_MEML-stMemLTbl,
221
 
               stMemLTbl, diff, CB_NSTAGES);
222
 
 
223
 
       }
224
 
       else { /* put adaptive part in the beginning */
225
 
 
226
 
           /* create reversed vectors for prediction */
227
 
 
228
 
           for (k=0; k<diff; k++) {
229
 
               reverseResidual[k] = residual[(start+1)*SUBL-1
230
 
                   -(k+iLBCenc_inst->state_short_len)];
231
 
           }
232
 
 
233
 
           /* setup memory */
234
 
 
235
 
           meml_gotten = iLBCenc_inst->state_short_len;
236
 
           for (k=0; k<meml_gotten; k++) {
237
 
               mem[CB_MEML-1-k] = decresidual[start_pos + k];
238
 
           }
239
 
           memset(mem, 0, (CB_MEML-k)*sizeof(float));
240
 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
241
 
 
242
 
           /* encode sub-frames */
243
 
 
244
 
           iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index,
245
 
               reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl,
246
 
               diff, CB_NSTAGES,
247
 
               &weightdenum[(start-1)*(LPC_FILTERORDER+1)],
248
 
               weightState, 0);
249
 
 
250
 
           /* construct decoded vector */
251
 
 
252
 
           iCBConstruct(reverseDecresidual, extra_cb_index,
253
 
               extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl,
254
 
               diff, CB_NSTAGES);
255
 
 
256
 
           /* get decoded residual from reversed vector */
257
 
 
258
 
           for (k=0; k<diff; k++) {
259
 
               decresidual[start_pos-1-k] = reverseDecresidual[k];
260
 
 
261
 
 
262
 
 
263
 
 
264
 
 
265
 
           }
266
 
       }
267
 
 
268
 
       /* counter for predicted sub-frames */
269
 
 
270
 
       subcount=0;
271
 
 
272
 
       /* forward prediction of sub-frames */
273
 
 
274
 
       Nfor = iLBCenc_inst->nsub-start-1;
275
 
 
276
 
 
277
 
       if ( Nfor > 0 ) {
278
 
 
279
 
           /* setup memory */
280
 
 
281
 
           memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
282
 
           memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
283
 
               STATE_LEN*sizeof(float));
284
 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
285
 
 
286
 
           /* loop over sub-frames to encode */
287
 
 
288
 
           for (subframe=0; subframe<Nfor; subframe++) {
289
 
 
290
 
               /* encode sub-frame */
291
 
 
292
 
               iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,
293
 
                   gain_index+subcount*CB_NSTAGES,
294
 
                   &residual[(start+1+subframe)*SUBL],
295
 
                   mem+CB_MEML-memLfTbl[subcount],
296
 
                   memLfTbl[subcount], SUBL, CB_NSTAGES,
297
 
                   &weightdenum[(start+1+subframe)*
298
 
                               (LPC_FILTERORDER+1)],
299
 
                   weightState, subcount+1);
300
 
 
301
 
               /* construct decoded vector */
302
 
 
303
 
               iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
304
 
                   cb_index+subcount*CB_NSTAGES,
305
 
                   gain_index+subcount*CB_NSTAGES,
306
 
                   mem+CB_MEML-memLfTbl[subcount],
307
 
                   memLfTbl[subcount], SUBL, CB_NSTAGES);
308
 
 
309
 
               /* update memory */
310
 
 
311
 
               memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
312
 
               memcpy(mem+CB_MEML-SUBL,
313
 
 
314
 
 
315
 
 
316
 
 
317
 
 
318
 
                   &decresidual[(start+1+subframe)*SUBL],
319
 
                   SUBL*sizeof(float));
320
 
               memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
321
 
 
322
 
               subcount++;
323
 
           }
324
 
       }
325
 
 
326
 
 
327
 
       /* backward prediction of sub-frames */
328
 
 
329
 
       Nback = start-1;
330
 
 
331
 
 
332
 
       if ( Nback > 0 ) {
333
 
 
334
 
           /* create reverse order vectors */
335
 
 
336
 
           for (n=0; n<Nback; n++) {
337
 
               for (k=0; k<SUBL; k++) {
338
 
                   reverseResidual[n*SUBL+k] =
339
 
                       residual[(start-1)*SUBL-1-n*SUBL-k];
340
 
                   reverseDecresidual[n*SUBL+k] =
341
 
                       decresidual[(start-1)*SUBL-1-n*SUBL-k];
342
 
               }
343
 
           }
344
 
 
345
 
           /* setup memory */
346
 
 
347
 
           meml_gotten = SUBL*(iLBCenc_inst->nsub+1-start);
348
 
 
349
 
 
350
 
           if ( meml_gotten > CB_MEML ) {
351
 
               meml_gotten=CB_MEML;
352
 
           }
353
 
           for (k=0; k<meml_gotten; k++) {
354
 
               mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
355
 
           }
356
 
           memset(mem, 0, (CB_MEML-k)*sizeof(float));
357
 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
358
 
 
359
 
           /* loop over sub-frames to encode */
360
 
 
361
 
           for (subframe=0; subframe<Nback; subframe++) {
362
 
 
363
 
               /* encode sub-frame */
364
 
 
365
 
               iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,
366
 
 
367
 
 
368
 
 
369
 
 
370
 
 
371
 
                   gain_index+subcount*CB_NSTAGES,
372
 
                   &reverseResidual[subframe*SUBL],
373
 
                   mem+CB_MEML-memLfTbl[subcount],
374
 
                   memLfTbl[subcount], SUBL, CB_NSTAGES,
375
 
                   &weightdenum[(start-2-subframe)*
376
 
                               (LPC_FILTERORDER+1)],
377
 
                   weightState, subcount+1);
378
 
 
379
 
               /* construct decoded vector */
380
 
 
381
 
               iCBConstruct(&reverseDecresidual[subframe*SUBL],
382
 
                   cb_index+subcount*CB_NSTAGES,
383
 
                   gain_index+subcount*CB_NSTAGES,
384
 
                   mem+CB_MEML-memLfTbl[subcount],
385
 
                   memLfTbl[subcount], SUBL, CB_NSTAGES);
386
 
 
387
 
               /* update memory */
388
 
 
389
 
               memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
390
 
               memcpy(mem+CB_MEML-SUBL,
391
 
                   &reverseDecresidual[subframe*SUBL],
392
 
                   SUBL*sizeof(float));
393
 
               memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
394
 
 
395
 
               subcount++;
396
 
 
397
 
           }
398
 
 
399
 
           /* get decoded residual from reversed vector */
400
 
 
401
 
           for (i=0; i<SUBL*Nback; i++) {
402
 
               decresidual[SUBL*Nback - i - 1] =
403
 
                   reverseDecresidual[i];
404
 
           }
405
 
       }
406
 
       /* end encoding part */
407
 
 
408
 
       /* adjust index */
409
 
       index_conv_enc(cb_index);
410
 
 
411
 
       /* pack bytes */
412
 
 
413
 
       pbytes=bytes;
414
 
       pos=0;
415
 
 
416
 
       /* loop over the 3 ULP classes */
417
 
 
418
 
       for (ulp=0; ulp<3; ulp++) {
419
 
 
420
 
 
421
 
 
422
 
 
423
 
 
424
 
 
425
 
           /* LSF */
426
 
           for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_n; k++) {
427
 
               packsplit(&lsf_i[k], &firstpart, &lsf_i[k],
428
 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp],
429
 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+
430
 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+
431
 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]);
432
 
               dopack( &pbytes, firstpart,
433
 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos);
434
 
           }
435
 
 
436
 
           /* Start block info */
437
 
 
438
 
           packsplit(&start, &firstpart, &start,
439
 
               iLBCenc_inst->ULP_inst->start_bits[ulp],
440
 
               iLBCenc_inst->ULP_inst->start_bits[ulp]+
441
 
               iLBCenc_inst->ULP_inst->start_bits[ulp+1]+
442
 
               iLBCenc_inst->ULP_inst->start_bits[ulp+2]);
443
 
           dopack( &pbytes, firstpart,
444
 
               iLBCenc_inst->ULP_inst->start_bits[ulp], &pos);
445
 
 
446
 
           packsplit(&state_first, &firstpart, &state_first,
447
 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp],
448
 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+
449
 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+
450
 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]);
451
 
           dopack( &pbytes, firstpart,
452
 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos);
453
 
 
454
 
           packsplit(&idxForMax, &firstpart, &idxForMax,
455
 
               iLBCenc_inst->ULP_inst->scale_bits[ulp],
456
 
               iLBCenc_inst->ULP_inst->scale_bits[ulp]+
457
 
               iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+
458
 
               iLBCenc_inst->ULP_inst->scale_bits[ulp+2]);
459
 
           dopack( &pbytes, firstpart,
460
 
               iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos);
461
 
 
462
 
           for (k=0; k<iLBCenc_inst->state_short_len; k++) {
463
 
               packsplit(idxVec+k, &firstpart, idxVec+k,
464
 
                   iLBCenc_inst->ULP_inst->state_bits[ulp],
465
 
                   iLBCenc_inst->ULP_inst->state_bits[ulp]+
466
 
                   iLBCenc_inst->ULP_inst->state_bits[ulp+1]+
467
 
                   iLBCenc_inst->ULP_inst->state_bits[ulp+2]);
468
 
               dopack( &pbytes, firstpart,
469
 
                   iLBCenc_inst->ULP_inst->state_bits[ulp], &pos);
470
 
           }
471
 
 
472
 
 
473
 
 
474
 
 
475
 
 
476
 
 
477
 
           /* 23/22 (20ms/30ms) sample block */
478
 
 
479
 
           for (k=0;k<CB_NSTAGES;k++) {
480
 
               packsplit(extra_cb_index+k, &firstpart,
481
 
                   extra_cb_index+k,
482
 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp],
483
 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+
484
 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+
485
 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]);
486
 
               dopack( &pbytes, firstpart,
487
 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp],
488
 
                   &pos);
489
 
           }
490
 
 
491
 
           for (k=0;k<CB_NSTAGES;k++) {
492
 
               packsplit(extra_gain_index+k, &firstpart,
493
 
                   extra_gain_index+k,
494
 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp],
495
 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+
496
 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+
497
 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]);
498
 
               dopack( &pbytes, firstpart,
499
 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp],
500
 
                   &pos);
501
 
           }
502
 
 
503
 
           /* The two/four (20ms/30ms) 40 sample sub-blocks */
504
 
 
505
 
           for (i=0; i<iLBCenc_inst->nasub; i++) {
506
 
               for (k=0; k<CB_NSTAGES; k++) {
507
 
                   packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,
508
 
                       cb_index+i*CB_NSTAGES+k,
509
 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp],
510
 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+
511
 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+
512
 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]);
513
 
                   dopack( &pbytes, firstpart,
514
 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp],
515
 
                       &pos);
516
 
               }
517
 
           }
518
 
 
519
 
           for (i=0; i<iLBCenc_inst->nasub; i++) {
520
 
               for (k=0; k<CB_NSTAGES; k++) {
521
 
                   packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,
522
 
                       gain_index+i*CB_NSTAGES+k,
523
 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp],
524
 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+
525
 
 
526
 
 
527
 
 
528
 
 
529
 
 
530
 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+
531
 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]);
532
 
                   dopack( &pbytes, firstpart,
533
 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp],
534
 
                       &pos);
535
 
               }
536
 
           }
537
 
       }
538
 
 
539
 
       /* set the last bit to zero (otherwise the decoder
540
 
          will treat it as a lost frame) */
541
 
       dopack( &pbytes, 0, 1, &pos);
542
 
   }