1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 /****************************************************************************************
19 Portions of this file are derived from the following 3GPP standard:
20
21 3GPP TS 26.073
22 ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
23 Available from http://www.3gpp.org
24
25 (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
26 Permission to distribute, modify and use this file under the standard license
27 terms listed above has been obtained from the copyright holder.
28 ****************************************************************************************/
29 /*
30 ------------------------------------------------------------------------------
31
32
33
34 Filename: d8_31pf.cpp
35
36 ------------------------------------------------------------------------------
37
38 MODULE DESCRIPTION
39 */
40
41 /*----------------------------------------------------------------------------
42 ; INCLUDES
43 ----------------------------------------------------------------------------*/
44 #include "d8_31pf.h"
45 #include "typedef.h"
46 #include "basic_op.h"
47 #include "cnst.h"
48
49
50 /*----------------------------------------------------------------------------
51 ; MACROS
52 ; Define module specific macros here
53 ----------------------------------------------------------------------------*/
54
55 /*----------------------------------------------------------------------------
56 ; DEFINES
57 ; Include all pre-processor statements here. Include conditional
58 ; compile variables also.
59 ----------------------------------------------------------------------------*/
60 #define NB_PULSE 8 /* number of pulses */
61
62 /* define values/representation for output codevector and sign */
63 #define POS_CODE 8191
64 #define NEG_CODE 8191
65
66
67 /*----------------------------------------------------------------------------
68 ; LOCAL FUNCTION DEFINITIONS
69 ; Function Prototype declaration
70 ----------------------------------------------------------------------------*/
71
72 /*----------------------------------------------------------------------------
73 ; LOCAL VARIABLE DEFINITIONS
74 ; Variable declaration - defined here and used outside this module
75 ----------------------------------------------------------------------------*/
76
77 /*
78 ------------------------------------------------------------------------------
79 FUNCTION NAME: decompress10
80 ------------------------------------------------------------------------------
81 INPUT AND OUTPUT DEFINITIONS
82
83 Inputs:
84 MSBs -- Word16 -- MSB part of the index
85 LSBs -- Word16 -- LSB part of the index
86 index1 -- Word16 -- index for first pos in pos_index[]
87 index2 -- Word16 -- index for second pos in pos_index[]
88 index3 -- Word16 -- index for third pos in pos_index[]
89
90 Outputs:
91 pos_indx[] -- array of type Word16 -- position of 3 pulses (decompressed)
92
93 pOverflow Flag set when overflow occurs, pointer of type Flag *
94
95 Returns:
96 None
97
98 Global Variables Used:
99 None
100
101 Local Variables Needed:
102 None
103
104 ------------------------------------------------------------------------------
105 FUNCTION DESCRIPTION
106
107
108 ------------------------------------------------------------------------------
109 REQUIREMENTS
110
111 None
112
113 ------------------------------------------------------------------------------
114 REFERENCES
115
116 d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
117
118 ------------------------------------------------------------------------------
119 PSEUDO-CODE
120
121
122 ------------------------------------------------------------------------------
123 CAUTION [optional]
124 [State any special notes, constraints or cautions for users of this function]
125
126 ------------------------------------------------------------------------------
127 */
128
decompress10(Word16 MSBs,Word16 LSBs,Word16 index1,Word16 index2,Word16 index3,Word16 pos_indx[],Flag * pOverflow)129 static void decompress10(
130 Word16 MSBs, /* i : MSB part of the index */
131 Word16 LSBs, /* i : LSB part of the index */
132 Word16 index1, /* i : index for first pos in pos_index[] */
133 Word16 index2, /* i : index for second pos in pos_index[] */
134 Word16 index3, /* i : index for third pos in pos_index[] */
135 Word16 pos_indx[], /* o : position of 3 pulses (decompressed) */
136 Flag *pOverflow) /* o : Flag set when overflow occurs */
137 {
138 Word16 ia;
139 Word16 ib;
140 Word16 ic;
141 Word32 tempWord32;
142
143 /*
144 pos_indx[index1] = ((MSBs-25*(MSBs/25))%5)*2 + (LSBs-4*(LSBs/4))%2;
145 pos_indx[index2] = ((MSBs-25*(MSBs/25))/5)*2 + (LSBs-4*(LSBs/4))/2;
146 pos_indx[index3] = (MSBs/25)*2 + LSBs/4;
147 */
148
149 if (MSBs > 124)
150 {
151 MSBs = 124;
152 }
153
154 ia =
155 mult(
156 MSBs,
157 1311,
158 pOverflow);
159
160 tempWord32 =
161 L_mult(
162 ia,
163 25,
164 pOverflow);
165
166
167 ia = (Word16)(MSBs - (tempWord32 >> 1));
168 ib =
169 mult(
170 ia,
171 6554,
172 pOverflow);
173
174 tempWord32 =
175 L_mult(
176 ib,
177 5,
178 pOverflow);
179
180 ib = ia - (Word16)(tempWord32 >> 1);
181
182 ib =
183 shl(
184 ib,
185 1,
186 pOverflow);
187
188
189 ic = LSBs - ((LSBs >> 2) << 2);
190
191
192 pos_indx[index1] = ib + (ic & 1);
193
194
195 ib =
196 mult(
197 ia,
198 6554,
199 pOverflow);
200
201 ib =
202 shl(
203 ib,
204 1,
205 pOverflow);
206
207
208 pos_indx[index2] = ib + (ic >> 1);
209
210
211 ib = LSBs >> 2;
212
213 ic =
214 mult(
215 MSBs,
216 1311,
217 pOverflow);
218
219 ic =
220 shl(
221 ic,
222 1,
223 pOverflow);
224
225 pos_indx[index3] = add_16(ib, ic, pOverflow);
226
227 return;
228 }
229
230
231 /*
232 ------------------------------------------------------------------------------
233 FUNCTION NAME: decompress_code
234 ------------------------------------------------------------------------------
235 INPUT AND OUTPUT DEFINITIONS
236
237 Inputs:
238 indx[] -- array of type Word16 -- position and sign of
239 8 pulses (compressed)
240
241 Outputs:
242 sign_indx[] -- array of type Word16 -- signs of 4 pulses (signs only)
243 pos_indx[] -- array of type Word16 -- position index of 8 pulses
244 (position only)
245 pOverflow pointer to type Flag -- Flag set when overflow occurs
246
247 Returns:
248 None
249
250 Global Variables Used:
251 None
252
253 Local Variables Needed:
254 None
255
256 ------------------------------------------------------------------------------
257 FUNCTION DESCRIPTION
258
259 PURPOSE: decompression of the linear codewords to 4+three indeces
260 one bit from each pulse is made robust to errors by
261 minimizing the phase shift of a bit error.
262 4 signs (one for each track)
263 i0,i4,i1 => one index (7+3) bits, 3 LSBs more robust
264 i2,i6,i5 => one index (7+3) bits, 3 LSBs more robust
265 i3,i7 => one index (5+2) bits, 2-3 LSbs more robust
266
267 ------------------------------------------------------------------------------
268 REQUIREMENTS
269
270 None
271
272 ------------------------------------------------------------------------------
273 REFERENCES
274
275 d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
276
277 ------------------------------------------------------------------------------
278 PSEUDO-CODE
279
280
281 ------------------------------------------------------------------------------
282 CAUTION [optional]
283 [State any special notes, constraints or cautions for users of this function]
284
285 ------------------------------------------------------------------------------
286 */
287
decompress_code(Word16 indx[],Word16 sign_indx[],Word16 pos_indx[],Flag * pOverflow)288 static void decompress_code(
289 Word16 indx[], /* i : position and sign of 8 pulses (compressed) */
290 Word16 sign_indx[], /* o : signs of 4 pulses (signs only) */
291 Word16 pos_indx[], /* o : position index of 8 pulses (position only) */
292 Flag *pOverflow /* o : Flag set when overflow occurs */
293 )
294 {
295 Word16 i;
296 Word16 ia;
297 Word16 ib;
298 Word16 MSBs;
299 Word16 LSBs;
300 Word16 MSBs0_24;
301 Word32 tempWord32;
302
303 for (i = 0; i < NB_TRACK_MR102; i++)
304 {
305 sign_indx[i] = indx[i];
306 }
307
308 /*
309 First index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits
310 MSBs = indx[NB_TRACK]/8;
311 LSBs = indx[NB_TRACK]%8;
312 */
313 MSBs = indx[NB_TRACK_MR102] >> 3;
314
315 LSBs = indx[NB_TRACK_MR102] & 0x7;
316
317 decompress10(
318 MSBs,
319 LSBs,
320 0,
321 4,
322 1,
323 pos_indx,
324 pOverflow);
325
326 /*
327 Second index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits
328 MSBs = indx[NB_TRACK+1]/8;
329 LSBs = indx[NB_TRACK+1]%8;
330 */
331 MSBs = indx[NB_TRACK_MR102+1] >> 3;
332
333 LSBs = indx[NB_TRACK_MR102+1] & 0x7;
334
335 decompress10(
336 MSBs,
337 LSBs,
338 2,
339 6,
340 5,
341 pos_indx,
342 pOverflow);
343
344 /*
345 Third index: 10x10 -> 2x5x2x5-> 25x2x2 -> 5+1x2 bits
346 MSBs = indx[NB_TRACK+2]/4;
347 LSBs = indx[NB_TRACK+2]%4;
348 MSBs0_24 = (MSBs*25+12)/32;
349 if ((MSBs0_24/5)%2==1)
350 pos_indx[3] = (4-(MSBs0_24%5))*2 + LSBs%2;
351 else
352 pos_indx[3] = (MSBs0_24%5)*2 + LSBs%2;
353 pos_indx[7] = (MSBs0_24/5)*2 + LSBs/2;
354 */
355
356 MSBs = indx[NB_TRACK_MR102+2] >> 2;
357
358 LSBs = indx[NB_TRACK_MR102+2] & 0x3;
359
360 tempWord32 =
361 L_mult(
362 MSBs,
363 25,
364 pOverflow);
365
366 ia =
367 (Word16)
368 L_shr(
369 tempWord32,
370 1,
371 pOverflow);
372
373 ia += 12;
374
375 MSBs0_24 = ia >> 5;
376
377
378 ia =
379 mult(
380 MSBs0_24,
381 6554,
382 pOverflow);
383
384 ia &= 1;
385
386
387 ib =
388 mult(
389 MSBs0_24,
390 6554,
391 pOverflow);
392
393 tempWord32 =
394 L_mult(
395 ib,
396 5,
397 pOverflow);
398
399
400 ib = MSBs0_24 - (Word16)(tempWord32 >> 1);
401
402 if (ia == 1)
403 {
404 ib = 4 - ib;
405
406 }
407
408
409 ib =
410 shl(
411 ib,
412 1,
413 pOverflow);
414
415 ia = LSBs & 0x1;
416
417 pos_indx[3] =
418 add_16(
419 ib,
420 ia,
421 pOverflow);
422
423 ia =
424 mult(
425 MSBs0_24,
426 6554,
427 pOverflow);
428
429 ia =
430 shl(
431 ia,
432 1,
433 pOverflow);
434
435 pos_indx[7] = ia + (LSBs >> 1);
436
437 }
438
439 /*
440 ------------------------------------------------------------------------------
441 FUNCTION NAME: dec_8i40_31bits
442 ------------------------------------------------------------------------------
443 INPUT AND OUTPUT DEFINITIONS
444
445 Inputs:
446 index array of type Word16 -- index of 8 pulses (sign+position)
447
448 Outputs:
449 cod array of type Word16 -- algebraic (fixed) codebook excitation
450 pOverflow pointer to type Flag -- Flag set when overflow occurs
451
452 Returns:
453 None
454
455 Global Variables Used:
456 None
457
458 Local Variables Needed:
459 None
460
461 ------------------------------------------------------------------------------
462 FUNCTION DESCRIPTION
463
464 PURPOSE: Builds the innovative codevector from the received
465 index of algebraic codebook.
466
467 ------------------------------------------------------------------------------
468 REQUIREMENTS
469
470 None
471
472 ------------------------------------------------------------------------------
473 REFERENCES
474
475 d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
476
477 ------------------------------------------------------------------------------
478 PSEUDO-CODE
479
480
481 ------------------------------------------------------------------------------
482 CAUTION [optional]
483 [State any special notes, constraints or cautions for users of this function]
484
485 ------------------------------------------------------------------------------
486 */
487
dec_8i40_31bits(Word16 index[],Word16 cod[],Flag * pOverflow)488 void dec_8i40_31bits(
489 Word16 index[], /* i : index of 8 pulses (sign+position) */
490 Word16 cod[], /* o : algebraic (fixed) codebook excitation */
491 Flag *pOverflow /* o : Flag set when overflow occurs */
492 )
493 {
494 Word16 i;
495 Word16 j;
496 Word16 pos1;
497 Word16 pos2;
498 Word16 sign;
499
500 Word16 linear_signs[NB_TRACK_MR102];
501 Word16 linear_codewords[NB_PULSE];
502
503 for (i = 0; i < L_CODE; i++)
504 {
505 cod[i] = 0;
506 }
507
508 decompress_code(
509 index,
510 linear_signs,
511 linear_codewords,
512 pOverflow);
513
514 /* decode the positions and signs of pulses and build the codeword */
515 for (j = 0; j < NB_TRACK_MR102; j++) /* NB_TRACK_MR102 = 4 */
516 {
517 /* position of pulse "j" */
518
519 pos1 = (linear_codewords[j] << 2) + j;
520
521
522 if (linear_signs[j] == 0)
523 {
524 sign = POS_CODE; /* +1.0 */
525 }
526 else
527 {
528 sign = -NEG_CODE; /* -1.0 */
529 }
530
531 if (pos1 < L_SUBFR)
532 {
533 cod[pos1] = sign; /* avoid buffer overflow */
534 }
535
536 /* compute index i */
537 /* position of pulse "j+4" */
538
539 pos2 = (linear_codewords[j + 4] << 2) + j;
540
541
542 if (pos2 < pos1)
543 {
544 sign = negate(sign);
545 }
546
547 if (pos2 < L_SUBFR)
548 {
549 cod[pos2] += sign; /* avoid buffer overflow */
550 }
551
552
553 } /* for (j = 0; j < NB_TRACK_MR102; j++) */
554
555 return;
556 }
557