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