?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make function Gsm_Long_Term_Synthesis_Filtering() static, only used in xa_gsm.c.
[mplayer/greg.git] / libmpcodecs / native / xa_gsm.c
blob2fc2357c135160f8972a53d6dfd5609539189ddb
1
2 /*
3 Written by Mark Podlipec <podlipec@ici.net>.
4
5 Most of this code comes from a GSM 06.10 library by
6 Jutta Degener and Carsten Bormann, available via
7 <http://www.pobox.com/~jutta/toast.html>.
8
9 That library is distributed with the following copyright:
10
11 Copyright 1992 by Jutta Degener and Carsten Bormann,
12 Technische Universitaet Berlin
13
14 Any use of this software is permitted provided that this notice is not
15 removed and that neither the authors nor the Technische Universitaet Berlin
16 are deemed to have made any representations as to the suitability of this
17 software for any purpose nor are held responsible for any defects of
18 this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
19
20 As a matter of courtesy, the authors request to be informed about uses
21 this software has found, about bugs in this software, and about any
22 improvements that may be of general interest.
23
24 Berlin, 15.09.1992
25 Jutta Degener
26 Carsten Bormann
27 */
28
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <assert.h> /* POD optional */
33 #include "xa_gsm_int.h"
34
35 //void XA_MSGSM_Decoder();
36 static void GSM_Decode();
37 static void Gsm_RPE_Decoding();
38
39 //static short gsm_buf[320];
40 static XA_GSM_STATE gsm_state;
41
42
43 void GSM_Init(void)
44 {
45 memset((char *)(&gsm_state), 0, sizeof(XA_GSM_STATE));
46 gsm_state.nrp = 40;
47 }
48
49
50 /* Table 4.3b Quantization levels of the LTP gain quantizer
51 */
52 /* bc 0 1 2 3 */
53 static word gsm_QLB[4] = { 3277, 11469, 21299, 32767 };
54
55 /* Table 4.6 Normalized direct mantissa used to compute xM/xmax
56 */
57 /* i 0 1 2 3 4 5 6 7 */
58 static word gsm_FAC[8] = { 18431, 20479, 22527, 24575, 26623, 28671, 30719, 32767 };
59
60
61
62 /****************/
63 #define saturate(x) \
64 ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))
65
66 /****************/
67 static word gsm_sub (a,b)
68 word a;
69 word b;
70 {
71 longword diff = (longword)a - (longword)b;
72 return saturate(diff);
73 }
74
75 /****************/
76 static word gsm_asr (a,n)
77 word a;
78 int n;
79 {
80 if (n >= 16) return -(a < 0);
81 if (n <= -16) return 0;
82 if (n < 0) return a << -n;
83
84 # ifdef SASR
85 return a >> n;
86 # else
87 if (a >= 0) return a >> n;
88 else return -(word)( -(uword)a >> n );
89 # endif
90 }
91
92 /****************/
93 static word gsm_asl (a,n)
94 word a;
95 int n;
96 {
97 if (n >= 16) return 0;
98 if (n <= -16) return -(a < 0);
99 if (n < 0) return gsm_asr(a, -n);
100 return a << n;
101 }
102
103
104 /*
105 * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
106 * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
107 * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
108 */
109
110 /**** 4.2.17 */
111 static void RPE_grid_positioning(Mc,xMp,ep)
112 word Mc; /* grid position IN */
113 register word * xMp; /* [0..12] IN */
114 register word * ep; /* [0..39] OUT */
115 /*
116 * This procedure computes the reconstructed long term residual signal
117 * ep[0..39] for the LTP analysis filter. The inputs are the Mc
118 * which is the grid position selection and the xMp[0..12] decoded
119 * RPE samples which are upsampled by a factor of 3 by inserting zero
120 * values.
121 */
122 {
123 int i = 13;
124
125 assert(0 <= Mc && Mc <= 3);
126
127 switch (Mc) {
128 case 3: *ep++ = 0;
129 case 2: do {
130 *ep++ = 0;
131 case 1: *ep++ = 0;
132 case 0: *ep++ = *xMp++;
133 } while (--i);
134 }
135 while (++Mc < 4) *ep++ = 0;
136
137 /*
138
139 int i, k;
140 for (k = 0; k <= 39; k++) ep[k] = 0;
141 for (i = 0; i <= 12; i++) {
142 ep[ Mc + (3*i) ] = xMp[i];
143 }
144 */
145 }
146
147
148 /**** 4.2.16 */
149 static void APCM_inverse_quantization (xMc,mant,exp,xMp)
150 register word * xMc; /* [0..12] IN */
151 word mant;
152 word exp;
153 register word * xMp; /* [0..12] OUT */
154 /*
155 * This part is for decoding the RPE sequence of coded xMc[0..12]
156 * samples to obtain the xMp[0..12] array. Table 4.6 is used to get
157 * the mantissa of xmaxc (FAC[0..7]).
158 */
159 {
160 int i;
161 word temp, temp1, temp2, temp3;
162 longword ltmp;
163
164 assert( mant >= 0 && mant <= 7 );
165
166 temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */
167 temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp */
168 temp3 = gsm_asl( 1, gsm_sub( temp2, 1 ));
169
170 for (i = 13; i--;) {
171
172 assert( *xMc <= 7 && *xMc >= 0 ); /* 3 bit unsigned */
173
174 /* temp = gsm_sub( *xMc++ << 1, 7 ); */
175 temp = (*xMc++ << 1) - 7; /* restore sign */
176 assert( temp <= 7 && temp >= -7 ); /* 4 bit signed */
177
178 temp <<= 12; /* 16 bit signed */
179 temp = GSM_MULT_R( temp1, temp );
180 temp = GSM_ADD( temp, temp3 );
181 *xMp++ = gsm_asr( temp, temp2 );
182 }
183 }
184
185
186 /**** 4.12.15 */
187 static void APCM_quantization_xmaxc_to_exp_mant (xmaxc,exp_out,mant_out)
188 word xmaxc; /* IN */
189 word * exp_out; /* OUT */
190 word * mant_out; /* OUT */
191 {
192 word exp, mant;
193
194 /* Compute exponent and mantissa of the decoded version of xmaxc
195 */
196
197 exp = 0;
198 if (xmaxc > 15) exp = SASR(xmaxc, 3) - 1;
199 mant = xmaxc - (exp << 3);
200
201 if (mant == 0) {
202 exp = -4;
203 mant = 7;
204 }
205 else {
206 while (mant <= 7) {
207 mant = mant << 1 | 1;
208 exp--;
209 }
210 mant -= 8;
211 }
212
213 assert( exp >= -4 && exp <= 6 );
214 assert( mant >= 0 && mant <= 7 );
215
216 *exp_out = exp;
217 *mant_out = mant;
218 }
219
220 static void Gsm_RPE_Decoding (S, xmaxcr, Mcr, xMcr, erp)
221 XA_GSM_STATE * S;
222 word xmaxcr;
223 word Mcr;
224 word * xMcr; /* [0..12], 3 bits IN */
225 word * erp; /* [0..39] OUT */
226
227 {
228 word exp, mant;
229 word xMp[ 13 ];
230
231 APCM_quantization_xmaxc_to_exp_mant( xmaxcr, &exp, &mant );
232 APCM_inverse_quantization( xMcr, mant, exp, xMp );
233 RPE_grid_positioning( Mcr, xMp, erp );
234
235 }
236
237
238 /*
239 * 4.3 FIXED POINT IMPLEMENTATION OF THE RPE-LTP DECODER
240 */
241
242 static void Postprocessing(S,s)
243 XA_GSM_STATE * S;
244 register word * s;
245 {
246 register int k;
247 register word msr = S->msr;
248 register longword ltmp; /* for GSM_ADD */
249 register word tmp;
250
251 for (k = 160; k--; s++)
252 {
253 tmp = GSM_MULT_R( msr, 28180 );
254 msr = GSM_ADD(*s, tmp); /* Deemphasis */
255 *s = GSM_ADD(msr, msr) & 0xFFF8; /* Truncation & Upscaling */
256 }
257 S->msr = msr;
258 }
259
260 /**** 4.3.2 */
261 static void Gsm_Long_Term_Synthesis_Filtering (S,Ncr,bcr,erp,drp)
262 XA_GSM_STATE * S;
263 word Ncr;
264 word bcr;
265 register word * erp; /* [0..39] IN */
266 register word * drp; /* [-120..-1] IN, [-120..40] OUT */
267
268 /*
269 * This procedure uses the bcr and Ncr parameter to realize the
270 * long term synthesis filtering. The decoding of bcr needs
271 * table 4.3b.
272 */
273 {
274 register longword ltmp; /* for ADD */
275 register int k;
276 word brp, drpp, Nr;
277
278 /* Check the limits of Nr.
279 */
280 Nr = Ncr < 40 || Ncr > 120 ? S->nrp : Ncr;
281 S->nrp = Nr;
282 assert(Nr >= 40 && Nr <= 120);
283
284 /* Decoding of the LTP gain bcr
285 */
286 brp = gsm_QLB[ bcr ];
287
288 /* Computation of the reconstructed short term residual
289 * signal drp[0..39]
290 */
291 assert(brp != MIN_WORD);
292
293 for (k = 0; k <= 39; k++) {
294 drpp = GSM_MULT_R( brp, drp[ k - Nr ] );
295 drp[k] = GSM_ADD( erp[k], drpp );
296 }
297
298 /*
299 * Update of the reconstructed short term residual signal
300 * drp[ -1..-120 ]
301 */
302
303 for (k = 0; k <= 119; k++) drp[ -120 + k ] = drp[ -80 + k ];
304 }
305
306 static void Short_term_synthesis_filtering (S,rrp,k,wt,sr)
307 XA_GSM_STATE *S;
308 register word *rrp; /* [0..7] IN */
309 register int k; /* k_end - k_start */
310 register word *wt; /* [0..k-1] IN */
311 register word *sr; /* [0..k-1] OUT */
312 {
313 register word * v = S->v;
314 register int i;
315 register word sri, tmp1, tmp2;
316 register longword ltmp; /* for GSM_ADD & GSM_SUB */
317
318 while (k--) {
319 sri = *wt++;
320 for (i = 8; i--;) {
321
322 /* sri = GSM_SUB( sri, gsm_mult_r( rrp[i], v[i] ) );
323 */
324 tmp1 = rrp[i];
325 tmp2 = v[i];
326 tmp2 = ( tmp1 == MIN_WORD && tmp2 == MIN_WORD
327 ? MAX_WORD
328 : 0x0FFFF & (( (longword)tmp1 * (longword)tmp2
329 + 16384) >> 15)) ;
330
331 sri = GSM_SUB( sri, tmp2 );
332
333 /* v[i+1] = GSM_ADD( v[i], gsm_mult_r( rrp[i], sri ) );
334 */
335 tmp1 = ( tmp1 == MIN_WORD && sri == MIN_WORD
336 ? MAX_WORD
337 : 0x0FFFF & (( (longword)tmp1 * (longword)sri
338 + 16384) >> 15)) ;
339
340 v[i+1] = GSM_ADD( v[i], tmp1);
341 }
342 *sr++ = v[0] = sri;
343 }
344 }
345
346 /* 4.2.8 */
347
348 static void Decoding_of_the_coded_Log_Area_Ratios (LARc,LARpp)
349 word * LARc; /* coded log area ratio [0..7] IN */
350 word * LARpp; /* out: decoded .. */
351 {
352 register word temp1 /* , temp2 */;
353 register long ltmp; /* for GSM_ADD */
354
355 /* This procedure requires for efficient implementation
356 * two tables.
357 *
358 * INVA[1..8] = integer( (32768 * 8) / real_A[1..8])
359 * MIC[1..8] = minimum value of the LARc[1..8]
360 */
361
362 /* Compute the LARpp[1..8]
363 */
364
365 /* for (i = 1; i <= 8; i++, B++, MIC++, INVA++, LARc++, LARpp++) {
366 *
367 * temp1 = GSM_ADD( *LARc, *MIC ) << 10;
368 * temp2 = *B << 1;
369 * temp1 = GSM_SUB( temp1, temp2 );
370 *
371 * assert(*INVA != MIN_WORD);
372 *
373 * temp1 = GSM_MULT_R( *INVA, temp1 );
374 * *LARpp = GSM_ADD( temp1, temp1 );
375 * }
376 */
377
378 #undef STEP
379 #define STEP( B, MIC, INVA ) \
380 temp1 = GSM_ADD( *LARc++, MIC ) << 10; \
381 temp1 = GSM_SUB( temp1, B << 1 ); \
382 temp1 = GSM_MULT_R( INVA, temp1 ); \
383 *LARpp++ = GSM_ADD( temp1, temp1 );
384
385 STEP( 0, -32, 13107 );
386 STEP( 0, -32, 13107 );
387 STEP( 2048, -16, 13107 );
388 STEP( -2560, -16, 13107 );
389
390 STEP( 94, -8, 19223 );
391 STEP( -1792, -8, 17476 );
392 STEP( -341, -4, 31454 );
393 STEP( -1144, -4, 29708 );
394
395 /* NOTE: the addition of *MIC is used to restore
396 * the sign of *LARc.
397 */
398 }
399
400 /* 4.2.9 */
401 /* Computation of the quantized reflection coefficients
402 */
403
404 /* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]
405 */
406
407 /*
408 * Within each frame of 160 analyzed speech samples the short term
409 * analysis and synthesis filters operate with four different sets of
410 * coefficients, derived from the previous set of decoded LARs(LARpp(j-1))
411 * and the actual set of decoded LARs (LARpp(j))
412 *
413 * (Initial value: LARpp(j-1)[1..8] = 0.)
414 */
415
416 static void Coefficients_0_12 (LARpp_j_1, LARpp_j, LARp)
417 register word * LARpp_j_1;
418 register word * LARpp_j;
419 register word * LARp;
420 {
421 register int i;
422 register longword ltmp;
423
424 for (i = 1; i <= 8; i++, LARp++, LARpp_j_1++, LARpp_j++) {
425 *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
426 *LARp = GSM_ADD( *LARp, SASR( *LARpp_j_1, 1));
427 }
428 }
429
430 static void Coefficients_13_26 (LARpp_j_1, LARpp_j, LARp)
431 register word * LARpp_j_1;
432 register word * LARpp_j;
433 register word * LARp;
434 {
435 register int i;
436 register longword ltmp;
437 for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
438 *LARp = GSM_ADD( SASR( *LARpp_j_1, 1), SASR( *LARpp_j, 1 ));
439 }
440 }
441
442 static void Coefficients_27_39 (LARpp_j_1, LARpp_j, LARp)
443 register word * LARpp_j_1;
444 register word * LARpp_j;
445 register word * LARp;
446 {
447 register int i;
448 register longword ltmp;
449
450 for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
451 *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
452 *LARp = GSM_ADD( *LARp, SASR( *LARpp_j, 1 ));
453 }
454 }
455
456
457 static void Coefficients_40_159 (LARpp_j, LARp)
458 register word * LARpp_j;
459 register word * LARp;
460 {
461 register int i;
462
463 for (i = 1; i <= 8; i++, LARp++, LARpp_j++)
464 *LARp = *LARpp_j;
465 }
466 /* 4.2.9.2 */
467
468 static void LARp_to_rp (LARp)
469 register word * LARp; /* [0..7] IN/OUT */
470 /*
471 * The input of this procedure is the interpolated LARp[0..7] array.
472 * The reflection coefficients, rp[i], are used in the analysis
473 * filter and in the synthesis filter.
474 */
475 {
476 register int i;
477 register word temp;
478 register longword ltmp;
479
480 for (i = 1; i <= 8; i++, LARp++) {
481
482 /* temp = GSM_ABS( *LARp );
483 *
484 * if (temp < 11059) temp <<= 1;
485 * else if (temp < 20070) temp += 11059;
486 * else temp = GSM_ADD( temp >> 2, 26112 );
487 *
488 * *LARp = *LARp < 0 ? -temp : temp;
489 */
490
491 if (*LARp < 0) {
492 temp = *LARp == MIN_WORD ? MAX_WORD : -(*LARp);
493 *LARp = - ((temp < 11059) ? temp << 1
494 : ((temp < 20070) ? temp + 11059
495 : GSM_ADD( temp >> 2, 26112 )));
496 } else {
497 temp = *LARp;
498 *LARp = (temp < 11059) ? temp << 1
499 : ((temp < 20070) ? temp + 11059
500 : GSM_ADD( temp >> 2, 26112 ));
501 }
502 }
503 }
504
505
506
507
508
509 /**** */
510 static void Gsm_Short_Term_Synthesis_Filter (S, LARcr, wt, s)
511 XA_GSM_STATE * S;
512 word * LARcr; /* received log area ratios [0..7] IN */
513 word * wt; /* received d [0..159] IN */
514 word * s; /* signal s [0..159] OUT */
515 {
516 word * LARpp_j = S->LARpp[ S->j ];
517 word * LARpp_j_1 = S->LARpp[ S->j ^=1 ];
518
519 word LARp[8];
520
521 #undef FILTER
522 #if defined(FAST) && defined(USE_FLOAT_MUL)
523
524 # define FILTER (* (S->fast \
525 ? Fast_Short_term_synthesis_filtering \
526 : Short_term_synthesis_filtering ))
527 #else
528 # define FILTER Short_term_synthesis_filtering
529 #endif
530
531 Decoding_of_the_coded_Log_Area_Ratios( LARcr, LARpp_j );
532
533 Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );
534 LARp_to_rp( LARp );
535 FILTER( S, LARp, 13, wt, s );
536
537 Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);
538 LARp_to_rp( LARp );
539 FILTER( S, LARp, 14, wt + 13, s + 13 );
540
541 Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);
542 LARp_to_rp( LARp );
543 FILTER( S, LARp, 13, wt + 27, s + 27 );
544
545 Coefficients_40_159( LARpp_j, LARp );
546 LARp_to_rp( LARp );
547 FILTER(S, LARp, 120, wt + 40, s + 40);
548 }
549
550
551
552
553 static void GSM_Decode(S,LARcr, Ncr,bcr,Mcr,xmaxcr,xMcr,s)
554 XA_GSM_STATE *S;
555 word *LARcr; /* [0..7] IN */
556 word *Ncr; /* [0..3] IN */
557 word *bcr; /* [0..3] IN */
558 word *Mcr; /* [0..3] IN */
559 word *xmaxcr; /* [0..3] IN */
560 word *xMcr; /* [0..13*4] IN */
561 word *s; /* [0..159] OUT */
562 {
563 int j, k;
564 word erp[40], wt[160];
565 word *drp = S->dp0 + 120;
566
567 for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13)
568 {
569 Gsm_RPE_Decoding( S, *xmaxcr, *Mcr, xMcr, erp );
570 Gsm_Long_Term_Synthesis_Filtering( S, *Ncr, *bcr, erp, drp );
571 for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];
572 }
573
574 Gsm_Short_Term_Synthesis_Filter( S, LARcr, wt, s );
575 Postprocessing(S, s);
576 }
577
578
579
580 /****-------------------------------------------------------------------****
581 **** Podlipec: For AVI/WAV files GSM 6.10 combines two 33 bytes frames
582 **** into one 65 byte frame.
583 ****-------------------------------------------------------------------****/
584 void XA_MSGSM_Decoder(unsigned char *ibuf,unsigned short *obuf)
585 { word sr;
586 word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
587
588 sr = *ibuf++;
589
590 LARc[0] = sr & 0x3f; sr >>= 6;
591 sr |= (word)*ibuf++ << 2;
592 LARc[1] = sr & 0x3f; sr >>= 6;
593 sr |= (word)*ibuf++ << 4;
594 LARc[2] = sr & 0x1f; sr >>= 5;
595 LARc[3] = sr & 0x1f; sr >>= 5;
596 sr |= (word)*ibuf++ << 2;
597 LARc[4] = sr & 0xf; sr >>= 4;
598 LARc[5] = sr & 0xf; sr >>= 4;
599 sr |= (word)*ibuf++ << 2; /* 5 */
600 LARc[6] = sr & 0x7; sr >>= 3;
601 LARc[7] = sr & 0x7; sr >>= 3;
602 sr |= (word)*ibuf++ << 4;
603 Nc[0] = sr & 0x7f; sr >>= 7;
604 bc[0] = sr & 0x3; sr >>= 2;
605 Mc[0] = sr & 0x3; sr >>= 2;
606 sr |= (word)*ibuf++ << 1;
607 xmaxc[0] = sr & 0x3f; sr >>= 6;
608 xmc[0] = sr & 0x7; sr >>= 3;
609 sr = *ibuf++;
610 xmc[1] = sr & 0x7; sr >>= 3;
611 xmc[2] = sr & 0x7; sr >>= 3;
612 sr |= (word)*ibuf++ << 2;
613 xmc[3] = sr & 0x7; sr >>= 3;
614 xmc[4] = sr & 0x7; sr >>= 3;
615 xmc[5] = sr & 0x7; sr >>= 3;
616 sr |= (word)*ibuf++ << 1; /* 10 */
617 xmc[6] = sr & 0x7; sr >>= 3;
618 xmc[7] = sr & 0x7; sr >>= 3;
619 xmc[8] = sr & 0x7; sr >>= 3;
620 sr = *ibuf++;
621 xmc[9] = sr & 0x7; sr >>= 3;
622 xmc[10] = sr & 0x7; sr >>= 3;
623 sr |= (word)*ibuf++ << 2;
624 xmc[11] = sr & 0x7; sr >>= 3;
625 xmc[12] = sr & 0x7; sr >>= 3;
626 sr |= (word)*ibuf++ << 4;
627 Nc[1] = sr & 0x7f; sr >>= 7;
628 bc[1] = sr & 0x3; sr >>= 2;
629 Mc[1] = sr & 0x3; sr >>= 2;
630 sr |= (word)*ibuf++ << 1;
631 xmaxc[1] = sr & 0x3f; sr >>= 6;
632 xmc[13] = sr & 0x7; sr >>= 3;
633 sr = *ibuf++; /* 15 */
634 xmc[14] = sr & 0x7; sr >>= 3;
635 xmc[15] = sr & 0x7; sr >>= 3;
636 sr |= (word)*ibuf++ << 2;
637 xmc[16] = sr & 0x7; sr >>= 3;
638 xmc[17] = sr & 0x7; sr >>= 3;
639 xmc[18] = sr & 0x7; sr >>= 3;
640 sr |= (word)*ibuf++ << 1;
641 xmc[19] = sr & 0x7; sr >>= 3;
642 xmc[20] = sr & 0x7; sr >>= 3;
643 xmc[21] = sr & 0x7; sr >>= 3;
644 sr = *ibuf++;
645 xmc[22] = sr & 0x7; sr >>= 3;
646 xmc[23] = sr & 0x7; sr >>= 3;
647 sr |= (word)*ibuf++ << 2;
648 xmc[24] = sr & 0x7; sr >>= 3;
649 xmc[25] = sr & 0x7; sr >>= 3;
650 sr |= (word)*ibuf++ << 4; /* 20 */
651 Nc[2] = sr & 0x7f; sr >>= 7;
652 bc[2] = sr & 0x3; sr >>= 2;
653 Mc[2] = sr & 0x3; sr >>= 2;
654 sr |= (word)*ibuf++ << 1;
655 xmaxc[2] = sr & 0x3f; sr >>= 6;
656 xmc[26] = sr & 0x7; sr >>= 3;
657 sr = *ibuf++;
658 xmc[27] = sr & 0x7; sr >>= 3;
659 xmc[28] = sr & 0x7; sr >>= 3;
660 sr |= (word)*ibuf++ << 2;
661 xmc[29] = sr & 0x7; sr >>= 3;
662 xmc[30] = sr & 0x7; sr >>= 3;
663 xmc[31] = sr & 0x7; sr >>= 3;
664 sr |= (word)*ibuf++ << 1;
665 xmc[32] = sr & 0x7; sr >>= 3;
666 xmc[33] = sr & 0x7; sr >>= 3;
667 xmc[34] = sr & 0x7; sr >>= 3;
668 sr = *ibuf++; /* 25 */
669 xmc[35] = sr & 0x7; sr >>= 3;
670 xmc[36] = sr & 0x7; sr >>= 3;
671 sr |= (word)*ibuf++ << 2;
672 xmc[37] = sr & 0x7; sr >>= 3;
673 xmc[38] = sr & 0x7; sr >>= 3;
674 sr |= (word)*ibuf++ << 4;
675 Nc[3] = sr & 0x7f; sr >>= 7;
676 bc[3] = sr & 0x3; sr >>= 2;
677 Mc[3] = sr & 0x3; sr >>= 2;
678 sr |= (word)*ibuf++ << 1;
679 xmaxc[3] = sr & 0x3f; sr >>= 6;
680 xmc[39] = sr & 0x7; sr >>= 3;
681 sr = *ibuf++;
682 xmc[40] = sr & 0x7; sr >>= 3;
683 xmc[41] = sr & 0x7; sr >>= 3;
684 sr |= (word)*ibuf++ << 2; /* 30 */
685 xmc[42] = sr & 0x7; sr >>= 3;
686 xmc[43] = sr & 0x7; sr >>= 3;
687 xmc[44] = sr & 0x7; sr >>= 3;
688 sr |= (word)*ibuf++ << 1;
689 xmc[45] = sr & 0x7; sr >>= 3;
690 xmc[46] = sr & 0x7; sr >>= 3;
691 xmc[47] = sr & 0x7; sr >>= 3;
692 sr = *ibuf++;
693 xmc[48] = sr & 0x7; sr >>= 3;
694 xmc[49] = sr & 0x7; sr >>= 3;
695 sr |= (word)*ibuf++ << 2;
696 xmc[50] = sr & 0x7; sr >>= 3;
697 xmc[51] = sr & 0x7; sr >>= 3;
698
699 GSM_Decode(&gsm_state, LARc, Nc, bc, Mc, xmaxc, xmc, obuf);
700
701 /*
702 carry = sr & 0xf;
703 sr = carry;
704 */
705 /* 2nd frame */
706 sr &= 0xf;
707 sr |= (word)*ibuf++ << 4; /* 1 */
708 LARc[0] = sr & 0x3f; sr >>= 6;
709 LARc[1] = sr & 0x3f; sr >>= 6;
710 sr = *ibuf++;
711 LARc[2] = sr & 0x1f; sr >>= 5;
712 sr |= (word)*ibuf++ << 3;
713 LARc[3] = sr & 0x1f; sr >>= 5;
714 LARc[4] = sr & 0xf; sr >>= 4;
715 sr |= (word)*ibuf++ << 2;
716 LARc[5] = sr & 0xf; sr >>= 4;
717 LARc[6] = sr & 0x7; sr >>= 3;
718 LARc[7] = sr & 0x7; sr >>= 3;
719 sr = *ibuf++; /* 5 */
720 Nc[0] = sr & 0x7f; sr >>= 7;
721 sr |= (word)*ibuf++ << 1;
722 bc[0] = sr & 0x3; sr >>= 2;
723 Mc[0] = sr & 0x3; sr >>= 2;
724 sr |= (word)*ibuf++ << 5;
725 xmaxc[0] = sr & 0x3f; sr >>= 6;
726 xmc[0] = sr & 0x7; sr >>= 3;
727 xmc[1] = sr & 0x7; sr >>= 3;
728 sr |= (word)*ibuf++ << 1;
729 xmc[2] = sr & 0x7; sr >>= 3;
730 xmc[3] = sr & 0x7; sr >>= 3;
731 xmc[4] = sr & 0x7; sr >>= 3;
732 sr = *ibuf++;
733 xmc[5] = sr & 0x7; sr >>= 3;
734 xmc[6] = sr & 0x7; sr >>= 3;
735 sr |= (word)*ibuf++ << 2; /* 10 */
736 xmc[7] = sr & 0x7; sr >>= 3;
737 xmc[8] = sr & 0x7; sr >>= 3;
738 xmc[9] = sr & 0x7; sr >>= 3;
739 sr |= (word)*ibuf++ << 1;
740 xmc[10] = sr & 0x7; sr >>= 3;
741 xmc[11] = sr & 0x7; sr >>= 3;
742 xmc[12] = sr & 0x7; sr >>= 3;
743 sr = *ibuf++;
744 Nc[1] = sr & 0x7f; sr >>= 7;
745 sr |= (word)*ibuf++ << 1;
746 bc[1] = sr & 0x3; sr >>= 2;
747 Mc[1] = sr & 0x3; sr >>= 2;
748 sr |= (word)*ibuf++ << 5;
749 xmaxc[1] = sr & 0x3f; sr >>= 6;
750 xmc[13] = sr & 0x7; sr >>= 3;
751 xmc[14] = sr & 0x7; sr >>= 3;
752 sr |= (word)*ibuf++ << 1; /* 15 */
753 xmc[15] = sr & 0x7; sr >>= 3;
754 xmc[16] = sr & 0x7; sr >>= 3;
755 xmc[17] = sr & 0x7; sr >>= 3;
756 sr = *ibuf++;
757 xmc[18] = sr & 0x7; sr >>= 3;
758 xmc[19] = sr & 0x7; sr >>= 3;
759 sr |= (word)*ibuf++ << 2;
760 xmc[20] = sr & 0x7; sr >>= 3;
761 xmc[21] = sr & 0x7; sr >>= 3;
762 xmc[22] = sr & 0x7; sr >>= 3;
763 sr |= (word)*ibuf++ << 1;
764 xmc[23] = sr & 0x7; sr >>= 3;
765 xmc[24] = sr & 0x7; sr >>= 3;
766 xmc[25] = sr & 0x7; sr >>= 3;
767 sr = *ibuf++;
768 Nc[2] = sr & 0x7f; sr >>= 7;
769 sr |= (word)*ibuf++ << 1; /* 20 */
770 bc[2] = sr & 0x3; sr >>= 2;
771 Mc[2] = sr & 0x3; sr >>= 2;
772 sr |= (word)*ibuf++ << 5;
773 xmaxc[2] = sr & 0x3f; sr >>= 6;
774 xmc[26] = sr & 0x7; sr >>= 3;
775 xmc[27] = sr & 0x7; sr >>= 3;
776 sr |= (word)*ibuf++ << 1;
777 xmc[28] = sr & 0x7; sr >>= 3;
778 xmc[29] = sr & 0x7; sr >>= 3;
779 xmc[30] = sr & 0x7; sr >>= 3;
780 sr = *ibuf++;
781 xmc[31] = sr & 0x7; sr >>= 3;
782 xmc[32] = sr & 0x7; sr >>= 3;
783 sr |= (word)*ibuf++ << 2;
784 xmc[33] = sr & 0x7; sr >>= 3;
785 xmc[34] = sr & 0x7; sr >>= 3;
786 xmc[35] = sr & 0x7; sr >>= 3;
787 sr |= (word)*ibuf++ << 1; /* 25 */
788 xmc[36] = sr & 0x7; sr >>= 3;
789 xmc[37] = sr & 0x7; sr >>= 3;
790 xmc[38] = sr & 0x7; sr >>= 3;
791 sr = *ibuf++;
792 Nc[3] = sr & 0x7f; sr >>= 7;
793 sr |= (word)*ibuf++ << 1;
794 bc[3] = sr & 0x3; sr >>= 2;
795 Mc[3] = sr & 0x3; sr >>= 2;
796 sr |= (word)*ibuf++ << 5;
797 xmaxc[3] = sr & 0x3f; sr >>= 6;
798 xmc[39] = sr & 0x7; sr >>= 3;
799 xmc[40] = sr & 0x7; sr >>= 3;
800 sr |= (word)*ibuf++ << 1;
801 xmc[41] = sr & 0x7; sr >>= 3;
802 xmc[42] = sr & 0x7; sr >>= 3;
803 xmc[43] = sr & 0x7; sr >>= 3;
804 sr = (word)*ibuf++; /* 30 */
805 xmc[44] = sr & 0x7; sr >>= 3;
806 xmc[45] = sr & 0x7; sr >>= 3;
807 sr |= (word)*ibuf++ << 2;
808 xmc[46] = sr & 0x7; sr >>= 3;
809 xmc[47] = sr & 0x7; sr >>= 3;
810 xmc[48] = sr & 0x7; sr >>= 3;
811 sr |= (word)*ibuf++ << 1;
812 xmc[49] = sr & 0x7; sr >>= 3;
813 xmc[50] = sr & 0x7; sr >>= 3;
814 xmc[51] = sr & 0x7; sr >>= 3;
815
816 GSM_Decode(&gsm_state, LARc, Nc, bc, Mc, xmaxc, xmc, &obuf[160]);
817
818 /* Return number of source bytes consumed and output samples produced */
819 // *icnt = 65;
820 // *ocnt = 320;
821 return;
822 }
823
824 #define GSM_MAGIC 0xd
825
826 void XA_GSM_Decoder(unsigned char *ibuf,unsigned short *obuf)
827 { word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
828
829 /* Sanity */
830 if (((*ibuf >> 4) & 0x0F) != GSM_MAGIC)
831 { int i;
832 for(i=0;i<160;i++) obuf[i] = 0;
833 // *icnt = 33;
834 // *ocnt = 160;
835 return;
836 }
837
838 LARc[0] = (*ibuf++ & 0xF) << 2; /* 1 */
839 LARc[0] |= (*ibuf >> 6) & 0x3;
840 LARc[1] = *ibuf++ & 0x3F;
841 LARc[2] = (*ibuf >> 3) & 0x1F;
842 LARc[3] = (*ibuf++ & 0x7) << 2;
843 LARc[3] |= (*ibuf >> 6) & 0x3;
844 LARc[4] = (*ibuf >> 2) & 0xF;
845 LARc[5] = (*ibuf++ & 0x3) << 2;
846 LARc[5] |= (*ibuf >> 6) & 0x3;
847 LARc[6] = (*ibuf >> 3) & 0x7;
848 LARc[7] = *ibuf++ & 0x7;
849
850 Nc[0] = (*ibuf >> 1) & 0x7F;
851
852 bc[0] = (*ibuf++ & 0x1) << 1;
853 bc[0] |= (*ibuf >> 7) & 0x1;
854
855 Mc[0] = (*ibuf >> 5) & 0x3;
856
857 xmaxc[0] = (*ibuf++ & 0x1F) << 1;
858 xmaxc[0] |= (*ibuf >> 7) & 0x1;
859
860 xmc[0] = (*ibuf >> 4) & 0x7;
861 xmc[1] = (*ibuf >> 1) & 0x7;
862 xmc[2] = (*ibuf++ & 0x1) << 2;
863 xmc[2] |= (*ibuf >> 6) & 0x3;
864 xmc[3] = (*ibuf >> 3) & 0x7;
865 xmc[4] = *ibuf++ & 0x7;
866 xmc[5] = (*ibuf >> 5) & 0x7;
867 xmc[6] = (*ibuf >> 2) & 0x7;
868 xmc[7] = (*ibuf++ & 0x3) << 1; /* 10 */
869 xmc[7] |= (*ibuf >> 7) & 0x1;
870 xmc[8] = (*ibuf >> 4) & 0x7;
871 xmc[9] = (*ibuf >> 1) & 0x7;
872 xmc[10] = (*ibuf++ & 0x1) << 2;
873 xmc[10] |= (*ibuf >> 6) & 0x3;
874 xmc[11] = (*ibuf >> 3) & 0x7;
875 xmc[12] = *ibuf++ & 0x7;
876
877 Nc[1] = (*ibuf >> 1) & 0x7F;
878
879 bc[1] = (*ibuf++ & 0x1) << 1;
880 bc[1] |= (*ibuf >> 7) & 0x1;
881
882 Mc[1] = (*ibuf >> 5) & 0x3;
883
884 xmaxc[1] = (*ibuf++ & 0x1F) << 1;
885 xmaxc[1] |= (*ibuf >> 7) & 0x1;
886
887
888 xmc[13] = (*ibuf >> 4) & 0x7;
889 xmc[14] = (*ibuf >> 1) & 0x7;
890 xmc[15] = (*ibuf++ & 0x1) << 2;
891 xmc[15] |= (*ibuf >> 6) & 0x3;
892 xmc[16] = (*ibuf >> 3) & 0x7;
893 xmc[17] = *ibuf++ & 0x7;
894 xmc[18] = (*ibuf >> 5) & 0x7;
895 xmc[19] = (*ibuf >> 2) & 0x7;
896 xmc[20] = (*ibuf++ & 0x3) << 1;
897 xmc[20] |= (*ibuf >> 7) & 0x1;
898 xmc[21] = (*ibuf >> 4) & 0x7;
899 xmc[22] = (*ibuf >> 1) & 0x7;
900 xmc[23] = (*ibuf++ & 0x1) << 2;
901 xmc[23] |= (*ibuf >> 6) & 0x3;
902 xmc[24] = (*ibuf >> 3) & 0x7;
903 xmc[25] = *ibuf++ & 0x7;
904
905 Nc[2] = (*ibuf >> 1) & 0x7F;
906
907 bc[2] = (*ibuf++ & 0x1) << 1; /* 20 */
908 bc[2] |= (*ibuf >> 7) & 0x1;
909
910 Mc[2] = (*ibuf >> 5) & 0x3;
911
912 xmaxc[2] = (*ibuf++ & 0x1F) << 1;
913 xmaxc[2] |= (*ibuf >> 7) & 0x1;
914
915
916 xmc[26] = (*ibuf >> 4) & 0x7;
917 xmc[27] = (*ibuf >> 1) & 0x7;
918 xmc[28] = (*ibuf++ & 0x1) << 2;
919 xmc[28] |= (*ibuf >> 6) & 0x3;
920 xmc[29] = (*ibuf >> 3) & 0x7;
921 xmc[30] = *ibuf++ & 0x7;
922 xmc[31] = (*ibuf >> 5) & 0x7;
923 xmc[32] = (*ibuf >> 2) & 0x7;
924 xmc[33] = (*ibuf++ & 0x3) << 1;
925 xmc[33] |= (*ibuf >> 7) & 0x1;
926 xmc[34] = (*ibuf >> 4) & 0x7;
927 xmc[35] = (*ibuf >> 1) & 0x7;
928 xmc[36] = (*ibuf++ & 0x1) << 2;
929 xmc[36] |= (*ibuf >> 6) & 0x3;
930 xmc[37] = (*ibuf >> 3) & 0x7;
931 xmc[38] = *ibuf++ & 0x7;
932
933 Nc[3] = (*ibuf >> 1) & 0x7F;
934
935 bc[3] = (*ibuf++ & 0x1) << 1;
936 bc[3] |= (*ibuf >> 7) & 0x1;
937
938 Mc[3] = (*ibuf >> 5) & 0x3;
939
940 xmaxc[3] = (*ibuf++ & 0x1F) << 1;
941 xmaxc[3] |= (*ibuf >> 7) & 0x1;
942
943 xmc[39] = (*ibuf >> 4) & 0x7;
944 xmc[40] = (*ibuf >> 1) & 0x7;
945 xmc[41] = (*ibuf++ & 0x1) << 2;
946 xmc[41] |= (*ibuf >> 6) & 0x3;
947 xmc[42] = (*ibuf >> 3) & 0x7;
948 xmc[43] = *ibuf++ & 0x7; /* 30 */
949 xmc[44] = (*ibuf >> 5) & 0x7;
950 xmc[45] = (*ibuf >> 2) & 0x7;
951 xmc[46] = (*ibuf++ & 0x3) << 1;
952 xmc[46] |= (*ibuf >> 7) & 0x1;
953 xmc[47] = (*ibuf >> 4) & 0x7;
954 xmc[48] = (*ibuf >> 1) & 0x7;
955 xmc[49] = (*ibuf++ & 0x1) << 2;
956 xmc[49] |= (*ibuf >> 6) & 0x3;
957 xmc[50] = (*ibuf >> 3) & 0x7;
958 xmc[51] = *ibuf & 0x7; /* 33 */
959
960 GSM_Decode(&gsm_state, LARc, Nc, bc, Mc, xmaxc, xmc, obuf);
961
962 /* Return number of source bytes consumed and output samples produced */
963 // *icnt = 33;
964 // *ocnt = 160;
965 }