← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/third_party/ilbc/iLBC_test.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/third_party/ilbc/iLBC_test.c
 
1
 
 
2
   /******************************************************************
 
3
 
 
4
       iLBC Speech Coder ANSI-C Source Code
 
5
 
 
6
       iLBC_test.c
 
7
 
 
8
       Copyright (C) The Internet Society (2004).
 
9
       All Rights Reserved.
 
10
 
 
11
   ******************************************************************/
 
12
 
 
13
   #include <math.h>
 
14
   #include <stdlib.h>
 
15
   #include <stdio.h>
 
16
   #include <string.h>
 
17
   #include "iLBC_define.h"
 
18
   #include "iLBC_encode.h"
 
19
   #include "iLBC_decode.h"
 
20
 
 
21
   /* Runtime statistics */
 
22
   #include <time.h>
 
23
 
 
24
   #define ILBCNOOFWORDS_MAX   (NO_OF_BYTES_30MS/2)
 
25
 
 
26
   /*----------------------------------------------------------------*
 
27
    *  Encoder interface function
 
28
 
 
29
 
 
30
 
 
31
 
 
32
 
 
33
    *---------------------------------------------------------------*/
 
34
 
 
35
   short encode(   /* (o) Number of bytes encoded */
 
36
       iLBC_Enc_Inst_t *iLBCenc_inst,
 
37
                                   /* (i/o) Encoder instance */
 
38
       short *encoded_data,    /* (o) The encoded bytes */
 
39
       short *data                 /* (i) The signal block to encode*/
 
40
   ){
 
41
       float block[BLOCKL_MAX];
 
42
       int k;
 
43
 
 
44
       /* convert signal to float */
 
45
 
 
46
       for (k=0; k<iLBCenc_inst->blockl; k++)
 
47
           block[k] = (float)data[k];
 
48
 
 
49
       /* do the actual encoding */
 
50
 
 
51
       iLBC_encode((unsigned char *)encoded_data, block, iLBCenc_inst);
 
52
 
 
53
 
 
54
       return (iLBCenc_inst->no_of_bytes);
 
55
   }
 
56
 
 
57
   /*----------------------------------------------------------------*
 
58
    *  Decoder interface function
 
59
    *---------------------------------------------------------------*/
 
60
 
 
61
   short decode(       /* (o) Number of decoded samples */
 
62
       iLBC_Dec_Inst_t *iLBCdec_inst,  /* (i/o) Decoder instance */
 
63
       short *decoded_data,        /* (o) Decoded signal block*/
 
64
       short *encoded_data,        /* (i) Encoded bytes */
 
65
       short mode                       /* (i) 0=PL, 1=Normal */
 
66
   ){
 
67
       int k;
 
68
       float decblock[BLOCKL_MAX], dtmp;
 
69
 
 
70
       /* check if mode is valid */
 
71
 
 
72
       if (mode<0 || mode>1) {
 
73
           printf("\nERROR - Wrong mode - 0, 1 allowed\n"); exit(3);}
 
74
 
 
75
       /* do actual decoding of block */
 
76
 
 
77
       iLBC_decode(decblock, (unsigned char *)encoded_data,
 
78
           iLBCdec_inst, mode);
 
79
 
 
80
       /* convert to short */
 
81
 
 
82
 
 
83
 
 
84
 
 
85
 
 
86
       for (k=0; k<iLBCdec_inst->blockl; k++){
 
87
           dtmp=decblock[k];
 
88
 
 
89
           if (dtmp<MIN_SAMPLE)
 
90
               dtmp=MIN_SAMPLE;
 
91
           else if (dtmp>MAX_SAMPLE)
 
92
               dtmp=MAX_SAMPLE;
 
93
           decoded_data[k] = (short) dtmp;
 
94
       }
 
95
 
 
96
       return (iLBCdec_inst->blockl);
 
97
   }
 
98
 
 
99
   /*---------------------------------------------------------------*
 
100
    *  Main program to test iLBC encoding and decoding
 
101
    *
 
102
    *  Usage:
 
103
    *    exefile_name.exe <infile> <bytefile> <outfile> <channel>
 
104
    *
 
105
    *    <infile>   : Input file, speech for encoder (16-bit pcm file)
 
106
    *    <bytefile> : Bit stream output from the encoder
 
107
    *    <outfile>  : Output file, decoded speech (16-bit pcm file)
 
108
    *    <channel>  : Bit error file, optional (16-bit)
 
109
    *                     1 - Packet received correctly
 
110
    *                     0 - Packet Lost
 
111
    *
 
112
    *--------------------------------------------------------------*/
 
113
 
 
114
   int main(int argc, char* argv[])
 
115
   {
 
116
 
 
117
       /* Runtime statistics */
 
118
 
 
119
       float starttime;
 
120
       float runtime;
 
121
       float outtime;
 
122
 
 
123
       FILE *ifileid,*efileid,*ofileid, *cfileid;
 
124
       short data[BLOCKL_MAX];
 
125
       short encoded_data[ILBCNOOFWORDS_MAX], decoded_data[BLOCKL_MAX];
 
126
       int len;
 
127
       short pli, mode;
 
128
       int blockcount = 0;
 
129
       int packetlosscount = 0;
 
130
 
 
131
       /* Create structs */
 
132
       iLBC_Enc_Inst_t Enc_Inst;
 
133
       iLBC_Dec_Inst_t Dec_Inst;
 
134
 
 
135
 
 
136
 
 
137
 
 
138
 
 
139
       /* get arguments and open files */
 
140
 
 
141
       if ((argc!=5) && (argc!=6)) {
 
142
           fprintf(stderr,
 
143
           "\n*-----------------------------------------------*\n");
 
144
           fprintf(stderr,
 
145
           "   %s <20,30> input encoded decoded (channel)\n\n",
 
146
               argv[0]);
 
147
           fprintf(stderr,
 
148
           "   mode    : Frame size for the encoding/decoding\n");
 
149
           fprintf(stderr,
 
150
           "                 20 - 20 ms\n");
 
151
           fprintf(stderr,
 
152
           "                 30 - 30 ms\n");
 
153
           fprintf(stderr,
 
154
           "   input   : Speech for encoder (16-bit pcm file)\n");
 
155
           fprintf(stderr,
 
156
           "   encoded : Encoded bit stream\n");
 
157
           fprintf(stderr,
 
158
           "   decoded : Decoded speech (16-bit pcm file)\n");
 
159
           fprintf(stderr,
 
160
           "   channel : Packet loss pattern, optional (16-bit)\n");
 
161
           fprintf(stderr,
 
162
           "                  1 - Packet received correctly\n");
 
163
           fprintf(stderr,
 
164
           "                  0 - Packet Lost\n");
 
165
           fprintf(stderr,
 
166
           "*-----------------------------------------------*\n\n");
 
167
           exit(1);
 
168
       }
 
169
       mode=atoi(argv[1]);
 
170
       if (mode != 20 && mode != 30) {
 
171
           fprintf(stderr,"Wrong mode %s, must be 20, or 30\n",
 
172
               argv[1]);
 
173
           exit(2);
 
174
       }
 
175
       if ( (ifileid=fopen(argv[2],"rb")) == NULL) {
 
176
           fprintf(stderr,"Cannot open input file %s\n", argv[2]);
 
177
           exit(2);}
 
178
       if ( (efileid=fopen(argv[3],"wb")) == NULL) {
 
179
           fprintf(stderr, "Cannot open encoded file %s\n",
 
180
               argv[3]); exit(1);}
 
181
       if ( (ofileid=fopen(argv[4],"wb")) == NULL) {
 
182
           fprintf(stderr, "Cannot open decoded file %s\n",
 
183
               argv[4]); exit(1);}
 
184
       if (argc==6) {
 
185
           if( (cfileid=fopen(argv[5],"rb")) == NULL) {
 
186
               fprintf(stderr, "Cannot open channel file %s\n",
 
187
 
 
188
 
 
189
 
 
190
 
 
191
 
 
192
                   argv[5]);
 
193
               exit(1);
 
194
           }
 
195
       } else {
 
196
           cfileid=NULL;
 
197
       }
 
198
 
 
199
       /* print info */
 
200
 
 
201
       fprintf(stderr, "\n");
 
202
       fprintf(stderr,
 
203
           "*---------------------------------------------------*\n");
 
204
       fprintf(stderr,
 
205
           "*                                                   *\n");
 
206
       fprintf(stderr,
 
207
           "*      iLBC test program                            *\n");
 
208
       fprintf(stderr,
 
209
           "*                                                   *\n");
 
210
       fprintf(stderr,
 
211
           "*                                                   *\n");
 
212
       fprintf(stderr,
 
213
           "*---------------------------------------------------*\n");
 
214
       fprintf(stderr,"\nMode           : %2d ms\n", mode);
 
215
       fprintf(stderr,"Input file     : %s\n", argv[2]);
 
216
       fprintf(stderr,"Encoded file   : %s\n", argv[3]);
 
217
       fprintf(stderr,"Output file    : %s\n", argv[4]);
 
218
       if (argc==6) {
 
219
           fprintf(stderr,"Channel file   : %s\n", argv[5]);
 
220
       }
 
221
       fprintf(stderr,"\n");
 
222
 
 
223
       /* Initialization */
 
224
 
 
225
       initEncode(&Enc_Inst, mode);
 
226
       initDecode(&Dec_Inst, mode, 1);
 
227
 
 
228
       /* Runtime statistics */
 
229
 
 
230
       starttime=clock()/(float)CLOCKS_PER_SEC;
 
231
 
 
232
       /* loop over input blocks */
 
233
 
 
234
       while (fread(data,sizeof(short),Enc_Inst.blockl,ifileid)==
 
235
               (size_t)Enc_Inst.blockl) {
 
236
 
 
237
           blockcount++;
 
238
 
 
239
           /* encoding */
 
240
 
 
241
 
 
242
 
 
243
 
 
244
 
 
245
           fprintf(stderr, "--- Encoding block %i --- ",blockcount);
 
246
           len=encode(&Enc_Inst, encoded_data, data);
 
247
           fprintf(stderr, "\r");
 
248
 
 
249
           /* write byte file */
 
250
 
 
251
           fwrite(encoded_data, sizeof(unsigned char), len, efileid);
 
252
 
 
253
           /* get channel data if provided */
 
254
           if (argc==6) {
 
255
               if (fread(&pli, sizeof(short), 1, cfileid)) {
 
256
                   if ((pli!=0)&&(pli!=1)) {
 
257
                       fprintf(stderr, "Error in channel file\n");
 
258
                       exit(0);
 
259
                   }
 
260
                   if (pli==0) {
 
261
                       /* Packet loss -> remove info from frame */
 
262
                       memset(encoded_data, 0,
 
263
                           sizeof(short)*ILBCNOOFWORDS_MAX);
 
264
                       packetlosscount++;
 
265
                   }
 
266
               } else {
 
267
                   fprintf(stderr, "Error. Channel file too short\n");
 
268
                   exit(0);
 
269
               }
 
270
           } else {
 
271
               pli=1;
 
272
           }
 
273
 
 
274
           /* decoding */
 
275
 
 
276
           fprintf(stderr, "--- Decoding block %i --- ",blockcount);
 
277
 
 
278
           len=decode(&Dec_Inst, decoded_data, encoded_data, pli);
 
279
           fprintf(stderr, "\r");
 
280
 
 
281
           /* write output file */
 
282
 
 
283
           fwrite(decoded_data,sizeof(short),len,ofileid);
 
284
       }
 
285
 
 
286
       /* Runtime statistics */
 
287
 
 
288
       runtime = (float)(clock()/(float)CLOCKS_PER_SEC-starttime);
 
289
       outtime = (float)((float)blockcount*(float)mode/1000.0);
 
290
       printf("\n\nLength of speech file: %.1f s\n", outtime);
 
291
       printf("Packet loss          : %.1f%%\n",
 
292
           100.0*(float)packetlosscount/(float)blockcount);
 
293
 
 
294
 
 
295
 
 
296
 
 
297
 
 
298
       printf("Time to run iLBC     :");
 
299
       printf(" %.1f s (%.1f %% of realtime)\n\n", runtime,
 
300
           (100*runtime/outtime));
 
301
 
 
302
       /* close files */
 
303
 
 
304
       fclose(ifileid);  fclose(efileid); fclose(ofileid);
 
305
       if (argc==6) {
 
306
           fclose(cfileid);
 
307
       }
 
308
       return(0);
 
309
   }
 
310