summaryrefslogtreecommitdiff
path: root/audio_codec/libamr/interf_dec.c (plain)
blob: 291ef20aa5971114e07f43d7ce157c72faacbd0c
1/*
2 * ===================================================================
3 * TS 26.104
4 * R99 V3.5.0 2003-03
5 * REL-4 V4.4.0 2003-03
6 * REL-5 V5.1.0 2003-03
7 * 3GPP AMR Floating-point Speech Codec
8 * ===================================================================
9 *
10 */
11
12/*
13 * interf_dec.c
14 *
15 *
16 * Project:
17 * AMR Floating-Point Codec
18 *
19 * Contains:
20 * This module provides means to conversion from 3GPP or ETSI
21 * bitstream to AMR parameters
22 */
23
24/*
25 * include files
26 */
27#include <stdlib.h>
28#include <stdio.h>
29#include <memory.h>
30#include "typedef.h"
31#include "sp_dec.h"
32#include "interf_rom.h"
33#include "rom_dec.h"
34
35/*
36 * definition of constants
37 */
38#define EHF_MASK 0x0008 /* encoder homing frame pattern */
39typedef
40
41struct {
42 int reset_flag_old; /* previous was homing frame */
43
44
45 enum RXFrameType prev_ft; /* previous frame type */
46 enum Mode prev_mode; /* previous mode */
47 void *decoder_State; /* Points decoder state */
48
49
50} dec_interface_State;
51
52#ifdef ETSI
53
54
55/*
56 * Bin2Int
57 *
58 *
59 * Parameters:
60 * no_of_bits I: number of bits associated with value
61 * bits O: address where bits are written
62 *
63 * Function:
64 * Read nuber of bits from the array and convert to integer.
65 *
66 * Returns:
67 * value
68 */
69static Word16 Bin2Int(Word16 no_of_bits, Word16 *bitstream)
70{
71 Word32 value, i, bit;
72
73
74 value = 0;
75
76 for (i = 0; i < no_of_bits; i++) {
77 value = value << 1;
78 bit = *bitstream++;
79
80 if (bit == 0x1) {
81 value = value + 1;
82 }
83 }
84 return(Word16)(value);
85}
86
87
88/*
89 * Bits2Prm
90 *
91 *
92 * Parameters:
93 * mode I: AMR mode
94 * bits I: serial bits
95 * param O: AMR parameters
96 *
97 * Function:
98 * Retrieves the vector of encoder parameters from
99 * the received serial bits in a frame.
100 *
101 * Returns:
102 * void
103 */
104static void Bits2Prm(enum Mode mode, Word16 bits[], Word16 prm[])
105{
106 Word32 i;
107
108
109 switch (mode) {
110 case MR122:
111 for (i = 0; i < PRMNO_MR122; i++) {
112 prm[i] = Bin2Int(bitno_MR122[i], bits);
113 bits += bitno_MR122[i];
114 }
115 break;
116
117 case MR102:
118 for (i = 0; i < PRMNO_MR102; i++) {
119 prm[i] = Bin2Int(bitno_MR102[i], bits);
120 bits += bitno_MR102[i];
121 }
122 break;
123
124 case MR795:
125 for (i = 0; i < PRMNO_MR795; i++) {
126 prm[i] = Bin2Int(bitno_MR795[i], bits);
127 bits += bitno_MR795[i];
128 }
129 break;
130
131 case MR74:
132 for (i = 0; i < PRMNO_MR74; i++) {
133 prm[i] = Bin2Int(bitno_MR74[i], bits);
134 bits += bitno_MR74[i];
135 }
136 break;
137
138 case MR67:
139 for (i = 0; i < PRMNO_MR67; i++) {
140 prm[i] = Bin2Int(bitno_MR67[i], bits);
141 bits += bitno_MR67[i];
142 }
143 break;
144
145 case MR59:
146 for (i = 0; i < PRMNO_MR59; i++) {
147 prm[i] = Bin2Int(bitno_MR59[i], bits);
148 bits += bitno_MR59[i];
149 }
150 break;
151
152 case MR515:
153 for (i = 0; i < PRMNO_MR515; i++) {
154 prm[i] = Bin2Int(bitno_MR515[i], bits);
155 bits += bitno_MR515[i];
156 }
157 break;
158
159 case MR475:
160 for (i = 0; i < PRMNO_MR475; i++) {
161 prm[i] = Bin2Int(bitno_MR475[i], bits);
162 bits += bitno_MR475[i];
163 }
164 break;
165
166 case MRDTX:
167 for (i = 0; i < PRMNO_MRDTX; i++) {
168 prm[i] = Bin2Int(bitno_MRDTX[i], bits);
169 bits += bitno_MRDTX[i];
170 }
171 break;
172 }
173 return;
174}
175
176#else
177
178#ifndef IF2
179
180/*
181 * DecoderMMS
182 *
183 *
184 * Parameters:
185 * param O: AMR parameters
186 * stream I: input bitstream
187 * frame_type O: frame type
188 * speech_mode O: speech mode in DTX
189 *
190 * Function:
191 * AMR file storage format frame to decoder parameters
192 *
193 * Returns:
194 * mode used mode
195 */
196enum Mode DecoderMMS(Word16 *param, UWord8 *stream, enum RXFrameType
197 *frame_type, enum Mode *speech_mode, Word16 *q_bit)
198{
199 enum Mode mode;
200 Word32 j;
201 Word16 *mask;
202
203
204 memset(param, 0, PRMNO_MR122 << 1);
205 *q_bit = 0x01 & (*stream >> 2);
206 mode = 0x0F & (*stream >> 3);
207 stream++;
208
209 if (mode == MRDTX) {
210 mask = order_MRDTX;
211
212 for (j = 1; j < 36; j++) {
213 if (*stream & 0x80) {
214 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
215 }
216 mask += 2;
217
218 if (j % 8) {
219 *stream <<= 1;
220 } else {
221 stream++;
222 }
223 }
224
225 /* get SID type bit */
226
227 *frame_type = RX_SID_FIRST;
228 if (*stream & 0x80) {
229 *frame_type = RX_SID_UPDATE;
230 }
231
232 /* since there is update, use it */
233 /* *frame_type = RX_SID_UPDATE; */
234
235 /* speech mode indicator */
236 *speech_mode = (*stream >> 4) && 0x07;
237
238 } else if (mode == 15) {
239 *frame_type = RX_NO_DATA;
240 } else if (mode == MR475) {
241 mask = order_MR475;
242
243 for (j = 1; j < 96; j++) {
244 if (*stream & 0x80) {
245 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
246 }
247 mask += 2;
248
249 if (j % 8) {
250 *stream <<= 1;
251 } else {
252 stream++;
253 }
254 }
255 *frame_type = RX_SPEECH_GOOD;
256 } else if (mode == MR515) {
257 mask = order_MR515;
258
259 for (j = 1; j < 104; j++) {
260 if (*stream & 0x80) {
261 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
262 }
263 mask += 2;
264
265 if (j % 8) {
266 *stream <<= 1;
267 } else {
268 stream++;
269 }
270 }
271 *frame_type = RX_SPEECH_GOOD;
272 } else if (mode == MR59) {
273 mask = order_MR59;
274
275 for (j = 1; j < 119; j++) {
276 if (*stream & 0x80) {
277 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
278 }
279 mask += 2;
280
281 if (j % 8) {
282 *stream <<= 1;
283 } else {
284 stream++;
285 }
286 }
287 *frame_type = RX_SPEECH_GOOD;
288 } else if (mode == MR67) {
289 mask = order_MR67;
290
291 for (j = 1; j < 135; j++) {
292 if (*stream & 0x80) {
293 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
294 }
295 mask += 2;
296
297 if (j % 8) {
298 *stream <<= 1;
299 } else {
300 stream++;
301 }
302 }
303 *frame_type = RX_SPEECH_GOOD;
304 } else if (mode == MR74) {
305 mask = order_MR74;
306
307 for (j = 1; j < 149; j++) {
308 if (*stream & 0x80) {
309 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
310 }
311 mask += 2;
312
313 if (j % 8) {
314 *stream <<= 1;
315 } else {
316 stream++;
317 }
318 }
319 *frame_type = RX_SPEECH_GOOD;
320 } else if (mode == MR795) {
321 mask = order_MR795;
322
323 for (j = 1; j < 160; j++) {
324 if (*stream & 0x80) {
325 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
326 }
327 mask += 2;
328
329 if (j % 8) {
330 *stream <<= 1;
331 } else {
332 stream++;
333 }
334 }
335 *frame_type = RX_SPEECH_GOOD;
336 } else if (mode == MR102) {
337 mask = order_MR102;
338
339 for (j = 1; j < 205; j++) {
340 if (*stream & 0x80) {
341 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
342 }
343 mask += 2;
344
345 if (j % 8) {
346 *stream <<= 1;
347 } else {
348 stream++;
349 }
350 }
351 *frame_type = RX_SPEECH_GOOD;
352 } else if (mode == MR122) {
353 mask = order_MR122;
354
355 for (j = 1; j < 245; j++) {
356 if (*stream & 0x80) {
357 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
358 }
359 mask += 2;
360
361 if (j % 8) {
362 *stream <<= 1;
363 } else {
364 stream++;
365 }
366 }
367 *frame_type = RX_SPEECH_GOOD;
368 } else {
369 *frame_type = RX_SPEECH_BAD;
370 }
371 return mode;
372}
373
374#else
375
376/*
377 * Decoder3GPP
378 *
379 *
380 * Parameters:
381 * param O: AMR parameters
382 * stream I: input bitstream
383 * frame_type O: frame type
384 * speech_mode O: speech mode in DTX
385 *
386 * Function:
387 * Resets state memory
388 *
389 * Returns:
390 * mode used mode
391 */
392enum Mode Decoder3GPP(Word16 *param, UWord8 *stream, enum RXFrameType
393 *frame_type, enum Mode *speech_mode)
394{
395 enum Mode mode;
396 Word32 j;
397 Word16 *mask;
398
399
400 memset(param, 0, PRMNO_MR122 << 1);
401 mode = 0xF & *stream;
402 *stream >>= 4;
403
404 if (mode == MRDTX) {
405 mask = order_MRDTX;
406
407 for (j = 5; j < 40; j++) {
408 if (*stream & 0x1) {
409 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
410 }
411 mask += 2;
412
413 if (j % 8) {
414 *stream >>= 1;
415 } else {
416 stream++;
417 }
418 }
419
420 /* get SID type bit */
421
422 *frame_type = RX_SID_FIRST;
423 if (*stream) {
424 *frame_type = RX_SID_UPDATE;
425 }
426
427 /* since there is update, use it */
428 /* *frame_type = RX_SID_UPDATE; */
429 stream++;
430
431 /* speech mode indicator */
432 *speech_mode = *stream;
433 } else if (mode == 15) {
434 *frame_type = RX_NO_DATA;
435 } else if (mode == MR475) {
436 mask = order_MR475;
437
438 for (j = 5; j < 100; j++) {
439 if (*stream & 0x1) {
440 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
441 }
442 mask += 2;
443
444 if (j % 8) {
445 *stream >>= 1;
446 } else {
447 stream++;
448 }
449 }
450 *frame_type = RX_SPEECH_GOOD;
451 } else if (mode == MR515) {
452 mask = order_MR515;
453
454 for (j = 5; j < 108; j++) {
455 if (*stream & 0x1) {
456 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
457 }
458 mask += 2;
459
460 if (j % 8) {
461 *stream >>= 1;
462 } else {
463 stream++;
464 }
465 }
466 *frame_type = RX_SPEECH_GOOD;
467 } else if (mode == MR59) {
468 mask = order_MR59;
469
470 for (j = 5; j < 123; j++) {
471 if (*stream & 0x1) {
472 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
473 }
474 mask += 2;
475
476 if (j % 8) {
477 *stream >>= 1;
478 } else {
479 stream++;
480 }
481 }
482 *frame_type = RX_SPEECH_GOOD;
483 } else if (mode == MR67) {
484 mask = order_MR67;
485
486 for (j = 5; j < 139; j++) {
487 if (*stream & 0x1) {
488 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
489 }
490 mask += 2;
491
492 if (j % 8) {
493 *stream >>= 1;
494 } else {
495 stream++;
496 }
497 }
498 *frame_type = RX_SPEECH_GOOD;
499 } else if (mode == MR74) {
500 mask = order_MR74;
501
502 for (j = 5; j < 153; j++) {
503 if (*stream & 0x1) {
504 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
505 }
506 mask += 2;
507
508 if (j % 8) {
509 *stream >>= 1;
510 } else {
511 stream++;
512 }
513 }
514 *frame_type = RX_SPEECH_GOOD;
515 } else if (mode == MR795) {
516 mask = order_MR795;
517
518 for (j = 5; j < 164; j++) {
519 if (*stream & 0x1) {
520 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
521 }
522 mask += 2;
523
524 if (j % 8) {
525 *stream >>= 1;
526 } else {
527 stream++;
528 }
529 }
530 *frame_type = RX_SPEECH_GOOD;
531 } else if (mode == MR102) {
532 mask = order_MR102;
533
534 for (j = 5; j < 209; j++) {
535 if (*stream & 0x1) {
536 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
537 }
538 mask += 2;
539
540 if (j % 8) {
541 *stream >>= 1;
542 } else {
543 stream++;
544 }
545 }
546 *frame_type = RX_SPEECH_GOOD;
547 } else if (mode == MR122) {
548 mask = order_MR122;
549
550 for (j = 5; j < 249; j++) {
551 if (*stream & 0x1) {
552 param[ * mask] = (short)(param[ * mask] + * (mask + 1));
553 }
554 mask += 2;
555
556 if (j % 8) {
557 *stream >>= 1;
558 } else {
559 stream++;
560 }
561 }
562 *frame_type = RX_SPEECH_GOOD;
563 } else {
564 *frame_type = RX_SPEECH_BAD;
565 }
566 return mode;
567}
568#endif
569#endif
570
571/*
572 * Decoder_Interface_reset
573 *
574 *
575 * Parameters:
576 * st O: state struct
577 *
578 * Function:
579 * Reset homing frame counter
580 *
581 * Returns:
582 * void
583 */
584void Decoder_Interface_reset(dec_interface_State *st)
585{
586 st->reset_flag_old = 1;
587 st->prev_ft = RX_SPEECH_GOOD;
588 st->prev_mode = MR475; /* minimum bitrate */
589}
590
591
592/*
593 * Decoder_Interface_init
594 *
595 *
596 * Parameters:
597 * void
598 *
599 * Function:
600 * Allocates state memory and initializes state memory
601 *
602 * Returns:
603 * success : pointer to structure
604 * failure : NULL
605 */
606static dec_interface_State g_dec_interface_State;
607void * Decoder_Interface_init(void)
608{
609 dec_interface_State * s;
610
611 /* allocate memory */
612 /*if ( ( s = ( dec_interface_State * ) tlsf_malloc( sizeof( dec_interface_State ) ) ) ==
613 NULL ) {
614 fprintf( stderr, "Decoder_Interface_init: "
615 "can not malloc state structure\n" );
616 return NULL;
617 }*/
618 s = &g_dec_interface_State;
619
620 s->decoder_State = Speech_Decode_Frame_init();
621
622 if (s->decoder_State == NULL) {
623 // tlsf_free( s );
624 return NULL;
625 }
626 Decoder_Interface_reset(s);
627 return (void *)s;
628}
629
630
631/*
632 * Decoder_Interface_exit
633 *
634 *
635 * Parameters:
636 * state I: state structure
637 *
638 * Function:
639 * The memory used for state memory is freed
640 *
641 * Returns:
642 * Void
643 */
644void Decoder_Interface_exit(void *state)
645{
646 dec_interface_State * s;
647 s = (dec_interface_State *)state;
648
649 /* free memory */
650 Speech_Decode_Frame_exit(s->decoder_State);
651 // tlsf_free( s );
652 s = NULL;
653 state = NULL;
654}
655
656
657/*
658 * Decoder_Interface_Decode
659 *
660 *
661 * Parameters:
662 * st B: state structure
663 * bits I: bit stream
664 * synth O: synthesized speech
665 * bfi I: bad frame indicator
666 *
667 * Function:
668 * Decode bit stream to synthesized speech
669 *
670 * Returns:
671 * Void
672 */
673void Decoder_Interface_Decode(void *st,
674
675#ifndef ETSI
676 UWord8 *bits,
677
678#else
679 Word16 *bits,
680#endif
681
682 Word16 *synth, int bfi)
683{
684 enum Mode mode; /* AMR mode */
685
686#ifndef ETSI
687 enum Mode speech_mode = MR475; /* speech mode */
688#endif
689
690 Word16 prm[PRMNO_MR122]; /* AMR parameters */
691
692 enum RXFrameType frame_type; /* frame type */
693 dec_interface_State * s; /* pointer to structure */
694
695 const Word16 *homing; /* pointer to homing frame */
696 Word16 homingSize; /* frame size for homing frame */
697 Word32 i; /* counter */
698 Word32 resetFlag = 1; /* homing frame */
699
700#ifndef ETSI
701#ifndef IF2
702 Word16 q_bit;
703#endif
704#endif
705
706 s = (dec_interface_State *)st;
707
708#ifndef ETSI
709
710 /*
711 * extract mode information and frametype,
712 * octets to parameters
713 */
714#ifdef IF2
715 mode = Decoder3GPP(prm, bits, &frame_type, &speech_mode);
716#else
717 mode = DecoderMMS(prm, bits, &frame_type, &speech_mode, &q_bit);
718 if (!bfi) {
719 bfi = 1 - q_bit;
720 }
721#endif
722
723 /*
724 * if no mode information
725 * guess one from the previous frame
726 */
727 if (frame_type == RX_SPEECH_BAD) {
728 if (s->prev_ft > 3) {
729 frame_type = RX_SID_BAD;
730 mode = MRDTX;
731 } else {
732 mode = s->prev_mode;
733 }
734 } else if (frame_type == RX_NO_DATA) {
735 mode = s->prev_mode;
736 }
737
738 if (bfi == 1) {
739 if (mode < 8) {
740 frame_type = RX_SPEECH_BAD;
741 } else if (mode != 15) {
742 frame_type = RX_SID_BAD;
743 }
744 }
745
746#else
747 bfi = 0;
748 frame_type = bits[0];
749
750 switch (frame_type) {
751 case 0:
752 frame_type = RX_SPEECH_GOOD;
753 mode = bits[245];
754 Bits2Prm(mode, &bits[1], prm);
755 break;
756
757 case 1:
758 frame_type = RX_SID_FIRST;
759 mode = s->prev_mode;
760 break;
761
762 case 2:
763 frame_type = RX_SID_UPDATE;
764 mode = s->prev_mode;
765 Bits2Prm(MRDTX, &bits[1], prm);
766 break;
767
768 case 3:
769 frame_type = RX_NO_DATA;
770 mode = s->prev_mode;
771 break;
772 }
773
774#endif
775
776 /* test for homing frame */
777 if (s->reset_flag_old == 1) {
778 switch (mode) {
779 case MR122:
780 homing = dhf_MR122;
781 homingSize = 18;
782 break;
783
784 case MR102:
785 homing = dhf_MR102;
786 homingSize = 12;
787 break;
788
789 case MR795:
790 homing = dhf_MR795;
791 homingSize = 8;
792 break;
793
794 case MR74:
795 homing = dhf_MR74;
796 homingSize = 7;
797 break;
798
799 case MR67:
800 homing = dhf_MR67;
801 homingSize = 7;
802 break;
803
804 case MR59:
805 homing = dhf_MR59;
806 homingSize = 7;
807 break;
808
809 case MR515:
810 homing = dhf_MR515;
811 homingSize = 7;
812 break;
813
814 case MR475:
815 homing = dhf_MR475;
816 homingSize = 7;
817 break;
818
819 default:
820 homing = NULL;
821 homingSize = 0;
822 break;
823 }
824
825 for (i = 0; i < homingSize; i++) {
826 resetFlag = prm[i] ^ homing[i];
827
828 if (resetFlag) {
829 break;
830 }
831 }
832 }
833
834 if ((resetFlag == 0) && (s->reset_flag_old != 0)) {
835 for (i = 0; i < 160; i++) {
836 synth[i] = EHF_MASK;
837 }
838 } else {
839 Speech_Decode_Frame(s->decoder_State, mode, prm, frame_type, synth);
840 }
841
842 if (s->reset_flag_old == 0) {
843 /* check whole frame */
844 switch (mode) {
845 case MR122:
846 homing = dhf_MR122;
847 homingSize = PRMNO_MR122;
848 break;
849
850 case MR102:
851 homing = dhf_MR102;
852 homingSize = PRMNO_MR102;
853 break;
854
855 case MR795:
856 homing = dhf_MR795;
857 homingSize = PRMNO_MR795;
858 break;
859
860 case MR74:
861 homing = dhf_MR74;
862 homingSize = PRMNO_MR74;
863 break;
864
865 case MR67:
866 homing = dhf_MR67;
867 homingSize = PRMNO_MR67;
868 break;
869
870 case MR59:
871 homing = dhf_MR59;
872 homingSize = PRMNO_MR59;
873 break;
874
875 case MR515:
876 homing = dhf_MR515;
877 homingSize = PRMNO_MR515;
878 break;
879
880 case MR475:
881 homing = dhf_MR475;
882 homingSize = PRMNO_MR475;
883 break;
884
885 default:
886 homing = NULL;
887 homingSize = 0;
888 }
889
890 for (i = 0; i < homingSize; i++) {
891 resetFlag = prm[i] ^ homing[i];
892
893 if (resetFlag) {
894 break;
895 }
896 }
897 }
898
899 /* reset decoder if current frame is a homing frame */
900 if (resetFlag == 0) {
901 Speech_Decode_Frame_reset(s->decoder_State);
902 }
903 s->reset_flag_old = !resetFlag;
904 s->prev_ft = frame_type;
905 s->prev_mode = mode;
906}
907
generated by cgit at 2024-05-18 21:29:25 (GMT)