zeroed channel logic fix to residue backend 2

Monty

svn path=/trunk/vorbis/; revision=1481

diff --git a/lib/backends.h b/lib/backends.h
index 7994710..e4199d5 100644 (file)
--- a/lib/backends.h
+++ b/lib/backends.h
@@ -12,7 +12,7 @@
 
  function: libvorbis backend and mapping structures; needed for 
            static mode headers
- last mod: $Id: backends.h,v 1.8 2001/06/15 21:15:39 xiphmont Exp $
+ last mod: $Id: backends.h,v 1.9 2001/06/15 23:31:00 xiphmont Exp $
 
  ********************************************************************/
 
@@ -126,9 +126,9 @@ typedef struct{
   void (*free_info)    (vorbis_info_residue *);
   void (*free_look)    (vorbis_look_residue *);
   int  (*forward)      (struct vorbis_block *,vorbis_look_residue *,
-                       float **,int);
+                       float **,int *,int);
   int  (*inverse)      (struct vorbis_block *,vorbis_look_residue *,
-                       float **,int);
+                       float **,int *,int);
 } vorbis_func_residue;
 
 typedef struct vorbis_info_residue0{

diff --git a/lib/floor0.c b/lib/floor0.c
index 41c8e37..4f01392 100644 (file)
--- a/lib/floor0.c
+++ b/lib/floor0.c
@@ -11,7 +11,7 @@
  ********************************************************************
 
  function: floor backend 0 implementation
- last mod: $Id: floor0.c,v 1.42 2001/06/15 21:15:39 xiphmont Exp $
+ last mod: $Id: floor0.c,v 1.43 2001/06/15 23:31:00 xiphmont Exp $
 
  ********************************************************************/
 
@@ -399,6 +399,7 @@ static int floor0_forward(vorbis_block *vb,vorbis_look_floor *in,
 #endif
 
   memset(codedflr,0,sizeof(float)*look->n);
+  memset(residue,0,sizeof(float)*look->n);
   return(val);
 }
 

diff --git a/lib/floor1.c b/lib/floor1.c
index 241cb82..fc19b74 100644 (file)
--- a/lib/floor1.c
+++ b/lib/floor1.c
@@ -11,7 +11,7 @@
  ********************************************************************
 
  function: floor backend 1 implementation
- last mod: $Id: floor1.c,v 1.8 2001/06/15 22:07:06 xiphmont Exp $
+ last mod: $Id: floor1.c,v 1.9 2001/06/15 23:31:00 xiphmont Exp $
 
  ********************************************************************/
 
@@ -1016,6 +1016,7 @@ static int floor1_forward(vorbis_block *vb,vorbis_look_floor *in,
   }else{
     oggpack_write(&vb->opb,0,1);
     memset(codedflr,0,n*sizeof(float));
+    memset(residue,0,n*sizeof(float));
   }
   seq++;
   return(nonzero);

diff --git a/lib/mapping0.c b/lib/mapping0.c
index 1b70885..5f91468 100644 (file)
--- a/lib/mapping0.c
+++ b/lib/mapping0.c
@@ -11,7 +11,7 @@
  ********************************************************************
 
  function: channel mapping 0 implementation
- last mod: $Id: mapping0.c,v 1.30 2001/06/15 21:15:39 xiphmont Exp $
+ last mod: $Id: mapping0.c,v 1.31 2001/06/15 23:31:00 xiphmont Exp $
 
  ********************************************************************/
 
@@ -270,6 +270,7 @@ static int mapping0_forward(vorbis_block *vb,vorbis_look_mapping *l){
   float *window=b->window[vb->W][vb->lW][vb->nW][mode->windowtype];
 
   float **pcmbundle=alloca(sizeof(float *)*vi->channels);
+  int    *zerobundle=alloca(sizeof(int)*vi->channels);
 
   int    *nonzero=alloca(sizeof(int)*vi->channels);
 
@@ -369,31 +370,36 @@ static int mapping0_forward(vorbis_block *vb,vorbis_look_mapping *l){
     for(j=n/2-1;j>=0;j--){
       float A=rint(pcmM[j]);
       float B=rint(pcmA[j]);
+      float mag;
+      float ang;
       
       if(fabs(A)>fabs(B)){
-       pcmM[j]=A;
+       mag=A;
        if(A>0)
-         pcmA[j]=A-B;
+         ang=A-B;
        else
-         pcmA[j]=B-A;
+         ang=B-A;
       }else{
-       pcmM[j]=B;
+       mag=B;
        if(B>0)
-         pcmA[j]=A-B;
+         ang=A-B;
        else
-         pcmA[j]=B-A;
+         ang=B-A;
       }
 
       /*if(fabs(mag)<3.5f)
        ang=rint(ang/(mag*2.f))*mag*2.f;*/
       
-      /*if(fabs(mag)<1.5)
-       ang=0;*/
+      if(fabs(mag)<1.5)
+       ang=0;
+      
+      if(j>(n*3/16))
+       ang=0;
+      
+      if(ang>=fabs(mag*2))ang=-fabs(mag*2);
 
-      /*if(i>(n*3/16))
-       ang=0;*/
-            
-      /*if(ang>=fabs(mag*2))ang=-fabs(mag*2);*/
+      pcmM[j]=mag;
+      pcmA[j]=ang;
     }
   }
 
@@ -404,13 +410,17 @@ static int mapping0_forward(vorbis_block *vb,vorbis_look_mapping *l){
   for(i=0;i<info->submaps;i++){
     int ch_in_bundle=0;
     for(j=0;j<vi->channels;j++){
-      if(info->chmuxlist[j]==i && nonzero[j])
+      if(info->chmuxlist[j]==i){
+       if(nonzero[j])
+         zerobundle[ch_in_bundle]=1;
+       else
+         zerobundle[ch_in_bundle]=0;
        pcmbundle[ch_in_bundle++]=vb->pcm[j];
-   
+      }
     }
     
     look->residue_func[i]->forward(vb,look->residue_look[i],
-                                  pcmbundle,ch_in_bundle);
+                                  pcmbundle,zerobundle,ch_in_bundle);
   }
   
   look->lastframe=vb->sequence;
@@ -430,6 +440,7 @@ static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){
 
   float *window=b->window[vb->W][vb->lW][vb->nW][mode->windowtype];
   float **pcmbundle=alloca(sizeof(float *)*vi->channels);
+  int    *zerobundle=alloca(sizeof(int)*vi->channels);
   void **nonzero=alloca(sizeof(void *)*vi->channels);
   
   /* time domain information decode (note that applying the
@@ -450,11 +461,17 @@ static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){
   for(i=0;i<info->submaps;i++){
     int ch_in_bundle=0;
     for(j=0;j<vi->channels;j++){
-      if(info->chmuxlist[j]==i && nonzero[j])
+      if(info->chmuxlist[j]==i){
+       if(nonzero[j])
+         zerobundle[ch_in_bundle]=1;
+       else
+         zerobundle[ch_in_bundle]=0;
        pcmbundle[ch_in_bundle++]=vb->pcm[j];
+      }
     }
-
-    look->residue_func[i]->inverse(vb,look->residue_look[i],pcmbundle,ch_in_bundle);
+    
+    look->residue_func[i]->inverse(vb,look->residue_look[i],
+                                  pcmbundle,zerobundle,ch_in_bundle);
   }
 
   /* channel coupling */

diff --git a/lib/res0.c b/lib/res0.c
index 0bab071..20df837 100644 (file)
--- a/lib/res0.c
+++ b/lib/res0.c
@@ -11,7 +11,7 @@
  ********************************************************************
 
  function: residue backend 0, 1 and 2 implementation
- last mod: $Id: res0.c,v 1.31 2001/06/15 21:15:40 xiphmont Exp $
+ last mod: $Id: res0.c,v 1.32 2001/06/15 23:31:00 xiphmont Exp $
 
  ********************************************************************/
 
@@ -532,43 +532,79 @@ static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl,
 /* residue 0 and 1 are just slight variants of one another. 0 is
    interleaved, 1 is not */
 int res0_forward(vorbis_block *vb,vorbis_look_residue *vl,
-           float **in,int ch){
-  return(_01forward(vb,vl,in,ch,_interleaved_testhack,_interleaved_encodepart));
+           float **in,int *nonzero,int ch){
+  /* we encode only the nonzero parts of a bundle */
+  int i,used=0;
+  for(i=0;i<ch;i++)
+    if(nonzero[i])
+      in[used++]=in[i];
+  if(used)
+    return(_01forward(vb,vl,in,used,_interleaved_testhack,_interleaved_encodepart));
+  else
+    return(0);
 }
 
-int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl,float **in,int ch){
-  return(_01inverse(vb,vl,in,ch,vorbis_book_decodevs_add));
+int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+                float **in,int *nonzero,int ch){
+  int i,used=0;
+  for(i=0;i<ch;i++)
+    if(nonzero[i])
+      in[used++]=in[i];
+  if(used)
+    return(_01inverse(vb,vl,in,used,vorbis_book_decodevs_add));
+  else
+    return(0);
 }
 
 int res1_forward(vorbis_block *vb,vorbis_look_residue *vl,
-                float **in,int ch){
-  return(_01forward(vb,vl,in,ch,_testhack,_encodepart));
+                float **in,int *nonzero,int ch){
+  int i,used=0;
+  for(i=0;i<ch;i++)
+    if(nonzero[i])
+      in[used++]=in[i];
+  if(used)
+    return(_01forward(vb,vl,in,used,_testhack,_encodepart));
+  else
+    return(0);
 }
 
-int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl,float **in,int ch){
-  return(_01inverse(vb,vl,in,ch,vorbis_book_decodev_add));
+int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+                float **in,int *nonzero,int ch){
+  int i,used=0;
+  for(i=0;i<ch;i++)
+    if(nonzero[i])
+      in[used++]=in[i];
+  if(used)
+    return(_01inverse(vb,vl,in,used,vorbis_book_decodev_add));
+  else
+    return(0);
 }
 
 /* res2 is slightly more different; all the channels are interleaved
    into a single vector and encoded. */
 int res2_forward(vorbis_block *vb,vorbis_look_residue *vl,
-           float **in,int ch){
-  long i,j,k,n=vb->pcmend/2;
+           float **in,int *nonzero,int ch){
+  long i,j,k,n=vb->pcmend/2,used=0;
 
   /* don't duplicate the code; use a working vector hack for now and
      reshape ourselves into a single channel res1 */
   float *work=_vorbis_block_alloc(vb,ch*n*sizeof(float));
   for(i=0;i<ch;i++){
     float *pcm=vb->pcm[i];
+    if(nonzero[i])used++;
     for(j=0,k=i;j<n;j++,k+=ch)
       work[k]=pcm[j];
   }
-
-  return(_01forward(vb,vl,&work,1,_testhack,_encodepart));
+  
+  if(used)
+    return(_01forward(vb,vl,&work,1,_testhack,_encodepart));
+  else
+    return(0);
 }
 
 /* duplicate code here as speed is somewhat more important */
-int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,float **in,int ch){
+int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+                float **in,int *nonzero,int ch){
   long i,k,l,s;
   vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
   vorbis_info_residue0 *info=look->info;
@@ -581,8 +617,12 @@ int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,float **in,int ch){
   int partvals=n/samples_per_partition;
   int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
   int **partword=_vorbis_block_alloc(vb,partwords*sizeof(int *));
+  int used;
   partvals=partwords*partitions_per_word;
 
+  for(i=0;i<ch;i++)if(nonzero[i])break;
+  if(i==ch)return(0); /* no nonzero vectors */
+
   for(s=0;s<look->stages;s++){
     for(i=info->begin,l=0;i<info->end;l++){