FreeCalypso > hg > gsmhr-codec-ref

comparison utils.c @ 0:9008dbc8ca74

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import original C code from GSM 06.06
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 14 Jun 2024 23:27:16 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:9008dbc8ca74
1 /*___________________________________________________________________________
2 | |
3 | |
4 | Residual Error Insertion Device |
5 | |
6 | |
7 | File : REID.C |
8 | |
9 | Date : February 03, 1995 |
10 | |
11 | Version: 4.1 |
12 | |
13 | |
14 | Description: |
15 | ------------ |
16 | This routine transforms the output file format of the GSM Half |
17 | Rate Encoder module consisting of: |
18 | * 18 speech parameters (see GSM TS 06.20) |
19 | * 1 speech flag SP (see GSM TS 06.41) |
20 | * 1 voice activity flag VAD (see GSM TS 06.42) |
21 | |
22 | to the input file format of the GSM Half Rate Decoder module |
23 | requiring: |
24 | * 18 speech parameters (see GSM TS 06.20) |
25 | * 1 channel condition flag BFI (see GSM TS 06.21, 05.05) |
26 | * 1 channel condition flag UFI (see GSM TS 06.21, 05.05) |
27 | * 1 SID flag (2 bits) (see GSM TS 06.41, 05.05) |
28 | * 1 time alignment flag TAF (see GSM TS 06.41) |
29 | |
30 | Between SID updates the speech parameters are replaced by random |
31 | values simulating an interrupted transmission on the air interface |
32 | |
33 | The actual implementation only supports error free transmission (EP0)|
34 | |
35 | The shell for the future use of error patterns (residual error |
36 | pattern insertion) is already included. If necessary, byte swapping |
37 | is performed on the input speech parameters so that they are always |
38 | represented internally in PC byte order (assuming that the byte |
39 | order of the input file is compatible with the machine on which the |
40 | program is run). However, byte swapping is not done on the flag |
41 | words (input: SP and VAD, output: BFI, UFI, SID, and TAF). Thus, |
42 | the residual error pattern insertion code may be written to handle |
43 | the speech parameter words on a byte basis, but the flag words must |
44 | always be handled on a word basis. |
45 |___________________________________________________________________________|
46 */
47 /*___________________________________________________________________________
48 | |
49 | Creation: 19.12.94 |
50 | |
51 | Changes: |
52 | 22.12.94: Removal of BCI flag, instead: determination of SID flag |
53 | 12.01.95: SID update period = 12 (instead of 24) |
54 | 13.01.95: When in CNI mode, the parameters between SID updates are |
55 | random values. This simulates the interrupted transmission|
56 | 03.02.95: Longword main( Longword...) replaced by int main(int ...),|
57 | initial value of swTAFCnt set to 1 |
58 |___________________________________________________________________________|
59 */
60
61 /*___________________________________________________________________________
62 | |
63 | Include-Files |
64 |___________________________________________________________________________|
65 */
66 #include <stdlib.h>
67 #include <stdio.h>
68 #include <string.h>
69 #include <ctype.h>
70
71 #ifdef VAX
72 # define OPEN_WI "wb","mrs=512","rfm=fix","ctx=stm"
73 # define OPEN_RI "rb","mrs=512","rfm=fix","ctx=stm"
74 # define OPEN_WB "wb","mrs=512","rfm=fix","ctx=stm"
75 # define OPEN_RB "rb","mrs=2","rfm=fix","ctx=stm"
76 # define OPEN_WT "w","mrs=256","rat=cr","rfm=var"
77 # define OPEN_RT "r","mrs=256","rat=cr","rfm=var"
78 #else
79 # define OPEN_WB "wb"
80 # define OPEN_RB "rb"
81 # define OPEN_WI "wb"
82 # define OPEN_RI "rb"
83 # define OPEN_WT "wt"
84 # define OPEN_RT "rt"
85 #endif
86
87 #define LW_SIGN (long)0x80000000 /* sign bit */
88 #define LW_MIN (long)0x80000000
89 #define LW_MAX (long)0x7fffffff
90 #define SW_MIN (short)0x8000 /* smallest Ram */
91 #define SW_MAX (short)0x7fff /* largest Ram */
92
93 typedef char Byte;
94 typedef long int Longword; /* 32 bit "accumulator" (L_*) */
95 typedef short int Shortword; /* 16 bit "register" (sw*) */
96
97 /*___________________________________________________________________________
98 | |
99 | local Functions |
100 |___________________________________________________________________________|
101 */
102 static Longword error_free( FILE *infile, FILE *outfile);
103 static void SwapBytes( Shortword buffer[], Longword len );
104 static Longword ByteOrder( void );
105 static size_t ReadInputFile( Shortword buffer[], FILE *fp );
106 static size_t WriteOutputFile( Shortword buffer[], FILE *fp );
107 static Longword EncoderInterface( FILE *infile, Shortword swInPara[] );
108 static Shortword swSidDetection(Shortword pswParameters[],
109 Shortword pswErrorFlag[]);
110 static void RandomParameters(Shortword pswParameters[]);
111 static Shortword getPnBits(Shortword iBits, Longword *pL_PNSeed);
112 FILE *OpenBinfile( char *name, char *mode );
113 Longword Strincmp( const char *s, const char *t, size_t max );
114 Longword Stricmp( const char *s, const char *t );
115
116 Longword L_shr(Longword L_var1, Shortword var2); /* 2 ops */
117 Longword L_shl(Longword L_var1, Shortword var2); /* 2 ops */
118 Shortword shr(Shortword var1, Shortword var2); /* 1 ops */
119 Shortword shl(Shortword var1, Shortword var2); /* 1 ops */
120
121 /*___________________________________________________________________________
122 | |
123 | Subroutines |
124 |___________________________________________________________________________|
125 */
126 static Longword error_free( FILE *infile, FILE *outfile)
127 {
128
129 #define SPEECH 1
130 #define CNIFIRSTSID 2
131 #define CNICONT 3
132 #define VALIDSID 11
133 #define GOODSPEECH 33
134
135 static Shortword swDecoMode = {SPEECH};
136 static Shortword swTAFCnt = {1};
137 Shortword swInPara[20], i, swFrameType;
138 Shortword swOutPara[22],pswErrorFlag[3];
139
140 if( EncoderInterface( infile, swInPara )) return( 1 );
141
142 /* Copy input parameters to output parameters (error free transmission) */
143 /* -------------------------------------------------------------------- */
144 for (i=0;i<18;i++)
145 swOutPara[i] = swInPara[i];
146
147 /* Set channel status flags (error free transmission) */
148 /* -------------------------------------------------- */
149 swOutPara[18] = 0; /* BFI flag */
150 swOutPara[19] = 0; /* UFI flag */
151
152 /* Evaluate SID flag */
153 /* ----------------- */
154 pswErrorFlag[0] = 0; /* BFI flag */
155 pswErrorFlag[1] = 0; /* UFI flag */
156 pswErrorFlag[2] = 0; /* BCI flag */
157 swOutPara[20] = swSidDetection(swOutPara, pswErrorFlag);
158
159
160 /* Evaluate TAF flag */
161 /* ----------------- */
162 if (swTAFCnt == 0) swOutPara[21] = 1;
163 else swOutPara[21] = 0;
164 swTAFCnt = (swTAFCnt + 1) % 12;
165
166
167 /* Frame classification: */
168 /* Since the transmission is error free, the received frames are either */
169 /* valid speech or valid SID frames */
170 /* -------------------------------------------------------------------- */
171 if ( swOutPara[20] == 2) swFrameType = VALIDSID;
172 else if ( swOutPara[20] == 0) swFrameType = GOODSPEECH;
173 else {
174 printf( "Error in SID detection\n" );
175 return( 1 );
176 }
177
178 /* Update of decoder state */
179 /* ----------------------- */
180 if (swDecoMode == SPEECH) {
181 if (swFrameType == VALIDSID) swDecoMode = CNIFIRSTSID;
182 else if (swFrameType == GOODSPEECH) swDecoMode = SPEECH;
183 }
184 else { /* comfort noise insertion mode */
185 if (swFrameType == VALIDSID) swDecoMode = CNICONT;
186 else if (swFrameType == GOODSPEECH) swDecoMode = SPEECH;
187 }
188
189
190 /* Replace parameters by random data if in CNICONT-mode and TAF=0 */
191 /* -------------------------------------------------------------- */
192 if ((swDecoMode == CNICONT) && (swOutPara[21] == 0)){
193 RandomParameters(swOutPara);
194 /* Set flags such, that an "unusable frame" is produced */
195 swOutPara[18] = 1; /* BFI flag */
196 swOutPara[19] = 1; /* UFI flag */
197 swOutPara[20] = 0; /* SID flag */
198 }
199
200
201
202 if( outfile ) {
203 if( WriteOutputFile( swOutPara, outfile )) {
204 printf( "Error writing File\n" );
205 return( 1 );
206 }
207 }
208 return( 0 );
209 }
210
211 static Longword EncoderInterface( FILE *infile, Shortword swInPara[] )
212 {
213 size_t i = 0;
214
215 i = ReadInputFile( swInPara, infile );
216
217 return(( i == 0 ) ? 1 : 0 );
218 }
219
220 static size_t ReadInputFile( Shortword buffer[], FILE *fp )
221 {
222 size_t i;
223
224 i = fread( buffer, sizeof( Shortword ), 20, fp );
225 SwapBytes( buffer, 18 );
226 return( i );
227 }
228
229 static size_t WriteOutputFile( Shortword buffer[], FILE *fp )
230 {
231 size_t i;
232
233 SwapBytes( buffer, 18 );
234 i = fwrite( buffer, sizeof( Shortword ), 22, fp );
235 return( ( i == 22 ) ? 0 : 1 );
236 }
237
238
239 static void SwapBytes( Shortword buffer[], Longword len )
240 {
241 Byte *pc, tmp;
242 Longword i;
243
244 if( !ByteOrder())
245 return;
246 pc = (Byte *)buffer;
247 for( i = 0; i < len; i++ ) {
248 tmp = pc[0];
249 pc[0] = pc[1];
250 pc[1] = tmp;
251 pc += 2;
252 }
253 }
254
255 static Longword ByteOrder( void )
256 {
257 Shortword si;
258 Byte *pc;
259
260 si = 0x1234;
261 pc = (Byte *)&si;
262 if (pc[1] == 0x12 && pc[0] == 0x34 )
263 return( 0 );
264 if (pc[0] == 0x12 && pc[1] == 0x34 )
265 return( 1 );
266 printf( "Error in ByteOrder: %X, %X\n", (int)pc[0], (int)pc[1] );
267 exit( 1 );
268 return( 2 );
269 }
270
271 FILE *OpenBinfile( char *name, char *mode )
272 {
273 FILE *fp;
274
275 if( toupper( *mode ) == 'W' ) { /* Write access */
276 if(( fp = fopen( name, OPEN_WB )) == NULL ) {
277 printf( "Can't open output file '%s'\n", name );
278 exit( 1 );
279 }
280 } else { /* Read access */
281 if(( fp = fopen( name, OPEN_RB )) == NULL ) {
282 printf( "Can't open file '%s'\n", name );
283 exit( 1 );
284 }
285 }
286 return( fp );
287 }
288
289 Longword Strincmp( const char *s, const char *t, size_t max )
290 {
291 for( ; max > 1; ++s, ++t, --max ) {
292 if( toupper( *s ) != toupper( *t ))
293 break;
294 if( *s == '\0' )
295 return( 0 );
296 }
297 return( toupper( *s ) - toupper( *t ));
298 }
299
300 Longword Stricmp( const char *s, const char *t )
301 {
302 for(; toupper( *s ) == toupper( *t ); ++s, ++t ) {
303 if( *s == '\0' )
304 return( 0 );
305 }
306 return( toupper( *s ) - toupper( *t ));
307 }
308
309 /*************************************************************************
310 *
311 * FUNCTION NAME: getPnBits
312 *
313 * PURPOSE:
314 *
315 * Generate iBits pseudo-random bits using *pL_PNSeed as the
316 * pn-generators seed.
317 *
318 * INPUTS:
319 *
320 * iBits - integer indicating how many random bits to return.
321 * range [0,15], 0 yields 1 bit output
322 *
323 * *pL_PNSeed - 32 bit seed (changed by function)
324 *
325 * OUTPUTS:
326 *
327 * *pL_PNSeed - 32 bit seed, modified.
328 *
329 * RETURN VALUE:
330 *
331 * random bits in iBits LSB's.
332 *
333 *
334 * IMPLEMENTATION:
335 *
336 * implementation of x**31 + x**3 + 1 == PN_XOR_REG | PN_XOR_ADD a
337 * PN sequence generator using Longwords generating a 2**31 -1
338 * length pn-sequence.
339 *
340 *************************************************************************/
341
342 static Shortword getPnBits(Shortword iBits, Longword *pL_PNSeed){
343
344 #define PN_XOR_REG (Longword)0x00000005L
345 #define PN_XOR_ADD (Longword)0x40000000L
346
347 Shortword swPnBits=0;
348 Longword L_Taps,L_FeedBack;
349 Shortword i;
350
351 for (i=0; i < iBits; i++){
352
353 /* update the state */
354 /********************/
355
356 L_Taps = *pL_PNSeed & PN_XOR_REG;
357 L_FeedBack = L_Taps; /* Xor tap bits to yield feedback bit */
358 L_Taps = L_shr(L_Taps,1);
359
360 while(L_Taps){
361 L_FeedBack = L_FeedBack ^ L_Taps;
362 L_Taps = L_shr(L_Taps,1);
363 }
364
365 /* LSB of L_FeedBack is next MSB of PN register */
366
367 *pL_PNSeed = L_shr(*pL_PNSeed,1);
368 if (L_FeedBack & 1)
369 *pL_PNSeed = *pL_PNSeed | PN_XOR_ADD;
370
371 /* State update complete.
372 Get the output bit from the state, add/or it into output */
373
374 swPnBits = shl(swPnBits,1);
375 swPnBits = swPnBits | (*pL_PNSeed & 1);
376
377 }
378 return(swPnBits);
379 }
380
381
382 /***************************************************************************
383 *
384 * FUNCTION NAME: L_shl
385 *
386 * PURPOSE:
387 *
388 * Arithmetic shift left (or right).
389 * Arithmetically shift the input left by var2. If var2 is
390 * negative then an arithmetic shift right (L_shr) of L_var1 by
391 * -var2 is performed.
392 *
393 * INPUTS:
394 *
395 * var2
396 * 16 bit short signed integer (Shortword) whose value
397 * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
398 * L_var1
399 * 32 bit long signed integer (Longword) whose value
400 * falls in the range
401 * 0x8000 0000 <= L_var1 <= 0x7fff ffff.
402 * OUTPUTS:
403 *
404 * none
405 *
406 * RETURN VALUE:
407 *
408 * L_Out
409 * 32 bit long signed integer (Longword) whose value
410 * falls in the range
411 * 0x8000 0000 <= L_var1 <= 0x7fff ffff.
412 *
413 *
414 * IMPLEMENTATION:
415 *
416 * Arithmetically shift the 32 bit input left by var2. This
417 * operation maintains the sign of the input number. If var2 is
418 * negative then an arithmetic shift right (L_shr) of L_var1 by
419 * -var2 is performed. See description of L_shr for details.
420 *
421 * Equivalent to the Full-Rate GSM ">> n" operation. Note that
422 * ANSI-C does not guarantee operation of the C ">>" or "<<"
423 * operator for negative numbers.
424 *
425 * KEYWORDS: shift, arithmetic shift left,
426 *
427 *************************************************************************/
428
429 Longword L_shl(Longword L_var1, Shortword var2)
430 {
431
432 Longword L_Mask,
433 L_Out;
434 int i,
435 iOverflow = 0;
436
437 if (var2 == 0 || L_var1 == 0)
438 {
439 L_Out = L_var1;
440 }
441 else if (var2 < 0)
442 {
443 if (var2 <= -31)
444 {
445 if (L_var1 > 0)
446 L_Out = 0;
447 else
448 L_Out = 0xffffffffL;
449 }
450 else
451 L_Out = L_shr(L_var1, -var2);
452 }
453 else
454 {
455
456 if (var2 >= 31)
457 iOverflow = 1;
458
459 else
460 {
461
462 if (L_var1 < 0)
463 L_Mask = LW_SIGN; /* sign bit mask */
464 else
465 L_Mask = 0x0;
466 L_Out = L_var1;
467 for (i = 0; i < var2 && !iOverflow; i++)
468 {
469 /* check the sign bit */
470 L_Out = (L_Out & 0x7fffffffL) << 1;
471 if ((L_Mask ^ L_Out) & LW_SIGN)
472 iOverflow = 1;
473 }
474 }
475
476 if (iOverflow)
477 {
478 /* saturate */
479 if (L_var1 > 0)
480 L_Out = LW_MAX;
481 else
482 L_Out = LW_MIN;
483 }
484 }
485
486 return (L_Out);
487 }
488
489 /***************************************************************************
490 *
491 * FUNCTION NAME: L_shr
492 *
493 * PURPOSE:
494 *
495 * Arithmetic shift right (or left).
496 * Arithmetically shift the input right by var2. If var2 is
497 * negative then an arithmetic shift left (shl) of var1 by
498 * -var2 is performed.
499 *
500 * INPUTS:
501 *
502 * var2
503 * 16 bit short signed integer (Shortword) whose value
504 * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
505 * L_var1
506 * 32 bit long signed integer (Longword) whose value
507 * falls in the range
508 * 0x8000 0000 <= L_var1 <= 0x7fff ffff.
509 * OUTPUTS:
510 *
511 * none
512 *
513 * RETURN VALUE:
514 *
515 * L_Out
516 * 32 bit long signed integer (Longword) whose value
517 * falls in the range
518 * 0x8000 0000 <= L_var1 <= 0x7fff ffff.
519 *
520 *
521 * IMPLEMENTATION:
522 *
523 * Arithmetically shift the input right by var2. This
524 * operation maintains the sign of the input number. If var2 is
525 * negative then an arithmetic shift left (shl) of L_var1 by
526 * -var2 is performed. See description of L_shl for details.
527 *
528 * The input is a 32 bit number, as is the output.
529 *
530 * Equivalent to the Full-Rate GSM ">> n" operation. Note that
531 * ANSI-C does not guarantee operation of the C ">>" or "<<"
532 * operator for negative numbers.
533 *
534 * KEYWORDS: shift, arithmetic shift right,
535 *
536 *************************************************************************/
537
538 Longword L_shr(Longword L_var1, Shortword var2)
539 {
540
541 Longword L_Mask,
542 L_Out;
543
544 if (var2 == 0 || L_var1 == 0)
545 {
546 L_Out = L_var1;
547 }
548 else if (var2 < 0)
549 {
550 /* perform a left shift */
551 /*----------------------*/
552 if (var2 <= -31)
553 {
554 /* saturate */
555 if (L_var1 > 0)
556 L_Out = LW_MAX;
557 else
558 L_Out = LW_MIN;
559 }
560 else
561 L_Out = L_shl(L_var1, -var2);
562 }
563 else
564 {
565
566 if (var2 >= 31)
567 {
568 if (L_var1 > 0)
569 L_Out = 0;
570 else
571 L_Out = 0xffffffffL;
572 }
573 else
574 {
575 L_Mask = 0;
576
577 if (L_var1 < 0)
578 {
579 L_Mask = ~L_Mask << (32 - var2);
580 }
581
582 L_var1 >>= var2;
583 L_Out = L_Mask | L_var1;
584 }
585 }
586 return (L_Out);
587 }
588
589
590 /***************************************************************************
591 *
592 * FUNCTION NAME: shl
593 *
594 * PURPOSE:
595 *
596 * Arithmetically shift the input left by var2.
597 *
598 *
599 * INPUTS:
600 *
601 * var1
602 * 16 bit short signed integer (Shortword) whose value
603 * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
604 * var2
605 * 16 bit short signed integer (Shortword) whose value
606 * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
607 *
608 * OUTPUTS:
609 *
610 * none
611 *
612 * RETURN VALUE:
613 *
614 * swOut
615 * 16 bit short signed integer (Shortword) whose value
616 * falls in the range
617 * 0xffff 8000 <= swOut <= 0x0000 7fff.
618 *
619 * IMPLEMENTATION:
620 *
621 * If Arithmetically shift the input left by var2. If var2 is
622 * negative then an arithmetic shift right (shr) of var1 by
623 * -var2 is performed. See description of shr for details.
624 * When an arithmetic shift left is performed the var2 LS bits
625 * are zero filled.
626 *
627 * The only exception is if the left shift causes an overflow
628 * or underflow. In this case the LS bits are not modified.
629 * The number returned is 0x8000 in the case of an underflow or
630 * 0x7fff in the case of an overflow.
631 *
632 * The shl is equivalent to the Full-Rate GSM "<< n" operation.
633 * Note that ANSI-C does not guarantee operation of the C ">>"
634 * or "<<" operator for negative numbers - it is not specified
635 * whether this shift is an arithmetic or logical shift.
636 *
637 * KEYWORDS: asl, arithmetic shift left, shift
638 *
639 *************************************************************************/
640
641 Shortword shl(Shortword var1, Shortword var2)
642 {
643 Shortword swOut;
644 Longword L_Out;
645
646 if (var2 == 0 || var1 == 0)
647 {
648 swOut = var1;
649 }
650 else if (var2 < 0)
651 {
652
653 /* perform a right shift */
654 /*-----------------------*/
655
656 if (var2 <= -15)
657 {
658 if (var1 < 0)
659 swOut = (Shortword) 0xffff;
660 else
661 swOut = 0x0;
662 }
663 else
664 swOut = shr(var1, -var2);
665
666 }
667 else
668 {
669 /* var2 > 0 */
670 if (var2 >= 15)
671 {
672 /* saturate */
673 if (var1 > 0)
674 swOut = SW_MAX;
675 else
676 swOut = SW_MIN;
677 }
678 else
679 {
680
681 L_Out = (Longword) var1 *(1 << var2);
682
683 swOut = (Shortword) L_Out; /* copy low portion to swOut,
684 * overflow could have hpnd */
685 if (swOut != L_Out)
686 {
687 /* overflow */
688 if (var1 > 0)
689 swOut = SW_MAX; /* saturate */
690 else
691 swOut = SW_MIN; /* saturate */
692 }
693 }
694 }
695 return (swOut);
696 }
697
698 /***************************************************************************
699 *
700 * FUNCTION NAME: shr
701 *
702 * PURPOSE:
703 *
704 * Arithmetic shift right (or left).
705 * Arithmetically shift the input right by var2. If var2 is
706 * negative then an arithmetic shift left (shl) of var1 by
707 * -var2 is performed.
708 *
709 * INPUTS:
710 *
711 * var1
712 * 16 bit short signed integer (Shortword) whose value
713 * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
714 * var2
715 * 16 bit short signed integer (Shortword) whose value
716 * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
717 *
718 * OUTPUTS:
719 *
720 * none
721 *
722 * RETURN VALUE:
723 *
724 * swOut
725 * 16 bit short signed integer (Shortword) whose value
726 * falls in the range
727 * 0xffff 8000 <= swOut <= 0x0000 7fff.
728 *
729 * IMPLEMENTATION:
730 *
731 * Arithmetically shift the input right by var2. This
732 * operation maintains the sign of the input number. If var2 is
733 * negative then an arithmetic shift left (shl) of var1 by
734 * -var2 is performed. See description of shl for details.
735 *
736 * Equivalent to the Full-Rate GSM ">> n" operation. Note that
737 * ANSI-C does not guarantee operation of the C ">>" or "<<"
738 * operator for negative numbers.
739 *
740 * KEYWORDS: shift, arithmetic shift right,
741 *
742 *************************************************************************/
743
744 Shortword shr(Shortword var1, Shortword var2)
745 {
746
747 Shortword swMask,
748 swOut;
749
750 if (var2 == 0 || var1 == 0)
751 swOut = var1;
752
753 else if (var2 < 0)
754 {
755 /* perform an arithmetic left shift */
756 /*----------------------------------*/
757 if (var2 <= -15)
758 {
759 /* saturate */
760 if (var1 > 0)
761 swOut = SW_MAX;
762 else
763 swOut = SW_MIN;
764 }
765 else
766 swOut = shl(var1, -var2);
767 }
768
769 else
770 {
771
772 /* positive shift count */
773 /*----------------------*/
774
775 if (var2 >= 15)
776 {
777 if (var1 < 0)
778 swOut = (Shortword) 0xffff;
779 else
780 swOut = 0x0;
781 }
782 else
783 {
784 /* take care of sign extension */
785 /*-----------------------------*/
786
787 swMask = 0;
788 if (var1 < 0)
789 {
790 swMask = ~swMask << (16 - var2);
791 }
792
793 var1 >>= var2;
794 swOut = swMask | var1;
795
796 }
797 }
798 return (swOut);
799 }
800
801 /*___________________________________________________________________________
802 | |
803 | This subroutine calculates the 'SID flag' |
804 | |
805 | Input: pswParameters[18] |
806 | input parameters of the speech decoder |
807 | |
808 | pswErrorFlag[3] |
809 | error flags, generated by channel decoder |
810 | |
811 | Return Value: |
812 | 0: speech frame detected |
813 | 1: most likely SID frame received |
814 | 2: SID frame detected |
815 | |
816 |___________________________________________________________________________|
817 | |
818 | History: |
819 | |
820 | 12-Oct-1994: Bug removed: error corrected in case of a mode (unvoiced/|
821 | voiced) mismatch, if a SID frame was received as an |
822 | unvoiced frame |
823 |___________________________________________________________________________|
824 */
825
826 static Shortword swSidDetection(Shortword pswParameters[],
827 Shortword pswErrorFlag[])
828 {
829 static Shortword ppswIBit[2][18] = {
830 5, 11,9,8, 1, 2, 7,7,5, 7,7,5, 7,7,5, 7,7,5, /* unvoiced */
831 5, 11,9,8, 1, 2, 8,9,5, 4,9,5, 4,9,5, 4,9,5}; /* voiced */
832
833 static Shortword ppswCL1pCL2[2][18] = {
834 0x0001, /* R0 */ /* unvoiced */
835 0x00ef, /* LPC1 */
836 0x003e, /* LPC2 */
837 0x007f, /* LPC3 */
838 0x0001, /* INT LPC */
839 0x0003, /* Mode */
840 0x001f, /* Code1_1 */
841 0x0072, /* Code2_1 */
842 0x0012, /* GSP0_1 */
843 0x003f, /* Code1_2 */
844 0x007f, /* Code2_2 */
845 0x0008, /* GSP0_2 */
846 0x007f, /* Code1_3 */
847 0x007f, /* Code2_3 */
848 0x0008, /* GSP0_3 */
849 0x007f, /* Code1_4 */
850 0x007f, /* Code2_4 */
851 0x000c, /* GSP0_4 */
852
853 0x0000, /* R0 */ /* voiced */
854 0x0000, /* LPC1 */
855 0x0000, /* LPC2 */
856 0x0000, /* LPC3 */
857 0x0001, /* INT LPC */
858 0x0003, /* Mode */
859 0x00ff, /* Lag_1 */
860 0x01ff, /* Code_1 */
861 0x001f, /* GSP0_1 */
862 0x000f, /* Lag_2 */
863 0x01ff, /* Code_2 */
864 0x001f, /* GSP0_2 */
865 0x000f, /* Lag_3 */
866 0x01ff, /* Code_3 */
867 0x001f, /* GSP0_3 */
868 0x000f, /* Lag_4 */
869 0x01ff, /* Code_4 */
870 0x001f}; /* GSP0_4 */
871
872 static Shortword ppswCL2[2][18] = {
873 0x0000, /* R0 */ /* unvoiced */
874 0x0000, /* LPC1 */
875 0x0000, /* LPC2 */
876 0x0000, /* LPC3 */
877 0x0000, /* INT LPC */
878 0x0000, /* Mode */
879 0x0000, /* Code1_1 */
880 0x0000, /* Code2_1 */
881 0x0000, /* GSP0_1 */
882 0x0000, /* Code1_2 */
883 0x0000, /* Code2_2 */
884 0x0000, /* GSP0_2 */
885 0x0000, /* Code1_3 */
886 0x0007, /* Code2_3 */ /* 3 bits */
887 0x0000, /* GSP0_3 */
888 0x007f, /* Code1_4 */ /* 7 bits */
889 0x007f, /* Code2_4 */ /* 7 bits */
890 0x0000, /* GSP0_4 */
891
892 0x0000, /* R0 */ /* voiced */
893 0x0000, /* LPC1 */
894 0x0000, /* LPC2 */
895 0x0000, /* LPC3 */
896 0x0000, /* INT LPC */
897 0x0000, /* Mode */
898 0x0000, /* Lag_1 */
899 0x0000, /* Code_1 */
900 0x0000, /* GSP0_1 */
901 0x0000, /* Lag_2 */
902 0x0000, /* Code_2 */
903 0x0000, /* GSP0_2 */
904 0x0000, /* Lag_3 */
905 0x00ff, /* Code_3 */ /* 8 bits */
906 0x0000, /* GSP0_3 */
907 0x0000, /* Lag_4 */
908 0x01ff, /* Code_4 */ /* 9 bits */
909 0x0000}; /* GSP0_4 */
910
911 static int first = 1;
912
913 Shortword swMode, swBitMask;
914 Shortword swSidN1, swSidN2, swSidN1pN2;
915 Shortword swSid ;
916
917 short siI, siII;
918
919
920 if (first)
921 {
922 /* Force Sid codewords to be represented */
923 /* internally in PC byte order */
924 /* ------------------------------------- */
925
926 SwapBytes(ppswCL1pCL2[0], 18);
927 SwapBytes(ppswCL1pCL2[1], 18);
928 SwapBytes(ppswCL2[0], 18);
929 SwapBytes(ppswCL2[1], 18);
930
931 first = 0;
932 }
933
934
935 /* count transmission errors within the SID codeword */
936 /* count number of bits equal '0' within the SID codeword */
937 /* ------------------------------------------------------ */
938
939 if (pswParameters[5] == 0)
940 swMode = 0;
941 else
942 swMode = 1;
943
944
945 swSidN1pN2 = 0; /* N1 + N2 */
946 swSidN2 = 0;
947 swSidN1 = 0;
948
949 for (siI = 0; siI < 18; siI++) {
950 swBitMask = 0x0001;
951 SwapBytes(&swBitMask, 1); /* force swBitMask to PC byte order */
952 for (siII = 0; siII < ppswIBit[swMode][siI]; siII++) {
953 if ( (pswParameters[siI] & swBitMask) == 0 ) {
954 if ( (ppswCL1pCL2[swMode][siI] & swBitMask) != 0 ) swSidN1pN2++;
955 if ( (ppswCL2[swMode][siI] & swBitMask) != 0 ) swSidN2++;
956 }
957 SwapBytes(&swBitMask, 1); /* return swBitMask to native byte order */
958 swBitMask = swBitMask << 1;
959 SwapBytes(&swBitMask, 1); /* force swBitMask to PC byte order */
960 }
961 }
962
963 swSidN1 = swSidN1pN2 - swSidN2;
964
965
966 /* frame classification */
967 /* -------------------- */
968
969 if (pswErrorFlag[2]) {
970
971 if (swSidN1 < 3)
972 swSid = 2;
973 else if (swSidN1pN2 < 16)
974 swSid = 1;
975 else
976 swSid = 0;
977
978 if ( (swSidN1pN2 >= 16) && (swSidN1pN2 <= 25) ) {
979 pswErrorFlag[0] = 1;
980 }
981
982 }
983 else {
984
985 if (swSidN1 < 3)
986 swSid = 2;
987 else if (swSidN1pN2 < 11)
988 swSid = 1;
989 else
990 swSid = 0;
991
992 }
993
994
995 /* in case of a mode mismatch */
996 /*----------------------------*/
997
998 if ( (swSid == 2) && (swMode == 0) ) swSid = 1;
999
1000 return(swSid);
1001
1002 }
1003
1004
1005 /*___________________________________________________________________________
1006 | |
1007 | This subroutine sets the 18 speech parameters to random values |
1008 | |
1009 | Input: pswParameters[18] |
1010 | input parameters of the speech decoder |
1011 | |
1012 |___________________________________________________________________________|
1013 */
1014
1015 static void RandomParameters(Shortword pswParameters[])
1016 {
1017 static Shortword ppswIBit[2][18] = {
1018 5, 11,9,8, 1, 2, 7,7,5, 7,7,5, 7,7,5, 7,7,5, /* unvoiced */
1019 5, 11,9,8, 1, 2, 8,9,5, 4,9,5, 4,9,5, 4,9,5}; /* voiced */
1020
1021 static Longword L_PNSeed=(Longword)0x1091988L;
1022 Shortword i,ind;
1023
1024 /* Determine mode bit */
1025 /* ------------------ */
1026 pswParameters[5] = getPnBits(2, &L_PNSeed);
1027
1028 /* Switch bit allocation accordingly */
1029 /* --------------------------------- */
1030 ind = 0;
1031 if (pswParameters[5] > 0) ind = 1;
1032
1033 for (i=0; i < 5; i++){
1034 pswParameters[i] = getPnBits(ppswIBit[ind][i], &L_PNSeed);
1035 }
1036 for (i=6; i < 18; i++){
1037 pswParameters[i] = getPnBits(ppswIBit[ind][i], &L_PNSeed);
1038 }
1039
1040 /* force random parameters to PC byte order */
1041 /* ---------------------------------------- */
1042
1043 SwapBytes(pswParameters, 18);
1044 }
1045
1046 /*___________________________________________________________________________
1047 | |
1048 | Main - Program |
1049 | |
1050 |___________________________________________________________________________|
1051 */
1052 int main( int argc, char *argv[] )
1053 {
1054 FILE *infile, *outfile;
1055 Shortword errpat, i = 0;
1056
1057 if( argc < 4 || argc > 4 ) {
1058 fprintf( stderr, "\tUsage: REID input output EPx \n" );
1059 fprintf( stderr, "\tEPx: EP0\n" );
1060 fprintf( stderr, "\t EP1 (not implemented)\n" );
1061 fprintf( stderr, "\t EP2 (not implemented)\n" );
1062 fprintf( stderr, "\t EP3 (not implemented)\n" );
1063 return( 1 );
1064 }
1065
1066
1067 if( !Strincmp( argv[3], "ep", 2 ))
1068 errpat = atoi( &argv[3][2] );
1069
1070 printf( " _____________________________________________\n" );
1071 printf( " | |\n" );
1072 printf( " | Residual Error Insertion Device |\n" );
1073 printf( " | for |\n" );
1074 printf( " | GSM Half-Rate Codec Simulation |\n" );
1075 printf( " | |\n" );
1076 printf( " |_____________________________________________|\n\n" );
1077
1078 printf( " Input File : %s\n", argv[1] );
1079 printf( " Output File : %s\n", argv[2] );
1080 if( errpat ){
1081 printf( " Error Pattern : EP%d (not implemented)\n", errpat);
1082 return (1);
1083 }
1084 else
1085 printf( " Error Pattern : EP%d (error free)\n", errpat );
1086 printf( "\n" );
1087
1088 infile = OpenBinfile( argv[1], "r" );
1089 outfile = OpenBinfile( argv[2], "w" );
1090
1091
1092 if (errpat == 0) {
1093 for (i=0;i<6000;i++)
1094 if( error_free( infile, outfile)) break;
1095 }
1096 /*else
1097 for (i=0;i<6000;i++)
1098 if( residual_error_pattern( infile, outfile)) break;
1099 EP1-3 not implemented */
1100
1101 fclose( infile );
1102 fclose( outfile );
1103
1104 printf( " %d Frame%s processed \n\n", i,( i != 1 ) ? "s" : "" );
1105 return( 0 );
1106 }