Cleanup, slightly changed analysis band layout, MFCC-like features
[opus.git] / celt / tests / test_unit_entropy.c
1 #ifdef HAVE_CONFIG_H
2 #include "config.h"
3 #endif
4
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <math.h>
8 #include <time.h>
9 #include "entcode.h"
10 #include "entenc.h"
11 #include "entdec.h"
12 #include <string.h>
13
14 #include "entenc.c"
15 #include "entdec.c"
16 #include "entcode.c"
17
18 #ifndef M_LOG2E
19 # define M_LOG2E    1.4426950408889634074
20 #endif
21 #define DATA_SIZE 10000000
22 #define DATA_SIZE2 10000
23
24 int main(int _argc,char **_argv){
25   ec_enc         enc;
26   ec_dec         dec;
27   long           nbits;
28   long           nbits2;
29   double         entropy;
30   int            ft;
31   int            ftb;
32   int            sz;
33   int            i;
34   int            ret;
35   unsigned int   sym;
36   unsigned int   seed;
37   unsigned char *ptr;
38   const char    *env_seed;
39   ret=0;
40   entropy=0;
41     if (_argc > 2) {
42         fprintf(stderr, "Usage: %s [<seed>]\n", _argv[0]);
43         return 1;
44     }
45   env_seed = getenv("SEED");
46   if (_argc > 1)
47     seed = atoi(_argv[1]);
48   else if (env_seed)
49     seed = atoi(env_seed);
50   else
51     seed = time(NULL);
52   /*Testing encoding of raw bit values.*/
53   ptr = (unsigned char *)malloc(DATA_SIZE);
54   ec_enc_init(&enc,ptr, DATA_SIZE);
55   for(ft=2;ft<1024;ft++){
56     for(i=0;i<ft;i++){
57       entropy+=log(ft)*M_LOG2E;
58       ec_enc_uint(&enc,i,ft);
59     }
60   }
61   /*Testing encoding of raw bit values.*/
62   for(ftb=1;ftb<16;ftb++){
63     for(i=0;i<(1<<ftb);i++){
64       entropy+=ftb;
65       nbits=ec_tell(&enc);
66       ec_enc_bits(&enc,i,ftb);
67       nbits2=ec_tell(&enc);
68       if(nbits2-nbits!=ftb){
69         fprintf(stderr,"Used %li bits to encode %i bits directly.\n",
70          nbits2-nbits,ftb);
71         ret=-1;
72       }
73     }
74   }
75   nbits=ec_tell_frac(&enc);
76   ec_enc_done(&enc);
77   fprintf(stderr,
78    "Encoded %0.2lf bits of entropy to %0.2lf bits (%0.3lf%% wasted).\n",
79    entropy,ldexp(nbits,-3),100*(nbits-ldexp(entropy,3))/nbits);
80   fprintf(stderr,"Packed to %li bytes.\n",(long)ec_range_bytes(&enc));
81   ec_dec_init(&dec,ptr,DATA_SIZE);
82   for(ft=2;ft<1024;ft++){
83     for(i=0;i<ft;i++){
84       sym=ec_dec_uint(&dec,ft);
85       if(sym!=(unsigned)i){
86         fprintf(stderr,"Decoded %i instead of %i with ft of %i.\n",sym,i,ft);
87         ret=-1;
88       }
89     }
90   }
91   for(ftb=1;ftb<16;ftb++){
92     for(i=0;i<(1<<ftb);i++){
93       sym=ec_dec_bits(&dec,ftb);
94       if(sym!=(unsigned)i){
95         fprintf(stderr,"Decoded %i instead of %i with ftb of %i.\n",sym,i,ftb);
96         ret=-1;
97       }
98     }
99   }
100   nbits2=ec_tell_frac(&dec);
101   if(nbits!=nbits2){
102     fprintf(stderr,
103      "Reported number of bits used was %0.2lf, should be %0.2lf.\n",
104      ldexp(nbits2,-3),ldexp(nbits,-3));
105     ret=-1;
106   }
107   /*Testing an encoder bust prefers range coder data over raw bits.
108     This isn't a general guarantee, will only work for data that is buffered in
109      the encoder state and not yet stored in the user buffer, and should never
110      get used in practice.
111     It's mostly here for code coverage completeness.*/
112   /*Start with a 16-bit buffer.*/
113   ec_enc_init(&enc,ptr,2);
114   /*Write 7 raw bits.*/
115   ec_enc_bits(&enc,0x55,7);
116   /*Write 12.3 bits of range coder data.*/
117   ec_enc_uint(&enc,1,2);
118   ec_enc_uint(&enc,1,3);
119   ec_enc_uint(&enc,1,4);
120   ec_enc_uint(&enc,1,5);
121   ec_enc_uint(&enc,2,6);
122   ec_enc_uint(&enc,6,7);
123   ec_enc_done(&enc);
124   ec_dec_init(&dec,ptr,2);
125   if(!enc.error
126    /*The raw bits should have been overwritten by the range coder data.*/
127    ||ec_dec_bits(&dec,7)!=0x05
128    /*And all the range coder data should have been encoded correctly.*/
129    ||ec_dec_uint(&dec,2)!=1
130    ||ec_dec_uint(&dec,3)!=1
131    ||ec_dec_uint(&dec,4)!=1
132    ||ec_dec_uint(&dec,5)!=1
133    ||ec_dec_uint(&dec,6)!=2
134    ||ec_dec_uint(&dec,7)!=6){
135     fprintf(stderr,"Encoder bust overwrote range coder data with raw bits.\n");
136     ret=-1;
137   }
138   srand(seed);
139   fprintf(stderr,"Testing random streams... Random seed: %u (%.4X)\n", seed, rand() % 65536);
140   for(i=0;i<409600;i++){
141     unsigned *data;
142     unsigned *tell;
143     unsigned tell_bits;
144     int       j;
145     int zeros;
146     ft=rand()/((RAND_MAX>>(rand()%11U))+1U)+10;
147     sz=rand()/((RAND_MAX>>(rand()%9U))+1U);
148     data=(unsigned *)malloc(sz*sizeof(*data));
149     tell=(unsigned *)malloc((sz+1)*sizeof(*tell));
150     ec_enc_init(&enc,ptr,DATA_SIZE2);
151     zeros = rand()%13==0;
152     tell[0]=ec_tell_frac(&enc);
153     for(j=0;j<sz;j++){
154       if (zeros)
155         data[j]=0;
156       else
157         data[j]=rand()%ft;
158       ec_enc_uint(&enc,data[j],ft);
159       tell[j+1]=ec_tell_frac(&enc);
160     }
161     if (rand()%2==0)
162       while(ec_tell(&enc)%8 != 0)
163         ec_enc_uint(&enc, rand()%2, 2);
164     tell_bits = ec_tell(&enc);
165     ec_enc_done(&enc);
166     if(tell_bits!=(unsigned)ec_tell(&enc)){
167       fprintf(stderr,"ec_tell() changed after ec_enc_done(): %i instead of %i (Random seed: %u)\n",
168        ec_tell(&enc),tell_bits,seed);
169       ret=-1;
170     }
171     if ((tell_bits+7)/8 < ec_range_bytes(&enc))
172     {
173       fprintf (stderr, "ec_tell() lied, there's %i bytes instead of %d (Random seed: %u)\n",
174                ec_range_bytes(&enc), (tell_bits+7)/8,seed);
175       ret=-1;
176     }
177     ec_dec_init(&dec,ptr,DATA_SIZE2);
178     if(ec_tell_frac(&dec)!=tell[0]){
179       fprintf(stderr,
180        "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n",
181        0,ec_tell_frac(&dec),tell[0],seed);
182     }
183     for(j=0;j<sz;j++){
184       sym=ec_dec_uint(&dec,ft);
185       if(sym!=data[j]){
186         fprintf(stderr,
187          "Decoded %i instead of %i with ft of %i at position %i of %i (Random seed: %u).\n",
188          sym,data[j],ft,j,sz,seed);
189         ret=-1;
190       }
191       if(ec_tell_frac(&dec)!=tell[j+1]){
192         fprintf(stderr,
193          "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n",
194          j+1,ec_tell_frac(&dec),tell[j+1],seed);
195       }
196     }
197     free(tell);
198     free(data);
199   }
200   /*Test compatibility between multiple different encode/decode routines.*/
201   for(i=0;i<409600;i++){
202     unsigned *logp1;
203     unsigned *data;
204     unsigned *tell;
205     unsigned *enc_method;
206     int       j;
207     sz=rand()/((RAND_MAX>>(rand()%9U))+1U);
208     logp1=(unsigned *)malloc(sz*sizeof(*logp1));
209     data=(unsigned *)malloc(sz*sizeof(*data));
210     tell=(unsigned *)malloc((sz+1)*sizeof(*tell));
211     enc_method=(unsigned *)malloc(sz*sizeof(*enc_method));
212     ec_enc_init(&enc,ptr,DATA_SIZE2);
213     tell[0]=ec_tell_frac(&enc);
214     for(j=0;j<sz;j++){
215       data[j]=rand()/((RAND_MAX>>1)+1);
216       logp1[j]=(rand()%15)+1;
217       enc_method[j]=rand()/((RAND_MAX>>2)+1);
218       switch(enc_method[j]){
219         case 0:{
220           ec_encode(&enc,data[j]?(1<<logp1[j])-1:0,
221            (1<<logp1[j])-(data[j]?0:1),1<<logp1[j]);
222         }break;
223         case 1:{
224           ec_encode_bin(&enc,data[j]?(1<<logp1[j])-1:0,
225            (1<<logp1[j])-(data[j]?0:1),logp1[j]);
226         }break;
227         case 2:{
228           ec_enc_bit_logp(&enc,data[j],logp1[j]);
229         }break;
230         case 3:{
231           unsigned char icdf[2];
232           icdf[0]=1;
233           icdf[1]=0;
234           ec_enc_icdf(&enc,data[j],icdf,logp1[j]);
235         }break;
236       }
237       tell[j+1]=ec_tell_frac(&enc);
238     }
239     ec_enc_done(&enc);
240     if((ec_tell(&enc)+7U)/8U<ec_range_bytes(&enc)){
241       fprintf(stderr,"tell() lied, there's %i bytes instead of %d (Random seed: %u)\n",
242        ec_range_bytes(&enc),(ec_tell(&enc)+7)/8,seed);
243       ret=-1;
244     }
245     ec_dec_init(&dec,ptr,DATA_SIZE2);
246     if(ec_tell_frac(&dec)!=tell[0]){
247       fprintf(stderr,
248        "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n",
249        0,ec_tell_frac(&dec),tell[0],seed);
250     }
251     for(j=0;j<sz;j++){
252       int fs;
253       int dec_method;
254       dec_method=rand()/((RAND_MAX>>2)+1);
255       switch(dec_method){
256         case 0:{
257           fs=ec_decode(&dec,1<<logp1[j]);
258           sym=fs>=(1<<logp1[j])-1;
259           ec_dec_update(&dec,sym?(1<<logp1[j])-1:0,
260            (1<<logp1[j])-(sym?0:1),1<<logp1[j]);
261         }break;
262         case 1:{
263           fs=ec_decode_bin(&dec,logp1[j]);
264           sym=fs>=(1<<logp1[j])-1;
265           ec_dec_update(&dec,sym?(1<<logp1[j])-1:0,
266            (1<<logp1[j])-(sym?0:1),1<<logp1[j]);
267         }break;
268         case 2:{
269           sym=ec_dec_bit_logp(&dec,logp1[j]);
270         }break;
271         case 3:{
272           unsigned char icdf[2];
273           icdf[0]=1;
274           icdf[1]=0;
275           sym=ec_dec_icdf(&dec,icdf,logp1[j]);
276         }break;
277       }
278       if(sym!=data[j]){
279         fprintf(stderr,
280          "Decoded %i instead of %i with logp1 of %i at position %i of %i (Random seed: %u).\n",
281          sym,data[j],logp1[j],j,sz,seed);
282         fprintf(stderr,"Encoding method: %i, decoding method: %i\n",
283          enc_method[j],dec_method);
284         ret=-1;
285       }
286       if(ec_tell_frac(&dec)!=tell[j+1]){
287         fprintf(stderr,
288          "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n",
289          j+1,ec_tell_frac(&dec),tell[j+1],seed);
290       }
291     }
292     free(enc_method);
293     free(tell);
294     free(data);
295     free(logp1);
296   }
297   ec_enc_init(&enc,ptr,DATA_SIZE2);
298   ec_enc_bit_logp(&enc,0,1);
299   ec_enc_bit_logp(&enc,0,1);
300   ec_enc_bit_logp(&enc,0,1);
301   ec_enc_bit_logp(&enc,0,1);
302   ec_enc_bit_logp(&enc,0,2);
303   ec_enc_patch_initial_bits(&enc,3,2);
304   if(enc.error){
305     fprintf(stderr,"patch_initial_bits failed");
306     ret=-1;
307   }
308   ec_enc_patch_initial_bits(&enc,0,5);
309   if(!enc.error){
310     fprintf(stderr,"patch_initial_bits didn't fail when it should have");
311     ret=-1;
312   }
313   ec_enc_done(&enc);
314   if(ec_range_bytes(&enc)!=1||ptr[0]!=192){
315     fprintf(stderr,"Got %d when expecting 192 for patch_initial_bits",ptr[0]);
316     ret=-1;
317   }
318   ec_enc_init(&enc,ptr,DATA_SIZE2);
319   ec_enc_bit_logp(&enc,0,1);
320   ec_enc_bit_logp(&enc,0,1);
321   ec_enc_bit_logp(&enc,1,6);
322   ec_enc_bit_logp(&enc,0,2);
323   ec_enc_patch_initial_bits(&enc,0,2);
324   if(enc.error){
325     fprintf(stderr,"patch_initial_bits failed");
326     ret=-1;
327   }
328   ec_enc_done(&enc);
329   if(ec_range_bytes(&enc)!=2||ptr[0]!=63){
330     fprintf(stderr,"Got %d when expecting 63 for patch_initial_bits",ptr[0]);
331     ret=-1;
332   }
333   ec_enc_init(&enc,ptr,2);
334   ec_enc_bit_logp(&enc,0,2);
335   for(i=0;i<48;i++){
336     ec_enc_bits(&enc,0,1);
337   }
338   ec_enc_done(&enc);
339   if(!enc.error){
340     fprintf(stderr,"Raw bits overfill didn't fail when it should have");
341     ret=-1;
342   }
343   ec_enc_init(&enc,ptr,2);
344   for(i=0;i<17;i++){
345     ec_enc_bits(&enc,0,1);
346   }
347   ec_enc_done(&enc);
348   if(!enc.error){
349     fprintf(stderr,"17 raw bits encoded in two bytes");
350     ret=-1;
351   }
352   free(ptr);
353   return ret;
354 }