Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/libvorbis-1.2.0/lib/res0.c @ 29

Last change on this file since 29 was 16, checked in by landauf, 17 years ago

added libvorbis

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