← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
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.1.0/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
   }
 
543