lib/res0.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   7  *                                                                  *
   8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001             *
   9  * by the XIPHOPHORUS Company http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13  function: residue backend 0, 1 and 2 implementation
  14  last mod: $Id: res0.c,v 1.37 2001/10/02 00:14:32 segher Exp $
  15
  16  ********************************************************************/
  17
  18 /* Slow, slow, slow, simpleminded and did I mention it was slow?  The
  19    encode/decode loops are coded for clarity and performance is not
  20    yet even a nagging little idea lurking in the shadows.  Oh and BTW,
  21    it's slow. */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdio.h>
  27 #include <ogg/ogg.h>
  28 #include "vorbis/codec.h"
  29 #include "codec_internal.h"
  30 #include "registry.h"
  31 #include "codebook.h"
  32 #include "misc.h"
  33 #include "os.h"
  34
  35 typedef struct {
  36   vorbis_info_residue0 *info;
  37   int         map;
  38
  39   int         parts;
  40   int         stages;
  41   codebook   *fullbooks;
  42   codebook   *phrasebook;
  43   codebook ***partbooks;
  44
  45   int         partvals;
  46   int       **decodemap;
  47
  48   long      postbits;
  49   long      phrasebits;
  50   long      frames;
  51
  52 } vorbis_look_residue0;
  53
  54 vorbis_info_residue *res0_copy_info(vorbis_info_residue *vr){
  55   vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
  56   vorbis_info_residue0 *ret=_ogg_malloc(sizeof(*ret));
  57   memcpy(ret,info,sizeof(*ret));
  58   return(ret);
  59 }
  60
  61 void res0_free_info(vorbis_info_residue *i){
  62   vorbis_info_residue0 *info=(vorbis_info_residue0 *)i;
  63   if(info){
  64     memset(info,0,sizeof(*info));
  65     _ogg_free(info);
  66   }
  67 }
  68
  69 void res0_free_look(vorbis_look_residue *i){
  70   int j;
  71   if(i){
  72
  73     vorbis_look_residue0 *look=(vorbis_look_residue0 *)i;
  74
  75     fprintf(stderr,"residue bit usage %f:%f (%f total)\n",
  76             (float)look->phrasebits/look->frames,
  77             (float)look->postbits/look->frames,
  78             (float)(look->postbits+look->phrasebits)/look->frames);
  79
  80     /*vorbis_info_residue0 *info=look->info;
  81
  82     fprintf(stderr,
  83             "%ld frames encoded in %ld phrasebits and %ld residue bits "
  84             "(%g/frame) \n",look->frames,look->phrasebits,
  85             look->resbitsflat,
  86             (look->phrasebits+look->resbitsflat)/(float)look->frames);
  87
  88     for(j=0;j<look->parts;j++){
  89       long acc=0;
  90       fprintf(stderr,"\t[%d] == ",j);
  91       for(k=0;k<look->stages;k++)
  92         if((info->secondstages[j]>>k)&1){
  93           fprintf(stderr,"%ld,",look->resbits[j][k]);
  94           acc+=look->resbits[j][k];
  95         }
  96
  97       fprintf(stderr,":: (%ld vals) %1.2fbits/sample\n",look->resvals[j],
  98               acc?(float)acc/(look->resvals[j]*info->grouping):0);
  99     }
 100     fprintf(stderr,"\n");*/
 101
 102     for(j=0;j<look->parts;j++)
 103       if(look->partbooks[j])_ogg_free(look->partbooks[j]);
 104     _ogg_free(look->partbooks);
 105     for(j=0;j<look->partvals;j++)
 106       _ogg_free(look->decodemap[j]);
 107     _ogg_free(look->decodemap);
 108     memset(look,0,sizeof(*look));
 109     _ogg_free(look);
 110   }
 111 }
 112
 113 static int ilog(unsigned int v){
 114   int ret=0;
 115   while(v){
 116     ret++;
 117     v>>=1;
 118   }
 119   return(ret);
 120 }
 121
 122 static int icount(unsigned int v){
 123   int ret=0;
 124   while(v){
 125     ret+=v&1;
 126     v>>=1;
 127   }
 128   return(ret);
 129 }
 130
 131
 132 void res0_pack(vorbis_info_residue *vr,oggpack_buffer *opb){
 133   vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
 134   int j,acc=0;
 135   oggpack_write(opb,info->begin,24);
 136   oggpack_write(opb,info->end,24);
 137
 138   oggpack_write(opb,info->grouping-1,24);  /* residue vectors to group and
 139                                              code with a partitioned book */
 140   oggpack_write(opb,info->partitions-1,6); /* possible partition choices */
 141   oggpack_write(opb,info->groupbook,8);  /* group huffman book */
 142
 143   /* secondstages is a bitmask; as encoding progresses pass by pass, a
 144      bitmask of one indicates this partition class has bits to write
 145      this pass */
 146   for(j=0;j<info->partitions;j++){
 147     if(ilog(info->secondstages[j])>3){
 148       /* yes, this is a minor hack due to not thinking ahead */
 149       oggpack_write(opb,info->secondstages[j],3);
 150       oggpack_write(opb,1,1);
 151       oggpack_write(opb,info->secondstages[j]>>3,5);
 152     }else
 153       oggpack_write(opb,info->secondstages[j],4); /* trailing zero */
 154     acc+=icount(info->secondstages[j]);
 155   }
 156   for(j=0;j<acc;j++)
 157     oggpack_write(opb,info->booklist[j],8);
 158
 159 }
 160
 161 /* vorbis_info is for range checking */
 162 vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){
 163   int j,acc=0;
 164   vorbis_info_residue0 *info=_ogg_calloc(1,sizeof(*info));
 165   codec_setup_info     *ci=vi->codec_setup;
 166
 167   info->begin=oggpack_read(opb,24);
 168   info->end=oggpack_read(opb,24);
 169   info->grouping=oggpack_read(opb,24)+1;
 170   info->partitions=oggpack_read(opb,6)+1;
 171   info->groupbook=oggpack_read(opb,8);
 172
 173   for(j=0;j<info->partitions;j++){
 174     int cascade=oggpack_read(opb,3);
 175     if(oggpack_read(opb,1))
 176       cascade|=(oggpack_read(opb,5)<<3);
 177     info->secondstages[j]=cascade;
 178
 179     acc+=icount(cascade);
 180   }
 181   for(j=0;j<acc;j++)
 182     info->booklist[j]=oggpack_read(opb,8);
 183
 184   if(info->groupbook>=ci->books)goto errout;
 185   for(j=0;j<acc;j++)
 186     if(info->booklist[j]>=ci->books)goto errout;
 187
 188   return(info);
 189  errout:
 190   res0_free_info(info);
 191   return(NULL);
 192 }
 193
 194 vorbis_look_residue *res0_look (vorbis_dsp_state *vd,vorbis_info_mode *vm,
 195                           vorbis_info_residue *vr){
 196   vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
 197   vorbis_look_residue0 *look=_ogg_calloc(1,sizeof(*look));
 198   backend_lookup_state *be=vd->backend_state;
 199
 200   int j,k,acc=0;
 201   int dim;
 202   int maxstage=0;
 203   look->info=info;
 204   look->map=vm->mapping;
 205
 206   look->parts=info->partitions;
 207   look->fullbooks=be->fullbooks;
 208   look->phrasebook=be->fullbooks+info->groupbook;
 209   dim=look->phrasebook->dim;
 210
 211   look->partbooks=_ogg_calloc(look->parts,sizeof(*look->partbooks));
 212
 213   for(j=0;j<look->parts;j++){
 214     int stages=ilog(info->secondstages[j]);
 215     if(stages){
 216       if(stages>maxstage)maxstage=stages;
 217       look->partbooks[j]=_ogg_calloc(stages,sizeof(*look->partbooks[j]));
 218       for(k=0;k<stages;k++)
 219         if(info->secondstages[j]&(1<<k))
 220           look->partbooks[j][k]=be->fullbooks+info->booklist[acc++];
 221     }
 222   }
 223
 224   look->partvals=rint(pow(look->parts,dim));
 225   look->stages=maxstage;
 226   look->decodemap=_ogg_malloc(look->partvals*sizeof(*look->decodemap));
 227   for(j=0;j<look->partvals;j++){
 228     long val=j;
 229     long mult=look->partvals/look->parts;
 230     look->decodemap[j]=_ogg_malloc(dim*sizeof(*look->decodemap[j]));
 231     for(k=0;k<dim;k++){
 232       long deco=val/mult;
 233       val-=deco*mult;
 234       mult/=look->parts;
 235       look->decodemap[j][k]=deco;
 236     }
 237   }
 238
 239   return(look);
 240 }
 241
 242
 243 /* does not guard against invalid settings; eg, a subn of 16 and a
 244    subgroup request of 32.  Max subn of 128 */
 245 static int _interleaved_testhack(float *vec,int n,vorbis_look_residue0 *look,
 246                                  int auxparts,int auxpartnum){
 247   vorbis_info_residue0 *info=look->info;
 248   int i,j=0;
 249   float max,localmax=0.f;
 250   float temp[128];
 251   float entropy[8];
 252
 253   /* setup */
 254   for(i=0;i<n;i++)temp[i]=fabs(vec[i]);
 255
 256   /* handle case subgrp==1 outside */
 257   for(i=0;i<n;i++)
 258     if(temp[i]>localmax)localmax=temp[i];
 259   max=localmax;
 260
 261   for(i=0;i<n;i++)temp[i]=rint(temp[i]);
 262
 263   while(1){
 264     entropy[j]=localmax;
 265     n>>=1;
 266     if(!n)break;
 267     j++;
 268
 269     for(i=0;i<n;i++){
 270       temp[i]+=temp[i+n];
 271     }
 272     localmax=0.f;
 273     for(i=0;i<n;i++)
 274       if(temp[i]>localmax)localmax=temp[i];
 275   }
 276
 277   for(i=0;i<auxparts-1;i++)
 278     if(auxpartnum<info->blimit[i] &&
 279        entropy[info->subgrp[i]]<=info->entmax[i] &&
 280        max<=info->ampmax[i])
 281       break;
 282
 283   return(i);
 284 }
 285
 286 static int _testhack(float *vec,int n,vorbis_look_residue0 *look,
 287                      int auxparts,int auxpartnum){
 288   vorbis_info_residue0 *info=look->info;
 289   int i;
 290   float max=0.f;
 291   float temp[128];
 292   float entropy=0.f;
 293
 294   /* setup */
 295   for(i=0;i<n;i++)temp[i]=fabs(vec[i]);
 296
 297   for(i=0;i<n;i++)
 298     if(temp[i]>max)max=temp[i];
 299
 300   for(i=0;i<n;i++)temp[i]=rint(temp[i]);
 301
 302   for(i=0;i<n;i++)
 303     entropy+=temp[i];
 304
 305   for(i=0;i<auxparts-1;i++)
 306     if(auxpartnum<info->blimit[i] &&
 307        entropy<=info->entmax[i] &&
 308        max<=info->ampmax[i])
 309       break;
 310
 311   return(i);
 312 }
 313
 314 static int _interleaved_encodepart(oggpack_buffer *opb,float *vec, int n,
 315                                    codebook *book,vorbis_look_residue0 *look){
 316   int i,bits=0;
 317   int dim=book->dim;
 318   int step=n/dim;
 319 #ifdef TRAIN_RESENT
 320   char buf[80];
 321   FILE *f;
 322   sprintf(buf,"res0_b%d.vqd",book-look->fullbooks);
 323   f=fopen(buf,"a");
 324 #endif
 325
 326   for(i=0;i<step;i++){
 327     int entry=vorbis_book_besterror(book,vec+i,step,0);
 328
 329 #ifdef TRAIN_RESENT
 330     fprintf(f,"%d\n",entry);
 331 #endif
 332
 333     bits+=vorbis_book_encode(book,entry,opb);
 334   }
 335
 336 #ifdef TRAIN_RESENT
 337   fclose(f);
 338 #endif
 339   return(bits);
 340 }
 341
 342 static int _encodepart(oggpack_buffer *opb,float *vec, int n,
 343                        codebook *book,vorbis_look_residue0 *look){
 344   int i,bits=0;
 345   int dim=book->dim;
 346   int step=n/dim;
 347 #ifdef TRAIN_RESENT
 348   char buf[80];
 349   FILE *f;
 350   sprintf(buf,"res0_b%d.vqd",book-look->fullbooks);
 351   f=fopen(buf,"a");
 352 #endif
 353
 354   for(i=0;i<step;i++){
 355     int entry=vorbis_book_besterror(book,vec+i*dim,1,0);
 356
 357 #ifdef TRAIN_RESENT
 358     fprintf(f,"%d\n",entry);
 359 #endif
 360
 361     bits+=vorbis_book_encode(book,entry,opb);
 362   }
 363
 364 #ifdef TRAIN_RESENT
 365   fclose(f);
 366 #endif
 367   return(bits);
 368 }
 369
 370 static long **_01class(vorbis_block *vb,vorbis_look_residue *vl,
 371                        float **in,int ch,
 372                        int (*classify)(float *,int,vorbis_look_residue0 *,
 373                                        int,int)){
 374   long i,j;
 375   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
 376   vorbis_info_residue0 *info=look->info;
 377
 378   /* move all this setup out later */
 379   int samples_per_partition=info->grouping;
 380   int possible_partitions=info->partitions;
 381   int n=info->end-info->begin;
 382
 383   int partvals=n/samples_per_partition;
 384   long **partword=_vorbis_block_alloc(vb,ch*sizeof(*partword));
 385
 386   /* we find the partition type for each partition of each
 387      channel.  We'll go back and do the interleaved encoding in a
 388      bit.  For now, clarity */
 389
 390   for(i=0;i<ch;i++){
 391     partword[i]=_vorbis_block_alloc(vb,n/samples_per_partition*sizeof(*partword[i]));
 392     memset(partword[i],0,n/samples_per_partition*sizeof(*partword[i]));
 393   }
 394
 395   for(i=0;i<partvals;i++){
 396     for(j=0;j<ch;j++)
 397       /* do the partition decision based on the 'entropy'
 398          int the block */
 399       partword[j][i]=
 400         classify(in[j]+i*samples_per_partition+info->begin,
 401                  samples_per_partition,look,possible_partitions,i);
 402
 403   }
 404
 405 #ifdef TRAIN_RES
 406   {
 407     FILE *of;
 408     char buffer[80];
 409
 410     for(i=0;i<ch;i++){
 411       sprintf(buffer,"resaux_%d.vqd",vb->mode);
 412       of=fopen(buffer,"a");
 413       for(j=0;j<partvals;j++)
 414         fprintf(of,"%ld, ",partword[i][j]);
 415       fprintf(of,"\n");
 416       fclose(of);
 417     }
 418   }
 419 #endif
 420   look->frames++;
 421
 422   return(partword);
 423 }
 424
 425 static long **_2class(vorbis_block *vb,vorbis_look_residue *vl,
 426                        float **in,int ch,
 427                        int (*classify)(float *,int,vorbis_look_residue0 *,
 428                                        int,int)){
 429   long i,j,k,l;
 430   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
 431   vorbis_info_residue0 *info=look->info;
 432
 433   /* move all this setup out later */
 434   int samples_per_partition=info->grouping;
 435   int possible_partitions=info->partitions;
 436   int n=info->end-info->begin;
 437
 438   int partvals=n/samples_per_partition;
 439   long **partword=_vorbis_block_alloc(vb,sizeof(*partword));
 440   float *work=alloca(sizeof(*work)*samples_per_partition);
 441
 442   partword[0]=_vorbis_block_alloc(vb,n*ch/samples_per_partition*sizeof(*partword[0]));
 443   memset(partword[0],0,n*ch/samples_per_partition*sizeof(*partword[0]));
 444
 445   for(i=0,j=0,k=0,l=info->begin;i<partvals;i++){
 446     for(k=0;k<samples_per_partition;k++){
 447       work[k]=in[j][l];
 448       j++;
 449       if(j>=ch){
 450         j=0;
 451         l++;
 452       }
 453     }
 454     partword[0][i]=
 455       classify(work,samples_per_partition,look,possible_partitions,i);
 456   }
 457
 458 #ifdef TRAIN_RES
 459   {
 460     FILE *of;
 461     char buffer[80];
 462
 463     sprintf(buffer,"resaux_%d.vqd",vb->mode);
 464     of=fopen(buffer,"a");
 465     for(i=0;i<partvals;i++)
 466       fprintf(of,"%ld, ",partword[0][i]);
 467     fprintf(of,"\n");
 468     fclose(of);
 469   }
 470 #endif
 471   look->frames++;
 472
 473   return(partword);
 474 }
 475
 476 static int _01forward(vorbis_block *vb,vorbis_look_residue *vl,
 477                       float **in,int ch,
 478                       int pass,long **partword,
 479                       int (*encode)(oggpack_buffer *,float *,int,
 480                                     codebook *,vorbis_look_residue0 *)){
 481   long i,j,k,s;
 482   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
 483   vorbis_info_residue0 *info=look->info;
 484
 485   /* move all this setup out later */
 486   int samples_per_partition=info->grouping;
 487   int possible_partitions=info->partitions;
 488   int partitions_per_word=look->phrasebook->dim;
 489   int n=info->end-info->begin;
 490
 491   int partvals=n/samples_per_partition;
 492   long resbits[128];
 493   long resvals[128];
 494
 495 #ifdef TRAIN_RES
 496   FILE *of;
 497   char buffer[80];
 498   int m;
 499
 500   for(i=0;i<ch;i++){
 501     sprintf(buffer,"residue_%d#%d.vqd",vb->mode,pass);
 502     of=fopen(buffer,"a");
 503     for(m=0;m<info->end;m++)
 504       fprintf(of,"%.2f, ",in[i][m]);
 505     fprintf(of,"\n");
 506     fclose(of);
 507   }
 508 #endif
 509
 510   memset(resbits,0,sizeof(resbits));
 511   memset(resvals,0,sizeof(resvals));
 512
 513   /* we code the partition words for each channel, then the residual
 514      words for a partition per channel until we've written all the
 515      residual words for that partition word.  Then write the next
 516      partition channel words... */
 517
 518   for(s=(pass==0?0:info->passlimit[pass-1]);s<info->passlimit[pass];s++){
 519     for(i=0;i<partvals;){
 520
 521       /* first we encode a partition codeword for each channel */
 522       if(s==0){
 523         for(j=0;j<ch;j++){
 524           long val=partword[j][i];
 525           long ret;
 526           for(k=1;k<partitions_per_word;k++){
 527             val*=possible_partitions;
 528             if(i+k<partvals)
 529               val+=partword[j][i+k];
 530           }
 531
 532           /* training hack */
 533           if(val<look->phrasebook->entries)
 534             ret=vorbis_book_encode(look->phrasebook,val,&vb->opb);
 535           else
 536             fprintf(stderr,"!");
 537
 538           look->phrasebits+=ret;
 539
 540         }
 541       }
 542
 543       /* now we encode interleaved residual values for the partitions */
 544       for(k=0;k<partitions_per_word && i<partvals;k++,i++){
 545         long offset=i*samples_per_partition+info->begin;
 546
 547         for(j=0;j<ch;j++){
 548           if(s==0)resvals[partword[j][i]]+=samples_per_partition;
 549           if(info->secondstages[partword[j][i]]&(1<<s)){
 550             codebook *statebook=look->partbooks[partword[j][i]][s];
 551             if(statebook){
 552               int ret=encode(&vb->opb,in[j]+offset,samples_per_partition,
 553                              statebook,look);
 554               look->postbits+=ret;
 555               resbits[partword[j][i]]+=ret;
 556             }
 557           }
 558         }
 559       }
 560     }
 561   }
 562
 563   /*{
 564     long total=0;
 565     long totalbits=0;
 566     fprintf(stderr,"%d :: ",vb->mode);
 567     for(k=0;k<possible_partitions;k++){
 568       fprintf(stderr,"%ld/%1.2g, ",resvals[k],(float)resbits[k]/resvals[k]);
 569       total+=resvals[k];
 570       totalbits+=resbits[k];
 571       }
 572
 573     fprintf(stderr,":: %ld:%1.2g\n",total,(double)totalbits/total);
 574     }*/
 575   return(0);
 576 }
 577
 578 /* a truncated packet here just means 'stop working'; it's not an error */
 579 static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl,
 580                       float **in,int ch,
 581                       long (*decodepart)(codebook *, float *,
 582                                          oggpack_buffer *,int)){
 583
 584   long i,j,k,l,s;
 585   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
 586   vorbis_info_residue0 *info=look->info;
 587
 588   /* move all this setup out later */
 589   int samples_per_partition=info->grouping;
 590   int partitions_per_word=look->phrasebook->dim;
 591   int n=info->end-info->begin;
 592
 593   int partvals=n/samples_per_partition;
 594   int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
 595   int ***partword=alloca(ch*sizeof(*partword));
 596
 597   for(j=0;j<ch;j++)
 598     partword[j]=_vorbis_block_alloc(vb,partwords*sizeof(*partword[j]));
 599
 600   for(s=0;s<look->stages;s++){
 601
 602     /* each loop decodes on partition codeword containing
 603        partitions_pre_word partitions */
 604     for(i=0,l=0;i<partvals;l++){
 605       if(s==0){
 606         /* fetch the partition word for each channel */
 607         for(j=0;j<ch;j++){
 608           int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
 609           if(temp==-1)goto eopbreak;
 610           partword[j][l]=look->decodemap[temp];
 611           if(partword[j][l]==NULL)goto errout;
 612         }
 613       }
 614
 615       /* now we decode residual values for the partitions */
 616       for(k=0;k<partitions_per_word && i<partvals;k++,i++)
 617         for(j=0;j<ch;j++){
 618           long offset=info->begin+i*samples_per_partition;
 619           if(info->secondstages[partword[j][l][k]]&(1<<s)){
 620             codebook *stagebook=look->partbooks[partword[j][l][k]][s];
 621             if(stagebook){
 622               if(decodepart(stagebook,in[j]+offset,&vb->opb,
 623                             samples_per_partition)==-1)goto eopbreak;
 624             }
 625           }
 626         }
 627     }
 628   }
 629
 630  errout:
 631  eopbreak:
 632   return(0);
 633 }
 634
 635 /* residue 0 and 1 are just slight variants of one another. 0 is
 636    interleaved, 1 is not */
 637 long **res0_class(vorbis_block *vb,vorbis_look_residue *vl,
 638                   float **in,int *nonzero,int ch){
 639   /* we encode only the nonzero parts of a bundle */
 640   int i,used=0;
 641   for(i=0;i<ch;i++)
 642     if(nonzero[i])
 643       in[used++]=in[i];
 644   if(used)
 645     /*return(_01class(vb,vl,in,used,_interleaved_testhack));*/
 646     return(_01class(vb,vl,in,used,_testhack));
 647   else
 648     return(0);
 649 }
 650
 651 int res0_forward(vorbis_block *vb,vorbis_look_residue *vl,
 652                  float **in,float **out,int *nonzero,int ch,
 653                  int pass, long **partword){
 654   /* we encode only the nonzero parts of a bundle */
 655   int i,j,used=0,n=vb->pcmend/2;
 656   for(i=0;i<ch;i++)
 657     if(nonzero[i]){
 658       for(j=0;j<n;j++)
 659         out[i][j]+=in[i][j];
 660       in[used++]=in[i];
 661     }
 662   if(used){
 663     int ret=_01forward(vb,vl,in,used,pass,partword,
 664                       _interleaved_encodepart);
 665     used=0;
 666     for(i=0;i<ch;i++)
 667       if(nonzero[i]){
 668         for(j=0;j<n;j++)
 669           out[i][j]-=in[used][j];
 670         used++;
 671       }
 672     return(ret);
 673   }else
 674     return(0);
 675 }
 676
 677 int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl,
 678                  float **in,int *nonzero,int ch){
 679   int i,used=0;
 680   for(i=0;i<ch;i++)
 681     if(nonzero[i])
 682       in[used++]=in[i];
 683   if(used)
 684     return(_01inverse(vb,vl,in,used,vorbis_book_decodevs_add));
 685   else
 686     return(0);
 687 }
 688
 689 int res1_forward(vorbis_block *vb,vorbis_look_residue *vl,
 690                  float **in,float **out,int *nonzero,int ch,
 691                  int pass, long **partword){
 692   int i,j,used=0,n=vb->pcmend/2;
 693   for(i=0;i<ch;i++)
 694     if(nonzero[i]){
 695       for(j=0;j<n;j++)
 696         out[i][j]+=in[i][j];
 697       in[used++]=in[i];
 698     }
 699
 700   if(used){
 701     int ret=_01forward(vb,vl,in,used,pass,partword,_encodepart);
 702     used=0;
 703     for(i=0;i<ch;i++)
 704       if(nonzero[i]){
 705         for(j=0;j<n;j++)
 706           out[i][j]-=in[used][j];
 707         used++;
 708       }
 709     return(ret);
 710   }else
 711     return(0);
 712 }
 713
 714 long **res1_class(vorbis_block *vb,vorbis_look_residue *vl,
 715                   float **in,int *nonzero,int ch){
 716   int i,used=0;
 717   for(i=0;i<ch;i++)
 718     if(nonzero[i])
 719       in[used++]=in[i];
 720   if(used)
 721     return(_01class(vb,vl,in,used,_testhack));
 722   else
 723     return(0);
 724 }
 725
 726 int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl,
 727                  float **in,int *nonzero,int ch){
 728   int i,used=0;
 729   for(i=0;i<ch;i++)
 730     if(nonzero[i])
 731       in[used++]=in[i];
 732   if(used)
 733     return(_01inverse(vb,vl,in,used,vorbis_book_decodev_add));
 734   else
 735     return(0);
 736 }
 737
 738 long **res2_class(vorbis_block *vb,vorbis_look_residue *vl,
 739                   float **in,int *nonzero,int ch){
 740   int i,used=0;
 741   for(i=0;i<ch;i++)
 742     if(nonzero[i])
 743       in[used++]=in[i];
 744   if(used)
 745     return(_2class(vb,vl,in,used,_testhack));
 746   else
 747     return(0);
 748 }
 749
 750 /* res2 is slightly more different; all the channels are interleaved
 751    into a single vector and encoded. */
 752
 753 int res2_forward(vorbis_block *vb,vorbis_look_residue *vl,
 754                  float **in,float **out,int *nonzero,int ch,
 755                  int pass,long **partword){
 756   long i,j,k,n=vb->pcmend/2,used=0;
 757
 758   /* don't duplicate the code; use a working vector hack for now and
 759      reshape ourselves into a single channel res1 */
 760   /* ugly; reallocs for each coupling pass :-( */
 761   float *work=_vorbis_block_alloc(vb,ch*n*sizeof(*work));
 762   for(i=0;i<ch;i++){
 763     float *pcm=in[i];
 764     if(nonzero[i])used++;
 765     for(j=0,k=i;j<n;j++,k+=ch)
 766       work[k]=pcm[j];
 767   }
 768
 769   if(used){
 770     int ret=_01forward(vb,vl,&work,1,pass,partword,_encodepart);
 771     /* update the sofar vector */
 772     for(i=0;i<ch;i++){
 773       float *pcm=in[i];
 774       float *sofar=out[i];
 775       for(j=0,k=i;j<n;j++,k+=ch)
 776         sofar[j]+=pcm[j]-work[k];
 777     }
 778
 779     return(ret);
 780   }else
 781     return(0);
 782 }
 783
 784 /* duplicate code here as speed is somewhat more important */
 785 int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,
 786                  float **in,int *nonzero,int ch){
 787   long i,k,l,s;
 788   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
 789   vorbis_info_residue0 *info=look->info;
 790
 791   /* move all this setup out later */
 792   int samples_per_partition=info->grouping;
 793   int partitions_per_word=look->phrasebook->dim;
 794   int n=info->end-info->begin;
 795
 796   int partvals=n/samples_per_partition;
 797   int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
 798   int **partword=_vorbis_block_alloc(vb,partwords*sizeof(*partword));
 799
 800   for(i=0;i<ch;i++)if(nonzero[i])break;
 801   if(i==ch)return(0); /* no nonzero vectors */
 802
 803   for(s=0;s<look->stages;s++){
 804     for(i=0,l=0;i<partvals;l++){
 805
 806       if(s==0){
 807         /* fetch the partition word */
 808         int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
 809         if(temp==-1)goto eopbreak;
 810         partword[l]=look->decodemap[temp];
 811         if(partword[l]==NULL)goto errout;
 812       }
 813
 814       /* now we decode residual values for the partitions */
 815       for(k=0;k<partitions_per_word && i<partvals;k++,i++)
 816         if(info->secondstages[partword[l][k]]&(1<<s)){
 817           codebook *stagebook=look->partbooks[partword[l][k]][s];
 818
 819           if(stagebook){
 820             if(vorbis_book_decodevv_add(stagebook,in,
 821                                         i*samples_per_partition+info->begin,ch,
 822                                         &vb->opb,samples_per_partition)==-1)
 823               goto eopbreak;
 824           }
 825         }
 826     }
 827   }
 828
 829  errout:
 830  eopbreak:
 831   return(0);
 832 }
 833
 834
 835 vorbis_func_residue residue0_exportbundle={
 836   &res0_pack,
 837   &res0_unpack,
 838   &res0_look,
 839   &res0_copy_info,
 840   &res0_free_info,
 841   &res0_free_look,
 842   &res0_class,
 843   &res0_forward,
 844   &res0_inverse
 845 };
 846
 847 vorbis_func_residue residue1_exportbundle={
 848   &res0_pack,
 849   &res0_unpack,
 850   &res0_look,
 851   &res0_copy_info,
 852   &res0_free_info,
 853   &res0_free_look,
 854   &res1_class,
 855   &res1_forward,
 856   &res1_inverse
 857 };
 858
 859 vorbis_func_residue residue2_exportbundle={
 860   &res0_pack,
 861   &res0_unpack,
 862   &res0_look,
 863   &res0_copy_info,
 864   &res0_free_info,
 865   &res0_free_look,
 866   &res2_class,
 867   &res2_forward,
 868   &res2_inverse
 869 };