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-2001             *
   9  * by the XIPHOPHORUS Company http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13  function: simple programmatic interface for encoder mode setup
  14  last mod: $Id: vorbisenc.c,v 1.23 2001/12/16 04:15:47 xiphmont Exp $
  15
  16  ********************************************************************/
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <math.h>
  21 #include <stdarg.h>
  22
  23 #include "vorbis/codec.h"
  24 #include "vorbis/vorbisenc.h"
  25
  26 #include "codec_internal.h"
  27 #include "registry-api.h"
  28
  29 #include "os.h"
  30 #include "misc.h"
  31
  32 /* careful with this; it's using static array sizing to make managing
  33    all the modes a little less annoying.  If we use a residue backend
  34    with > 10 partition types, or a different division of iteration,
  35    this needs to be updated. */
  36 typedef struct {
  37   vorbis_info_residue0 *res[2];
  38   static_codebook *book_aux[2];
  39   static_codebook *books_base[5][10][3];
  40   static_codebook *books_stereo_backfill[5][10];
  41   static_codebook *books_residue_backfill[5][10][2];
  42 } vorbis_residue_template;
  43
  44 static double stereo_threshholds[]={0.0, 2.5, 4.5, 8.5, 16.5};
  45
  46 typedef struct vp_adjblock{
  47   int block[P_BANDS][P_LEVELS];
  48 } vp_adjblock;
  49
  50 #include "modes/residue_44.h"
  51 #include "modes/psych_44.h"
  52 #include "modes/floor_44.h"
  53
  54 /* a few static coder conventions */
  55 static vorbis_info_time0 _time_dummy={0};
  56 static vorbis_info_mode _mode_set_short={0,0,0,0};
  57 static vorbis_info_mode _mode_set_long={1,0,0,1};
  58
  59 /* mapping conventions:
  60    only one submap (this would change for efficient 5.1 support for example)*/
  61 /* Four psychoacoustic profiles are used, one for each blocktype */
  62 static vorbis_info_mapping0 _mapping_set_short={
  63   1, {0,0}, {0}, {0}, {0}, {0,1}, 0,{0},{0}};
  64 static vorbis_info_mapping0 _mapping_set_long={
  65   1, {0,0}, {0}, {1}, {1}, {2,3}, 0,{0},{0}};
  66
  67 static int vorbis_encode_toplevel_init(vorbis_info *vi,int small,int large,int ch,long rate){
  68   if(vi && vi->codec_setup){
  69     codec_setup_info *ci=vi->codec_setup;
  70
  71     vi->version=0;
  72     vi->channels=ch;
  73     vi->rate=rate;
  74
  75     ci->blocksizes[0]=small;
  76     ci->blocksizes[1]=large;
  77
  78     /* time mapping hooks are unused in vorbis I */
  79     ci->times=1;
  80     ci->time_type[0]=0;
  81     ci->time_param[0]=calloc(1,sizeof(_time_dummy));
  82     memcpy(ci->time_param[0],&_time_dummy,sizeof(_time_dummy));
  83
  84     /* by convention, two modes: one for short, one for long blocks.
  85        short block mode uses mapping sero, long block uses mapping 1 */
  86     ci->modes=2;
  87     ci->mode_param[0]=calloc(1,sizeof(_mode_set_short));
  88     memcpy(ci->mode_param[0],&_mode_set_short,sizeof(_mode_set_short));
  89     ci->mode_param[1]=calloc(1,sizeof(_mode_set_long));
  90     memcpy(ci->mode_param[1],&_mode_set_long,sizeof(_mode_set_long));
  91
  92     /* by convention two mappings, both mapping type zero (polyphonic
  93        PCM), first for short, second for long blocks */
  94     ci->maps=2;
  95     ci->map_type[0]=0;
  96     ci->map_param[0]=calloc(1,sizeof(_mapping_set_short));
  97     memcpy(ci->map_param[0],&_mapping_set_short,sizeof(_mapping_set_short));
  98     ci->map_type[1]=0;
  99     ci->map_param[1]=calloc(1,sizeof(_mapping_set_long));
 100     memcpy(ci->map_param[1],&_mapping_set_long,sizeof(_mapping_set_long));
 101
 102     return(0);
 103   }
 104   return(OV_EINVAL);
 105 }
 106
 107 static int vorbis_encode_floor_init(vorbis_info *vi,double q,int block,
 108                                     static_codebook    ***books,
 109                                     vorbis_info_floor1 *in,
 110                                     ...){
 111   int x[11],i,k,iq=rint(q*10);
 112   vorbis_info_floor1 *f=calloc(1,sizeof(*f));
 113   codec_setup_info *ci=vi->codec_setup;
 114   va_list ap;
 115
 116   va_start(ap,in);
 117   for(i=0;i<11;i++)
 118     x[i]=va_arg(ap,int);
 119   va_end(ap);
 120
 121   memcpy(f,in+x[iq],sizeof(*f));
 122   /* fill in the lowpass field, even if it's temporary */
 123   f->n=ci->blocksizes[block]>>1;
 124
 125   /* books */
 126   {
 127     int partitions=f->partitions;
 128     int maxclass=-1;
 129     int maxbook=-1;
 130     for(i=0;i<partitions;i++)
 131       if(f->partitionclass[i]>maxclass)maxclass=f->partitionclass[i];
 132     for(i=0;i<=maxclass;i++){
 133       if(f->class_book[i]>maxbook)maxbook=f->class_book[i];
 134       f->class_book[i]+=ci->books;
 135       for(k=0;k<(1<<f->class_subs[i]);k++){
 136         if(f->class_subbook[i][k]>maxbook)maxbook=f->class_subbook[i][k];
 137         if(f->class_subbook[i][k]>=0)f->class_subbook[i][k]+=ci->books;
 138       }
 139     }
 140
 141     for(i=0;i<=maxbook;i++)
 142       ci->book_param[ci->books++]=books[x[iq]][i];
 143   }
 144
 145   /* for now, we're only using floor 1 */
 146   ci->floor_type[ci->floors]=1;
 147   ci->floor_param[ci->floors]=f;
 148   ci->floors++;
 149
 150   return(0);
 151 }
 152
 153 static int vorbis_encode_global_psych_init(vorbis_info *vi,double q,
 154                                            vorbis_info_psy_global *in, ...){
 155   int i,iq=q*10;
 156   double x[11],dq;
 157   codec_setup_info *ci=vi->codec_setup;
 158   vorbis_info_psy_global *g=&ci->psy_g_param;
 159   va_list ap;
 160
 161   va_start(ap,in);
 162   for(i=0;i<11;i++)
 163     x[i]=va_arg(ap,double);
 164   va_end(ap);
 165
 166   if(iq==10){
 167     iq=9;
 168     dq=1.;
 169   }else{
 170     dq=q*10.-iq;
 171   }
 172
 173   memcpy(g,in+(int)x[iq],sizeof(*g));
 174
 175   dq=x[iq]*(1.-dq)+x[iq+1]*dq;
 176   iq=(int)dq;
 177   dq-=iq;
 178   if(dq==0 && iq>0){
 179     iq--;
 180     dq=1.;
 181   }
 182
 183   /* interpolate the trigger threshholds */
 184   for(i=0;i<4;i++){
 185     g->preecho_thresh[i]=in[iq].preecho_thresh[i]*(1.-dq)+in[iq+1].preecho_thresh[i]*dq;
 186     g->postecho_thresh[i]=in[iq].postecho_thresh[i]*(1.-dq)+in[iq+1].postecho_thresh[i]*dq;
 187   }
 188   g->ampmax_att_per_sec=in[iq].ampmax_att_per_sec*(1.-dq)+in[iq+1].ampmax_att_per_sec*dq;
 189   return(0);
 190 }
 191
 192 static int vorbis_encode_psyset_init(vorbis_info *vi,double q,int block,
 193                                            vorbis_info_psy *in){
 194   int iq=q*10;
 195   double dq;
 196   codec_setup_info *ci=vi->codec_setup;
 197   vorbis_info_psy *p=ci->psy_param[block];
 198
 199   if(iq==10){
 200     iq=9;
 201     dq=1.;
 202   }else{
 203     dq=q*10.-iq;
 204   }
 205
 206   if(block>=ci->psys)
 207     ci->psys=block+1;
 208   if(!p){
 209     p=calloc(1,sizeof(*p));
 210     ci->psy_param[block]=p;
 211   }
 212
 213   memcpy(p,in+(int)(q*10.),sizeof(*p));
 214
 215   p->ath_adjatt=in[iq].ath_adjatt*(1.-dq)+in[iq+1].ath_adjatt*dq;
 216   p->ath_maxatt=in[iq].ath_maxatt*(1.-dq)+in[iq+1].ath_maxatt*dq;
 217
 218   p->tone_masteratt=in[iq].tone_masteratt*(1.-dq)+in[iq+1].tone_masteratt*dq;
 219   p->tone_guard=in[iq].tone_guard*(1.-dq)+in[iq+1].tone_guard*dq;
 220   p->tone_abs_limit=in[iq].tone_abs_limit*(1.-dq)+in[iq+1].tone_abs_limit*dq;
 221
 222   p->noisemaxsupp=in[iq].noisemaxsupp*(1.-dq)+in[iq+1].noisemaxsupp*dq;
 223
 224   return(0);
 225 }
 226
 227 static int vorbis_encode_compand_init(vorbis_info *vi,double q,int block,
 228                                            float in[][NOISE_COMPAND_LEVELS], ...){
 229   int i,iq=q*10;
 230   double x[11],dq;
 231   codec_setup_info *ci=vi->codec_setup;
 232   vorbis_info_psy *p=ci->psy_param[block];
 233   va_list ap;
 234
 235   va_start(ap,in);
 236   for(i=0;i<11;i++)
 237     x[i]=va_arg(ap,double);
 238   va_end(ap);
 239
 240   if(iq==10){
 241     iq=9;
 242     dq=1.;
 243   }else{
 244     dq=q*10.-iq;
 245   }
 246
 247   dq=x[iq]*(1.-dq)+x[iq+1]*dq;
 248   iq=(int)dq;
 249   dq-=iq;
 250   if(dq==0 && iq>0){
 251     iq--;
 252     dq=1.;
 253   }
 254
 255   /* interpolate the compander settings */
 256   for(i=0;i<NOISE_COMPAND_LEVELS;i++)
 257     p->noisecompand[i]=in[iq][i]*(1.-dq)+in[iq+1][i]*dq;
 258   return(0);
 259 }
 260
 261 static int vorbis_encode_tonemask_init(vorbis_info *vi,double q,int block,
 262                                        vp_adjblock *in){
 263   int i,j,iq=q*5.;
 264   double dq;
 265   codec_setup_info *ci=vi->codec_setup;
 266   vorbis_info_psy *p=ci->psy_param[block];
 267
 268   if(iq==5){
 269     iq=5;
 270     dq=1.;
 271   }else{
 272     dq=q*5.-iq;
 273   }
 274
 275   for(i=0;i<P_BANDS;i++)
 276     for(j=0;j<P_LEVELS;j++)
 277       p->toneatt.block[i][j]=(j<4?4:j)*-10.+
 278         in[iq].block[i][j]*(1.-dq)+in[iq+1].block[i][j]*dq;
 279   return(0);
 280 }
 281
 282 static int vorbis_encode_peak_init(vorbis_info *vi,double q,int block,
 283                                    vp_adjblock *in){
 284   int i,j,iq=q*5.;
 285   double dq;
 286   codec_setup_info *ci=vi->codec_setup;
 287   vorbis_info_psy *p=ci->psy_param[block];
 288
 289   if(iq==5){
 290     iq=5;
 291     dq=1.;
 292   }else{
 293     dq=q*5.-iq;
 294   }
 295
 296   for(i=0;i<P_BANDS;i++)
 297     for(j=0;j<P_LEVELS;j++)
 298       p->peakatt.block[i][j]=(j<4?4:j)*-10.+
 299         in[iq].block[i][j]*(1.-dq)+in[iq+1].block[i][j]*dq;
 300   return(0);
 301 }
 302
 303 static int vorbis_encode_noisebias_init(vorbis_info *vi,double q,int block,
 304                                         int in[][17],int guard[33]){
 305   int i,iq=q*10;
 306   double dq;
 307   codec_setup_info *ci=vi->codec_setup;
 308   vorbis_info_psy *p=ci->psy_param[block];
 309
 310   if(iq==10){
 311     iq=9;
 312     dq=1.;
 313   }else{
 314     dq=q*10.-iq;
 315   }
 316
 317   p->noisewindowlomin=guard[iq*3];
 318   p->noisewindowhimin=guard[iq*3+1];
 319   p->noisewindowfixed=guard[iq*3+2];
 320
 321   for(i=0;i<P_BANDS;i++)
 322     p->noiseoff[i]=in[iq][i]*(1.-dq)+in[iq+1][i]*dq;
 323   return(0);
 324 }
 325
 326 static int vorbis_encode_ath_init(vorbis_info *vi,double q,int block,
 327                                   float in[][27], ...){
 328   int i,iq=q*10;
 329   double x[11],dq;
 330   codec_setup_info *ci=vi->codec_setup;
 331   vorbis_info_psy *p=ci->psy_param[block];
 332   va_list ap;
 333
 334   va_start(ap,in);
 335   for(i=0;i<11;i++)
 336     x[i]=va_arg(ap,double);
 337   va_end(ap);
 338
 339   if(iq==10){
 340     iq=9;
 341     dq=1.;
 342   }else{
 343     dq=q*10.-iq;
 344   }
 345
 346   dq=x[iq]*(1.-dq)+x[iq+1]*dq;
 347   iq=(int)dq;
 348   dq-=iq;
 349   if(dq==0 && iq>0){
 350     iq--;
 351     dq=1.;
 352   }
 353
 354   for(i=0;i<27;i++)
 355     p->ath[i]=in[iq][i]*(1.-dq)+in[iq+1][i]*dq;
 356   return(0);
 357 }
 358
 359
 360 static int book_dup_or_new(codec_setup_info *ci,static_codebook *book){
 361   int i;
 362   for(i=0;i<ci->books;i++)
 363     if(ci->book_param[i]==book)return(i);
 364
 365   return(ci->books++);
 366 }
 367
 368 static int vorbis_encode_residue_init(vorbis_info *vi,double q,int block,
 369                                       int coupled_p,
 370                                       int stereo_backfill_p,
 371                                       int residue_backfill_p,
 372                                       vorbis_residue_template *in, ...){
 373
 374   int i,iq=q*10;
 375   int a[11];
 376   double c[11];
 377   int n,k;
 378   int partition_position;
 379   int res_position;
 380   int iterations=1;
 381   int amplitude_select=0;
 382
 383   codec_setup_info *ci=vi->codec_setup;
 384   vorbis_info_residue0 *r;
 385   vorbis_info_psy *psy=ci->psy_param[block*2];
 386   va_list ap;
 387
 388   va_start(ap,in);
 389   for(i=0;i<11;i++)
 390     a[i]=va_arg(ap,int);
 391   for(i=0;i<11;i++)
 392     c[i]=va_arg(ap,double);
 393   va_end(ap);
 394
 395   /* may be re-called due to ctl */
 396   if(ci->residue_param[block])
 397     /* free preexisting instance */
 398     residue_free_info(ci->residue_param[block],ci->residue_type[block]);
 399
 400   r=ci->residue_param[block]=malloc(sizeof(*r));
 401   memcpy(r,in[iq].res[block],sizeof(*r));
 402   if(ci->residues<=block)ci->residues=block+1;
 403
 404   if(block){
 405     r->grouping=32;
 406   }else{
 407     r->grouping=16;
 408   }
 409
 410   /* for uncoupled, we use type 1, else type 2 */
 411   if(coupled_p){
 412     ci->residue_type[block]=2;
 413   }else{
 414     ci->residue_type[block]=1;
 415   }
 416
 417   switch(ci->residue_type[block]){
 418   case 1:
 419     n=r->end=ci->blocksizes[block?1:0]>>1; /* to be adjusted by lowpass later */
 420     partition_position=rint((double)c[iq]*1000/(vi->rate/2)*n/r->grouping);
 421     res_position=partition_position*r->grouping;
 422     break;
 423   case 2:
 424     n=r->end=(ci->blocksizes[block?1:0]>>1)*vi->channels; /* to be adjusted by lowpass later */
 425     partition_position=rint((double)c[iq]*1000/(vi->rate/2)*n/r->grouping);
 426     res_position=partition_position*r->grouping/vi->channels;
 427     break;
 428   }
 429
 430   for(i=0;i<r->partitions;i++)
 431     if(r->blimit[i]<0)r->blimit[i]=partition_position;
 432
 433   for(i=0;i<r->partitions;i++)
 434     for(k=0;k<3;k++)
 435       if(in[iq].books_base[a[iq]][i][k])
 436         r->secondstages[i]|=(1<<k);
 437
 438   ci->passlimit[0]=3;
 439
 440
 441   if(coupled_p){
 442     vorbis_info_mapping0 *map=ci->map_param[block];
 443
 444     map->coupling_steps=1;
 445     map->coupling_mag[0]=0;
 446     map->coupling_ang[0]=1;
 447
 448     psy->couple_pass[0].granulem=1.;
 449     psy->couple_pass[0].igranulem=1.;
 450
 451     psy->couple_pass[0].couple_pass[0].limit=res_position;
 452     psy->couple_pass[0].couple_pass[0].outofphase_redundant_flip_p=1;
 453     psy->couple_pass[0].couple_pass[0].outofphase_requant_limit=9e10;
 454     psy->couple_pass[0].couple_pass[0].amppost_point=0;
 455     psy->couple_pass[0].couple_pass[1].limit=9999;
 456     psy->couple_pass[0].couple_pass[1].outofphase_redundant_flip_p=1;
 457     psy->couple_pass[0].couple_pass[1].outofphase_requant_limit=9e10;
 458     psy->couple_pass[0].couple_pass[1].amppost_point=stereo_threshholds[a[iq]];
 459     amplitude_select=a[iq];
 460
 461     if(stereo_backfill_p && a[iq]){
 462       memcpy(psy->couple_pass+iterations,psy->couple_pass+iterations-1,
 463              sizeof(*psy->couple_pass));
 464       amplitude_select=a[iq]-1;
 465       psy->couple_pass[1].couple_pass[1].amppost_point=stereo_threshholds[a[iq]-1];
 466       ci->passlimit[1]=4;
 467       for(i=0;i<r->partitions;i++)
 468         if(in[iq].books_stereo_backfill[a[iq]-1][i])
 469           r->secondstages[i]|=8;
 470       iterations++;
 471     }
 472
 473     if(residue_backfill_p){
 474       memcpy(psy->couple_pass+iterations,psy->couple_pass+iterations-1,
 475              sizeof(*psy->couple_pass));
 476       psy->couple_pass[iterations].granulem=.333333333;
 477       psy->couple_pass[iterations].igranulem=3.;
 478       for(i=0;i<r->partitions;i++)
 479         if(in[iq].books_residue_backfill[amplitude_select][i][0])
 480           r->secondstages[i]|=(1<<(iterations+2));
 481       ci->passlimit[iterations]=ci->passlimit[iterations-1]+1;
 482       iterations++;
 483
 484       memcpy(psy->couple_pass+iterations,psy->couple_pass+iterations-1,
 485              sizeof(*psy->couple_pass));
 486       psy->couple_pass[iterations].granulem=.1111111111;
 487       psy->couple_pass[iterations].igranulem=9.;
 488       for(i=0;i<r->partitions;i++)
 489         if(in[iq].books_residue_backfill[amplitude_select][i][1])
 490           r->secondstages[i]|=(1<<(iterations+2));
 491       ci->passlimit[iterations]=ci->passlimit[iterations-1]+1;
 492       iterations++;
 493     }
 494     ci->coupling_passes=iterations;
 495
 496   }else{
 497
 498     if(residue_backfill_p){
 499       for(i=0;i<r->partitions;i++){
 500         if(in[iq].books_residue_backfill[0][i][0])
 501           r->secondstages[i]|=8;
 502         if(in[iq].books_residue_backfill[0][i][1])
 503           r->secondstages[i]|=16;
 504       }
 505       ci->passlimit[1]=4;
 506       ci->passlimit[2]=5;
 507       ci->coupling_passes=3;
 508     }else
 509       ci->coupling_passes=1;
 510   }
 511
 512   memcpy(&ci->psy_param[block*2+1]->couple_pass,
 513          &ci->psy_param[block*2]->couple_pass,
 514          sizeof(psy->couple_pass[0]));
 515
 516   /* fill in all the books */
 517   {
 518     int booklist=0,k;
 519     r->groupbook=ci->books;
 520     ci->book_param[ci->books++]=in[iq].book_aux[block];
 521     for(i=0;i<r->partitions;i++){
 522       for(k=0;k<3;k++){
 523         if(in[iq].books_base[a[iq]][i][k]){
 524           int bookid=book_dup_or_new(ci,in[iq].books_base[a[iq]][i][k]);
 525           r->booklist[booklist++]=bookid;
 526           ci->book_param[bookid]=in[iq].books_base[a[iq]][i][k];
 527         }
 528       }
 529       if(coupled_p && stereo_backfill_p && a[iq] &&
 530          in[iq].books_stereo_backfill[a[iq]][i]){
 531         int bookid=book_dup_or_new(ci,in[iq].books_stereo_backfill[a[iq]][i]);
 532         r->booklist[booklist++]=bookid;
 533         ci->book_param[bookid]=in[iq].books_stereo_backfill[a[iq]][i];
 534       }
 535       if(residue_backfill_p){
 536         for(k=0;k<2;k++){
 537           if(in[iq].books_residue_backfill[amplitude_select][i][k]){
 538             int bookid=book_dup_or_new(ci,in[iq].books_residue_backfill[amplitude_select][i][k]);
 539             r->booklist[booklist++]=bookid;
 540             ci->book_param[bookid]=in[iq].books_residue_backfill[amplitude_select][i][k];
 541           }
 542         }
 543       }
 544     }
 545   }
 546
 547   return(0);
 548 }
 549
 550 static int vorbis_encode_lowpass_init(vorbis_info *vi,double q,int block,...){
 551   int i,iq=q*10;
 552   double x[11],dq;
 553   double freq;
 554   codec_setup_info *ci=vi->codec_setup;
 555   vorbis_info_floor1 *f=ci->floor_param[block];
 556   vorbis_info_residue0 *r=ci->residue_param[block];
 557   int blocksize=ci->blocksizes[block]>>1;
 558   double nyq=vi->rate/2.;
 559   va_list ap;
 560
 561   va_start(ap,block);
 562   for(i=0;i<11;i++)
 563     x[i]=va_arg(ap,double);
 564   va_end(ap);
 565
 566   if(iq==10){
 567     iq=9;
 568     dq=1.;
 569   }else{
 570     dq=q*10.-iq;
 571   }
 572
 573   freq=(x[iq]*(1.-dq)+x[iq+1]*dq)*1000.;
 574   if(freq>vi->rate/2)freq=vi->rate/2;
 575   /* lowpass needs to be set in the floor and the residue. */
 576
 577   /* in the floor, the granularity can be very fine; it doesn't alter
 578      the encoding structure, only the samples used to fit the floor
 579      approximation */
 580   f->n=freq/nyq*blocksize;
 581
 582   /* in the residue, we're constrained, physically, by partition
 583      boundaries.  We still lowpass 'wherever', but we have to round up
 584      here to next boundary, or the vorbis spec will round it *down* to
 585      previous boundary in encode/decode */
 586   if(ci->residue_type[block]==2)
 587     r->end=((freq/nyq*blocksize*2)/r->grouping+.9)* /* round up only if we're well past */
 588       r->grouping;
 589   else
 590     r->end=((freq/nyq*blocksize)/r->grouping+.9)* /* round up only if we're well past */
 591       r->grouping;
 592   return(0);
 593 }
 594
 595 /* encoders will need to use vorbis_info_init beforehand and call
 596    vorbis_info clear when all done */
 597
 598 int vorbis_encode_init_vbr(vorbis_info *vi,
 599                            long channels,
 600                            long rate,
 601
 602                            float base_quality /* 0. to 1. */
 603                            ){
 604   int ret=0;
 605
 606   base_quality+=.001;
 607   if(base_quality<0.)base_quality=0.;
 608   if(base_quality>.999)base_quality=.999;
 609
 610   if(rate>40000){
 611     ret|=vorbis_encode_toplevel_init(vi,256,2048,channels,rate);
 612     ret|=vorbis_encode_floor_init(vi,base_quality,0,_floor_44_128_books,_floor_44_128,
 613                                   0,1,1,2,2,2,2,2,2,2,2);
 614     ret|=vorbis_encode_floor_init(vi,base_quality,1,_floor_44_1024_books,_floor_44_1024,
 615                                   0,0,0,0,0,0,0,0,0,0,0);
 616
 617     ret|=vorbis_encode_global_psych_init(vi,base_quality,_psy_global_44,
 618                                          0., 1., 1.5, 2., 2., 2., 2., 2., 2., 2., 2.);
 619
 620     ret|=vorbis_encode_psyset_init(vi,base_quality,0,_psy_settings);
 621     ret|=vorbis_encode_psyset_init(vi,base_quality,1,_psy_settings);
 622     ret|=vorbis_encode_psyset_init(vi,base_quality,2,_psy_settings);
 623     ret|=vorbis_encode_psyset_init(vi,base_quality,3,_psy_settings);
 624
 625     ret|=vorbis_encode_tonemask_init(vi,base_quality,0,_vp_tonemask_adj_otherblock);
 626     ret|=vorbis_encode_tonemask_init(vi,base_quality,1,_vp_tonemask_adj_otherblock);
 627     ret|=vorbis_encode_tonemask_init(vi,base_quality,2,_vp_tonemask_adj_otherblock);
 628     ret|=vorbis_encode_tonemask_init(vi,base_quality,3,_vp_tonemask_adj_longblock);
 629
 630     ret|=vorbis_encode_compand_init(vi,base_quality,0,_psy_compand_44_short,
 631                                     1., 1., 1.3, 1.6, 2., 2., 2., 2., 2., 2., 2.);
 632     ret|=vorbis_encode_compand_init(vi,base_quality,1,_psy_compand_44_short,
 633                                     1., 1., 1.3, 1.6, 2., 2., 2., 2., 2., 2., 2.);
 634     ret|=vorbis_encode_compand_init(vi,base_quality,2,_psy_compand_44,
 635                                     1., 1., 1.3, 1.6, 2., 2., 2., 2., 2., 2., 2.);
 636     ret|=vorbis_encode_compand_init(vi,base_quality,3,_psy_compand_44,
 637                                     1., 1., 1.3, 1.6, 2., 2., 2., 2., 2., 2., 2.);
 638
 639     ret|=vorbis_encode_peak_init(vi,base_quality,0,_vp_peakguard);
 640     ret|=vorbis_encode_peak_init(vi,base_quality,1,_vp_peakguard);
 641     ret|=vorbis_encode_peak_init(vi,base_quality,2,_vp_peakguard);
 642     ret|=vorbis_encode_peak_init(vi,base_quality,3,_vp_peakguard);
 643
 644     ret|=vorbis_encode_noisebias_init(vi,base_quality,0,_psy_noisebias_impulse,
 645                                       _psy_noiseguards_short);
 646     ret|=vorbis_encode_noisebias_init(vi,base_quality,1,_psy_noisebias_other,
 647                                       _psy_noiseguards_short);
 648     ret|=vorbis_encode_noisebias_init(vi,base_quality,2,_psy_noisebias_other,
 649                                       _psy_noiseguards_long);
 650     ret|=vorbis_encode_noisebias_init(vi,base_quality,3,_psy_noisebias_long,
 651                                       _psy_noiseguards_long);
 652
 653     ret|=vorbis_encode_ath_init(vi,base_quality,0,ATH_Bark_dB,
 654                                 0., 0., 0., 0., .2, .5, 1., 1., 1.5, 2., 2.);
 655     ret|=vorbis_encode_ath_init(vi,base_quality,1,ATH_Bark_dB,
 656                                 0., 0., 0., 0., .2, .5, 1., 1., 1.5, 2., 2.);
 657     ret|=vorbis_encode_ath_init(vi,base_quality,2,ATH_Bark_dB,
 658                                 0., 0., 0., 0., .2, .5, 1., 1., 1.5, 2., 2.);
 659     ret|=vorbis_encode_ath_init(vi,base_quality,3,ATH_Bark_dB,
 660                                 0., 0., 0., 0., .2, .5, 1., 1., 1.5, 2., 2.);
 661
 662     if(ret){
 663       vorbis_info_clear(vi);
 664       return ret;
 665     }
 666
 667     switch(channels){
 668     case 2:
 669       /* setup specific to stereo coupling */
 670
 671       /* unmanaged, one iteration residue setup */
 672       ret|=vorbis_encode_residue_init(vi,base_quality,0,
 673                                       1, /* coupled */
 674                                       0, /* no mid stereo backfill */
 675                                       0, /* no residue backfill */
 676                                       _residue_template_44_stereo,
 677                                       4,  3,  2,  2,   1,  0,  0,  0,  0,  0,  0,
 678                                       4., 6., 6., 6., 10., 6., 6., 4., 4., 4., 4.);
 679
 680       ret|=vorbis_encode_residue_init(vi,base_quality,1,
 681                                       1, /* coupled */
 682                                       0, /* no mid stereo backfill */
 683                                       0, /* no residue backfill */
 684                                       _residue_template_44_stereo,
 685                                       4,  3,  2,   2,   1,  0,  0,  0,  0,  0,  0,
 686                                       6., 6., 6., 10., 10., 6., 6., 4., 4., 4., 4.);
 687
 688       ret|=vorbis_encode_lowpass_init(vi,base_quality,0,
 689                                       15.1,15.8,16.5,17.9,20.5,
 690                                       999.,999.,999.,999.,999.,999.);
 691       ret|=vorbis_encode_lowpass_init(vi,base_quality,1,
 692                                       15.1,15.8,16.5,17.9,20.5,
 693                                       999.,999.,999.,999.,999.,999.);
 694
 695       return(ret);
 696
 697       break;
 698     default:
 699       /* setup specific to non-stereo (mono or uncoupled polyphonic)
 700          coupling */
 701
 702       /* unmanaged, one iteration residue setup */
 703       ret|=vorbis_encode_residue_init(vi,base_quality,0,
 704                                       0, /* uncoupled */
 705                                       0, /* no mid stereo backfill */
 706                                       0, /* residue backfill */
 707                                       _residue_template_44_uncoupled,
 708                                       0,0,0,0,0,0,0,0,0,0,0,
 709                                       4.,4.,4.,6.,6.,6.,6.,4.,4.,4.,4.);
 710
 711       ret|=vorbis_encode_residue_init(vi,base_quality,1,
 712                                       0, /* uncoupled */
 713                                       0, /* no mid stereo backfill */
 714                                       0, /* residue backfill */
 715                                       _residue_template_44_uncoupled,
 716                                       0,0,0,0,0,0,0,0,0,0,0,
 717                                       4.,4.,4.,6.,6.,6.,6.,4.,4.,4.,4.);
 718
 719       ret|=vorbis_encode_lowpass_init(vi,base_quality,0,
 720                                       15.1,15.8,16.5,17.9,20.5,
 721                                       999.,999.,999.,999.,999.,999.);
 722       ret|=vorbis_encode_lowpass_init(vi,base_quality,1,
 723                                       15.1,15.8,16.5,17.9,20.5,
 724                                       999.,999.,999.,999.,999.,999.);
 725
 726       return(ret);
 727       break;
 728     }
 729     return(0);
 730   }else
 731     return(OV_EIMPL);
 732
 733   if(ret)
 734     vorbis_info_clear(vi);
 735   return(ret);
 736 }
 737
 738
 739 int vorbis_encode_init(vorbis_info *vi,
 740                        long channels,
 741                        long rate,
 742
 743                        long max_bitrate,
 744                        long nominal_bitrate,
 745                        long min_bitrate){
 746
 747   /* it's temporary while I do the merge; relax */
 748   if(rate>40000){
 749     if(nominal_bitrate>360000){
 750       return(vorbis_encode_init_vbr(vi,channels,rate, 1.));
 751     }else if(nominal_bitrate>270000){
 752       return(vorbis_encode_init_vbr(vi,channels,rate, .9));
 753     }else if(nominal_bitrate>230000){
 754       return(vorbis_encode_init_vbr(vi,channels,rate, .8));
 755     }else if(nominal_bitrate>200000){
 756       return(vorbis_encode_init_vbr(vi,channels,rate, .7));
 757     }else if(nominal_bitrate>180000){
 758       return(vorbis_encode_init_vbr(vi,channels,rate, .6));
 759     }else if(nominal_bitrate>140000){
 760       return(vorbis_encode_init_vbr(vi,channels,rate, .5));
 761     }else if(nominal_bitrate>120000){
 762       return(vorbis_encode_init_vbr(vi,channels,rate, .4));
 763     }else if(nominal_bitrate>100000){
 764       return(vorbis_encode_init_vbr(vi,channels,rate, .3));
 765     }else if(nominal_bitrate>90000){
 766       return(vorbis_encode_init_vbr(vi,channels,rate, .2));
 767     }else if(nominal_bitrate>75000){
 768       return(vorbis_encode_init_vbr(vi,channels,rate, .1));
 769     }else{
 770       return(vorbis_encode_init_vbr(vi,channels,rate, .0));
 771     }
 772   }
 773
 774   return(OV_EIMPL);
 775 }
 776
 777 int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg){
 778   return(OV_EIMPL);
 779 }
 780
 781
 782
 783
 784
 785
 786
 787