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