← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_lavcodec/amr_float/interf_dec.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_lavcodec/amr_float/interf_dec.c
 
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
 */
 
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
 */
 
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
 */
 
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
 */
 
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
 */
 
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
 */
 
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
 */
 
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
 */
 
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
}