X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=lib%2Fvorbisenc.c;h=193a396cd831a612fb9e36cd57ce5471437e7893;hb=0b8da3a6a8ce15a31e6f2540cd4b68b4e79c1360;hp=a9736d96985f6c9946b39d8672820a21048edd44;hpb=7687fb57293948d4f274a726c55e277154fc126f;p=platform%2Fupstream%2Flibvorbis.git

diff --git a/lib/vorbisenc.c b/lib/vorbisenc.c
index a9736d9..193a396 100644
--- a/lib/vorbisenc.c
+++ b/lib/vorbisenc.c
@@ -5,8 +5,8 @@
  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
- * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
- * by the XIPHOPHORUS Company http://www.xiph.org/                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2015             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
@@ -32,22 +32,23 @@
    with > 12 partition types, or a different division of iteration,
    this needs to be updated. */
 typedef struct {
-  static_codebook *books[12][3];
+  const static_codebook *books[12][4];
 } static_bookblock;
 
 typedef struct {
   int res_type;
   int limit_type; /* 0 lowpass limited, 1 point stereo limited */
-  vorbis_info_residue0 *res;
-  static_codebook  *book_aux;
-  static_codebook  *book_aux_managed;
-  static_bookblock *books_base;
-  static_bookblock *books_base_managed;
+  int grouping;
+  const vorbis_info_residue0 *res;
+  const static_codebook  *book_aux;
+  const static_codebook  *book_aux_managed;
+  const static_bookblock *books_base;
+  const static_bookblock *books_base_managed;
 } vorbis_residue_template;
 
 typedef struct {
-  vorbis_info_mapping0    *map;
-  vorbis_residue_template *res;
+  const vorbis_info_mapping0    *map;
+  const vorbis_residue_template *res;
 } vorbis_mapping_template;
 
 typedef struct vp_adjblock{
@@ -70,7 +71,7 @@ typedef struct {
   float boost;
   float decay;
 } att3;
-typedef struct { int data[P_NOISECURVES]; } adj3; 
+typedef struct { int data[P_NOISECURVES]; } adj3;
 
 typedef struct {
   int   pre[PACKETBLOBS];
@@ -90,69 +91,70 @@ typedef struct {
 
 typedef struct {
   int      mappings;
-  double  *rate_mapping;
-  double  *quality_mapping;
+  const double  *rate_mapping;
+  const double  *quality_mapping;
   int      coupling_restriction;
   long     samplerate_min_restriction;
   long     samplerate_max_restriction;
 
 
-  int     *blocksize_short;
-  int     *blocksize_long;
+  const int     *blocksize_short;
+  const int     *blocksize_long;
 
-  att3    *psy_tone_masteratt;
-  int     *psy_tone_0dB;
-  int     *psy_tone_dBsuppress;
+  const att3    *psy_tone_masteratt;
+  const int     *psy_tone_0dB;
+  const int     *psy_tone_dBsuppress;
 
-  vp_adjblock *psy_tone_adj_impulse;
-  vp_adjblock *psy_tone_adj_long;
-  vp_adjblock *psy_tone_adj_other;
+  const vp_adjblock *psy_tone_adj_impulse;
+  const vp_adjblock *psy_tone_adj_long;
+  const vp_adjblock *psy_tone_adj_other;
 
-  noiseguard  *psy_noiseguards;
-  noise3      *psy_noise_bias_impulse;
-  noise3      *psy_noise_bias_padding;
-  noise3      *psy_noise_bias_trans;
-  noise3      *psy_noise_bias_long;
-  int         *psy_noise_dBsuppress;
+  const noiseguard  *psy_noiseguards;
+  const noise3      *psy_noise_bias_impulse;
+  const noise3      *psy_noise_bias_padding;
+  const noise3      *psy_noise_bias_trans;
+  const noise3      *psy_noise_bias_long;
+  const int         *psy_noise_dBsuppress;
 
-  compandblock  *psy_noise_compand;
-  double        *psy_noise_compand_short_mapping;
-  double        *psy_noise_compand_long_mapping;
+  const compandblock  *psy_noise_compand;
+  const double        *psy_noise_compand_short_mapping;
+  const double        *psy_noise_compand_long_mapping;
 
-  int      *psy_noise_normal_start[2];
-  int      *psy_noise_normal_partition[2];
-  double   *psy_noise_normal_thresh;
+  const int      *psy_noise_normal_start[2];
+  const int      *psy_noise_normal_partition[2];
+  const double   *psy_noise_normal_thresh;
 
-  int      *psy_ath_float;
-  int      *psy_ath_abs;
+  const int      *psy_ath_float;
+  const int      *psy_ath_abs;
 
-  double   *psy_lowpass;
+  const double   *psy_lowpass;
 
-  vorbis_info_psy_global *global_params;
-  double     *global_mapping;
-  adj_stereo *stereo_modes;
+  const vorbis_info_psy_global *global_params;
+  const double     *global_mapping;
+  const adj_stereo *stereo_modes;
 
-  static_codebook ***floor_books;
-  vorbis_info_floor1 *floor_params;
-  int *floor_short_mapping;
-  int *floor_long_mapping;
+  const static_codebook *const *const *const floor_books;
+  const vorbis_info_floor1 *floor_params;
+  const int floor_mappings;
+  const int **floor_mapping_list;
 
-  vorbis_mapping_template *maps;
+  const vorbis_mapping_template *maps;
 } ve_setup_data_template;
 
 /* a few static coder conventions */
-static vorbis_info_mode _mode_template[2]={
+static const vorbis_info_mode _mode_template[2]={
   {0,0,0,0},
   {1,0,0,1}
 };
 
-static vorbis_info_mapping0 _map_nominal[2]={
+static const vorbis_info_mapping0 _map_nominal[2]={
   {1, {0,0}, {0}, {0}, 1,{0},{1}},
   {1, {0,0}, {1}, {1}, 1,{0},{1}}
 };
 
 #include "modes/setup_44.h"
 #include "modes/setup_44u.h"
+#include "modes/setup_44p51.h"
 #include "modes/setup_32.h"
 #include "modes/setup_8.h"
 #include "modes/setup_11.h"
@@ -160,8 +162,9 @@ static vorbis_info_mapping0 _map_nominal[2]={
 #include "modes/setup_22.h"
 #include "modes/setup_X.h"
 
-static ve_setup_data_template *setup_list[]={
+static const ve_setup_data_template *const setup_list[]={
   &ve_setup_44_stereo,
+  &ve_setup_44_51,
   &ve_setup_44_uncoupled,
 
   &ve_setup_32_stereo,
@@ -184,29 +187,15 @@ static ve_setup_data_template *setup_list[]={
   0
 };
 
-static int vorbis_encode_toplevel_setup(vorbis_info *vi,int ch,long rate){
-  if(vi && vi->codec_setup){
-
-    vi->version=0;
-    vi->channels=ch;
-    vi->rate=rate;
-
-    return(0);
-  }
-  return(OV_EINVAL);
-}
-
-static void vorbis_encode_floor_setup(vorbis_info *vi,double s,int block,
-				     static_codebook    ***books, 
-				     vorbis_info_floor1 *in, 
-				     int *x){
+static void vorbis_encode_floor_setup(vorbis_info *vi,int s,
+                                     const static_codebook *const *const *const books,
+                                     const vorbis_info_floor1 *in,
+                                     const int *x){
   int i,k,is=s;
   vorbis_info_floor1 *f=_ogg_calloc(1,sizeof(*f));
   codec_setup_info *ci=vi->codec_setup;
 
   memcpy(f,in+x[is],sizeof(*f));
-  /* fill in the lowpass field, even if it's temporary */
-  f->n=ci->blocksizes[block]>>1;
 
   /* books */
   {
@@ -219,13 +208,13 @@ static void vorbis_encode_floor_setup(vorbis_info *vi,double s,int block,
       if(f->class_book[i]>maxbook)maxbook=f->class_book[i];
       f->class_book[i]+=ci->books;
       for(k=0;k<(1<<f->class_subs[i]);k++){
-	if(f->class_subbook[i][k]>maxbook)maxbook=f->class_subbook[i][k];
-	if(f->class_subbook[i][k]>=0)f->class_subbook[i][k]+=ci->books;
+        if(f->class_subbook[i][k]>maxbook)maxbook=f->class_subbook[i][k];
+        if(f->class_subbook[i][k]>=0)f->class_subbook[i][k]+=ci->books;
       }
     }
 
     for(i=0;i<=maxbook;i++)
-      ci->book_param[ci->books++]=books[x[is]][i];
+      ci->book_param[ci->books++]=(static_codebook *)books[x[is]][i];
   }
 
   /* for now, we're only using floor 1 */
@@ -237,15 +226,15 @@ static void vorbis_encode_floor_setup(vorbis_info *vi,double s,int block,
 }
 
 static void vorbis_encode_global_psych_setup(vorbis_info *vi,double s,
-					    vorbis_info_psy_global *in, 
-					    double *x){
+                                            const vorbis_info_psy_global *in,
+                                            const double *x){
   int i,is=s;
   double ds=s-is;
   codec_setup_info *ci=vi->codec_setup;
   vorbis_info_psy_global *g=&ci->psy_g_param;
-  
+
   memcpy(g,in+(int)x[is],sizeof(*g));
-  
+
   ds=x[is]*(1.-ds)+x[is+1]*ds;
   is=(int)ds;
   ds-=is;
@@ -253,7 +242,7 @@ static void vorbis_encode_global_psych_setup(vorbis_info *vi,double s,
     is--;
     ds=1.;
   }
-  
+
   /* interpolate the trigger threshholds */
   for(i=0;i<4;i++){
     g->preecho_thresh[i]=in[is].preecho_thresh[i]*(1.-ds)+in[is+1].preecho_thresh[i]*ds;
@@ -264,8 +253,8 @@ static void vorbis_encode_global_psych_setup(vorbis_info *vi,double s,
 }
 
 static void vorbis_encode_global_stereo(vorbis_info *vi,
-				       highlevel_encode_setup *hi,
-				       adj_stereo *p){
+                                        const highlevel_encode_setup *const hi,
+                                        const adj_stereo *p){
   float s=hi->stereo_point_setting;
   int i,is=s;
   double ds=s-is;
@@ -279,28 +268,28 @@ static void vorbis_encode_global_stereo(vorbis_info *vi,
     if(hi->managed){
       /* interpolate the kHz threshholds */
       for(i=0;i<PACKETBLOBS;i++){
-	float kHz=p[is].kHz[i]*(1.-ds)+p[is+1].kHz[i]*ds;
-	g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
-	g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
-	g->coupling_pkHz[i]=kHz;
-	
-	kHz=p[is].lowpasskHz[i]*(1.-ds)+p[is+1].lowpasskHz[i]*ds;
-	g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
-	g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
-	
+        float kHz=p[is].kHz[i]*(1.-ds)+p[is+1].kHz[i]*ds;
+        g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+        g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+        g->coupling_pkHz[i]=kHz;
+
+        kHz=p[is].lowpasskHz[i]*(1.-ds)+p[is+1].lowpasskHz[i]*ds;
+        g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+        g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+
       }
     }else{
       float kHz=p[is].kHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].kHz[PACKETBLOBS/2]*ds;
       for(i=0;i<PACKETBLOBS;i++){
-	g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
-	g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
-	g->coupling_pkHz[i]=kHz;
+        g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+        g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+        g->coupling_pkHz[i]=kHz;
       }
-      
+
       kHz=p[is].lowpasskHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].lowpasskHz[PACKETBLOBS/2]*ds;
       for(i=0;i<PACKETBLOBS;i++){
-	g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
-	g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+        g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+        g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
       }
     }
   }else{
@@ -313,40 +302,39 @@ static void vorbis_encode_global_stereo(vorbis_info *vi,
 }
 
 static void vorbis_encode_psyset_setup(vorbis_info *vi,double s,
-				      int *nn_start,
-				      int *nn_partition,
-				      double *nn_thresh,
-				      int block){
+                                       const int *nn_start,
+                                       const int *nn_partition,
+                                       const double *nn_thresh,
+                                       int block){
   codec_setup_info *ci=vi->codec_setup;
   vorbis_info_psy *p=ci->psy_param[block];
   highlevel_encode_setup *hi=&ci->hi;
   int is=s;
-  
+
   if(block>=ci->psys)
     ci->psys=block+1;
   if(!p){
     p=_ogg_calloc(1,sizeof(*p));
     ci->psy_param[block]=p;
   }
-  
+
   memcpy(p,&_psy_info_template,sizeof(*p));
   p->blockflag=block>>1;
 
   if(hi->noise_normalize_p){
-    p->normal_channel_p=1;
-    p->normal_point_p=1;
+    p->normal_p=1;
     p->normal_start=nn_start[is];
     p->normal_partition=nn_partition[is];
     p->normal_thresh=nn_thresh[is];
   }
-    
+
   return;
 }
 
 static void vorbis_encode_tonemask_setup(vorbis_info *vi,double s,int block,
-					 att3 *att,
-					 int  *max,
-					 vp_adjblock *in){
+                                         const att3 *att,
+                                         const int  *max,
+                                         const vp_adjblock *in){
   int i,is=s;
   double ds=s-is;
   codec_setup_info *ci=vi->codec_setup;
@@ -369,7 +357,8 @@ static void vorbis_encode_tonemask_setup(vorbis_info *vi,double s,int block,
 
 
 static void vorbis_encode_compand_setup(vorbis_info *vi,double s,int block,
-				       compandblock *in, double *x){
+                                        const compandblock *in,
+                                        const double *x){
   int i,is=s;
   double ds=s-is;
   codec_setup_info *ci=vi->codec_setup;
@@ -390,7 +379,7 @@ static void vorbis_encode_compand_setup(vorbis_info *vi,double s,int block,
 }
 
 static void vorbis_encode_peak_setup(vorbis_info *vi,double s,int block,
-				    int *suppress){
+                                    const int *suppress){
   int is=s;
   double ds=s-is;
   codec_setup_info *ci=vi->codec_setup;
@@ -402,10 +391,10 @@ static void vorbis_encode_peak_setup(vorbis_info *vi,double s,int block,
 }
 
 static void vorbis_encode_noisebias_setup(vorbis_info *vi,double s,int block,
-					 int *suppress,
-					 noise3 *in,
-					 noiseguard *guard,
-					 double userbias){
+                                         const int *suppress,
+                                         const noise3 *in,
+                                         const noiseguard *guard,
+                                         double userbias){
   int i,is=s,j;
   double ds=s-is;
   codec_setup_info *ci=vi->codec_setup;
@@ -443,20 +432,20 @@ static void vorbis_encode_ath_setup(vorbis_info *vi,int block){
 }
 
 
-static int book_dup_or_new(codec_setup_info *ci,static_codebook *book){
+static int book_dup_or_new(codec_setup_info *ci,const static_codebook *book){
   int i;
   for(i=0;i<ci->books;i++)
     if(ci->book_param[i]==book)return(i);
-  
+
   return(ci->books++);
 }
 
 static void vorbis_encode_blocksize_setup(vorbis_info *vi,double s,
-					 int *shortb,int *longb){
+                                         const int *shortb,const int *longb){
 
   codec_setup_info *ci=vi->codec_setup;
   int is=s;
-  
+
   int blockshort=shortb[is];
   int blocklong=longb[is];
   ci->blocksizes[0]=blockshort;
@@ -465,78 +454,66 @@ static void vorbis_encode_blocksize_setup(vorbis_info *vi,double s,
 }
 
 static void vorbis_encode_residue_setup(vorbis_info *vi,
-				       int number, int block,
-				       vorbis_residue_template *res){
+                                        int number, int block,
+                                        const vorbis_residue_template *res){
 
   codec_setup_info *ci=vi->codec_setup;
-  int i,n;
-  
+  int i;
+
   vorbis_info_residue0 *r=ci->residue_param[number]=
     _ogg_malloc(sizeof(*r));
-  
+
   memcpy(r,res->res,sizeof(*r));
   if(ci->residues<=number)ci->residues=number+1;
 
-  switch(ci->blocksizes[block]){
-  case 64:case 128:case 256:
-    r->grouping=16;
-    break;
-  default:
-    r->grouping=32;
-    break;
-  }
+  r->grouping=res->grouping;
   ci->residue_type[number]=res->res_type;
 
-  /* to be adjusted by lowpass/pointlimit later */
-  n=r->end=ci->blocksizes[block]>>1; 
-  if(res->res_type==2)
-    n=r->end*=vi->channels;
-  
   /* fill in all the books */
   {
     int booklist=0,k;
-    
+
     if(ci->hi.managed){
       for(i=0;i<r->partitions;i++)
-	for(k=0;k<3;k++)
-	  if(res->books_base_managed->books[i][k])
-	    r->secondstages[i]|=(1<<k);
+        for(k=0;k<4;k++)
+          if(res->books_base_managed->books[i][k])
+            r->secondstages[i]|=(1<<k);
 
       r->groupbook=book_dup_or_new(ci,res->book_aux_managed);
-      ci->book_param[r->groupbook]=res->book_aux_managed;      
-    
+      ci->book_param[r->groupbook]=(static_codebook *)res->book_aux_managed;
+
       for(i=0;i<r->partitions;i++){
-	for(k=0;k<3;k++){
-	  if(res->books_base_managed->books[i][k]){
-	    int bookid=book_dup_or_new(ci,res->books_base_managed->books[i][k]);
-	    r->booklist[booklist++]=bookid;
-	    ci->book_param[bookid]=res->books_base_managed->books[i][k];
-	  }
-	}
+        for(k=0;k<4;k++){
+          if(res->books_base_managed->books[i][k]){
+            int bookid=book_dup_or_new(ci,res->books_base_managed->books[i][k]);
+            r->booklist[booklist++]=bookid;
+            ci->book_param[bookid]=(static_codebook *)res->books_base_managed->books[i][k];
+          }
+        }
       }
 
     }else{
 
       for(i=0;i<r->partitions;i++)
-	for(k=0;k<3;k++)
-	  if(res->books_base->books[i][k])
-	    r->secondstages[i]|=(1<<k);
-  
+        for(k=0;k<4;k++)
+          if(res->books_base->books[i][k])
+            r->secondstages[i]|=(1<<k);
+
       r->groupbook=book_dup_or_new(ci,res->book_aux);
-      ci->book_param[r->groupbook]=res->book_aux;
-      
+      ci->book_param[r->groupbook]=(static_codebook *)res->book_aux;
+
       for(i=0;i<r->partitions;i++){
-	for(k=0;k<3;k++){
-	  if(res->books_base->books[i][k]){
-	    int bookid=book_dup_or_new(ci,res->books_base->books[i][k]);
-	    r->booklist[booklist++]=bookid;
-	    ci->book_param[bookid]=res->books_base->books[i][k];
-	  }
-	}
+        for(k=0;k<4;k++){
+          if(res->books_base->books[i][k]){
+            int bookid=book_dup_or_new(ci,res->books_base->books[i][k]);
+            r->booklist[booklist++]=bookid;
+            ci->book_param[bookid]=(static_codebook *)res->books_base->books[i][k];
+          }
+        }
       }
     }
   }
-  
+
   /* lowpass setup/pointlimit */
   {
     double freq=ci->hi.lowpass_kHz*1000.;
@@ -544,45 +521,79 @@ static void vorbis_encode_residue_setup(vorbis_info *vi,
     double nyq=vi->rate/2.;
     long blocksize=ci->blocksizes[block]>>1;
 
-    /* lowpass needs to be set in the floor and the residue. */    
+    /* lowpass needs to be set in the floor and the residue. */
     if(freq>nyq)freq=nyq;
     /* in the floor, the granularity can be very fine; it doesn't alter
        the encoding structure, only the samples used to fit the floor
        approximation */
-    f->n=freq/nyq*blocksize; 
+    f->n=freq/nyq*blocksize;
 
     /* this res may by limited by the maximum pointlimit of the mode,
        not the lowpass. the floor is always lowpass limited. */
-    if(res->limit_type){
+    switch(res->limit_type){
+    case 1: /* point stereo limited */
       if(ci->hi.managed)
-	freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS-1]*1000.;
+        freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS-1]*1000.;
       else
-	freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS/2]*1000.;
+        freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS/2]*1000.;
       if(freq>nyq)freq=nyq;
+      break;
+    case 2: /* LFE channel; lowpass at ~ 250Hz */
+      freq=250;
+      break;
+    default:
+      /* already set */
+      break;
     }
-    
+
     /* in the residue, we're constrained, physically, by partition
        boundaries.  We still lowpass 'wherever', but we have to round up
        here to next boundary, or the vorbis spec will round it *down* to
        previous boundary in encode/decode */
-    if(ci->residue_type[block]==2)
-      r->end=(int)((freq/nyq*blocksize*2)/r->grouping+.9)* /* round up only if we're well past */
-	r->grouping;
-    else
+    if(ci->residue_type[number]==2){
+      /* residue 2 bundles together multiple channels; used by stereo
+         and surround.  Count the channels in use */
+      /* Multiple maps/submaps can point to the same residue.  In the case
+         of residue 2, they all better have the same number of
+         channels/samples. */
+      int j,k,ch=0;
+      for(i=0;i<ci->maps&&ch==0;i++){
+        vorbis_info_mapping0 *mi=(vorbis_info_mapping0 *)ci->map_param[i];
+        for(j=0;j<mi->submaps && ch==0;j++)
+          if(mi->residuesubmap[j]==number) /* we found a submap referencing theis residue backend */
+            for(k=0;k<vi->channels;k++)
+              if(mi->chmuxlist[k]==j) /* this channel belongs to the submap */
+                ch++;
+      }
+
+      r->end=(int)((freq/nyq*blocksize*ch)/r->grouping+.9)* /* round up only if we're well past */
+        r->grouping;
+      /* the blocksize and grouping may disagree at the end */
+      if(r->end>blocksize*ch)r->end=blocksize*ch/r->grouping*r->grouping;
+
+    }else{
+
       r->end=(int)((freq/nyq*blocksize)/r->grouping+.9)* /* round up only if we're well past */
-	r->grouping;
+        r->grouping;
+      /* the blocksize and grouping may disagree at the end */
+      if(r->end>blocksize)r->end=blocksize/r->grouping*r->grouping;
+
+    }
+
+    if(r->end==0)r->end=r->grouping; /* LFE channel */
+
   }
-}      
+}
 
 /* we assume two maps in this encoder */
 static void vorbis_encode_map_n_res_setup(vorbis_info *vi,double s,
-					  vorbis_mapping_template *maps){
+                                          const vorbis_mapping_template *maps){
 
   codec_setup_info *ci=vi->codec_setup;
   int i,j,is=s,modes=2;
-  vorbis_info_mapping0 *map=maps[is].map;
-  vorbis_info_mode *mode=_mode_template;
-  vorbis_residue_template *res=maps[is].res;
+  const vorbis_info_mapping0 *map=maps[is].map;
+  const vorbis_info_mode *mode=_mode_template;
+  const vorbis_residue_template *res=maps[is].res;
 
   if(ci->blocksizes[0]==ci->blocksizes[1])modes=1;
 
@@ -590,17 +601,17 @@ static void vorbis_encode_map_n_res_setup(vorbis_info *vi,double s,
 
     ci->map_param[i]=_ogg_calloc(1,sizeof(*map));
     ci->mode_param[i]=_ogg_calloc(1,sizeof(*mode));
-  
+
     memcpy(ci->mode_param[i],mode+i,sizeof(*_mode_template));
     if(i>=ci->modes)ci->modes=i+1;
 
     ci->map_type[i]=0;
     memcpy(ci->map_param[i],map+i,sizeof(*map));
     if(i>=ci->maps)ci->maps=i+1;
-    
+
     for(j=0;j<map[i].submaps;j++)
       vorbis_encode_residue_setup(vi,map[i].residuesubmap[j],i
-				  ,res+map[i].residuesubmap[j]);
+                                  ,res+map[i].residuesubmap[j]);
   }
 }
 
@@ -611,56 +622,53 @@ static double setting_to_approx_bitrate(vorbis_info *vi){
   int is=hi->base_setting;
   double ds=hi->base_setting-is;
   int ch=vi->channels;
-  double *r=setup->rate_mapping;
+  const double *r=setup->rate_mapping;
 
   if(r==NULL)
     return(-1);
-  
-  return((r[is]*(1.-ds)+r[is+1]*ds)*ch);  
+
+  return((r[is]*(1.-ds)+r[is+1]*ds)*ch);
 }
 
-static void get_setup_template(vorbis_info *vi,
-			       long ch,long srate,
-			       double req,int q_or_bitrate){
+static const void *get_setup_template(long ch,long srate,
+                                      double req,int q_or_bitrate,
+                                      double *base_setting){
   int i=0,j;
-  codec_setup_info *ci=vi->codec_setup;
-  highlevel_encode_setup *hi=&ci->hi;
   if(q_or_bitrate)req/=ch;
 
   while(setup_list[i]){
     if(setup_list[i]->coupling_restriction==-1 ||
        setup_list[i]->coupling_restriction==ch){
       if(srate>=setup_list[i]->samplerate_min_restriction &&
-	 srate<=setup_list[i]->samplerate_max_restriction){
-	int mappings=setup_list[i]->mappings;
-	double *map=(q_or_bitrate?
-		     setup_list[i]->rate_mapping:
-		     setup_list[i]->quality_mapping);
-
-	/* the template matches.  Does the requested quality mode
-	   fall within this template's modes? */
-	if(req<map[0]){++i;continue;}
-	if(req>map[setup_list[i]->mappings]){++i;continue;}
-	for(j=0;j<mappings;j++)
-	  if(req>=map[j] && req<map[j+1])break;
-	/* an all-points match */
-	hi->setup=setup_list[i];
-	if(j==mappings)
-	  hi->base_setting=j-.001;
-	else{
-	  float low=map[j];
-	  float high=map[j+1];
-	  float del=(req-low)/(high-low);
-	  hi->base_setting=j+del;
-	}
-
-	return;
+         srate<=setup_list[i]->samplerate_max_restriction){
+        int mappings=setup_list[i]->mappings;
+        const double *map=(q_or_bitrate?
+                     setup_list[i]->rate_mapping:
+                     setup_list[i]->quality_mapping);
+
+        /* the template matches.  Does the requested quality mode
+           fall within this template's modes? */
+        if(req<map[0]){++i;continue;}
+        if(req>map[setup_list[i]->mappings]){++i;continue;}
+        for(j=0;j<mappings;j++)
+          if(req>=map[j] && req<map[j+1])break;
+        /* an all-points match */
+        if(j==mappings)
+          *base_setting=j-.001;
+        else{
+          float low=map[j];
+          float high=map[j+1];
+          float del=(req-low)/(high-low);
+          *base_setting=j+del;
+        }
+
+        return(setup_list[i]);
       }
     }
     i++;
   }
-  
-  hi->setup=NULL;
+
+  return NULL;
 }
 
 /* encoders will need to use vorbis_info_init beforehand and call
@@ -671,7 +679,7 @@ static void get_setup_template(vorbis_info *vi,
 
 /* the final setup call */
 int vorbis_encode_setup_init(vorbis_info *vi){
-  int i0=0,singleblock=0;
+  int i,i0=0,singleblock=0;
   codec_setup_info *ci=vi->codec_setup;
   ve_setup_data_template *setup=NULL;
   highlevel_encode_setup *hi=&ci->hi;
@@ -687,7 +695,7 @@ int vorbis_encode_setup_init(vorbis_info *vi){
      too badly */
   if(hi->amplitude_track_dBpersec>0.)hi->amplitude_track_dBpersec=0.;
   if(hi->amplitude_track_dBpersec<-99999.)hi->amplitude_track_dBpersec=-99999.;
-  
+
   /* get the appropriate setup template; matches the fetch in previous
      stages */
   setup=(ve_setup_data_template *)hi->setup;
@@ -699,119 +707,115 @@ int vorbis_encode_setup_init(vorbis_info *vi){
      short and long blocks are the same length, we set long_block_p
      and unset short_block_p */
   vorbis_encode_blocksize_setup(vi,hi->base_setting,
-				setup->blocksize_short,
-				setup->blocksize_long);
+                                setup->blocksize_short,
+                                setup->blocksize_long);
   if(ci->blocksizes[0]==ci->blocksizes[1])singleblock=1;
-  
+
   /* floor setup; choose proper floor params.  Allocated on the floor
-     stack in order; if we alloc only long floor, it's 0 */
-  vorbis_encode_floor_setup(vi,hi->short_setting,0,
-			    setup->floor_books,
-			    setup->floor_params,
-			    setup->floor_short_mapping);
-  if(!singleblock)
-    vorbis_encode_floor_setup(vi,hi->long_setting,1,
-			      setup->floor_books,
-			      setup->floor_params,
-			      setup->floor_long_mapping);
-  
+     stack in order; if we alloc only a single long floor, it's 0 */
+  for(i=0;i<setup->floor_mappings;i++)
+    vorbis_encode_floor_setup(vi,hi->base_setting,
+                              setup->floor_books,
+                              setup->floor_params,
+                              setup->floor_mapping_list[i]);
+
   /* setup of [mostly] short block detection and stereo*/
   vorbis_encode_global_psych_setup(vi,hi->trigger_setting,
-				   setup->global_params,
-				   setup->global_mapping);
+                                   setup->global_params,
+                                   setup->global_mapping);
   vorbis_encode_global_stereo(vi,hi,setup->stereo_modes);
 
   /* basic psych setup and noise normalization */
-  vorbis_encode_psyset_setup(vi,hi->short_setting,
-			     setup->psy_noise_normal_start[0],
-			     setup->psy_noise_normal_partition[0],  
-			     setup->psy_noise_normal_thresh,  
-			     0);
-  vorbis_encode_psyset_setup(vi,hi->short_setting,
-			     setup->psy_noise_normal_start[0],
-			     setup->psy_noise_normal_partition[0],  
-			     setup->psy_noise_normal_thresh,  
-			     1);
+  vorbis_encode_psyset_setup(vi,hi->base_setting,
+                             setup->psy_noise_normal_start[0],
+                             setup->psy_noise_normal_partition[0],
+                             setup->psy_noise_normal_thresh,
+                             0);
+  vorbis_encode_psyset_setup(vi,hi->base_setting,
+                             setup->psy_noise_normal_start[0],
+                             setup->psy_noise_normal_partition[0],
+                             setup->psy_noise_normal_thresh,
+                             1);
   if(!singleblock){
-    vorbis_encode_psyset_setup(vi,hi->long_setting,
-			       setup->psy_noise_normal_start[1],
-			       setup->psy_noise_normal_partition[1],  
-				    setup->psy_noise_normal_thresh,  
-			       2);
-    vorbis_encode_psyset_setup(vi,hi->long_setting,
-			       setup->psy_noise_normal_start[1],
-			       setup->psy_noise_normal_partition[1],  
-			       setup->psy_noise_normal_thresh,  
-			       3);
+    vorbis_encode_psyset_setup(vi,hi->base_setting,
+                               setup->psy_noise_normal_start[1],
+                               setup->psy_noise_normal_partition[1],
+                                    setup->psy_noise_normal_thresh,
+                               2);
+    vorbis_encode_psyset_setup(vi,hi->base_setting,
+                               setup->psy_noise_normal_start[1],
+                               setup->psy_noise_normal_partition[1],
+                               setup->psy_noise_normal_thresh,
+                               3);
   }
 
   /* tone masking setup */
   vorbis_encode_tonemask_setup(vi,hi->block[i0].tone_mask_setting,0,
-			       setup->psy_tone_masteratt,
-			       setup->psy_tone_0dB,
-			       setup->psy_tone_adj_impulse);
+                               setup->psy_tone_masteratt,
+                               setup->psy_tone_0dB,
+                               setup->psy_tone_adj_impulse);
   vorbis_encode_tonemask_setup(vi,hi->block[1].tone_mask_setting,1,
-			       setup->psy_tone_masteratt,
-			       setup->psy_tone_0dB,
-			       setup->psy_tone_adj_other);
+                               setup->psy_tone_masteratt,
+                               setup->psy_tone_0dB,
+                               setup->psy_tone_adj_other);
   if(!singleblock){
     vorbis_encode_tonemask_setup(vi,hi->block[2].tone_mask_setting,2,
-				 setup->psy_tone_masteratt,
-				 setup->psy_tone_0dB,
-				 setup->psy_tone_adj_other);
+                                 setup->psy_tone_masteratt,
+                                 setup->psy_tone_0dB,
+                                 setup->psy_tone_adj_other);
     vorbis_encode_tonemask_setup(vi,hi->block[3].tone_mask_setting,3,
-				 setup->psy_tone_masteratt,
-				 setup->psy_tone_0dB,
-				 setup->psy_tone_adj_long);
+                                 setup->psy_tone_masteratt,
+                                 setup->psy_tone_0dB,
+                                 setup->psy_tone_adj_long);
   }
 
   /* noise companding setup */
   vorbis_encode_compand_setup(vi,hi->block[i0].noise_compand_setting,0,
-			      setup->psy_noise_compand,
-			      setup->psy_noise_compand_short_mapping);
+                              setup->psy_noise_compand,
+                              setup->psy_noise_compand_short_mapping);
   vorbis_encode_compand_setup(vi,hi->block[1].noise_compand_setting,1,
-			      setup->psy_noise_compand,
-			      setup->psy_noise_compand_short_mapping);
+                              setup->psy_noise_compand,
+                              setup->psy_noise_compand_short_mapping);
   if(!singleblock){
     vorbis_encode_compand_setup(vi,hi->block[2].noise_compand_setting,2,
-				setup->psy_noise_compand,
-				setup->psy_noise_compand_long_mapping);
+                                setup->psy_noise_compand,
+                                setup->psy_noise_compand_long_mapping);
     vorbis_encode_compand_setup(vi,hi->block[3].noise_compand_setting,3,
-				setup->psy_noise_compand,
-				setup->psy_noise_compand_long_mapping);
+                                setup->psy_noise_compand,
+                                setup->psy_noise_compand_long_mapping);
   }
 
   /* peak guarding setup  */
   vorbis_encode_peak_setup(vi,hi->block[i0].tone_peaklimit_setting,0,
-			   setup->psy_tone_dBsuppress);
+                           setup->psy_tone_dBsuppress);
   vorbis_encode_peak_setup(vi,hi->block[1].tone_peaklimit_setting,1,
-			   setup->psy_tone_dBsuppress);
+                           setup->psy_tone_dBsuppress);
   if(!singleblock){
     vorbis_encode_peak_setup(vi,hi->block[2].tone_peaklimit_setting,2,
-			     setup->psy_tone_dBsuppress);
+                             setup->psy_tone_dBsuppress);
     vorbis_encode_peak_setup(vi,hi->block[3].tone_peaklimit_setting,3,
-			     setup->psy_tone_dBsuppress);
+                             setup->psy_tone_dBsuppress);
   }
 
   /* noise bias setup */
   vorbis_encode_noisebias_setup(vi,hi->block[i0].noise_bias_setting,0,
-				setup->psy_noise_dBsuppress,
-				setup->psy_noise_bias_impulse,
-				setup->psy_noiseguards,
-				(i0==0?hi->impulse_noisetune:0.));
+                                setup->psy_noise_dBsuppress,
+                                setup->psy_noise_bias_impulse,
+                                setup->psy_noiseguards,
+                                (i0==0?hi->impulse_noisetune:0.));
   vorbis_encode_noisebias_setup(vi,hi->block[1].noise_bias_setting,1,
-				setup->psy_noise_dBsuppress,
-				setup->psy_noise_bias_padding,
-				setup->psy_noiseguards,0.);
+                                setup->psy_noise_dBsuppress,
+                                setup->psy_noise_bias_padding,
+                                setup->psy_noiseguards,0.);
   if(!singleblock){
     vorbis_encode_noisebias_setup(vi,hi->block[2].noise_bias_setting,2,
-				  setup->psy_noise_dBsuppress,
-				  setup->psy_noise_bias_trans,
-				  setup->psy_noiseguards,0.);
+                                  setup->psy_noise_dBsuppress,
+                                  setup->psy_noise_bias_trans,
+                                  setup->psy_noiseguards,0.);
     vorbis_encode_noisebias_setup(vi,hi->block[3].noise_bias_setting,3,
-				  setup->psy_noise_dBsuppress,
-				  setup->psy_noise_bias_long,
-				  setup->psy_noiseguards,0.);
+                                  setup->psy_noise_dBsuppress,
+                                  setup->psy_noise_bias_long,
+                                  setup->psy_noiseguards,0.);
   }
 
   vorbis_encode_ath_setup(vi,0);
@@ -845,42 +849,40 @@ int vorbis_encode_setup_init(vorbis_info *vi){
     ci->bi.reservoir_bits=hi->bitrate_reservoir;
     ci->bi.reservoir_bias=
       hi->bitrate_reservoir_bias;
-    
+
     ci->bi.slew_damp=hi->bitrate_av_damp;
 
   }
 
   return(0);
-  
+
 }
 
-static int vorbis_encode_setup_setting(vorbis_info *vi,
-				       long  channels,
-				       long  rate){
-  int ret=0,i,is;
+static void vorbis_encode_setup_setting(vorbis_info *vi,
+                                       long  channels,
+                                       long  rate){
+  int i,is;
   codec_setup_info *ci=vi->codec_setup;
   highlevel_encode_setup *hi=&ci->hi;
-  ve_setup_data_template *setup=hi->setup;
+  const ve_setup_data_template *setup=hi->setup;
   double ds;
 
-  ret=vorbis_encode_toplevel_setup(vi,channels,rate);
-  if(ret)return(ret);
+  vi->version=0;
+  vi->channels=channels;
+  vi->rate=rate;
+
+  hi->impulse_block_p=1;
+  hi->noise_normalize_p=1;
 
   is=hi->base_setting;
   ds=hi->base_setting-is;
 
-  hi->short_setting=hi->base_setting;
-  hi->long_setting=hi->base_setting;
-
-  hi->managed=0;
+  hi->stereo_point_setting=hi->base_setting;
 
-  hi->impulse_block_p=1;
-  hi->noise_normalize_p=1;
+  if(!hi->lowpass_altered)
+    hi->lowpass_kHz=
+      setup->psy_lowpass[is]*(1.-ds)+setup->psy_lowpass[is+1]*ds;
 
-  hi->stereo_point_setting=hi->base_setting;
-  hi->lowpass_kHz=
-    setup->psy_lowpass[is]*(1.-ds)+setup->psy_lowpass[is+1]*ds;  
-  
   hi->ath_floating_dB=setup->psy_ath_float[is]*(1.-ds)+
     setup->psy_ath_float[is+1]*ds;
   hi->ath_absolute_dB=setup->psy_ath_abs[is]*(1.-ds)+
@@ -895,39 +897,46 @@ static int vorbis_encode_setup_setting(vorbis_info *vi,
     hi->block[i].noise_bias_setting=hi->base_setting;
     hi->block[i].noise_compand_setting=hi->base_setting;
   }
-
-  return(ret);
 }
 
 int vorbis_encode_setup_vbr(vorbis_info *vi,
-			    long  channels,
-			    long  rate,			    
-			    float quality){
-  codec_setup_info *ci=vi->codec_setup;
-  highlevel_encode_setup *hi=&ci->hi;
+                            long  channels,
+                            long  rate,
+                            float quality){
+  codec_setup_info *ci;
+  highlevel_encode_setup *hi;
+  if(rate<=0) return OV_EINVAL;
+
+  ci=vi->codec_setup;
+  hi=&ci->hi;
 
   quality+=.0000001;
   if(quality>=1.)quality=.9999;
 
-  get_setup_template(vi,channels,rate,quality,0);
+  hi->req=quality;
+  hi->setup=get_setup_template(channels,rate,quality,0,&hi->base_setting);
   if(!hi->setup)return OV_EIMPL;
-  
-  return vorbis_encode_setup_setting(vi,channels,rate);
+
+  vorbis_encode_setup_setting(vi,channels,rate);
+  hi->managed=0;
+  hi->coupling_p=1;
+
+  return 0;
 }
 
 int vorbis_encode_init_vbr(vorbis_info *vi,
-			   long channels,
-			   long rate,
-			   
-			   float base_quality /* 0. to 1. */
-			   ){
+                           long channels,
+                           long rate,
+
+                           float base_quality /* 0. to 1. */
+                           ){
   int ret=0;
 
   ret=vorbis_encode_setup_vbr(vi,channels,rate,base_quality);
-  
+
   if(ret){
     vorbis_info_clear(vi);
-    return ret; 
+    return ret;
   }
   ret=vorbis_encode_setup_init(vi);
   if(ret)
@@ -936,43 +945,45 @@ int vorbis_encode_init_vbr(vorbis_info *vi,
 }
 
 int vorbis_encode_setup_managed(vorbis_info *vi,
-				long channels,
-				long rate,
-				
-				long max_bitrate,
-				long nominal_bitrate,
-				long min_bitrate){
+                                long channels,
+                                long rate,
 
-  codec_setup_info *ci=vi->codec_setup;
-  highlevel_encode_setup *hi=&ci->hi;
-  double tnominal=nominal_bitrate;
-  int ret=0;
+                                long max_bitrate,
+                                long nominal_bitrate,
+                                long min_bitrate){
+
+  codec_setup_info *ci;
+  highlevel_encode_setup *hi;
+  double tnominal;
+  if(rate<=0) return OV_EINVAL;
+
+  ci=vi->codec_setup;
+  hi=&ci->hi;
+  tnominal=nominal_bitrate;
 
   if(nominal_bitrate<=0.){
     if(max_bitrate>0.){
       if(min_bitrate>0.)
-	nominal_bitrate=(max_bitrate+min_bitrate)*.5;
+        nominal_bitrate=(max_bitrate+min_bitrate)*.5;
       else
-	nominal_bitrate=max_bitrate*.875;
+        nominal_bitrate=max_bitrate*.875;
     }else{
       if(min_bitrate>0.){
-	nominal_bitrate=min_bitrate;
+        nominal_bitrate=min_bitrate;
       }else{
-	return(OV_EINVAL);
+        return(OV_EINVAL);
       }
     }
   }
 
-  get_setup_template(vi,channels,rate,nominal_bitrate,1);
+  hi->req=nominal_bitrate;
+  hi->setup=get_setup_template(channels,rate,nominal_bitrate,1,&hi->base_setting);
   if(!hi->setup)return OV_EIMPL;
-  
-  ret=vorbis_encode_setup_setting(vi,channels,rate);
-  if(ret){
-    vorbis_info_clear(vi);
-    return ret; 
-  }
+
+  vorbis_encode_setup_setting(vi,channels,rate);
 
   /* initialize management with sane defaults */
+  hi->coupling_p=1;
   hi->managed=1;
   hi->bitrate_min=min_bitrate;
   hi->bitrate_max=max_bitrate;
@@ -981,22 +992,22 @@ int vorbis_encode_setup_managed(vorbis_info *vi,
   hi->bitrate_reservoir=nominal_bitrate*2;
   hi->bitrate_reservoir_bias=.1; /* bias toward hoarding bits */
 
-  return(ret);
+  return(0);
 
 }
 
 int vorbis_encode_init(vorbis_info *vi,
-		       long channels,
-		       long rate,
+                       long channels,
+                       long rate,
 
-		       long max_bitrate,
-		       long nominal_bitrate,
-		       long min_bitrate){
+                       long max_bitrate,
+                       long nominal_bitrate,
+                       long min_bitrate){
 
   int ret=vorbis_encode_setup_managed(vi,channels,rate,
-				      max_bitrate,
-				      nominal_bitrate,
-				      min_bitrate);
+                                      max_bitrate,
+                                      nominal_bitrate,
+                                      min_bitrate);
   if(ret){
     vorbis_info_clear(vi);
     return(ret);
@@ -1015,169 +1026,198 @@ int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg){
     int setp=(number&0xf); /* a read request has a low nibble of 0 */
 
     if(setp && hi->set_in_stone)return(OV_EINVAL);
-    
+
     switch(number){
-      
+
     /* now deprecated *****************/
     case OV_ECTL_RATEMANAGE_GET:
       {
-	
-	struct ovectl_ratemanage_arg *ai=
-	  (struct ovectl_ratemanage_arg *)arg;
-	
-	ai->management_active=hi->managed;
-	ai->bitrate_hard_window=ai->bitrate_av_window=
-	  (double)hi->bitrate_reservoir/vi->rate;
-	ai->bitrate_av_window_center=1.;
-	ai->bitrate_hard_min=hi->bitrate_min;
-	ai->bitrate_hard_max=hi->bitrate_max;
-	ai->bitrate_av_lo=hi->bitrate_av;
-	ai->bitrate_av_hi=hi->bitrate_av;
-	
+
+        struct ovectl_ratemanage_arg *ai=
+          (struct ovectl_ratemanage_arg *)arg;
+
+        ai->management_active=hi->managed;
+        ai->bitrate_hard_window=ai->bitrate_av_window=
+          (double)hi->bitrate_reservoir/vi->rate;
+        ai->bitrate_av_window_center=1.;
+        ai->bitrate_hard_min=hi->bitrate_min;
+        ai->bitrate_hard_max=hi->bitrate_max;
+        ai->bitrate_av_lo=hi->bitrate_av;
+        ai->bitrate_av_hi=hi->bitrate_av;
+
       }
       return(0);
-    
+
     /* now deprecated *****************/
     case OV_ECTL_RATEMANAGE_SET:
       {
-	struct ovectl_ratemanage_arg *ai=
-	  (struct ovectl_ratemanage_arg *)arg;
-	if(ai==NULL){
-	  hi->managed=0;
-	}else{
-	  hi->managed=ai->management_active;
-	  vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_AVG,arg);
-	  vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_HARD,arg);
-	}
+        struct ovectl_ratemanage_arg *ai=
+          (struct ovectl_ratemanage_arg *)arg;
+        if(ai==NULL){
+          hi->managed=0;
+        }else{
+          hi->managed=ai->management_active;
+          vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_AVG,arg);
+          vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_HARD,arg);
+        }
       }
       return 0;
 
     /* now deprecated *****************/
     case OV_ECTL_RATEMANAGE_AVG:
       {
-	struct ovectl_ratemanage_arg *ai=
-	  (struct ovectl_ratemanage_arg *)arg;
-	if(ai==NULL){
-	  hi->bitrate_av=0;
-	}else{
-	  hi->bitrate_av=(ai->bitrate_av_lo+ai->bitrate_av_hi)*.5;
-	}
+        struct ovectl_ratemanage_arg *ai=
+          (struct ovectl_ratemanage_arg *)arg;
+        if(ai==NULL){
+          hi->bitrate_av=0;
+        }else{
+          hi->bitrate_av=(ai->bitrate_av_lo+ai->bitrate_av_hi)*.5;
+        }
       }
       return(0);
     /* now deprecated *****************/
     case OV_ECTL_RATEMANAGE_HARD:
       {
-	struct ovectl_ratemanage_arg *ai=
-	  (struct ovectl_ratemanage_arg *)arg;
-	if(ai==NULL){
-	  hi->bitrate_min=0;
-	  hi->bitrate_max=0;
-	}else{
-	  hi->bitrate_min=ai->bitrate_hard_min;
-	  hi->bitrate_max=ai->bitrate_hard_max;
-	  hi->bitrate_reservoir=ai->bitrate_hard_window*
-	    (hi->bitrate_max+hi->bitrate_min)*.5;
-	}
-	if(hi->bitrate_reservoir<128.)
-	  hi->bitrate_reservoir=128.;
-      }   
+        struct ovectl_ratemanage_arg *ai=
+          (struct ovectl_ratemanage_arg *)arg;
+        if(ai==NULL){
+          hi->bitrate_min=0;
+          hi->bitrate_max=0;
+        }else{
+          hi->bitrate_min=ai->bitrate_hard_min;
+          hi->bitrate_max=ai->bitrate_hard_max;
+          hi->bitrate_reservoir=ai->bitrate_hard_window*
+            (hi->bitrate_max+hi->bitrate_min)*.5;
+        }
+        if(hi->bitrate_reservoir<128.)
+          hi->bitrate_reservoir=128.;
+      }
       return(0);
 
       /* replacement ratemanage interface */
     case OV_ECTL_RATEMANAGE2_GET:
       {
-	struct ovectl_ratemanage2_arg *ai=
-	  (struct ovectl_ratemanage2_arg *)arg;
-	if(ai==NULL)return OV_EINVAL;
-	
-	ai->management_active=hi->managed;
-	ai->bitrate_limit_min_kbps=hi->bitrate_min;
-	ai->bitrate_limit_max_kbps=hi->bitrate_max;
-	ai->bitrate_average_kbps=hi->bitrate_av/1000;
-	ai->bitrate_average_damping=hi->bitrate_av_damp;
-	ai->bitrate_limit_reservoir_bits=hi->bitrate_reservoir;
-	ai->bitrate_limit_reservoir_bias=hi->bitrate_reservoir_bias;
+        struct ovectl_ratemanage2_arg *ai=
+          (struct ovectl_ratemanage2_arg *)arg;
+        if(ai==NULL)return OV_EINVAL;
+
+        ai->management_active=hi->managed;
+        ai->bitrate_limit_min_kbps=hi->bitrate_min/1000;
+        ai->bitrate_limit_max_kbps=hi->bitrate_max/1000;
+        ai->bitrate_average_kbps=hi->bitrate_av/1000;
+        ai->bitrate_average_damping=hi->bitrate_av_damp;
+        ai->bitrate_limit_reservoir_bits=hi->bitrate_reservoir;
+        ai->bitrate_limit_reservoir_bias=hi->bitrate_reservoir_bias;
       }
       return (0);
     case OV_ECTL_RATEMANAGE2_SET:
       {
-	struct ovectl_ratemanage2_arg *ai=
-	  (struct ovectl_ratemanage2_arg *)arg;
-	if(ai==NULL){
-	  hi->managed=0;
-	}else{
-	  /* sanity check; only catch invariant violations */
-	  if(ai->bitrate_limit_min_kbps>0 &&
-	     ai->bitrate_average_kbps>0 &&
-	     ai->bitrate_limit_min_kbps>ai->bitrate_average_kbps)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_limit_max_kbps>0 &&
-	     ai->bitrate_average_kbps>0 &&
-	     ai->bitrate_limit_max_kbps<ai->bitrate_average_kbps)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_limit_min_kbps>0 &&
-	     ai->bitrate_limit_max_kbps>0 &&
-	     ai->bitrate_limit_min_kbps>ai->bitrate_limit_max_kbps)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_average_damping <= 0.)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_limit_reservoir_bits < 0)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_limit_reservoir_bias < 0.)
-	    return OV_EINVAL;
-
-	  if(ai->bitrate_limit_reservoir_bias > 1.)
-	    return OV_EINVAL;
-
-	  hi->managed=ai->management_active;
-	  hi->bitrate_min=ai->bitrate_limit_min_kbps;
-	  hi->bitrate_max=ai->bitrate_limit_max_kbps;
-	  hi->bitrate_av=ai->bitrate_average_kbps * 1000;
-	  hi->bitrate_av_damp=ai->bitrate_average_damping;
-	  hi->bitrate_reservoir=ai->bitrate_limit_reservoir_bits;
-	  hi->bitrate_reservoir_bias=ai->bitrate_limit_reservoir_bias;
-	}
+        struct ovectl_ratemanage2_arg *ai=
+          (struct ovectl_ratemanage2_arg *)arg;
+        if(ai==NULL){
+          hi->managed=0;
+        }else{
+          /* sanity check; only catch invariant violations */
+          if(ai->bitrate_limit_min_kbps>0 &&
+             ai->bitrate_average_kbps>0 &&
+             ai->bitrate_limit_min_kbps>ai->bitrate_average_kbps)
+            return OV_EINVAL;
+
+          if(ai->bitrate_limit_max_kbps>0 &&
+             ai->bitrate_average_kbps>0 &&
+             ai->bitrate_limit_max_kbps<ai->bitrate_average_kbps)
+            return OV_EINVAL;
+
+          if(ai->bitrate_limit_min_kbps>0 &&
+             ai->bitrate_limit_max_kbps>0 &&
+             ai->bitrate_limit_min_kbps>ai->bitrate_limit_max_kbps)
+            return OV_EINVAL;
+
+          if(ai->bitrate_average_damping <= 0.)
+            return OV_EINVAL;
+
+          if(ai->bitrate_limit_reservoir_bits < 0)
+            return OV_EINVAL;
+
+          if(ai->bitrate_limit_reservoir_bias < 0.)
+            return OV_EINVAL;
+
+          if(ai->bitrate_limit_reservoir_bias > 1.)
+            return OV_EINVAL;
+
+          hi->managed=ai->management_active;
+          hi->bitrate_min=ai->bitrate_limit_min_kbps * 1000;
+          hi->bitrate_max=ai->bitrate_limit_max_kbps * 1000;
+          hi->bitrate_av=ai->bitrate_average_kbps * 1000;
+          hi->bitrate_av_damp=ai->bitrate_average_damping;
+          hi->bitrate_reservoir=ai->bitrate_limit_reservoir_bits;
+          hi->bitrate_reservoir_bias=ai->bitrate_limit_reservoir_bias;
+        }
       }
       return 0;
-      
+
     case OV_ECTL_LOWPASS_GET:
       {
-	double *farg=(double *)arg;
-	*farg=hi->lowpass_kHz;
+        double *farg=(double *)arg;
+        *farg=hi->lowpass_kHz;
       }
       return(0);
     case OV_ECTL_LOWPASS_SET:
       {
-	double *farg=(double *)arg;
-	hi->lowpass_kHz=*farg;
+        double *farg=(double *)arg;
+        hi->lowpass_kHz=*farg;
 
-	if(hi->lowpass_kHz<2.)hi->lowpass_kHz=2.;
-	if(hi->lowpass_kHz>99.)hi->lowpass_kHz=99.;
+        if(hi->lowpass_kHz<2.)hi->lowpass_kHz=2.;
+        if(hi->lowpass_kHz>99.)hi->lowpass_kHz=99.;
+        hi->lowpass_altered=1;
       }
       return(0);
     case OV_ECTL_IBLOCK_GET:
       {
-	double *farg=(double *)arg;
-	*farg=hi->impulse_noisetune;
+        double *farg=(double *)arg;
+        *farg=hi->impulse_noisetune;
       }
       return(0);
     case OV_ECTL_IBLOCK_SET:
       {
-	double *farg=(double *)arg;
-	hi->impulse_noisetune=*farg;
+        double *farg=(double *)arg;
+        hi->impulse_noisetune=*farg;
 
-	if(hi->impulse_noisetune>0.)hi->impulse_noisetune=0.;
-	if(hi->impulse_noisetune<-15.)hi->impulse_noisetune=-15.;
+        if(hi->impulse_noisetune>0.)hi->impulse_noisetune=0.;
+        if(hi->impulse_noisetune<-15.)hi->impulse_noisetune=-15.;
+      }
+      return(0);
+    case OV_ECTL_COUPLING_GET:
+      {
+        int *iarg=(int *)arg;
+        *iarg=hi->coupling_p;
       }
-      return(0);      
+      return(0);
+    case OV_ECTL_COUPLING_SET:
+      {
+        const void *new_template;
+        double new_base=0.;
+        int *iarg=(int *)arg;
+        hi->coupling_p=((*iarg)!=0);
+
+        /* Fetching a new template can alter the base_setting, which
+           many other parameters are based on.  Right now, the only
+           parameter drawn from the base_setting that can be altered
+           by an encctl is the lowpass, so that is explictly flagged
+           to not be overwritten when we fetch a new template and
+           recompute the dependant settings */
+        new_template = get_setup_template(hi->coupling_p?vi->channels:-1,
+                                          vi->rate,
+                                          hi->req,
+                                          hi->managed,
+                                          &new_base);
+        if(!hi->setup)return OV_EIMPL;
+        hi->setup=new_template;
+        hi->base_setting=new_base;
+        vorbis_encode_setup_setting(vi,vi->channels,vi->rate);
+      }
+      return(0);
     }
-
-
     return(OV_EIMPL);
   }
   return(OV_EINVAL);