vrshoot

annotate libs/vorbis/sharedbook.c @ 3:c179c72369be

find changesets by author, revision, files, or words in the commit message
rename candy->vr
author John Tsiombikas <nuclear@member.fsf.org>
date Mon, 03 Feb 2014 08:52:13 +0200
parents
children
rev   line source
nuclear@0 1 /********************************************************************
nuclear@0 2 * *
nuclear@0 3 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
nuclear@0 4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
nuclear@0 5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
nuclear@0 6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
nuclear@0 7 * *
nuclear@0 8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
nuclear@0 9 * by the Xiph.Org Foundation http://www.xiph.org/ *
nuclear@0 10 * *
nuclear@0 11 ********************************************************************
nuclear@0 12
nuclear@0 13 function: basic shared codebook operations
nuclear@0 14 last mod: $Id: sharedbook.c 17030 2010-03-25 06:52:55Z xiphmont $
nuclear@0 15
nuclear@0 16 ********************************************************************/
nuclear@0 17
nuclear@0 18 #include <stdlib.h>
nuclear@0 19 #include <math.h>
nuclear@0 20 #include <string.h>
nuclear@0 21 #include <ogg/ogg.h>
nuclear@0 22 #include "os.h"
nuclear@0 23 #include "misc.h"
nuclear@0 24 #include "vorbis/codec.h"
nuclear@0 25 #include "codebook.h"
nuclear@0 26 #include "scales.h"
nuclear@0 27
nuclear@0 28 /**** pack/unpack helpers ******************************************/
nuclear@0 29 int _ilog(unsigned int v){
nuclear@0 30 int ret=0;
nuclear@0 31 while(v){
nuclear@0 32 ret++;
nuclear@0 33 v>>=1;
nuclear@0 34 }
nuclear@0 35 return(ret);
nuclear@0 36 }
nuclear@0 37
nuclear@0 38 /* 32 bit float (not IEEE; nonnormalized mantissa +
nuclear@0 39 biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm
nuclear@0 40 Why not IEEE? It's just not that important here. */
nuclear@0 41
nuclear@0 42 #define VQ_FEXP 10
nuclear@0 43 #define VQ_FMAN 21
nuclear@0 44 #define VQ_FEXP_BIAS 768 /* bias toward values smaller than 1. */
nuclear@0 45
nuclear@0 46 /* doesn't currently guard under/overflow */
nuclear@0 47 long _float32_pack(float val){
nuclear@0 48 int sign=0;
nuclear@0 49 long exp;
nuclear@0 50 long mant;
nuclear@0 51 if(val<0){
nuclear@0 52 sign=0x80000000;
nuclear@0 53 val= -val;
nuclear@0 54 }
nuclear@0 55 exp= floor(log(val)/log(2.f)+.001); /*+epsilon*/
nuclear@0 56 mant=rint(ldexp(val,(VQ_FMAN-1)-exp));
nuclear@0 57 exp=(exp+VQ_FEXP_BIAS)<<VQ_FMAN;
nuclear@0 58
nuclear@0 59 return(sign|exp|mant);
nuclear@0 60 }
nuclear@0 61
nuclear@0 62 float _float32_unpack(long val){
nuclear@0 63 double mant=val&0x1fffff;
nuclear@0 64 int sign=val&0x80000000;
nuclear@0 65 long exp =(val&0x7fe00000L)>>VQ_FMAN;
nuclear@0 66 if(sign)mant= -mant;
nuclear@0 67 return(ldexp(mant,exp-(VQ_FMAN-1)-VQ_FEXP_BIAS));
nuclear@0 68 }
nuclear@0 69
nuclear@0 70 /* given a list of word lengths, generate a list of codewords. Works
nuclear@0 71 for length ordered or unordered, always assigns the lowest valued
nuclear@0 72 codewords first. Extended to handle unused entries (length 0) */
nuclear@0 73 ogg_uint32_t *_make_words(long *l,long n,long sparsecount){
nuclear@0 74 long i,j,count=0;
nuclear@0 75 ogg_uint32_t marker[33];
nuclear@0 76 ogg_uint32_t *r=_ogg_malloc((sparsecount?sparsecount:n)*sizeof(*r));
nuclear@0 77 memset(marker,0,sizeof(marker));
nuclear@0 78
nuclear@0 79 for(i=0;i<n;i++){
nuclear@0 80 long length=l[i];
nuclear@0 81 if(length>0){
nuclear@0 82 ogg_uint32_t entry=marker[length];
nuclear@0 83
nuclear@0 84 /* when we claim a node for an entry, we also claim the nodes
nuclear@0 85 below it (pruning off the imagined tree that may have dangled
nuclear@0 86 from it) as well as blocking the use of any nodes directly
nuclear@0 87 above for leaves */
nuclear@0 88
nuclear@0 89 /* update ourself */
nuclear@0 90 if(length<32 && (entry>>length)){
nuclear@0 91 /* error condition; the lengths must specify an overpopulated tree */
nuclear@0 92 _ogg_free(r);
nuclear@0 93 return(NULL);
nuclear@0 94 }
nuclear@0 95 r[count++]=entry;
nuclear@0 96
nuclear@0 97 /* Look to see if the next shorter marker points to the node
nuclear@0 98 above. if so, update it and repeat. */
nuclear@0 99 {
nuclear@0 100 for(j=length;j>0;j--){
nuclear@0 101
nuclear@0 102 if(marker[j]&1){
nuclear@0 103 /* have to jump branches */
nuclear@0 104 if(j==1)
nuclear@0 105 marker[1]++;
nuclear@0 106 else
nuclear@0 107 marker[j]=marker[j-1]<<1;
nuclear@0 108 break; /* invariant says next upper marker would already
nuclear@0 109 have been moved if it was on the same path */
nuclear@0 110 }
nuclear@0 111 marker[j]++;
nuclear@0 112 }
nuclear@0 113 }
nuclear@0 114
nuclear@0 115 /* prune the tree; the implicit invariant says all the longer
nuclear@0 116 markers were dangling from our just-taken node. Dangle them
nuclear@0 117 from our *new* node. */
nuclear@0 118 for(j=length+1;j<33;j++)
nuclear@0 119 if((marker[j]>>1) == entry){
nuclear@0 120 entry=marker[j];
nuclear@0 121 marker[j]=marker[j-1]<<1;
nuclear@0 122 }else
nuclear@0 123 break;
nuclear@0 124 }else
nuclear@0 125 if(sparsecount==0)count++;
nuclear@0 126 }
nuclear@0 127
nuclear@0 128 /* sanity check the huffman tree; an underpopulated tree must be
nuclear@0 129 rejected. The only exception is the one-node pseudo-nil tree,
nuclear@0 130 which appears to be underpopulated because the tree doesn't
nuclear@0 131 really exist; there's only one possible 'codeword' or zero bits,
nuclear@0 132 but the above tree-gen code doesn't mark that. */
nuclear@0 133 if(sparsecount != 1){
nuclear@0 134 for(i=1;i<33;i++)
nuclear@0 135 if(marker[i] & (0xffffffffUL>>(32-i))){
nuclear@0 136 _ogg_free(r);
nuclear@0 137 return(NULL);
nuclear@0 138 }
nuclear@0 139 }
nuclear@0 140
nuclear@0 141 /* bitreverse the words because our bitwise packer/unpacker is LSb
nuclear@0 142 endian */
nuclear@0 143 for(i=0,count=0;i<n;i++){
nuclear@0 144 ogg_uint32_t temp=0;
nuclear@0 145 for(j=0;j<l[i];j++){
nuclear@0 146 temp<<=1;
nuclear@0 147 temp|=(r[count]>>j)&1;
nuclear@0 148 }
nuclear@0 149
nuclear@0 150 if(sparsecount){
nuclear@0 151 if(l[i])
nuclear@0 152 r[count++]=temp;
nuclear@0 153 }else
nuclear@0 154 r[count++]=temp;
nuclear@0 155 }
nuclear@0 156
nuclear@0 157 return(r);
nuclear@0 158 }
nuclear@0 159
nuclear@0 160 /* there might be a straightforward one-line way to do the below
nuclear@0 161 that's portable and totally safe against roundoff, but I haven't
nuclear@0 162 thought of it. Therefore, we opt on the side of caution */
nuclear@0 163 long _book_maptype1_quantvals(const static_codebook *b){
nuclear@0 164 long vals=floor(pow((float)b->entries,1.f/b->dim));
nuclear@0 165
nuclear@0 166 /* the above *should* be reliable, but we'll not assume that FP is
nuclear@0 167 ever reliable when bitstream sync is at stake; verify via integer
nuclear@0 168 means that vals really is the greatest value of dim for which
nuclear@0 169 vals^b->bim <= b->entries */
nuclear@0 170 /* treat the above as an initial guess */
nuclear@0 171 while(1){
nuclear@0 172 long acc=1;
nuclear@0 173 long acc1=1;
nuclear@0 174 int i;
nuclear@0 175 for(i=0;i<b->dim;i++){
nuclear@0 176 acc*=vals;
nuclear@0 177 acc1*=vals+1;
nuclear@0 178 }
nuclear@0 179 if(acc<=b->entries && acc1>b->entries){
nuclear@0 180 return(vals);
nuclear@0 181 }else{
nuclear@0 182 if(acc>b->entries){
nuclear@0 183 vals--;
nuclear@0 184 }else{
nuclear@0 185 vals++;
nuclear@0 186 }
nuclear@0 187 }
nuclear@0 188 }
nuclear@0 189 }
nuclear@0 190
nuclear@0 191 /* unpack the quantized list of values for encode/decode ***********/
nuclear@0 192 /* we need to deal with two map types: in map type 1, the values are
nuclear@0 193 generated algorithmically (each column of the vector counts through
nuclear@0 194 the values in the quant vector). in map type 2, all the values came
nuclear@0 195 in in an explicit list. Both value lists must be unpacked */
nuclear@0 196 float *_book_unquantize(const static_codebook *b,int n,int *sparsemap){
nuclear@0 197 long j,k,count=0;
nuclear@0 198 if(b->maptype==1 || b->maptype==2){
nuclear@0 199 int quantvals;
nuclear@0 200 float mindel=_float32_unpack(b->q_min);
nuclear@0 201 float delta=_float32_unpack(b->q_delta);
nuclear@0 202 float *r=_ogg_calloc(n*b->dim,sizeof(*r));
nuclear@0 203
nuclear@0 204 /* maptype 1 and 2 both use a quantized value vector, but
nuclear@0 205 different sizes */
nuclear@0 206 switch(b->maptype){
nuclear@0 207 case 1:
nuclear@0 208 /* most of the time, entries%dimensions == 0, but we need to be
nuclear@0 209 well defined. We define that the possible vales at each
nuclear@0 210 scalar is values == entries/dim. If entries%dim != 0, we'll
nuclear@0 211 have 'too few' values (values*dim<entries), which means that
nuclear@0 212 we'll have 'left over' entries; left over entries use zeroed
nuclear@0 213 values (and are wasted). So don't generate codebooks like
nuclear@0 214 that */
nuclear@0 215 quantvals=_book_maptype1_quantvals(b);
nuclear@0 216 for(j=0;j<b->entries;j++){
nuclear@0 217 if((sparsemap && b->lengthlist[j]) || !sparsemap){
nuclear@0 218 float last=0.f;
nuclear@0 219 int indexdiv=1;
nuclear@0 220 for(k=0;k<b->dim;k++){
nuclear@0 221 int index= (j/indexdiv)%quantvals;
nuclear@0 222 float val=b->quantlist[index];
nuclear@0 223 val=fabs(val)*delta+mindel+last;
nuclear@0 224 if(b->q_sequencep)last=val;
nuclear@0 225 if(sparsemap)
nuclear@0 226 r[sparsemap[count]*b->dim+k]=val;
nuclear@0 227 else
nuclear@0 228 r[count*b->dim+k]=val;
nuclear@0 229 indexdiv*=quantvals;
nuclear@0 230 }
nuclear@0 231 count++;
nuclear@0 232 }
nuclear@0 233
nuclear@0 234 }
nuclear@0 235 break;
nuclear@0 236 case 2:
nuclear@0 237 for(j=0;j<b->entries;j++){
nuclear@0 238 if((sparsemap && b->lengthlist[j]) || !sparsemap){
nuclear@0 239 float last=0.f;
nuclear@0 240
nuclear@0 241 for(k=0;k<b->dim;k++){
nuclear@0 242 float val=b->quantlist[j*b->dim+k];
nuclear@0 243 val=fabs(val)*delta+mindel+last;
nuclear@0 244 if(b->q_sequencep)last=val;
nuclear@0 245 if(sparsemap)
nuclear@0 246 r[sparsemap[count]*b->dim+k]=val;
nuclear@0 247 else
nuclear@0 248 r[count*b->dim+k]=val;
nuclear@0 249 }
nuclear@0 250 count++;
nuclear@0 251 }
nuclear@0 252 }
nuclear@0 253 break;
nuclear@0 254 }
nuclear@0 255
nuclear@0 256 return(r);
nuclear@0 257 }
nuclear@0 258 return(NULL);
nuclear@0 259 }
nuclear@0 260
nuclear@0 261 void vorbis_staticbook_destroy(static_codebook *b){
nuclear@0 262 if(b->allocedp){
nuclear@0 263 if(b->quantlist)_ogg_free(b->quantlist);
nuclear@0 264 if(b->lengthlist)_ogg_free(b->lengthlist);
nuclear@0 265 memset(b,0,sizeof(*b));
nuclear@0 266 _ogg_free(b);
nuclear@0 267 } /* otherwise, it is in static memory */
nuclear@0 268 }
nuclear@0 269
nuclear@0 270 void vorbis_book_clear(codebook *b){
nuclear@0 271 /* static book is not cleared; we're likely called on the lookup and
nuclear@0 272 the static codebook belongs to the info struct */
nuclear@0 273 if(b->valuelist)_ogg_free(b->valuelist);
nuclear@0 274 if(b->codelist)_ogg_free(b->codelist);
nuclear@0 275
nuclear@0 276 if(b->dec_index)_ogg_free(b->dec_index);
nuclear@0 277 if(b->dec_codelengths)_ogg_free(b->dec_codelengths);
nuclear@0 278 if(b->dec_firsttable)_ogg_free(b->dec_firsttable);
nuclear@0 279
nuclear@0 280 memset(b,0,sizeof(*b));
nuclear@0 281 }
nuclear@0 282
nuclear@0 283 int vorbis_book_init_encode(codebook *c,const static_codebook *s){
nuclear@0 284
nuclear@0 285 memset(c,0,sizeof(*c));
nuclear@0 286 c->c=s;
nuclear@0 287 c->entries=s->entries;
nuclear@0 288 c->used_entries=s->entries;
nuclear@0 289 c->dim=s->dim;
nuclear@0 290 c->codelist=_make_words(s->lengthlist,s->entries,0);
nuclear@0 291 /*c->valuelist=_book_unquantize(s,s->entries,NULL);*/
nuclear@0 292 c->quantvals=_book_maptype1_quantvals(s);
nuclear@0 293 c->minval=(int)rint(_float32_unpack(s->q_min));
nuclear@0 294 c->delta=(int)rint(_float32_unpack(s->q_delta));
nuclear@0 295
nuclear@0 296 return(0);
nuclear@0 297 }
nuclear@0 298
nuclear@0 299 static ogg_uint32_t bitreverse(ogg_uint32_t x){
nuclear@0 300 x= ((x>>16)&0x0000ffffUL) | ((x<<16)&0xffff0000UL);
nuclear@0 301 x= ((x>> 8)&0x00ff00ffUL) | ((x<< 8)&0xff00ff00UL);
nuclear@0 302 x= ((x>> 4)&0x0f0f0f0fUL) | ((x<< 4)&0xf0f0f0f0UL);
nuclear@0 303 x= ((x>> 2)&0x33333333UL) | ((x<< 2)&0xccccccccUL);
nuclear@0 304 return((x>> 1)&0x55555555UL) | ((x<< 1)&0xaaaaaaaaUL);
nuclear@0 305 }
nuclear@0 306
nuclear@0 307 static int sort32a(const void *a,const void *b){
nuclear@0 308 return ( **(ogg_uint32_t **)a>**(ogg_uint32_t **)b)-
nuclear@0 309 ( **(ogg_uint32_t **)a<**(ogg_uint32_t **)b);
nuclear@0 310 }
nuclear@0 311
nuclear@0 312 /* decode codebook arrangement is more heavily optimized than encode */
nuclear@0 313 int vorbis_book_init_decode(codebook *c,const static_codebook *s){
nuclear@0 314 int i,j,n=0,tabn;
nuclear@0 315 int *sortindex;
nuclear@0 316 memset(c,0,sizeof(*c));
nuclear@0 317
nuclear@0 318 /* count actually used entries */
nuclear@0 319 for(i=0;i<s->entries;i++)
nuclear@0 320 if(s->lengthlist[i]>0)
nuclear@0 321 n++;
nuclear@0 322
nuclear@0 323 c->entries=s->entries;
nuclear@0 324 c->used_entries=n;
nuclear@0 325 c->dim=s->dim;
nuclear@0 326
nuclear@0 327 if(n>0){
nuclear@0 328
nuclear@0 329 /* two different remappings go on here.
nuclear@0 330
nuclear@0 331 First, we collapse the likely sparse codebook down only to
nuclear@0 332 actually represented values/words. This collapsing needs to be
nuclear@0 333 indexed as map-valueless books are used to encode original entry
nuclear@0 334 positions as integers.
nuclear@0 335
nuclear@0 336 Second, we reorder all vectors, including the entry index above,
nuclear@0 337 by sorted bitreversed codeword to allow treeless decode. */
nuclear@0 338
nuclear@0 339 /* perform sort */
nuclear@0 340 ogg_uint32_t *codes=_make_words(s->lengthlist,s->entries,c->used_entries);
nuclear@0 341 ogg_uint32_t **codep=alloca(sizeof(*codep)*n);
nuclear@0 342
nuclear@0 343 if(codes==NULL)goto err_out;
nuclear@0 344
nuclear@0 345 for(i=0;i<n;i++){
nuclear@0 346 codes[i]=bitreverse(codes[i]);
nuclear@0 347 codep[i]=codes+i;
nuclear@0 348 }
nuclear@0 349
nuclear@0 350 qsort(codep,n,sizeof(*codep),sort32a);
nuclear@0 351
nuclear@0 352 sortindex=alloca(n*sizeof(*sortindex));
nuclear@0 353 c->codelist=_ogg_malloc(n*sizeof(*c->codelist));
nuclear@0 354 /* the index is a reverse index */
nuclear@0 355 for(i=0;i<n;i++){
nuclear@0 356 int position=codep[i]-codes;
nuclear@0 357 sortindex[position]=i;
nuclear@0 358 }
nuclear@0 359
nuclear@0 360 for(i=0;i<n;i++)
nuclear@0 361 c->codelist[sortindex[i]]=codes[i];
nuclear@0 362 _ogg_free(codes);
nuclear@0 363
nuclear@0 364
nuclear@0 365 c->valuelist=_book_unquantize(s,n,sortindex);
nuclear@0 366 c->dec_index=_ogg_malloc(n*sizeof(*c->dec_index));
nuclear@0 367
nuclear@0 368 for(n=0,i=0;i<s->entries;i++)
nuclear@0 369 if(s->lengthlist[i]>0)
nuclear@0 370 c->dec_index[sortindex[n++]]=i;
nuclear@0 371
nuclear@0 372 c->dec_codelengths=_ogg_malloc(n*sizeof(*c->dec_codelengths));
nuclear@0 373 for(n=0,i=0;i<s->entries;i++)
nuclear@0 374 if(s->lengthlist[i]>0)
nuclear@0 375 c->dec_codelengths[sortindex[n++]]=s->lengthlist[i];
nuclear@0 376
nuclear@0 377 c->dec_firsttablen=_ilog(c->used_entries)-4; /* this is magic */
nuclear@0 378 if(c->dec_firsttablen<5)c->dec_firsttablen=5;
nuclear@0 379 if(c->dec_firsttablen>8)c->dec_firsttablen=8;
nuclear@0 380
nuclear@0 381 tabn=1<<c->dec_firsttablen;
nuclear@0 382 c->dec_firsttable=_ogg_calloc(tabn,sizeof(*c->dec_firsttable));
nuclear@0 383 c->dec_maxlength=0;
nuclear@0 384
nuclear@0 385 for(i=0;i<n;i++){
nuclear@0 386 if(c->dec_maxlength<c->dec_codelengths[i])
nuclear@0 387 c->dec_maxlength=c->dec_codelengths[i];
nuclear@0 388 if(c->dec_codelengths[i]<=c->dec_firsttablen){
nuclear@0 389 ogg_uint32_t orig=bitreverse(c->codelist[i]);
nuclear@0 390 for(j=0;j<(1<<(c->dec_firsttablen-c->dec_codelengths[i]));j++)
nuclear@0 391 c->dec_firsttable[orig|(j<<c->dec_codelengths[i])]=i+1;
nuclear@0 392 }
nuclear@0 393 }
nuclear@0 394
nuclear@0 395 /* now fill in 'unused' entries in the firsttable with hi/lo search
nuclear@0 396 hints for the non-direct-hits */
nuclear@0 397 {
nuclear@0 398 ogg_uint32_t mask=0xfffffffeUL<<(31-c->dec_firsttablen);
nuclear@0 399 long lo=0,hi=0;
nuclear@0 400
nuclear@0 401 for(i=0;i<tabn;i++){
nuclear@0 402 ogg_uint32_t word=i<<(32-c->dec_firsttablen);
nuclear@0 403 if(c->dec_firsttable[bitreverse(word)]==0){
nuclear@0 404 while((lo+1)<n && c->codelist[lo+1]<=word)lo++;
nuclear@0 405 while( hi<n && word>=(c->codelist[hi]&mask))hi++;
nuclear@0 406
nuclear@0 407 /* we only actually have 15 bits per hint to play with here.
nuclear@0 408 In order to overflow gracefully (nothing breaks, efficiency
nuclear@0 409 just drops), encode as the difference from the extremes. */
nuclear@0 410 {
nuclear@0 411 unsigned long loval=lo;
nuclear@0 412 unsigned long hival=n-hi;
nuclear@0 413
nuclear@0 414 if(loval>0x7fff)loval=0x7fff;
nuclear@0 415 if(hival>0x7fff)hival=0x7fff;
nuclear@0 416 c->dec_firsttable[bitreverse(word)]=
nuclear@0 417 0x80000000UL | (loval<<15) | hival;
nuclear@0 418 }
nuclear@0 419 }
nuclear@0 420 }
nuclear@0 421 }
nuclear@0 422 }
nuclear@0 423
nuclear@0 424 return(0);
nuclear@0 425 err_out:
nuclear@0 426 vorbis_book_clear(c);
nuclear@0 427 return(-1);
nuclear@0 428 }
nuclear@0 429
nuclear@0 430 long vorbis_book_codeword(codebook *book,int entry){
nuclear@0 431 if(book->c) /* only use with encode; decode optimizations are
nuclear@0 432 allowed to break this */
nuclear@0 433 return book->codelist[entry];
nuclear@0 434 return -1;
nuclear@0 435 }
nuclear@0 436
nuclear@0 437 long vorbis_book_codelen(codebook *book,int entry){
nuclear@0 438 if(book->c) /* only use with encode; decode optimizations are
nuclear@0 439 allowed to break this */
nuclear@0 440 return book->c->lengthlist[entry];
nuclear@0 441 return -1;
nuclear@0 442 }
nuclear@0 443
nuclear@0 444 #ifdef _V_SELFTEST
nuclear@0 445
nuclear@0 446 /* Unit tests of the dequantizer; this stuff will be OK
nuclear@0 447 cross-platform, I simply want to be sure that special mapping cases
nuclear@0 448 actually work properly; a bug could go unnoticed for a while */
nuclear@0 449
nuclear@0 450 #include <stdio.h>
nuclear@0 451
nuclear@0 452 /* cases:
nuclear@0 453
nuclear@0 454 no mapping
nuclear@0 455 full, explicit mapping
nuclear@0 456 algorithmic mapping
nuclear@0 457
nuclear@0 458 nonsequential
nuclear@0 459 sequential
nuclear@0 460 */
nuclear@0 461
nuclear@0 462 static long full_quantlist1[]={0,1,2,3, 4,5,6,7, 8,3,6,1};
nuclear@0 463 static long partial_quantlist1[]={0,7,2};
nuclear@0 464
nuclear@0 465 /* no mapping */
nuclear@0 466 static_codebook test1={
nuclear@0 467 4,16,
nuclear@0 468 NULL,
nuclear@0 469 0,
nuclear@0 470 0,0,0,0,
nuclear@0 471 NULL,
nuclear@0 472 0
nuclear@0 473 };
nuclear@0 474 static float *test1_result=NULL;
nuclear@0 475
nuclear@0 476 /* linear, full mapping, nonsequential */
nuclear@0 477 static_codebook test2={
nuclear@0 478 4,3,
nuclear@0 479 NULL,
nuclear@0 480 2,
nuclear@0 481 -533200896,1611661312,4,0,
nuclear@0 482 full_quantlist1,
nuclear@0 483 0
nuclear@0 484 };
nuclear@0 485 static float test2_result[]={-3,-2,-1,0, 1,2,3,4, 5,0,3,-2};
nuclear@0 486
nuclear@0 487 /* linear, full mapping, sequential */
nuclear@0 488 static_codebook test3={
nuclear@0 489 4,3,
nuclear@0 490 NULL,
nuclear@0 491 2,
nuclear@0 492 -533200896,1611661312,4,1,
nuclear@0 493 full_quantlist1,
nuclear@0 494 0
nuclear@0 495 };
nuclear@0 496 static float test3_result[]={-3,-5,-6,-6, 1,3,6,10, 5,5,8,6};
nuclear@0 497
nuclear@0 498 /* linear, algorithmic mapping, nonsequential */
nuclear@0 499 static_codebook test4={
nuclear@0 500 3,27,
nuclear@0 501 NULL,
nuclear@0 502 1,
nuclear@0 503 -533200896,1611661312,4,0,
nuclear@0 504 partial_quantlist1,
nuclear@0 505 0
nuclear@0 506 };
nuclear@0 507 static float test4_result[]={-3,-3,-3, 4,-3,-3, -1,-3,-3,
nuclear@0 508 -3, 4,-3, 4, 4,-3, -1, 4,-3,
nuclear@0 509 -3,-1,-3, 4,-1,-3, -1,-1,-3,
nuclear@0 510 -3,-3, 4, 4,-3, 4, -1,-3, 4,
nuclear@0 511 -3, 4, 4, 4, 4, 4, -1, 4, 4,
nuclear@0 512 -3,-1, 4, 4,-1, 4, -1,-1, 4,
nuclear@0 513 -3,-3,-1, 4,-3,-1, -1,-3,-1,
nuclear@0 514 -3, 4,-1, 4, 4,-1, -1, 4,-1,
nuclear@0 515 -3,-1,-1, 4,-1,-1, -1,-1,-1};
nuclear@0 516
nuclear@0 517 /* linear, algorithmic mapping, sequential */
nuclear@0 518 static_codebook test5={
nuclear@0 519 3,27,
nuclear@0 520 NULL,
nuclear@0 521 1,
nuclear@0 522 -533200896,1611661312,4,1,
nuclear@0 523 partial_quantlist1,
nuclear@0 524 0
nuclear@0 525 };
nuclear@0 526 static float test5_result[]={-3,-6,-9, 4, 1,-2, -1,-4,-7,
nuclear@0 527 -3, 1,-2, 4, 8, 5, -1, 3, 0,
nuclear@0 528 -3,-4,-7, 4, 3, 0, -1,-2,-5,
nuclear@0 529 -3,-6,-2, 4, 1, 5, -1,-4, 0,
nuclear@0 530 -3, 1, 5, 4, 8,12, -1, 3, 7,
nuclear@0 531 -3,-4, 0, 4, 3, 7, -1,-2, 2,
nuclear@0 532 -3,-6,-7, 4, 1, 0, -1,-4,-5,
nuclear@0 533 -3, 1, 0, 4, 8, 7, -1, 3, 2,
nuclear@0 534 -3,-4,-5, 4, 3, 2, -1,-2,-3};
nuclear@0 535
nuclear@0 536 void run_test(static_codebook *b,float *comp){
nuclear@0 537 float *out=_book_unquantize(b,b->entries,NULL);
nuclear@0 538 int i;
nuclear@0 539
nuclear@0 540 if(comp){
nuclear@0 541 if(!out){
nuclear@0 542 fprintf(stderr,"_book_unquantize incorrectly returned NULL\n");
nuclear@0 543 exit(1);
nuclear@0 544 }
nuclear@0 545
nuclear@0 546 for(i=0;i<b->entries*b->dim;i++)
nuclear@0 547 if(fabs(out[i]-comp[i])>.0001){
nuclear@0 548 fprintf(stderr,"disagreement in unquantized and reference data:\n"
nuclear@0 549 "position %d, %g != %g\n",i,out[i],comp[i]);
nuclear@0 550 exit(1);
nuclear@0 551 }
nuclear@0 552
nuclear@0 553 }else{
nuclear@0 554 if(out){
nuclear@0 555 fprintf(stderr,"_book_unquantize returned a value array: \n"
nuclear@0 556 " correct result should have been NULL\n");
nuclear@0 557 exit(1);
nuclear@0 558 }
nuclear@0 559 }
nuclear@0 560 }
nuclear@0 561
nuclear@0 562 int main(){
nuclear@0 563 /* run the nine dequant tests, and compare to the hand-rolled results */
nuclear@0 564 fprintf(stderr,"Dequant test 1... ");
nuclear@0 565 run_test(&test1,test1_result);
nuclear@0 566 fprintf(stderr,"OK\nDequant test 2... ");
nuclear@0 567 run_test(&test2,test2_result);
nuclear@0 568 fprintf(stderr,"OK\nDequant test 3... ");
nuclear@0 569 run_test(&test3,test3_result);
nuclear@0 570 fprintf(stderr,"OK\nDequant test 4... ");
nuclear@0 571 run_test(&test4,test4_result);
nuclear@0 572 fprintf(stderr,"OK\nDequant test 5... ");
nuclear@0 573 run_test(&test5,test5_result);
nuclear@0 574 fprintf(stderr,"OK\n\n");
nuclear@0 575
nuclear@0 576 return(0);
nuclear@0 577 }
nuclear@0 578
nuclear@0 579 #endif