← Back to branch summary

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

« back to all changes in this revision

Viewing changes to adm_lavcodec/amr_float/interf_enc.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:
adm_lavcodec/amr_float/interf_enc.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_enc.c
13
 
 *
14
 
 *
15
 
 * Project:
16
 
 *    AMR Floating-Point Codec
17
 
 *
18
 
 * Contains:
19
 
 *    This module contains all the functions needed encoding 160
20
 
 *    16-bit speech samples to AMR encoder parameters.
21
 
 *
22
 
 */
23
 
 
24
 
/*
25
 
 * include files
26
 
 */
27
 
#include <stdlib.h>
28
 
#include <stdio.h>
29
 
#include <memory.h>
30
 
#include "sp_enc.h"
31
 
#include "interf_rom.h"
32
 
 
33
 
/*
34
 
 * Declare structure types
35
 
 */
36
 
/* Declaration transmitted frame types */
37
 
enum TXFrameType { TX_SPEECH_GOOD = 0,
38
 
                   TX_SID_FIRST,
39
 
                   TX_SID_UPDATE,
40
 
                   TX_NO_DATA,
41
 
                   TX_SPEECH_DEGRADED,
42
 
                   TX_SPEECH_BAD,
43
 
                   TX_SID_BAD,
44
 
                   TX_ONSET,
45
 
                   TX_N_FRAMETYPES     /* number of frame types */
46
 
};
47
 
 
48
 
/* Declaration of interface structure */
49
 
typedef struct
50
 
{
51
 
   Word16 sid_update_counter;   /* Number of frames since last SID */
52
 
   Word16 sid_handover_debt;   /* Number of extra SID_UPD frames to schedule */
53
 
   Word32 dtx;
54
 
   enum TXFrameType prev_ft;   /* Type of the previous frame */
55
 
   void *encoderState;   /* Points encoder state structure */
56
 
} enc_interface_State;
57
 
 
58
 
 
59
 
#ifdef ETSI
60
 
/*
61
 
 * Prm2Bits
62
 
 *
63
 
 *
64
 
 * Parameters:
65
 
 *    value             I: value to be converted to binary
66
 
 *    no_of_bits        I: number of bits associated with value
67
 
 *    bitstream         O: address where bits are written
68
 
 *
69
 
 * Function:
70
 
 *    Convert integer to binary and write the bits to the array.
71
 
 *    The most significant bits are written first.
72
 
 * Returns:
73
 
 *    void
74
 
 */
75
 
static void Int2Bin( Word16 value, Word16 no_of_bits, Word16 *bitstream )
76
 
{
77
 
   Word32 i, bit;
78
 
   Word16 *pt_bitstream;
79
 
 
80
 
   pt_bitstream = &bitstream[no_of_bits];
81
 
 
82
 
   for ( i = 0; i < no_of_bits; i++ ) {
83
 
      bit = value & 0x0001;
84
 
 
85
 
      if ( bit == 0 ) {
86
 
         * --pt_bitstream = 0;
87
 
      }
88
 
      else {
89
 
         * --pt_bitstream = 1;
90
 
      }
91
 
      value = ( Word16 )( value >> 1 );
92
 
   }
93
 
}
94
 
 
95
 
 
96
 
/*
97
 
 * Prm2Bits
98
 
 *
99
 
 *
100
 
 * Parameters:
101
 
 *    mode              I: AMR mode
102
 
 *    prm               I: analysis parameters
103
 
 *    bits              O: serial bits
104
 
 *
105
 
 * Function:
106
 
 *    converts the encoder parameter vector into a vector of serial bits.
107
 
 * Returns:
108
 
 *    void
109
 
 */
110
 
static void Prm2Bits( enum Mode mode, Word16 prm[], Word16 bits[] )
111
 
{
112
 
   Word32 i;
113
 
 
114
 
   switch ( mode ) {
115
 
      case MR122:
116
 
         for ( i = 0; i < PRMNO_MR122; i++ ) {
117
 
            Int2Bin( prm[i], bitno_MR122[i], bits );
118
 
            bits += bitno_MR122[i];
119
 
         }
120
 
         break;
121
 
 
122
 
      case MR102:
123
 
         for ( i = 0; i < PRMNO_MR102; i++ ) {
124
 
            Int2Bin( prm[i], bitno_MR102[i], bits );
125
 
            bits += bitno_MR102[i];
126
 
         }
127
 
         break;
128
 
 
129
 
      case MR795:
130
 
         for ( i = 0; i < PRMNO_MR795; i++ ) {
131
 
            Int2Bin( prm[i], bitno_MR795[i], bits );
132
 
            bits += bitno_MR795[i];
133
 
         }
134
 
         break;
135
 
 
136
 
      case MR74:
137
 
         for ( i = 0; i < PRMNO_MR74; i++ ) {
138
 
            Int2Bin( prm[i], bitno_MR74[i], bits );
139
 
            bits += bitno_MR74[i];
140
 
         }
141
 
         break;
142
 
 
143
 
      case MR67:
144
 
         for ( i = 0; i < PRMNO_MR67; i++ ) {
145
 
            Int2Bin( prm[i], bitno_MR67[i], bits );
146
 
            bits += bitno_MR67[i];
147
 
         }
148
 
         break;
149
 
 
150
 
      case MR59:
151
 
         for ( i = 0; i < PRMNO_MR59; i++ ) {
152
 
            Int2Bin( prm[i], bitno_MR59[i], bits );
153
 
            bits += bitno_MR59[i];
154
 
         }
155
 
         break;
156
 
 
157
 
      case MR515:
158
 
         for ( i = 0; i < PRMNO_MR515; i++ ) {
159
 
            Int2Bin( prm[i], bitno_MR515[i], bits );
160
 
            bits += bitno_MR515[i];
161
 
         }
162
 
         break;
163
 
 
164
 
      case MR475:
165
 
         for ( i = 0; i < PRMNO_MR475; i++ ) {
166
 
            Int2Bin( prm[i], bitno_MR475[i], bits );
167
 
            bits += bitno_MR475[i];
168
 
         }
169
 
         break;
170
 
 
171
 
      case MRDTX:
172
 
         for ( i = 0; i < PRMNO_MRDTX; i++ ) {
173
 
            Int2Bin( prm[i], bitno_MRDTX[i], bits );
174
 
            bits += bitno_MRDTX[i];
175
 
         }
176
 
         break;
177
 
   }
178
 
   return;
179
 
}
180
 
 
181
 
#else
182
 
 
183
 
#ifndef IF2
184
 
 
185
 
/*
186
 
 * EncoderMMS
187
 
 *
188
 
 *
189
 
 * Parameters:
190
 
 *    mode                 I: AMR mode
191
 
 *    param                I: Encoder output parameters
192
 
 *    stream               O: packed speech frame
193
 
 *    frame_type           I: frame type (DTX)
194
 
 *    speech_mode          I: speech mode (DTX)
195
 
 *
196
 
 * Function:
197
 
 *    Pack encoder output parameters to octet structure according
198
 
 *    importance table and AMR file storage format according to
199
 
 *    RFC 3267.
200
 
 * Returns:
201
 
 *    number of octets
202
 
 */
203
 
static int EncoderMMS( enum Mode mode, Word16 *param, UWord8 *stream, enum
204
 
      TXFrameType frame_type, enum Mode speech_mode )
205
 
{
206
 
   Word32 j = 0, k;
207
 
   Word16 *mask;
208
 
 
209
 
   memset(stream, 0, block_size[mode]);
210
 
 
211
 
   *stream = toc_byte[mode];
212
 
   stream++;
213
 
 
214
 
   if ( mode == 15 ) {
215
 
      return 1;
216
 
   }
217
 
   else if ( mode == MRDTX ) {
218
 
      mask = order_MRDTX;
219
 
 
220
 
      for ( j = 1; j < 36; j++ ) {
221
 
         if ( param[ * mask] & *( mask + 1 ) )
222
 
            *stream += 0x01;
223
 
         mask += 2;
224
 
 
225
 
         if ( j % 8 )
226
 
            *stream <<= 1;
227
 
         else
228
 
            stream++;
229
 
      }
230
 
 
231
 
      /* add SID type information */
232
 
      if ( frame_type == TX_SID_UPDATE )
233
 
         *stream += 0x01;
234
 
      *stream <<= 3;
235
 
 
236
 
      /* speech mode indication */
237
 
      *stream += ( unsigned char )(speech_mode & 0x0007);
238
 
 
239
 
          *stream <<= 1;
240
 
 
241
 
      /* don't shift at the end of the function */
242
 
      return 6;
243
 
   }
244
 
   else if ( mode == MR475 ) {
245
 
      mask = order_MR475;
246
 
 
247
 
      for ( j = 1; j < 96; j++ ) {
248
 
         if ( param[ * mask] & *( mask + 1 ) )
249
 
            *stream += 0x01;
250
 
         mask += 2;
251
 
 
252
 
         if ( j % 8 )
253
 
            *stream <<= 1;
254
 
         else
255
 
            stream++;
256
 
      }
257
 
   }
258
 
   else if ( mode == MR515 ) {
259
 
      mask = order_MR515;
260
 
 
261
 
      for ( j = 1; j < 104; j++ ) {
262
 
         if ( param[ * mask] & *( mask + 1 ) )
263
 
            *stream += 0x01;
264
 
         mask += 2;
265
 
 
266
 
         if ( j % 8 )
267
 
            *stream <<= 1;
268
 
         else
269
 
            stream++;
270
 
      }
271
 
   }
272
 
   else if ( mode == MR59 ) {
273
 
      mask = order_MR59;
274
 
 
275
 
      for ( j = 1; j < 119; j++ ) {
276
 
         if ( param[ * mask] & *( mask + 1 ) )
277
 
            *stream += 0x01;
278
 
         mask += 2;
279
 
 
280
 
         if ( j % 8 )
281
 
            *stream <<= 1;
282
 
         else
283
 
            stream++;
284
 
      }
285
 
   }
286
 
   else if ( mode == MR67 ) {
287
 
      mask = order_MR67;
288
 
 
289
 
      for ( j = 1; j < 135; j++ ) {
290
 
         if ( param[ * mask] & *( mask + 1 ) )
291
 
            *stream += 0x01;
292
 
         mask += 2;
293
 
 
294
 
         if ( j % 8 )
295
 
            *stream <<= 1;
296
 
         else
297
 
            stream++;
298
 
      }
299
 
   }
300
 
   else if ( mode == MR74 ) {
301
 
      mask = order_MR74;
302
 
 
303
 
      for ( j = 1; j < 149; j++ ) {
304
 
         if ( param[ * mask] & *( mask + 1 ) )
305
 
            *stream += 0x01;
306
 
         mask += 2;
307
 
 
308
 
         if ( j % 8 )
309
 
            *stream <<= 1;
310
 
         else
311
 
            stream++;
312
 
      }
313
 
   }
314
 
   else if ( mode == MR795 ) {
315
 
      mask = order_MR795;
316
 
 
317
 
      for ( j = 1; j < 160; j++ ) {
318
 
         if ( param[ * mask] & *( mask + 1 ) )
319
 
            *stream += 0x01;
320
 
         mask += 2;
321
 
 
322
 
         if ( j % 8 )
323
 
            *stream <<= 1;
324
 
         else
325
 
            stream++;
326
 
      }
327
 
   }
328
 
   else if ( mode == MR102 ) {
329
 
      mask = order_MR102;
330
 
 
331
 
      for ( j = 1; j < 205; j++ ) {
332
 
         if ( param[ * mask] & *( mask + 1 ) )
333
 
            *stream += 0x01;
334
 
         mask += 2;
335
 
 
336
 
         if ( j % 8 )
337
 
            *stream <<= 1;
338
 
         else
339
 
            stream++;
340
 
      }
341
 
   }
342
 
   else if ( mode == MR122 ) {
343
 
      mask = order_MR122;
344
 
 
345
 
      for ( j = 1; j < 245; j++ ) {
346
 
         if ( param[ * mask] & *( mask + 1 ) )
347
 
            *stream += 0x01;
348
 
         mask += 2;
349
 
 
350
 
         if ( j % 8 )
351
 
            *stream <<= 1;
352
 
         else
353
 
            stream++;
354
 
      }
355
 
   }
356
 
 
357
 
   /* shift remaining bits */
358
 
   if ( k = j % 8 )     *stream <<= ( 8 - k );
359
 
   return( (int)block_size[mode] );
360
 
}
361
 
 
362
 
#else
363
 
 
364
 
/*
365
 
 * Encoder3GPP
366
 
 *
367
 
 *
368
 
 * Parameters:
369
 
 *    mode                 I: AMR mode
370
 
 *    param                I: Encoder output parameters
371
 
 *    stream               O: packed speech frame
372
 
 *    frame_type           I: frame type (DTX)
373
 
 *    speech_mode          I: speech mode (DTX)
374
 
 *
375
 
 * Function:
376
 
 *    Pack encoder output parameters to octet structure according
377
 
 *    importance table.
378
 
 * Returns:
379
 
 *    number of octets
380
 
 */
381
 
static int Encoder3GPP( enum Mode mode, Word16 *param, UWord8 *stream, enum
382
 
      TXFrameType frame_type, enum Mode speech_mode )
383
 
{
384
 
   Word32 j = 0;
385
 
   Word16 *mask;
386
 
 
387
 
   memset(stream, 0, block_size[mode]);
388
 
 
389
 
   if ( mode == 15 ) {
390
 
      *stream = 0xF;
391
 
      return 1;
392
 
   }
393
 
   else if ( mode == MRDTX ) {
394
 
      mask = order_MRDTX;
395
 
      *stream = 0x40;
396
 
 
397
 
      for ( j = 5; j < 40; j++ ) {
398
 
         if ( param[ * mask] & *( mask + 1 ) )
399
 
            *stream += 0x80;
400
 
         mask += 2;
401
 
 
402
 
         if ( j % 8 )
403
 
            *stream >>= 1;
404
 
         else
405
 
            stream++;
406
 
      }
407
 
 
408
 
      /* add SID type information */
409
 
      if ( frame_type == TX_SID_UPDATE )
410
 
         *stream += 0x80;
411
 
      stream++;
412
 
 
413
 
      /* speech mode indication */
414
 
      *stream = ( unsigned char )speech_mode;
415
 
 
416
 
      /* don't shift at the end of the function */
417
 
      return 6;
418
 
   }
419
 
   else if ( mode == MR475 ) {
420
 
      mask = order_MR475;
421
 
      *stream = 0;
422
 
 
423
 
      for ( j = 5; j < 100; j++ ) {
424
 
         if ( param[ * mask] & *( mask + 1 ) )
425
 
            *stream += 0x80;
426
 
         mask += 2;
427
 
 
428
 
         if ( j % 8 )
429
 
            *stream >>= 1;
430
 
         else
431
 
            stream++;
432
 
      }
433
 
   }
434
 
   else if ( mode == MR515 ) {
435
 
      mask = order_MR515;
436
 
      *stream = 0x8;
437
 
 
438
 
      for ( j = 5; j < 108; j++ ) {
439
 
         if ( param[ * mask] & *( mask + 1 ) )
440
 
            *stream += 0x80;
441
 
         mask += 2;
442
 
 
443
 
         if ( j % 8 )
444
 
            *stream >>= 1;
445
 
         else
446
 
            stream++;
447
 
      }
448
 
   }
449
 
   else if ( mode == MR59 ) {
450
 
      mask = order_MR59;
451
 
      *stream = 0x10;
452
 
 
453
 
      for ( j = 5; j < 123; j++ ) {
454
 
         if ( param[ * mask] & *( mask + 1 ) )
455
 
            *stream += 0x80;
456
 
         mask += 2;
457
 
 
458
 
         if ( j % 8 )
459
 
            *stream >>= 1;
460
 
         else
461
 
            stream++;
462
 
      }
463
 
   }
464
 
   else if ( mode == MR67 ) {
465
 
      mask = order_MR67;
466
 
      *stream = 0x18;
467
 
 
468
 
      for ( j = 5; j < 139; j++ ) {
469
 
         if ( param[ * mask] & *( mask + 1 ) )
470
 
            *stream += 0x80;
471
 
         mask += 2;
472
 
 
473
 
         if ( j % 8 )
474
 
            *stream >>= 1;
475
 
         else
476
 
            stream++;
477
 
      }
478
 
   }
479
 
   else if ( mode == MR74 ) {
480
 
      mask = order_MR74;
481
 
      *stream = 0x20;
482
 
 
483
 
      for ( j = 5; j < 153; j++ ) {
484
 
         if ( param[ * mask] & *( mask + 1 ) )
485
 
            *stream += 0x80;
486
 
         mask += 2;
487
 
 
488
 
         if ( j % 8 )
489
 
            *stream >>= 1;
490
 
         else
491
 
            stream++;
492
 
      }
493
 
   }
494
 
   else if ( mode == MR795 ) {
495
 
      mask = order_MR795;
496
 
      *stream = 0x28;
497
 
 
498
 
      for ( j = 5; j < 164; j++ ) {
499
 
         if ( param[ * mask] & *( mask + 1 ) )
500
 
            *stream += 0x80;
501
 
         mask += 2;
502
 
 
503
 
         if ( j % 8 )
504
 
            *stream >>= 1;
505
 
         else
506
 
            stream++;
507
 
      }
508
 
   }
509
 
   else if ( mode == MR102 ) {
510
 
      mask = order_MR102;
511
 
      *stream = 0x30;
512
 
 
513
 
      for ( j = 5; j < 209; j++ ) {
514
 
         if ( param[ * mask] & *( mask + 1 ) )
515
 
            *stream += 0x80;
516
 
         mask += 2;
517
 
 
518
 
         if ( j % 8 )
519
 
            *stream >>= 1;
520
 
         else
521
 
            stream++;
522
 
      }
523
 
   }
524
 
   else if ( mode == MR122 ) {
525
 
      mask = order_MR122;
526
 
      *stream = 0x38;
527
 
 
528
 
      for ( j = 5; j < 249; j++ ) {
529
 
         if ( param[ * mask] & *( mask + 1 ) )
530
 
            *stream += 0x80;
531
 
         mask += 2;
532
 
 
533
 
         if ( j % 8 )
534
 
            *stream >>= 1;
535
 
         else
536
 
            stream++;
537
 
      }
538
 
   }
539
 
 
540
 
   /* shift remaining bits */
541
 
   *stream >>= ( 8 - j % 8 );
542
 
   return( (int)block_size[mode] );
543
 
}
544
 
#endif
545
 
#endif
546
 
 
547
 
/*
548
 
 * Sid_Sync_reset
549
 
 *
550
 
 *
551
 
 * Parameters:
552
 
 *    st                O: state structure
553
 
 *
554
 
 * Function:
555
 
 *    Initializes state memory
556
 
 *
557
 
 * Returns:
558
 
 *    void
559
 
 */
560
 
static void Sid_Sync_reset( enc_interface_State *st )
561
 
{
562
 
   st->sid_update_counter = 3;
563
 
   st->sid_handover_debt = 0;
564
 
   st->prev_ft = TX_SPEECH_GOOD;
565
 
}
566
 
 
567
 
 
568
 
/*
569
 
 * Encoder_Interface_Encode
570
 
 *
571
 
 *
572
 
 * Parameters:
573
 
 *    st                I: pointer to state structure
574
 
 *    mode              I: Speech Mode
575
 
 *    speech            I: Input speech
576
 
 *    serial            O: Output octet structure 3GPP or
577
 
 *                         ETSI serial stream
578
 
 *    force_speech      I: Force speech in DTX
579
 
 *
580
 
 * Function:
581
 
 *    Encoding and packing one frame of speech
582
 
 *
583
 
 * Returns:
584
 
 *    number of octets
585
 
 */
586
 
int Encoder_Interface_Encode( void *st, enum Mode mode, Word16 *speech,
587
 
 
588
 
#ifndef ETSI
589
 
      UWord8 *serial,
590
 
 
591
 
#else
592
 
      Word16 *serial,
593
 
#endif
594
 
 
595
 
      int force_speech )
596
 
{
597
 
   Word16 prm[PRMNO_MR122];   /* speech parameters, max size */
598
 
   const Word16 *homing;   /* pointer to homing frame */
599
 
   Word16 homing_size;   /* frame size for homing frame */
600
 
 
601
 
 
602
 
   enc_interface_State * s;
603
 
   enum TXFrameType txFrameType;   /* frame type */
604
 
 
605
 
   int i, noHoming = 0;
606
 
 
607
 
 
608
 
   /*
609
 
    * used encoder mode,
610
 
    * if used_mode == -1, force VAD on
611
 
    */
612
 
   enum Mode used_mode = -force_speech;
613
 
 
614
 
 
615
 
   s = ( enc_interface_State * )st;
616
 
 
617
 
    /*
618
 
     * Checks if all samples of the input frame matches the encoder
619
 
     * homing frame pattern, which is 0x0008 for all samples.
620
 
     */
621
 
   for ( i = 0; i < 160; i++ ) {
622
 
      noHoming = speech[i] ^ 0x0008;
623
 
 
624
 
      if ( noHoming )
625
 
         break;
626
 
   }
627
 
 
628
 
   if (noHoming){
629
 
      Speech_Encode_Frame( s->encoderState, mode, speech, prm, &used_mode );
630
 
   }
631
 
   else {
632
 
      switch ( mode ) {
633
 
         case MR122:
634
 
            homing = dhf_MR122;
635
 
            homing_size = 18;
636
 
            break;
637
 
 
638
 
         case MR102:
639
 
            homing = dhf_MR102;
640
 
            homing_size = 12;
641
 
            break;
642
 
 
643
 
         case MR795:
644
 
            homing = dhf_MR795;
645
 
            homing_size = 8;
646
 
            break;
647
 
 
648
 
         case MR74:
649
 
            homing = dhf_MR74;
650
 
            homing_size = 7;
651
 
            break;
652
 
 
653
 
         case MR67:
654
 
            homing = dhf_MR67;
655
 
            homing_size = 7;
656
 
            break;
657
 
 
658
 
         case MR59:
659
 
            homing = dhf_MR59;
660
 
            homing_size = 7;
661
 
            break;
662
 
 
663
 
         case MR515:
664
 
            homing = dhf_MR515;
665
 
            homing_size = 7;
666
 
            break;
667
 
 
668
 
         case MR475:
669
 
            homing = dhf_MR475;
670
 
            homing_size = 7;
671
 
            break;
672
 
 
673
 
         default:
674
 
            homing = NULL;
675
 
            homing_size = 0;
676
 
            break;
677
 
      }
678
 
      for( i = 0; i < homing_size; i++){
679
 
         prm[i] = homing[i];
680
 
      }
681
 
      /* rest of the parameters are zero */
682
 
      memset(&prm[homing_size], 0, (PRMNO_MR122 - homing_size) << 1);
683
 
      used_mode = mode;
684
 
   }
685
 
   if ( used_mode == MRDTX ) {
686
 
      s->sid_update_counter--;
687
 
 
688
 
      if ( s->prev_ft == TX_SPEECH_GOOD ) {
689
 
         txFrameType = TX_SID_FIRST;
690
 
         s->sid_update_counter = 3;
691
 
      }
692
 
      else {
693
 
         /* TX_SID_UPDATE or TX_NO_DATA */
694
 
         if ( ( s->sid_handover_debt > 0 ) && ( s->sid_update_counter > 2 ) ) {
695
 
              /*
696
 
               * ensure extra updates are properly delayed after
697
 
               * a possible SID_FIRST
698
 
               */
699
 
            txFrameType = TX_SID_UPDATE;
700
 
            s->sid_handover_debt--;
701
 
         }
702
 
         else {
703
 
            if ( s->sid_update_counter == 0 ) {
704
 
               txFrameType = TX_SID_UPDATE;
705
 
               s->sid_update_counter = 8;
706
 
            }
707
 
            else {
708
 
               txFrameType = TX_NO_DATA;
709
 
               used_mode = 15;
710
 
            }
711
 
         }
712
 
      }
713
 
   }
714
 
   else {
715
 
      s->sid_update_counter = 8;
716
 
      txFrameType = TX_SPEECH_GOOD;
717
 
   }
718
 
   s->prev_ft = txFrameType;
719
 
 
720
 
   if ( noHoming == 0 ) {
721
 
      Speech_Encode_Frame_reset( s->encoderState, s->dtx );
722
 
      Sid_Sync_reset( s );
723
 
   }
724
 
 
725
 
#ifndef ETSI
726
 
#ifdef IF2
727
 
   return Encoder3GPP( used_mode, prm, serial, txFrameType, mode );
728
 
 
729
 
#else
730
 
   return EncoderMMS( used_mode, prm, serial, txFrameType, mode );
731
 
 
732
 
#endif
733
 
#else
734
 
 
735
 
   Prm2Bits( used_mode, prm, &serial[1] );
736
 
   serial[0] = ( Word16 )txFrameType;
737
 
   serial[245] = ( Word16 )mode;
738
 
   return 500;
739
 
#endif
740
 
 
741
 
}
742
 
 
743
 
 
744
 
/*
745
 
 * Encoder_Interface_init
746
 
 *
747
 
 *
748
 
 * Parameters:
749
 
 *    dtx               I: DTX flag
750
 
 *
751
 
 * Function:
752
 
 *    Allocates state memory and initializes state memory
753
 
 *
754
 
 * Returns:
755
 
 *    pointer to encoder interface structure
756
 
 */
757
 
void * Encoder_Interface_init( int dtx )
758
 
{
759
 
   enc_interface_State * s;
760
 
 
761
 
   /* allocate memory */
762
 
   if ( ( s = ( enc_interface_State * ) malloc( sizeof( enc_interface_State ) ) ) ==
763
 
         NULL ) {
764
 
      fprintf( stderr, "Encoder_Interface_init: "
765
 
            "can not malloc state structure\n" );
766
 
      return NULL;
767
 
   }
768
 
   s->encoderState = Speech_Encode_Frame_init( dtx );
769
 
   Sid_Sync_reset( s );
770
 
   s->dtx = dtx;
771
 
   return s;
772
 
}
773
 
 
774
 
 
775
 
/*
776
 
 * DecoderInterfaceExit
777
 
 *
778
 
 *
779
 
 * Parameters:
780
 
 *    state             I: state structure
781
 
 *
782
 
 * Function:
783
 
 *    The memory used for state memory is freed
784
 
 *
785
 
 * Returns:
786
 
 *    Void
787
 
 */
788
 
void Encoder_Interface_exit( void *state )
789
 
{
790
 
   enc_interface_State * s;
791
 
   s = ( enc_interface_State * )state;
792
 
 
793
 
   /* free memory */
794
 
   Speech_Encode_Frame_exit( &s->encoderState );
795
 
   free( s );
796
 
   state = NULL;
797
 
}