lib/vorbisenc.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-2009             *
   9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13  function: simple programmatic interface for encoder mode setup
  14  last mod: $Id: vorbisenc.c 17028 2010-03-25 05:22:15Z xiphmont $
  15
  16  ********************************************************************/
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <math.h>
  21
  22 #include "vorbis/codec.h"
  23 #include "vorbis/vorbisenc.h"
  24
  25 #include "codec_internal.h"
  26
  27 #include "os.h"
  28 #include "misc.h"
  29
  30 /* careful with this; it's using static array sizing to make managing
  31    all the modes a little less annoying.  If we use a residue backend
  32    with > 12 partition types, or a different division of iteration,
  33    this needs to be updated. */
  34 typedef struct {
  35   const static_codebook *books[12][4];
  36 } static_bookblock;
  37
  38 typedef struct {
  39   int res_type;
  40   int limit_type; /* 0 lowpass limited, 1 point stereo limited */
  41   int grouping;
  42   const vorbis_info_residue0 *res;
  43   const static_codebook  *book_aux;
  44   const static_codebook  *book_aux_managed;
  45   const static_bookblock *books_base;
  46   const static_bookblock *books_base_managed;
  47 } vorbis_residue_template;
  48
  49 typedef struct {
  50   const vorbis_info_mapping0    *map;
  51   const vorbis_residue_template *res;
  52 } vorbis_mapping_template;
  53
  54 typedef struct vp_adjblock{
  55   int block[P_BANDS];
  56 } vp_adjblock;
  57
  58 typedef struct {
  59   int data[NOISE_COMPAND_LEVELS];
  60 } compandblock;
  61
  62 /* high level configuration information for setting things up
  63    step-by-step with the detailed vorbis_encode_ctl interface.
  64    There's a fair amount of redundancy such that interactive setup
  65    does not directly deal with any vorbis_info or codec_setup_info
  66    initialization; it's all stored (until full init) in this highlevel
  67    setup, then flushed out to the real codec setup structs later. */
  68
  69 typedef struct {
  70   int att[P_NOISECURVES];
  71   float boost;
  72   float decay;
  73 } att3;
  74 typedef struct { int data[P_NOISECURVES]; } adj3;
  75
  76 typedef struct {
  77   int   pre[PACKETBLOBS];
  78   int   post[PACKETBLOBS];
  79   float kHz[PACKETBLOBS];
  80   float lowpasskHz[PACKETBLOBS];
  81 } adj_stereo;
  82
  83 typedef struct {
  84   int lo;
  85   int hi;
  86   int fixed;
  87 } noiseguard;
  88 typedef struct {
  89   int data[P_NOISECURVES][17];
  90 } noise3;
  91
  92 typedef struct {
  93   int      mappings;
  94   const double  *rate_mapping;
  95   const double  *quality_mapping;
  96   int      coupling_restriction;
  97   long     samplerate_min_restriction;
  98   long     samplerate_max_restriction;
  99
 100
 101   const int     *blocksize_short;
 102   const int     *blocksize_long;
 103
 104   const att3    *psy_tone_masteratt;
 105   const int     *psy_tone_0dB;
 106   const int     *psy_tone_dBsuppress;
 107
 108   const vp_adjblock *psy_tone_adj_impulse;
 109   const vp_adjblock *psy_tone_adj_long;
 110   const vp_adjblock *psy_tone_adj_other;
 111
 112   const noiseguard  *psy_noiseguards;
 113   const noise3      *psy_noise_bias_impulse;
 114   const noise3      *psy_noise_bias_padding;
 115   const noise3      *psy_noise_bias_trans;
 116   const noise3      *psy_noise_bias_long;
 117   const int         *psy_noise_dBsuppress;
 118
 119   const compandblock  *psy_noise_compand;
 120   const double        *psy_noise_compand_short_mapping;
 121   const double        *psy_noise_compand_long_mapping;
 122
 123   const int      *psy_noise_normal_start[2];
 124   const int      *psy_noise_normal_partition[2];
 125   const double   *psy_noise_normal_thresh;
 126
 127   const int      *psy_ath_float;
 128   const int      *psy_ath_abs;
 129
 130   const double   *psy_lowpass;
 131
 132   const vorbis_info_psy_global *global_params;
 133   const double     *global_mapping;
 134   const adj_stereo *stereo_modes;
 135
 136   const static_codebook *const *const *const floor_books;
 137   const vorbis_info_floor1 *floor_params;
 138   const int floor_mappings;
 139   const int **floor_mapping_list;
 140
 141   const vorbis_mapping_template *maps;
 142 } ve_setup_data_template;
 143
 144 /* a few static coder conventions */
 145 static const vorbis_info_mode _mode_template[2]={
 146   {0,0,0,0},
 147   {1,0,0,1}
 148 };
 149
 150 static const vorbis_info_mapping0 _map_nominal[2]={
 151   {1, {0,0}, {0}, {0}, 1,{0},{1}},
 152   {1, {0,0}, {1}, {1}, 1,{0},{1}}
 153 };
 154
 155 #include "modes/setup_44.h"
 156 #include "modes/setup_44u.h"
 157 #include "modes/setup_44p51.h"
 158 #include "modes/setup_32.h"
 159 #include "modes/setup_8.h"
 160 #include "modes/setup_11.h"
 161 #include "modes/setup_16.h"
 162 #include "modes/setup_22.h"
 163 #include "modes/setup_X.h"
 164
 165 static const ve_setup_data_template *const setup_list[]={
 166   &ve_setup_44_stereo,
 167   &ve_setup_44_51,
 168   &ve_setup_44_uncoupled,
 169
 170   &ve_setup_32_stereo,
 171   &ve_setup_32_uncoupled,
 172
 173   &ve_setup_22_stereo,
 174   &ve_setup_22_uncoupled,
 175   &ve_setup_16_stereo,
 176   &ve_setup_16_uncoupled,
 177
 178   &ve_setup_11_stereo,
 179   &ve_setup_11_uncoupled,
 180   &ve_setup_8_stereo,
 181   &ve_setup_8_uncoupled,
 182
 183   &ve_setup_X_stereo,
 184   &ve_setup_X_uncoupled,
 185   &ve_setup_XX_stereo,
 186   &ve_setup_XX_uncoupled,
 187   0
 188 };
 189
 190 static void vorbis_encode_floor_setup(vorbis_info *vi,int s,
 191                                      const static_codebook *const *const *const books,
 192                                      const vorbis_info_floor1 *in,
 193                                      const int *x){
 194   int i,k,is=s;
 195   vorbis_info_floor1 *f=_ogg_calloc(1,sizeof(*f));
 196   codec_setup_info *ci=vi->codec_setup;
 197
 198   memcpy(f,in+x[is],sizeof(*f));
 199
 200   /* books */
 201   {
 202     int partitions=f->partitions;
 203     int maxclass=-1;
 204     int maxbook=-1;
 205     for(i=0;i<partitions;i++)
 206       if(f->partitionclass[i]>maxclass)maxclass=f->partitionclass[i];
 207     for(i=0;i<=maxclass;i++){
 208       if(f->class_book[i]>maxbook)maxbook=f->class_book[i];
 209       f->class_book[i]+=ci->books;
 210       for(k=0;k<(1<<f->class_subs[i]);k++){
 211         if(f->class_subbook[i][k]>maxbook)maxbook=f->class_subbook[i][k];
 212         if(f->class_subbook[i][k]>=0)f->class_subbook[i][k]+=ci->books;
 213       }
 214     }
 215
 216     for(i=0;i<=maxbook;i++)
 217       ci->book_param[ci->books++]=(static_codebook *)books[x[is]][i];
 218   }
 219
 220   /* for now, we're only using floor 1 */
 221   ci->floor_type[ci->floors]=1;
 222   ci->floor_param[ci->floors]=f;
 223   ci->floors++;
 224
 225   return;
 226 }
 227
 228 static void vorbis_encode_global_psych_setup(vorbis_info *vi,double s,
 229                                             const vorbis_info_psy_global *in,
 230                                             const double *x){
 231   int i,is=s;
 232   double ds=s-is;
 233   codec_setup_info *ci=vi->codec_setup;
 234   vorbis_info_psy_global *g=&ci->psy_g_param;
 235
 236   memcpy(g,in+(int)x[is],sizeof(*g));
 237
 238   ds=x[is]*(1.-ds)+x[is+1]*ds;
 239   is=(int)ds;
 240   ds-=is;
 241   if(ds==0 && is>0){
 242     is--;
 243     ds=1.;
 244   }
 245
 246   /* interpolate the trigger threshholds */
 247   for(i=0;i<4;i++){
 248     g->preecho_thresh[i]=in[is].preecho_thresh[i]*(1.-ds)+in[is+1].preecho_thresh[i]*ds;
 249     g->postecho_thresh[i]=in[is].postecho_thresh[i]*(1.-ds)+in[is+1].postecho_thresh[i]*ds;
 250   }
 251   g->ampmax_att_per_sec=ci->hi.amplitude_track_dBpersec;
 252   return;
 253 }
 254
 255 static void vorbis_encode_global_stereo(vorbis_info *vi,
 256                                         const highlevel_encode_setup *const hi,
 257                                         const adj_stereo *p){
 258   float s=hi->stereo_point_setting;
 259   int i,is=s;
 260   double ds=s-is;
 261   codec_setup_info *ci=vi->codec_setup;
 262   vorbis_info_psy_global *g=&ci->psy_g_param;
 263
 264   if(p){
 265     memcpy(g->coupling_prepointamp,p[is].pre,sizeof(*p[is].pre)*PACKETBLOBS);
 266     memcpy(g->coupling_postpointamp,p[is].post,sizeof(*p[is].post)*PACKETBLOBS);
 267
 268     if(hi->managed){
 269       /* interpolate the kHz threshholds */
 270       for(i=0;i<PACKETBLOBS;i++){
 271         float kHz=p[is].kHz[i]*(1.-ds)+p[is+1].kHz[i]*ds;
 272         g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
 273         g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
 274         g->coupling_pkHz[i]=kHz;
 275
 276         kHz=p[is].lowpasskHz[i]*(1.-ds)+p[is+1].lowpasskHz[i]*ds;
 277         g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
 278         g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
 279
 280       }
 281     }else{
 282       float kHz=p[is].kHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].kHz[PACKETBLOBS/2]*ds;
 283       for(i=0;i<PACKETBLOBS;i++){
 284         g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
 285         g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
 286         g->coupling_pkHz[i]=kHz;
 287       }
 288
 289       kHz=p[is].lowpasskHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].lowpasskHz[PACKETBLOBS/2]*ds;
 290       for(i=0;i<PACKETBLOBS;i++){
 291         g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
 292         g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
 293       }
 294     }
 295   }else{
 296     for(i=0;i<PACKETBLOBS;i++){
 297       g->sliding_lowpass[0][i]=ci->blocksizes[0];
 298       g->sliding_lowpass[1][i]=ci->blocksizes[1];
 299     }
 300   }
 301   return;
 302 }
 303
 304 static void vorbis_encode_psyset_setup(vorbis_info *vi,double s,
 305                                        const int *nn_start,
 306                                        const int *nn_partition,
 307                                        const double *nn_thresh,
 308                                        int block){
 309   codec_setup_info *ci=vi->codec_setup;
 310   vorbis_info_psy *p=ci->psy_param[block];
 311   highlevel_encode_setup *hi=&ci->hi;
 312   int is=s;
 313
 314   if(block>=ci->psys)
 315     ci->psys=block+1;
 316   if(!p){
 317     p=_ogg_calloc(1,sizeof(*p));
 318     ci->psy_param[block]=p;
 319   }
 320
 321   memcpy(p,&_psy_info_template,sizeof(*p));
 322   p->blockflag=block>>1;
 323
 324   if(hi->noise_normalize_p){
 325     p->normal_p=1;
 326     p->normal_start=nn_start[is];
 327     p->normal_partition=nn_partition[is];
 328     p->normal_thresh=nn_thresh[is];
 329   }
 330
 331   return;
 332 }
 333
 334 static void vorbis_encode_tonemask_setup(vorbis_info *vi,double s,int block,
 335                                          const att3 *att,
 336                                          const int  *max,
 337                                          const vp_adjblock *in){
 338   int i,is=s;
 339   double ds=s-is;
 340   codec_setup_info *ci=vi->codec_setup;
 341   vorbis_info_psy *p=ci->psy_param[block];
 342
 343   /* 0 and 2 are only used by bitmanagement, but there's no harm to always
 344      filling the values in here */
 345   p->tone_masteratt[0]=att[is].att[0]*(1.-ds)+att[is+1].att[0]*ds;
 346   p->tone_masteratt[1]=att[is].att[1]*(1.-ds)+att[is+1].att[1]*ds;
 347   p->tone_masteratt[2]=att[is].att[2]*(1.-ds)+att[is+1].att[2]*ds;
 348   p->tone_centerboost=att[is].boost*(1.-ds)+att[is+1].boost*ds;
 349   p->tone_decay=att[is].decay*(1.-ds)+att[is+1].decay*ds;
 350
 351   p->max_curve_dB=max[is]*(1.-ds)+max[is+1]*ds;
 352
 353   for(i=0;i<P_BANDS;i++)
 354     p->toneatt[i]=in[is].block[i]*(1.-ds)+in[is+1].block[i]*ds;
 355   return;
 356 }
 357
 358
 359 static void vorbis_encode_compand_setup(vorbis_info *vi,double s,int block,
 360                                         const compandblock *in,
 361                                         const double *x){
 362   int i,is=s;
 363   double ds=s-is;
 364   codec_setup_info *ci=vi->codec_setup;
 365   vorbis_info_psy *p=ci->psy_param[block];
 366
 367   ds=x[is]*(1.-ds)+x[is+1]*ds;
 368   is=(int)ds;
 369   ds-=is;
 370   if(ds==0 && is>0){
 371     is--;
 372     ds=1.;
 373   }
 374
 375   /* interpolate the compander settings */
 376   for(i=0;i<NOISE_COMPAND_LEVELS;i++)
 377     p->noisecompand[i]=in[is].data[i]*(1.-ds)+in[is+1].data[i]*ds;
 378   return;
 379 }
 380
 381 static void vorbis_encode_peak_setup(vorbis_info *vi,double s,int block,
 382                                     const int *suppress){
 383   int is=s;
 384   double ds=s-is;
 385   codec_setup_info *ci=vi->codec_setup;
 386   vorbis_info_psy *p=ci->psy_param[block];
 387
 388   p->tone_abs_limit=suppress[is]*(1.-ds)+suppress[is+1]*ds;
 389
 390   return;
 391 }
 392
 393 static void vorbis_encode_noisebias_setup(vorbis_info *vi,double s,int block,
 394                                          const int *suppress,
 395                                          const noise3 *in,
 396                                          const noiseguard *guard,
 397                                          double userbias){
 398   int i,is=s,j;
 399   double ds=s-is;
 400   codec_setup_info *ci=vi->codec_setup;
 401   vorbis_info_psy *p=ci->psy_param[block];
 402
 403   p->noisemaxsupp=suppress[is]*(1.-ds)+suppress[is+1]*ds;
 404   p->noisewindowlomin=guard[block].lo;
 405   p->noisewindowhimin=guard[block].hi;
 406   p->noisewindowfixed=guard[block].fixed;
 407
 408   for(j=0;j<P_NOISECURVES;j++)
 409     for(i=0;i<P_BANDS;i++)
 410       p->noiseoff[j][i]=in[is].data[j][i]*(1.-ds)+in[is+1].data[j][i]*ds;
 411
 412   /* impulse blocks may take a user specified bias to boost the
 413      nominal/high noise encoding depth */
 414   for(j=0;j<P_NOISECURVES;j++){
 415     float min=p->noiseoff[j][0]+6; /* the lowest it can go */
 416     for(i=0;i<P_BANDS;i++){
 417       p->noiseoff[j][i]+=userbias;
 418       if(p->noiseoff[j][i]<min)p->noiseoff[j][i]=min;
 419     }
 420   }
 421
 422   return;
 423 }
 424
 425 static void vorbis_encode_ath_setup(vorbis_info *vi,int block){
 426   codec_setup_info *ci=vi->codec_setup;
 427   vorbis_info_psy *p=ci->psy_param[block];
 428
 429   p->ath_adjatt=ci->hi.ath_floating_dB;
 430   p->ath_maxatt=ci->hi.ath_absolute_dB;
 431   return;
 432 }
 433
 434
 435 static int book_dup_or_new(codec_setup_info *ci,const static_codebook *book){
 436   int i;
 437   for(i=0;i<ci->books;i++)
 438     if(ci->book_param[i]==book)return(i);
 439
 440   return(ci->books++);
 441 }
 442
 443 static void vorbis_encode_blocksize_setup(vorbis_info *vi,double s,
 444                                          const int *shortb,const int *longb){
 445
 446   codec_setup_info *ci=vi->codec_setup;
 447   int is=s;
 448
 449   int blockshort=shortb[is];
 450   int blocklong=longb[is];
 451   ci->blocksizes[0]=blockshort;
 452   ci->blocksizes[1]=blocklong;
 453
 454 }
 455
 456 static void vorbis_encode_residue_setup(vorbis_info *vi,
 457                                         int number, int block,
 458                                         const vorbis_residue_template *res){
 459
 460   codec_setup_info *ci=vi->codec_setup;
 461   int i;
 462
 463   vorbis_info_residue0 *r=ci->residue_param[number]=
 464     _ogg_malloc(sizeof(*r));
 465
 466   memcpy(r,res->res,sizeof(*r));
 467   if(ci->residues<=number)ci->residues=number+1;
 468
 469   r->grouping=res->grouping;
 470   ci->residue_type[number]=res->res_type;
 471
 472   /* fill in all the books */
 473   {
 474     int booklist=0,k;
 475
 476     if(ci->hi.managed){
 477       for(i=0;i<r->partitions;i++)
 478         for(k=0;k<4;k++)
 479           if(res->books_base_managed->books[i][k])
 480             r->secondstages[i]|=(1<<k);
 481
 482       r->groupbook=book_dup_or_new(ci,res->book_aux_managed);
 483       ci->book_param[r->groupbook]=(static_codebook *)res->book_aux_managed;
 484
 485       for(i=0;i<r->partitions;i++){
 486         for(k=0;k<4;k++){
 487           if(res->books_base_managed->books[i][k]){
 488             int bookid=book_dup_or_new(ci,res->books_base_managed->books[i][k]);
 489             r->booklist[booklist++]=bookid;
 490             ci->book_param[bookid]=(static_codebook *)res->books_base_managed->books[i][k];
 491           }
 492         }
 493       }
 494
 495     }else{
 496
 497       for(i=0;i<r->partitions;i++)
 498         for(k=0;k<4;k++)
 499           if(res->books_base->books[i][k])
 500             r->secondstages[i]|=(1<<k);
 501
 502       r->groupbook=book_dup_or_new(ci,res->book_aux);
 503       ci->book_param[r->groupbook]=(static_codebook *)res->book_aux;
 504
 505       for(i=0;i<r->partitions;i++){
 506         for(k=0;k<4;k++){
 507           if(res->books_base->books[i][k]){
 508             int bookid=book_dup_or_new(ci,res->books_base->books[i][k]);
 509             r->booklist[booklist++]=bookid;
 510             ci->book_param[bookid]=(static_codebook *)res->books_base->books[i][k];
 511           }
 512         }
 513       }
 514     }
 515   }
 516
 517   /* lowpass setup/pointlimit */
 518   {
 519     double freq=ci->hi.lowpass_kHz*1000.;
 520     vorbis_info_floor1 *f=ci->floor_param[block]; /* by convention */
 521     double nyq=vi->rate/2.;
 522     long blocksize=ci->blocksizes[block]>>1;
 523
 524     /* lowpass needs to be set in the floor and the residue. */
 525     if(freq>nyq)freq=nyq;
 526     /* in the floor, the granularity can be very fine; it doesn't alter
 527        the encoding structure, only the samples used to fit the floor
 528        approximation */
 529     f->n=freq/nyq*blocksize;
 530
 531     /* this res may by limited by the maximum pointlimit of the mode,
 532        not the lowpass. the floor is always lowpass limited. */
 533     switch(res->limit_type){
 534     case 1: /* point stereo limited */
 535       if(ci->hi.managed)
 536         freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS-1]*1000.;
 537       else
 538         freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS/2]*1000.;
 539       if(freq>nyq)freq=nyq;
 540       break;
 541     case 2: /* LFE channel; lowpass at ~ 250Hz */
 542       freq=250;
 543       break;
 544     default:
 545       /* already set */
 546       break;
 547     }
 548
 549     /* in the residue, we're constrained, physically, by partition
 550        boundaries.  We still lowpass 'wherever', but we have to round up
 551        here to next boundary, or the vorbis spec will round it *down* to
 552        previous boundary in encode/decode */
 553     if(ci->residue_type[number]==2){
 554       /* residue 2 bundles together multiple channels; used by stereo
 555          and surround.  Count the channels in use */
 556       /* Multiple maps/submaps can point to the same residue.  In the case
 557          of residue 2, they all better have the same number of
 558          channels/samples. */
 559       int j,k,ch=0;
 560       for(i=0;i<ci->maps&&ch==0;i++){
 561         vorbis_info_mapping0 *mi=(vorbis_info_mapping0 *)ci->map_param[i];
 562         for(j=0;j<mi->submaps && ch==0;j++)
 563           if(mi->residuesubmap[j]==number) /* we found a submap referencing theis residue backend */
 564             for(k=0;k<vi->channels;k++)
 565               if(mi->chmuxlist[k]==j) /* this channel belongs to the submap */
 566                 ch++;
 567       }
 568
 569       r->end=(int)((freq/nyq*blocksize*ch)/r->grouping+.9)* /* round up only if we're well past */
 570         r->grouping;
 571       /* the blocksize and grouping may disagree at the end */
 572       if(r->end>blocksize*ch)r->end=blocksize*ch/r->grouping*r->grouping;
 573
 574     }else{
 575
 576       r->end=(int)((freq/nyq*blocksize)/r->grouping+.9)* /* round up only if we're well past */
 577         r->grouping;
 578       /* the blocksize and grouping may disagree at the end */
 579       if(r->end>blocksize)r->end=blocksize/r->grouping*r->grouping;
 580
 581     }
 582
 583     if(r->end==0)r->end=r->grouping; /* LFE channel */
 584
 585   }
 586 }
 587
 588 /* we assume two maps in this encoder */
 589 static void vorbis_encode_map_n_res_setup(vorbis_info *vi,double s,
 590                                           const vorbis_mapping_template *maps){
 591
 592   codec_setup_info *ci=vi->codec_setup;
 593   int i,j,is=s,modes=2;
 594   const vorbis_info_mapping0 *map=maps[is].map;
 595   const vorbis_info_mode *mode=_mode_template;
 596   const vorbis_residue_template *res=maps[is].res;
 597
 598   if(ci->blocksizes[0]==ci->blocksizes[1])modes=1;
 599
 600   for(i=0;i<modes;i++){
 601
 602     ci->map_param[i]=_ogg_calloc(1,sizeof(*map));
 603     ci->mode_param[i]=_ogg_calloc(1,sizeof(*mode));
 604
 605     memcpy(ci->mode_param[i],mode+i,sizeof(*_mode_template));
 606     if(i>=ci->modes)ci->modes=i+1;
 607
 608     ci->map_type[i]=0;
 609     memcpy(ci->map_param[i],map+i,sizeof(*map));
 610     if(i>=ci->maps)ci->maps=i+1;
 611
 612     for(j=0;j<map[i].submaps;j++)
 613       vorbis_encode_residue_setup(vi,map[i].residuesubmap[j],i
 614                                   ,res+map[i].residuesubmap[j]);
 615   }
 616 }
 617
 618 static double setting_to_approx_bitrate(vorbis_info *vi){
 619   codec_setup_info *ci=vi->codec_setup;
 620   highlevel_encode_setup *hi=&ci->hi;
 621   ve_setup_data_template *setup=(ve_setup_data_template *)hi->setup;
 622   int is=hi->base_setting;
 623   double ds=hi->base_setting-is;
 624   int ch=vi->channels;
 625   const double *r=setup->rate_mapping;
 626
 627   if(r==NULL)
 628     return(-1);
 629
 630   return((r[is]*(1.-ds)+r[is+1]*ds)*ch);
 631 }
 632
 633 static const void *get_setup_template(long ch,long srate,
 634                                       double req,int q_or_bitrate,
 635                                       double *base_setting){
 636   int i=0,j;
 637   if(q_or_bitrate)req/=ch;
 638
 639   while(setup_list[i]){
 640     if(setup_list[i]->coupling_restriction==-1 ||
 641        setup_list[i]->coupling_restriction==ch){
 642       if(srate>=setup_list[i]->samplerate_min_restriction &&
 643          srate<=setup_list[i]->samplerate_max_restriction){
 644         int mappings=setup_list[i]->mappings;
 645         const double *map=(q_or_bitrate?
 646                      setup_list[i]->rate_mapping:
 647                      setup_list[i]->quality_mapping);
 648
 649         /* the template matches.  Does the requested quality mode
 650            fall within this template's modes? */
 651         if(req<map[0]){++i;continue;}
 652         if(req>map[setup_list[i]->mappings]){++i;continue;}
 653         for(j=0;j<mappings;j++)
 654           if(req>=map[j] && req<map[j+1])break;
 655         /* an all-points match */
 656         if(j==mappings)
 657           *base_setting=j-.001;
 658         else{
 659           float low=map[j];
 660           float high=map[j+1];
 661           float del=(req-low)/(high-low);
 662           *base_setting=j+del;
 663         }
 664
 665         return(setup_list[i]);
 666       }
 667     }
 668     i++;
 669   }
 670
 671   return NULL;
 672 }
 673
 674 /* encoders will need to use vorbis_info_init beforehand and call
 675    vorbis_info clear when all done */
 676
 677 /* two interfaces; this, more detailed one, and later a convenience
 678    layer on top */
 679
 680 /* the final setup call */
 681 int vorbis_encode_setup_init(vorbis_info *vi){
 682   int i,i0=0,singleblock=0;
 683   codec_setup_info *ci=vi->codec_setup;
 684   ve_setup_data_template *setup=NULL;
 685   highlevel_encode_setup *hi=&ci->hi;
 686
 687   if(ci==NULL)return(OV_EINVAL);
 688   if(vi->channels<1||vi->channels>255)return(OV_EINVAL);
 689   if(!hi->impulse_block_p)i0=1;
 690
 691   /* too low/high an ATH floater is nonsensical, but doesn't break anything */
 692   if(hi->ath_floating_dB>-80)hi->ath_floating_dB=-80;
 693   if(hi->ath_floating_dB<-200)hi->ath_floating_dB=-200;
 694
 695   /* again, bound this to avoid the app shooting itself int he foot
 696      too badly */
 697   if(hi->amplitude_track_dBpersec>0.)hi->amplitude_track_dBpersec=0.;
 698   if(hi->amplitude_track_dBpersec<-99999.)hi->amplitude_track_dBpersec=-99999.;
 699
 700   /* get the appropriate setup template; matches the fetch in previous
 701      stages */
 702   setup=(ve_setup_data_template *)hi->setup;
 703   if(setup==NULL)return(OV_EINVAL);
 704
 705   hi->set_in_stone=1;
 706   /* choose block sizes from configured sizes as well as paying
 707      attention to long_block_p and short_block_p.  If the configured
 708      short and long blocks are the same length, we set long_block_p
 709      and unset short_block_p */
 710   vorbis_encode_blocksize_setup(vi,hi->base_setting,
 711                                 setup->blocksize_short,
 712                                 setup->blocksize_long);
 713   if(ci->blocksizes[0]==ci->blocksizes[1])singleblock=1;
 714
 715   /* floor setup; choose proper floor params.  Allocated on the floor
 716      stack in order; if we alloc only a single long floor, it's 0 */
 717   for(i=0;i<setup->floor_mappings;i++)
 718     vorbis_encode_floor_setup(vi,hi->base_setting,
 719                               setup->floor_books,
 720                               setup->floor_params,
 721                               setup->floor_mapping_list[i]);
 722
 723   /* setup of [mostly] short block detection and stereo*/
 724   vorbis_encode_global_psych_setup(vi,hi->trigger_setting,
 725                                    setup->global_params,
 726                                    setup->global_mapping);
 727   vorbis_encode_global_stereo(vi,hi,setup->stereo_modes);
 728
 729   /* basic psych setup and noise normalization */
 730   vorbis_encode_psyset_setup(vi,hi->base_setting,
 731                              setup->psy_noise_normal_start[0],
 732                              setup->psy_noise_normal_partition[0],
 733                              setup->psy_noise_normal_thresh,
 734                              0);
 735   vorbis_encode_psyset_setup(vi,hi->base_setting,
 736                              setup->psy_noise_normal_start[0],
 737                              setup->psy_noise_normal_partition[0],
 738                              setup->psy_noise_normal_thresh,
 739                              1);
 740   if(!singleblock){
 741     vorbis_encode_psyset_setup(vi,hi->base_setting,
 742                                setup->psy_noise_normal_start[1],
 743                                setup->psy_noise_normal_partition[1],
 744                                     setup->psy_noise_normal_thresh,
 745                                2);
 746     vorbis_encode_psyset_setup(vi,hi->base_setting,
 747                                setup->psy_noise_normal_start[1],
 748                                setup->psy_noise_normal_partition[1],
 749                                setup->psy_noise_normal_thresh,
 750                                3);
 751   }
 752
 753   /* tone masking setup */
 754   vorbis_encode_tonemask_setup(vi,hi->block[i0].tone_mask_setting,0,
 755                                setup->psy_tone_masteratt,
 756                                setup->psy_tone_0dB,
 757                                setup->psy_tone_adj_impulse);
 758   vorbis_encode_tonemask_setup(vi,hi->block[1].tone_mask_setting,1,
 759                                setup->psy_tone_masteratt,
 760                                setup->psy_tone_0dB,
 761                                setup->psy_tone_adj_other);
 762   if(!singleblock){
 763     vorbis_encode_tonemask_setup(vi,hi->block[2].tone_mask_setting,2,
 764                                  setup->psy_tone_masteratt,
 765                                  setup->psy_tone_0dB,
 766                                  setup->psy_tone_adj_other);
 767     vorbis_encode_tonemask_setup(vi,hi->block[3].tone_mask_setting,3,
 768                                  setup->psy_tone_masteratt,
 769                                  setup->psy_tone_0dB,
 770                                  setup->psy_tone_adj_long);
 771   }
 772
 773   /* noise companding setup */
 774   vorbis_encode_compand_setup(vi,hi->block[i0].noise_compand_setting,0,
 775                               setup->psy_noise_compand,
 776                               setup->psy_noise_compand_short_mapping);
 777   vorbis_encode_compand_setup(vi,hi->block[1].noise_compand_setting,1,
 778                               setup->psy_noise_compand,
 779                               setup->psy_noise_compand_short_mapping);
 780   if(!singleblock){
 781     vorbis_encode_compand_setup(vi,hi->block[2].noise_compand_setting,2,
 782                                 setup->psy_noise_compand,
 783                                 setup->psy_noise_compand_long_mapping);
 784     vorbis_encode_compand_setup(vi,hi->block[3].noise_compand_setting,3,
 785                                 setup->psy_noise_compand,
 786                                 setup->psy_noise_compand_long_mapping);
 787   }
 788
 789   /* peak guarding setup  */
 790   vorbis_encode_peak_setup(vi,hi->block[i0].tone_peaklimit_setting,0,
 791                            setup->psy_tone_dBsuppress);
 792   vorbis_encode_peak_setup(vi,hi->block[1].tone_peaklimit_setting,1,
 793                            setup->psy_tone_dBsuppress);
 794   if(!singleblock){
 795     vorbis_encode_peak_setup(vi,hi->block[2].tone_peaklimit_setting,2,
 796                              setup->psy_tone_dBsuppress);
 797     vorbis_encode_peak_setup(vi,hi->block[3].tone_peaklimit_setting,3,
 798                              setup->psy_tone_dBsuppress);
 799   }
 800
 801   /* noise bias setup */
 802   vorbis_encode_noisebias_setup(vi,hi->block[i0].noise_bias_setting,0,
 803                                 setup->psy_noise_dBsuppress,
 804                                 setup->psy_noise_bias_impulse,
 805                                 setup->psy_noiseguards,
 806                                 (i0==0?hi->impulse_noisetune:0.));
 807   vorbis_encode_noisebias_setup(vi,hi->block[1].noise_bias_setting,1,
 808                                 setup->psy_noise_dBsuppress,
 809                                 setup->psy_noise_bias_padding,
 810                                 setup->psy_noiseguards,0.);
 811   if(!singleblock){
 812     vorbis_encode_noisebias_setup(vi,hi->block[2].noise_bias_setting,2,
 813                                   setup->psy_noise_dBsuppress,
 814                                   setup->psy_noise_bias_trans,
 815                                   setup->psy_noiseguards,0.);
 816     vorbis_encode_noisebias_setup(vi,hi->block[3].noise_bias_setting,3,
 817                                   setup->psy_noise_dBsuppress,
 818                                   setup->psy_noise_bias_long,
 819                                   setup->psy_noiseguards,0.);
 820   }
 821
 822   vorbis_encode_ath_setup(vi,0);
 823   vorbis_encode_ath_setup(vi,1);
 824   if(!singleblock){
 825     vorbis_encode_ath_setup(vi,2);
 826     vorbis_encode_ath_setup(vi,3);
 827   }
 828
 829   vorbis_encode_map_n_res_setup(vi,hi->base_setting,setup->maps);
 830
 831   /* set bitrate readonlies and management */
 832   if(hi->bitrate_av>0)
 833     vi->bitrate_nominal=hi->bitrate_av;
 834   else{
 835     vi->bitrate_nominal=setting_to_approx_bitrate(vi);
 836   }
 837
 838   vi->bitrate_lower=hi->bitrate_min;
 839   vi->bitrate_upper=hi->bitrate_max;
 840   if(hi->bitrate_av)
 841     vi->bitrate_window=(double)hi->bitrate_reservoir/hi->bitrate_av;
 842   else
 843     vi->bitrate_window=0.;
 844
 845   if(hi->managed){
 846     ci->bi.avg_rate=hi->bitrate_av;
 847     ci->bi.min_rate=hi->bitrate_min;
 848     ci->bi.max_rate=hi->bitrate_max;
 849
 850     ci->bi.reservoir_bits=hi->bitrate_reservoir;
 851     ci->bi.reservoir_bias=
 852       hi->bitrate_reservoir_bias;
 853
 854     ci->bi.slew_damp=hi->bitrate_av_damp;
 855
 856   }
 857
 858   return(0);
 859
 860 }
 861
 862 static void vorbis_encode_setup_setting(vorbis_info *vi,
 863                                        long  channels,
 864                                        long  rate){
 865   int i,is;
 866   codec_setup_info *ci=vi->codec_setup;
 867   highlevel_encode_setup *hi=&ci->hi;
 868   const ve_setup_data_template *setup=hi->setup;
 869   double ds;
 870
 871   vi->version=0;
 872   vi->channels=channels;
 873   vi->rate=rate;
 874
 875   hi->impulse_block_p=1;
 876   hi->noise_normalize_p=1;
 877
 878   is=hi->base_setting;
 879   ds=hi->base_setting-is;
 880
 881   hi->stereo_point_setting=hi->base_setting;
 882
 883   if(!hi->lowpass_altered)
 884     hi->lowpass_kHz=
 885       setup->psy_lowpass[is]*(1.-ds)+setup->psy_lowpass[is+1]*ds;
 886
 887   hi->ath_floating_dB=setup->psy_ath_float[is]*(1.-ds)+
 888     setup->psy_ath_float[is+1]*ds;
 889   hi->ath_absolute_dB=setup->psy_ath_abs[is]*(1.-ds)+
 890     setup->psy_ath_abs[is+1]*ds;
 891
 892   hi->amplitude_track_dBpersec=-6.;
 893   hi->trigger_setting=hi->base_setting;
 894
 895   for(i=0;i<4;i++){
 896     hi->block[i].tone_mask_setting=hi->base_setting;
 897     hi->block[i].tone_peaklimit_setting=hi->base_setting;
 898     hi->block[i].noise_bias_setting=hi->base_setting;
 899     hi->block[i].noise_compand_setting=hi->base_setting;
 900   }
 901 }
 902
 903 int vorbis_encode_setup_vbr(vorbis_info *vi,
 904                             long  channels,
 905                             long  rate,
 906                             float quality){
 907   codec_setup_info *ci=vi->codec_setup;
 908   highlevel_encode_setup *hi=&ci->hi;
 909
 910   quality+=.0000001;
 911   if(quality>=1.)quality=.9999;
 912
 913   hi->req=quality;
 914   hi->setup=get_setup_template(channels,rate,quality,0,&hi->base_setting);
 915   if(!hi->setup)return OV_EIMPL;
 916
 917   vorbis_encode_setup_setting(vi,channels,rate);
 918   hi->managed=0;
 919   hi->coupling_p=1;
 920
 921   return 0;
 922 }
 923
 924 int vorbis_encode_init_vbr(vorbis_info *vi,
 925                            long channels,
 926                            long rate,
 927
 928                            float base_quality /* 0. to 1. */
 929                            ){
 930   int ret=0;
 931
 932   ret=vorbis_encode_setup_vbr(vi,channels,rate,base_quality);
 933
 934   if(ret){
 935     vorbis_info_clear(vi);
 936     return ret;
 937   }
 938   ret=vorbis_encode_setup_init(vi);
 939   if(ret)
 940     vorbis_info_clear(vi);
 941   return(ret);
 942 }
 943
 944 int vorbis_encode_setup_managed(vorbis_info *vi,
 945                                 long channels,
 946                                 long rate,
 947
 948                                 long max_bitrate,
 949                                 long nominal_bitrate,
 950                                 long min_bitrate){
 951
 952   codec_setup_info *ci=vi->codec_setup;
 953   highlevel_encode_setup *hi=&ci->hi;
 954   double tnominal=nominal_bitrate;
 955
 956   if(nominal_bitrate<=0.){
 957     if(max_bitrate>0.){
 958       if(min_bitrate>0.)
 959         nominal_bitrate=(max_bitrate+min_bitrate)*.5;
 960       else
 961         nominal_bitrate=max_bitrate*.875;
 962     }else{
 963       if(min_bitrate>0.){
 964         nominal_bitrate=min_bitrate;
 965       }else{
 966         return(OV_EINVAL);
 967       }
 968     }
 969   }
 970
 971   hi->req=nominal_bitrate;
 972   hi->setup=get_setup_template(channels,rate,nominal_bitrate,1,&hi->base_setting);
 973   if(!hi->setup)return OV_EIMPL;
 974
 975   vorbis_encode_setup_setting(vi,channels,rate);
 976
 977   /* initialize management with sane defaults */
 978   hi->coupling_p=1;
 979   hi->managed=1;
 980   hi->bitrate_min=min_bitrate;
 981   hi->bitrate_max=max_bitrate;
 982   hi->bitrate_av=tnominal;
 983   hi->bitrate_av_damp=1.5f; /* full range in no less than 1.5 second */
 984   hi->bitrate_reservoir=nominal_bitrate*2;
 985   hi->bitrate_reservoir_bias=.1; /* bias toward hoarding bits */
 986
 987   return(0);
 988
 989 }
 990
 991 int vorbis_encode_init(vorbis_info *vi,
 992                        long channels,
 993                        long rate,
 994
 995                        long max_bitrate,
 996                        long nominal_bitrate,
 997                        long min_bitrate){
 998
 999   int ret=vorbis_encode_setup_managed(vi,channels,rate,
1000                                       max_bitrate,
1001                                       nominal_bitrate,
1002                                       min_bitrate);
1003   if(ret){
1004     vorbis_info_clear(vi);
1005     return(ret);
1006   }
1007
1008   ret=vorbis_encode_setup_init(vi);
1009   if(ret)
1010     vorbis_info_clear(vi);
1011   return(ret);
1012 }
1013
1014 int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg){
1015   if(vi){
1016     codec_setup_info *ci=vi->codec_setup;
1017     highlevel_encode_setup *hi=&ci->hi;
1018     int setp=(number&0xf); /* a read request has a low nibble of 0 */
1019
1020     if(setp && hi->set_in_stone)return(OV_EINVAL);
1021
1022     switch(number){
1023
1024     /* now deprecated *****************/
1025     case OV_ECTL_RATEMANAGE_GET:
1026       {
1027
1028         struct ovectl_ratemanage_arg *ai=
1029           (struct ovectl_ratemanage_arg *)arg;
1030
1031         ai->management_active=hi->managed;
1032         ai->bitrate_hard_window=ai->bitrate_av_window=
1033           (double)hi->bitrate_reservoir/vi->rate;
1034         ai->bitrate_av_window_center=1.;
1035         ai->bitrate_hard_min=hi->bitrate_min;
1036         ai->bitrate_hard_max=hi->bitrate_max;
1037         ai->bitrate_av_lo=hi->bitrate_av;
1038         ai->bitrate_av_hi=hi->bitrate_av;
1039
1040       }
1041       return(0);
1042
1043     /* now deprecated *****************/
1044     case OV_ECTL_RATEMANAGE_SET:
1045       {
1046         struct ovectl_ratemanage_arg *ai=
1047           (struct ovectl_ratemanage_arg *)arg;
1048         if(ai==NULL){
1049           hi->managed=0;
1050         }else{
1051           hi->managed=ai->management_active;
1052           vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_AVG,arg);
1053           vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_HARD,arg);
1054         }
1055       }
1056       return 0;
1057
1058     /* now deprecated *****************/
1059     case OV_ECTL_RATEMANAGE_AVG:
1060       {
1061         struct ovectl_ratemanage_arg *ai=
1062           (struct ovectl_ratemanage_arg *)arg;
1063         if(ai==NULL){
1064           hi->bitrate_av=0;
1065         }else{
1066           hi->bitrate_av=(ai->bitrate_av_lo+ai->bitrate_av_hi)*.5;
1067         }
1068       }
1069       return(0);
1070     /* now deprecated *****************/
1071     case OV_ECTL_RATEMANAGE_HARD:
1072       {
1073         struct ovectl_ratemanage_arg *ai=
1074           (struct ovectl_ratemanage_arg *)arg;
1075         if(ai==NULL){
1076           hi->bitrate_min=0;
1077           hi->bitrate_max=0;
1078         }else{
1079           hi->bitrate_min=ai->bitrate_hard_min;
1080           hi->bitrate_max=ai->bitrate_hard_max;
1081           hi->bitrate_reservoir=ai->bitrate_hard_window*
1082             (hi->bitrate_max+hi->bitrate_min)*.5;
1083         }
1084         if(hi->bitrate_reservoir<128.)
1085           hi->bitrate_reservoir=128.;
1086       }
1087       return(0);
1088
1089       /* replacement ratemanage interface */
1090     case OV_ECTL_RATEMANAGE2_GET:
1091       {
1092         struct ovectl_ratemanage2_arg *ai=
1093           (struct ovectl_ratemanage2_arg *)arg;
1094         if(ai==NULL)return OV_EINVAL;
1095
1096         ai->management_active=hi->managed;
1097         ai->bitrate_limit_min_kbps=hi->bitrate_min/1000;
1098         ai->bitrate_limit_max_kbps=hi->bitrate_max/1000;
1099         ai->bitrate_average_kbps=hi->bitrate_av/1000;
1100         ai->bitrate_average_damping=hi->bitrate_av_damp;
1101         ai->bitrate_limit_reservoir_bits=hi->bitrate_reservoir;
1102         ai->bitrate_limit_reservoir_bias=hi->bitrate_reservoir_bias;
1103       }
1104       return (0);
1105     case OV_ECTL_RATEMANAGE2_SET:
1106       {
1107         struct ovectl_ratemanage2_arg *ai=
1108           (struct ovectl_ratemanage2_arg *)arg;
1109         if(ai==NULL){
1110           hi->managed=0;
1111         }else{
1112           /* sanity check; only catch invariant violations */
1113           if(ai->bitrate_limit_min_kbps>0 &&
1114              ai->bitrate_average_kbps>0 &&
1115              ai->bitrate_limit_min_kbps>ai->bitrate_average_kbps)
1116             return OV_EINVAL;
1117
1118           if(ai->bitrate_limit_max_kbps>0 &&
1119              ai->bitrate_average_kbps>0 &&
1120              ai->bitrate_limit_max_kbps<ai->bitrate_average_kbps)
1121             return OV_EINVAL;
1122
1123           if(ai->bitrate_limit_min_kbps>0 &&
1124              ai->bitrate_limit_max_kbps>0 &&
1125              ai->bitrate_limit_min_kbps>ai->bitrate_limit_max_kbps)
1126             return OV_EINVAL;
1127
1128           if(ai->bitrate_average_damping <= 0.)
1129             return OV_EINVAL;
1130
1131           if(ai->bitrate_limit_reservoir_bits < 0)
1132             return OV_EINVAL;
1133
1134           if(ai->bitrate_limit_reservoir_bias < 0.)
1135             return OV_EINVAL;
1136
1137           if(ai->bitrate_limit_reservoir_bias > 1.)
1138             return OV_EINVAL;
1139
1140           hi->managed=ai->management_active;
1141           hi->bitrate_min=ai->bitrate_limit_min_kbps * 1000;
1142           hi->bitrate_max=ai->bitrate_limit_max_kbps * 1000;
1143           hi->bitrate_av=ai->bitrate_average_kbps * 1000;
1144           hi->bitrate_av_damp=ai->bitrate_average_damping;
1145           hi->bitrate_reservoir=ai->bitrate_limit_reservoir_bits;
1146           hi->bitrate_reservoir_bias=ai->bitrate_limit_reservoir_bias;
1147         }
1148       }
1149       return 0;
1150
1151     case OV_ECTL_LOWPASS_GET:
1152       {
1153         double *farg=(double *)arg;
1154         *farg=hi->lowpass_kHz;
1155       }
1156       return(0);
1157     case OV_ECTL_LOWPASS_SET:
1158       {
1159         double *farg=(double *)arg;
1160         hi->lowpass_kHz=*farg;
1161
1162         if(hi->lowpass_kHz<2.)hi->lowpass_kHz=2.;
1163         if(hi->lowpass_kHz>99.)hi->lowpass_kHz=99.;
1164         hi->lowpass_altered=1;
1165       }
1166       return(0);
1167     case OV_ECTL_IBLOCK_GET:
1168       {
1169         double *farg=(double *)arg;
1170         *farg=hi->impulse_noisetune;
1171       }
1172       return(0);
1173     case OV_ECTL_IBLOCK_SET:
1174       {
1175         double *farg=(double *)arg;
1176         hi->impulse_noisetune=*farg;
1177
1178         if(hi->impulse_noisetune>0.)hi->impulse_noisetune=0.;
1179         if(hi->impulse_noisetune<-15.)hi->impulse_noisetune=-15.;
1180       }
1181       return(0);
1182     case OV_ECTL_COUPLING_GET:
1183       {
1184         int *iarg=(int *)arg;
1185         *iarg=hi->coupling_p;
1186       }
1187       return(0);
1188     case OV_ECTL_COUPLING_SET:
1189       {
1190         const void *new_template;
1191         double new_base=0.;
1192         int *iarg=(int *)arg;
1193         hi->coupling_p=((*iarg)!=0);
1194
1195         /* Fetching a new template can alter the base_setting, which
1196            many other parameters are based on.  Right now, the only
1197            parameter drawn from the base_setting that can be altered
1198            by an encctl is the lowpass, so that is explictly flagged
1199            to not be overwritten when we fetch a new template and
1200            recompute the dependant settings */
1201         new_template = get_setup_template(hi->coupling_p?vi->channels:-1,
1202                                           vi->rate,
1203                                           hi->req,
1204                                           hi->managed,
1205                                           &new_base);
1206         if(!hi->setup)return OV_EIMPL;
1207         hi->setup=new_template;
1208         hi->base_setting=new_base;
1209         vorbis_encode_setup_setting(vi,vi->channels,vi->rate);
1210       }
1211       return(0);
1212     }
1213     return(OV_EIMPL);
1214   }
1215   return(OV_EINVAL);
1216 }