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