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_channel_p=1;
 335     p->normal_point_p=1;
 336     p->normal_start=nn_start[is];
 337     p->normal_partition=nn_partition[is];
 338     p->normal_thresh=nn_thresh[is];
 339   }
 340
 341   return;
 342 }
 343
 344 static void vorbis_encode_tonemask_setup(vorbis_info *vi,double s,int block,
 345                                          const att3 *att,
 346                                          const int  *max,
 347                                          const vp_adjblock *in){
 348   int i,is=s;
 349   double ds=s-is;
 350   codec_setup_info *ci=vi->codec_setup;
 351   vorbis_info_psy *p=ci->psy_param[block];
 352
 353   /* 0 and 2 are only used by bitmanagement, but there's no harm to always
 354      filling the values in here */
 355   p->tone_masteratt[0]=att[is].att[0]*(1.-ds)+att[is+1].att[0]*ds;
 356   p->tone_masteratt[1]=att[is].att[1]*(1.-ds)+att[is+1].att[1]*ds;
 357   p->tone_masteratt[2]=att[is].att[2]*(1.-ds)+att[is+1].att[2]*ds;
 358   p->tone_centerboost=att[is].boost*(1.-ds)+att[is+1].boost*ds;
 359   p->tone_decay=att[is].decay*(1.-ds)+att[is+1].decay*ds;
 360
 361   p->max_curve_dB=max[is]*(1.-ds)+max[is+1]*ds;
 362
 363   for(i=0;i<P_BANDS;i++)
 364     p->toneatt[i]=in[is].block[i]*(1.-ds)+in[is+1].block[i]*ds;
 365   return;
 366 }
 367
 368
 369 static void vorbis_encode_compand_setup(vorbis_info *vi,double s,int block,
 370                                         const compandblock *in,
 371                                         const double *x){
 372   int i,is=s;
 373   double ds=s-is;
 374   codec_setup_info *ci=vi->codec_setup;
 375   vorbis_info_psy *p=ci->psy_param[block];
 376
 377   ds=x[is]*(1.-ds)+x[is+1]*ds;
 378   is=(int)ds;
 379   ds-=is;
 380   if(ds==0 && is>0){
 381     is--;
 382     ds=1.;
 383   }
 384
 385   /* interpolate the compander settings */
 386   for(i=0;i<NOISE_COMPAND_LEVELS;i++)
 387     p->noisecompand[i]=in[is].data[i]*(1.-ds)+in[is+1].data[i]*ds;
 388   return;
 389 }
 390
 391 static void vorbis_encode_peak_setup(vorbis_info *vi,double s,int block,
 392                                     const int *suppress){
 393   int is=s;
 394   double ds=s-is;
 395   codec_setup_info *ci=vi->codec_setup;
 396   vorbis_info_psy *p=ci->psy_param[block];
 397
 398   p->tone_abs_limit=suppress[is]*(1.-ds)+suppress[is+1]*ds;
 399
 400   return;
 401 }
 402
 403 static void vorbis_encode_noisebias_setup(vorbis_info *vi,double s,int block,
 404                                          const int *suppress,
 405                                          const noise3 *in,
 406                                          const noiseguard *guard,
 407                                          double userbias){
 408   int i,is=s,j;
 409   double ds=s-is;
 410   codec_setup_info *ci=vi->codec_setup;
 411   vorbis_info_psy *p=ci->psy_param[block];
 412
 413   p->noisemaxsupp=suppress[is]*(1.-ds)+suppress[is+1]*ds;
 414   p->noisewindowlomin=guard[block].lo;
 415   p->noisewindowhimin=guard[block].hi;
 416   p->noisewindowfixed=guard[block].fixed;
 417
 418   for(j=0;j<P_NOISECURVES;j++)
 419     for(i=0;i<P_BANDS;i++)
 420       p->noiseoff[j][i]=in[is].data[j][i]*(1.-ds)+in[is+1].data[j][i]*ds;
 421
 422   /* impulse blocks may take a user specified bias to boost the
 423      nominal/high noise encoding depth */
 424   for(j=0;j<P_NOISECURVES;j++){
 425     float min=p->noiseoff[j][0]+6; /* the lowest it can go */
 426     for(i=0;i<P_BANDS;i++){
 427       p->noiseoff[j][i]+=userbias;
 428       if(p->noiseoff[j][i]<min)p->noiseoff[j][i]=min;
 429     }
 430   }
 431
 432   return;
 433 }
 434
 435 static void vorbis_encode_ath_setup(vorbis_info *vi,int block){
 436   codec_setup_info *ci=vi->codec_setup;
 437   vorbis_info_psy *p=ci->psy_param[block];
 438
 439   p->ath_adjatt=ci->hi.ath_floating_dB;
 440   p->ath_maxatt=ci->hi.ath_absolute_dB;
 441   return;
 442 }
 443
 444
 445 static int book_dup_or_new(codec_setup_info *ci,const static_codebook *book){
 446   int i;
 447   for(i=0;i<ci->books;i++)
 448     if(ci->book_param[i]==book)return(i);
 449
 450   return(ci->books++);
 451 }
 452
 453 static void vorbis_encode_blocksize_setup(vorbis_info *vi,double s,
 454                                          const int *shortb,const int *longb){
 455
 456   codec_setup_info *ci=vi->codec_setup;
 457   int is=s;
 458
 459   int blockshort=shortb[is];
 460   int blocklong=longb[is];
 461   ci->blocksizes[0]=blockshort;
 462   ci->blocksizes[1]=blocklong;
 463
 464 }
 465
 466 static void vorbis_encode_residue_setup(vorbis_info *vi,
 467                                         int number, int block,
 468                                         const vorbis_residue_template *res){
 469
 470   codec_setup_info *ci=vi->codec_setup;
 471   int i,n;
 472
 473   vorbis_info_residue0 *r=ci->residue_param[number]=
 474     _ogg_malloc(sizeof(*r));
 475
 476   memcpy(r,res->res,sizeof(*r));
 477   if(ci->residues<=number)ci->residues=number+1;
 478
 479   switch(ci->blocksizes[block]){
 480   case 64:case 128:case 256:
 481     r->grouping=16;
 482     break;
 483   default:
 484     r->grouping=32;
 485     break;
 486   }
 487   ci->residue_type[number]=res->res_type;
 488
 489   /* to be adjusted by lowpass/pointlimit later */
 490   n=r->end=ci->blocksizes[block]>>1;
 491   if(res->res_type==2)
 492     n=r->end*=vi->channels;
 493
 494   /* fill in all the books */
 495   {
 496     int booklist=0,k;
 497
 498     if(ci->hi.managed){
 499       for(i=0;i<r->partitions;i++)
 500         for(k=0;k<3;k++)
 501           if(res->books_base_managed->books[i][k])
 502             r->secondstages[i]|=(1<<k);
 503
 504       r->groupbook=book_dup_or_new(ci,res->book_aux_managed);
 505       ci->book_param[r->groupbook]=(static_codebook *)res->book_aux_managed;
 506
 507       for(i=0;i<r->partitions;i++){
 508         for(k=0;k<3;k++){
 509           if(res->books_base_managed->books[i][k]){
 510             int bookid=book_dup_or_new(ci,res->books_base_managed->books[i][k]);
 511             r->booklist[booklist++]=bookid;
 512             ci->book_param[bookid]=(static_codebook *)res->books_base_managed->books[i][k];
 513           }
 514         }
 515       }
 516
 517     }else{
 518
 519       for(i=0;i<r->partitions;i++)
 520         for(k=0;k<3;k++)
 521           if(res->books_base->books[i][k])
 522             r->secondstages[i]|=(1<<k);
 523
 524       r->groupbook=book_dup_or_new(ci,res->book_aux);
 525       ci->book_param[r->groupbook]=(static_codebook *)res->book_aux;
 526
 527       for(i=0;i<r->partitions;i++){
 528         for(k=0;k<3;k++){
 529           if(res->books_base->books[i][k]){
 530             int bookid=book_dup_or_new(ci,res->books_base->books[i][k]);
 531             r->booklist[booklist++]=bookid;
 532             ci->book_param[bookid]=(static_codebook *)res->books_base->books[i][k];
 533           }
 534         }
 535       }
 536     }
 537   }
 538
 539   /* lowpass setup/pointlimit */
 540   {
 541     double freq=ci->hi.lowpass_kHz*1000.;
 542     vorbis_info_floor1 *f=ci->floor_param[block]; /* by convention */
 543     double nyq=vi->rate/2.;
 544     long blocksize=ci->blocksizes[block]>>1;
 545
 546     /* lowpass needs to be set in the floor and the residue. */
 547     if(freq>nyq)freq=nyq;
 548     /* in the floor, the granularity can be very fine; it doesn't alter
 549        the encoding structure, only the samples used to fit the floor
 550        approximation */
 551     f->n=freq/nyq*blocksize;
 552
 553     /* this res may by limited by the maximum pointlimit of the mode,
 554        not the lowpass. the floor is always lowpass limited. */
 555     switch(res->limit_type){
 556     case 1: /* point stereo limited */
 557       if(ci->hi.managed)
 558         freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS-1]*1000.;
 559       else
 560         freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS/2]*1000.;
 561       if(freq>nyq)freq=nyq;
 562       break;
 563     case 2: /* LFE channel; lowpass at ~ 250Hz */
 564       freq=250;
 565       break;
 566     default:
 567       /* already set */
 568       break;
 569     }
 570
 571     /* in the residue, we're constrained, physically, by partition
 572        boundaries.  We still lowpass 'wherever', but we have to round up
 573        here to next boundary, or the vorbis spec will round it *down* to
 574        previous boundary in encode/decode */
 575     if(ci->residue_type[block]==2)
 576       r->end=(int)((freq/nyq*blocksize*2)/r->grouping+.9)* /* round up only if we're well past */
 577         r->grouping;
 578     else
 579       r->end=(int)((freq/nyq*blocksize)/r->grouping+.9)* /* round up only if we're well past */
 580         r->grouping;
 581     if(r->end==0)r->end=r->grouping; /* LFE channel */
 582   }
 583 }
 584
 585 /* we assume two maps in this encoder */
 586 static void vorbis_encode_map_n_res_setup(vorbis_info *vi,double s,
 587                                           const vorbis_mapping_template *maps){
 588
 589   codec_setup_info *ci=vi->codec_setup;
 590   int i,j,is=s,modes=2;
 591   const vorbis_info_mapping0 *map=maps[is].map;
 592   const vorbis_info_mode *mode=_mode_template;
 593   const vorbis_residue_template *res=maps[is].res;
 594
 595   if(ci->blocksizes[0]==ci->blocksizes[1])modes=1;
 596
 597   for(i=0;i<modes;i++){
 598
 599     ci->map_param[i]=_ogg_calloc(1,sizeof(*map));
 600     ci->mode_param[i]=_ogg_calloc(1,sizeof(*mode));
 601
 602     memcpy(ci->mode_param[i],mode+i,sizeof(*_mode_template));
 603     if(i>=ci->modes)ci->modes=i+1;
 604
 605     ci->map_type[i]=0;
 606     memcpy(ci->map_param[i],map+i,sizeof(*map));
 607     if(i>=ci->maps)ci->maps=i+1;
 608
 609     for(j=0;j<map[i].submaps;j++)
 610       vorbis_encode_residue_setup(vi,map[i].residuesubmap[j],i
 611                                   ,res+map[i].residuesubmap[j]);
 612   }
 613 }
 614
 615 static double setting_to_approx_bitrate(vorbis_info *vi){
 616   codec_setup_info *ci=vi->codec_setup;
 617   highlevel_encode_setup *hi=&ci->hi;
 618   ve_setup_data_template *setup=(ve_setup_data_template *)hi->setup;
 619   int is=hi->base_setting;
 620   double ds=hi->base_setting-is;
 621   int ch=vi->channels;
 622   const double *r=setup->rate_mapping;
 623
 624   if(r==NULL)
 625     return(-1);
 626
 627   return((r[is]*(1.-ds)+r[is+1]*ds)*ch);
 628 }
 629
 630 static void get_setup_template(vorbis_info *vi,
 631                                long ch,long srate,
 632                                double req,int q_or_bitrate){
 633   int i=0,j;
 634   codec_setup_info *ci=vi->codec_setup;
 635   highlevel_encode_setup *hi=&ci->hi;
 636   if(q_or_bitrate)req/=ch;
 637
 638   while(setup_list[i]){
 639     if(setup_list[i]->coupling_restriction==-1 ||
 640        setup_list[i]->coupling_restriction==ch){
 641       if(srate>=setup_list[i]->samplerate_min_restriction &&
 642          srate<=setup_list[i]->samplerate_max_restriction){
 643         int mappings=setup_list[i]->mappings;
 644         const double *map=(q_or_bitrate?
 645                      setup_list[i]->rate_mapping:
 646                      setup_list[i]->quality_mapping);
 647
 648         /* the template matches.  Does the requested quality mode
 649            fall within this template's modes? */
 650         if(req<map[0]){++i;continue;}
 651         if(req>map[setup_list[i]->mappings]){++i;continue;}
 652         for(j=0;j<mappings;j++)
 653           if(req>=map[j] && req<map[j+1])break;
 654         /* an all-points match */
 655         hi->setup=setup_list[i];
 656         if(j==mappings)
 657           hi->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           hi->base_setting=j+del;
 663         }
 664
 665         return;
 666       }
 667     }
 668     i++;
 669   }
 670
 671   hi->setup=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(!hi->impulse_block_p)i0=1;
 689
 690   /* too low/high an ATH floater is nonsensical, but doesn't break anything */
 691   if(hi->ath_floating_dB>-80)hi->ath_floating_dB=-80;
 692   if(hi->ath_floating_dB<-200)hi->ath_floating_dB=-200;
 693
 694   /* again, bound this to avoid the app shooting itself int he foot
 695      too badly */
 696   if(hi->amplitude_track_dBpersec>0.)hi->amplitude_track_dBpersec=0.;
 697   if(hi->amplitude_track_dBpersec<-99999.)hi->amplitude_track_dBpersec=-99999.;
 698
 699   /* get the appropriate setup template; matches the fetch in previous
 700      stages */
 701   setup=(ve_setup_data_template *)hi->setup;
 702   if(setup==NULL)return(OV_EINVAL);
 703
 704   hi->set_in_stone=1;
 705   /* choose block sizes from configured sizes as well as paying
 706      attention to long_block_p and short_block_p.  If the configured
 707      short and long blocks are the same length, we set long_block_p
 708      and unset short_block_p */
 709   vorbis_encode_blocksize_setup(vi,hi->base_setting,
 710                                 setup->blocksize_short,
 711                                 setup->blocksize_long);
 712   if(ci->blocksizes[0]==ci->blocksizes[1])singleblock=1;
 713
 714   /* floor setup; choose proper floor params.  Allocated on the floor
 715      stack in order; if we alloc only a single long floor, it's 0 */
 716   for(i=0;i<setup->floor_mappings;i++)
 717     vorbis_encode_floor_setup(vi,hi->base_setting,
 718                               setup->floor_books,
 719                               setup->floor_params,
 720                               setup->floor_mapping_list[i]);
 721
 722   /* setup of [mostly] short block detection and stereo*/
 723   vorbis_encode_global_psych_setup(vi,hi->trigger_setting,
 724                                    setup->global_params,
 725                                    setup->global_mapping);
 726   vorbis_encode_global_stereo(vi,hi,setup->stereo_modes);
 727
 728   /* basic psych setup and noise normalization */
 729   vorbis_encode_psyset_setup(vi,hi->base_setting,
 730                              setup->psy_noise_normal_start[0],
 731                              setup->psy_noise_normal_partition[0],
 732                              setup->psy_noise_normal_thresh,
 733                              0);
 734   vorbis_encode_psyset_setup(vi,hi->base_setting,
 735                              setup->psy_noise_normal_start[0],
 736                              setup->psy_noise_normal_partition[0],
 737                              setup->psy_noise_normal_thresh,
 738                              1);
 739   if(!singleblock){
 740     vorbis_encode_psyset_setup(vi,hi->base_setting,
 741                                setup->psy_noise_normal_start[1],
 742                                setup->psy_noise_normal_partition[1],
 743                                     setup->psy_noise_normal_thresh,
 744                                2);
 745     vorbis_encode_psyset_setup(vi,hi->base_setting,
 746                                setup->psy_noise_normal_start[1],
 747                                setup->psy_noise_normal_partition[1],
 748                                setup->psy_noise_normal_thresh,
 749                                3);
 750   }
 751
 752   /* tone masking setup */
 753   vorbis_encode_tonemask_setup(vi,hi->block[i0].tone_mask_setting,0,
 754                                setup->psy_tone_masteratt,
 755                                setup->psy_tone_0dB,
 756                                setup->psy_tone_adj_impulse);
 757   vorbis_encode_tonemask_setup(vi,hi->block[1].tone_mask_setting,1,
 758                                setup->psy_tone_masteratt,
 759                                setup->psy_tone_0dB,
 760                                setup->psy_tone_adj_other);
 761   if(!singleblock){
 762     vorbis_encode_tonemask_setup(vi,hi->block[2].tone_mask_setting,2,
 763                                  setup->psy_tone_masteratt,
 764                                  setup->psy_tone_0dB,
 765                                  setup->psy_tone_adj_other);
 766     vorbis_encode_tonemask_setup(vi,hi->block[3].tone_mask_setting,3,
 767                                  setup->psy_tone_masteratt,
 768                                  setup->psy_tone_0dB,
 769                                  setup->psy_tone_adj_long);
 770   }
 771
 772   /* noise companding setup */
 773   vorbis_encode_compand_setup(vi,hi->block[i0].noise_compand_setting,0,
 774                               setup->psy_noise_compand,
 775                               setup->psy_noise_compand_short_mapping);
 776   vorbis_encode_compand_setup(vi,hi->block[1].noise_compand_setting,1,
 777                               setup->psy_noise_compand,
 778                               setup->psy_noise_compand_short_mapping);
 779   if(!singleblock){
 780     vorbis_encode_compand_setup(vi,hi->block[2].noise_compand_setting,2,
 781                                 setup->psy_noise_compand,
 782                                 setup->psy_noise_compand_long_mapping);
 783     vorbis_encode_compand_setup(vi,hi->block[3].noise_compand_setting,3,
 784                                 setup->psy_noise_compand,
 785                                 setup->psy_noise_compand_long_mapping);
 786   }
 787
 788   /* peak guarding setup  */
 789   vorbis_encode_peak_setup(vi,hi->block[i0].tone_peaklimit_setting,0,
 790                            setup->psy_tone_dBsuppress);
 791   vorbis_encode_peak_setup(vi,hi->block[1].tone_peaklimit_setting,1,
 792                            setup->psy_tone_dBsuppress);
 793   if(!singleblock){
 794     vorbis_encode_peak_setup(vi,hi->block[2].tone_peaklimit_setting,2,
 795                              setup->psy_tone_dBsuppress);
 796     vorbis_encode_peak_setup(vi,hi->block[3].tone_peaklimit_setting,3,
 797                              setup->psy_tone_dBsuppress);
 798   }
 799
 800   /* noise bias setup */
 801   vorbis_encode_noisebias_setup(vi,hi->block[i0].noise_bias_setting,0,
 802                                 setup->psy_noise_dBsuppress,
 803                                 setup->psy_noise_bias_impulse,
 804                                 setup->psy_noiseguards,
 805                                 (i0==0?hi->impulse_noisetune:0.));
 806   vorbis_encode_noisebias_setup(vi,hi->block[1].noise_bias_setting,1,
 807                                 setup->psy_noise_dBsuppress,
 808                                 setup->psy_noise_bias_padding,
 809                                 setup->psy_noiseguards,0.);
 810   if(!singleblock){
 811     vorbis_encode_noisebias_setup(vi,hi->block[2].noise_bias_setting,2,
 812                                   setup->psy_noise_dBsuppress,
 813                                   setup->psy_noise_bias_trans,
 814                                   setup->psy_noiseguards,0.);
 815     vorbis_encode_noisebias_setup(vi,hi->block[3].noise_bias_setting,3,
 816                                   setup->psy_noise_dBsuppress,
 817                                   setup->psy_noise_bias_long,
 818                                   setup->psy_noiseguards,0.);
 819   }
 820
 821   vorbis_encode_ath_setup(vi,0);
 822   vorbis_encode_ath_setup(vi,1);
 823   if(!singleblock){
 824     vorbis_encode_ath_setup(vi,2);
 825     vorbis_encode_ath_setup(vi,3);
 826   }
 827
 828   vorbis_encode_map_n_res_setup(vi,hi->base_setting,setup->maps);
 829
 830   /* set bitrate readonlies and management */
 831   if(hi->bitrate_av>0)
 832     vi->bitrate_nominal=hi->bitrate_av;
 833   else{
 834     vi->bitrate_nominal=setting_to_approx_bitrate(vi);
 835   }
 836
 837   vi->bitrate_lower=hi->bitrate_min;
 838   vi->bitrate_upper=hi->bitrate_max;
 839   if(hi->bitrate_av)
 840     vi->bitrate_window=(double)hi->bitrate_reservoir/hi->bitrate_av;
 841   else
 842     vi->bitrate_window=0.;
 843
 844   if(hi->managed){
 845     ci->bi.avg_rate=hi->bitrate_av;
 846     ci->bi.min_rate=hi->bitrate_min;
 847     ci->bi.max_rate=hi->bitrate_max;
 848
 849     ci->bi.reservoir_bits=hi->bitrate_reservoir;
 850     ci->bi.reservoir_bias=
 851       hi->bitrate_reservoir_bias;
 852
 853     ci->bi.slew_damp=hi->bitrate_av_damp;
 854
 855   }
 856
 857   return(0);
 858
 859 }
 860
 861 static int vorbis_encode_setup_setting(vorbis_info *vi,
 862                                        long  channels,
 863                                        long  rate){
 864   int ret=0,i,is;
 865   codec_setup_info *ci=vi->codec_setup;
 866   highlevel_encode_setup *hi=&ci->hi;
 867   const ve_setup_data_template *setup=hi->setup;
 868   double ds;
 869
 870   ret=vorbis_encode_toplevel_setup(vi,channels,rate);
 871   if(ret)return(ret);
 872
 873   is=hi->base_setting;
 874   ds=hi->base_setting-is;
 875
 876   hi->managed=0;
 877
 878   hi->impulse_block_p=1;
 879   hi->noise_normalize_p=1;
 880
 881   hi->stereo_point_setting=hi->base_setting;
 882   hi->lowpass_kHz=
 883     setup->psy_lowpass[is]*(1.-ds)+setup->psy_lowpass[is+1]*ds;
 884
 885   hi->ath_floating_dB=setup->psy_ath_float[is]*(1.-ds)+
 886     setup->psy_ath_float[is+1]*ds;
 887   hi->ath_absolute_dB=setup->psy_ath_abs[is]*(1.-ds)+
 888     setup->psy_ath_abs[is+1]*ds;
 889
 890   hi->amplitude_track_dBpersec=-6.;
 891   hi->trigger_setting=hi->base_setting;
 892
 893   for(i=0;i<4;i++){
 894     hi->block[i].tone_mask_setting=hi->base_setting;
 895     hi->block[i].tone_peaklimit_setting=hi->base_setting;
 896     hi->block[i].noise_bias_setting=hi->base_setting;
 897     hi->block[i].noise_compand_setting=hi->base_setting;
 898   }
 899
 900   return(ret);
 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   get_setup_template(vi,channels,rate,quality,0);
 914   if(!hi->setup)return OV_EIMPL;
 915
 916   return vorbis_encode_setup_setting(vi,channels,rate);
 917 }
 918
 919 int vorbis_encode_init_vbr(vorbis_info *vi,
 920                            long channels,
 921                            long rate,
 922
 923                            float base_quality /* 0. to 1. */
 924                            ){
 925   int ret=0;
 926
 927   ret=vorbis_encode_setup_vbr(vi,channels,rate,base_quality);
 928
 929   if(ret){
 930     vorbis_info_clear(vi);
 931     return ret;
 932   }
 933   ret=vorbis_encode_setup_init(vi);
 934   if(ret)
 935     vorbis_info_clear(vi);
 936   return(ret);
 937 }
 938
 939 int vorbis_encode_setup_managed(vorbis_info *vi,
 940                                 long channels,
 941                                 long rate,
 942
 943                                 long max_bitrate,
 944                                 long nominal_bitrate,
 945                                 long min_bitrate){
 946
 947   codec_setup_info *ci=vi->codec_setup;
 948   highlevel_encode_setup *hi=&ci->hi;
 949   double tnominal=nominal_bitrate;
 950   int ret=0;
 951
 952   if(nominal_bitrate<=0.){
 953     if(max_bitrate>0.){
 954       if(min_bitrate>0.)
 955         nominal_bitrate=(max_bitrate+min_bitrate)*.5;
 956       else
 957         nominal_bitrate=max_bitrate*.875;
 958     }else{
 959       if(min_bitrate>0.){
 960         nominal_bitrate=min_bitrate;
 961       }else{
 962         return(OV_EINVAL);
 963       }
 964     }
 965   }
 966
 967   get_setup_template(vi,channels,rate,nominal_bitrate,1);
 968   if(!hi->setup)return OV_EIMPL;
 969
 970   ret=vorbis_encode_setup_setting(vi,channels,rate);
 971   if(ret){
 972     vorbis_info_clear(vi);
 973     return ret;
 974   }
 975
 976   /* initialize management with sane defaults */
 977   hi->managed=1;
 978   hi->bitrate_min=min_bitrate;
 979   hi->bitrate_max=max_bitrate;
 980   hi->bitrate_av=tnominal;
 981   hi->bitrate_av_damp=1.5f; /* full range in no less than 1.5 second */
 982   hi->bitrate_reservoir=nominal_bitrate*2;
 983   hi->bitrate_reservoir_bias=.1; /* bias toward hoarding bits */
 984
 985   return(ret);
 986
 987 }
 988
 989 int vorbis_encode_init(vorbis_info *vi,
 990                        long channels,
 991                        long rate,
 992
 993                        long max_bitrate,
 994                        long nominal_bitrate,
 995                        long min_bitrate){
 996
 997   int ret=vorbis_encode_setup_managed(vi,channels,rate,
 998                                       max_bitrate,
 999                                       nominal_bitrate,
1000                                       min_bitrate);
1001   if(ret){
1002     vorbis_info_clear(vi);
1003     return(ret);
1004   }
1005
1006   ret=vorbis_encode_setup_init(vi);
1007   if(ret)
1008     vorbis_info_clear(vi);
1009   return(ret);
1010 }
1011
1012 int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg){
1013   if(vi){
1014     codec_setup_info *ci=vi->codec_setup;
1015     highlevel_encode_setup *hi=&ci->hi;
1016     int setp=(number&0xf); /* a read request has a low nibble of 0 */
1017
1018     if(setp && hi->set_in_stone)return(OV_EINVAL);
1019
1020     switch(number){
1021
1022     /* now deprecated *****************/
1023     case OV_ECTL_RATEMANAGE_GET:
1024       {
1025
1026         struct ovectl_ratemanage_arg *ai=
1027           (struct ovectl_ratemanage_arg *)arg;
1028
1029         ai->management_active=hi->managed;
1030         ai->bitrate_hard_window=ai->bitrate_av_window=
1031           (double)hi->bitrate_reservoir/vi->rate;
1032         ai->bitrate_av_window_center=1.;
1033         ai->bitrate_hard_min=hi->bitrate_min;
1034         ai->bitrate_hard_max=hi->bitrate_max;
1035         ai->bitrate_av_lo=hi->bitrate_av;
1036         ai->bitrate_av_hi=hi->bitrate_av;
1037
1038       }
1039       return(0);
1040
1041     /* now deprecated *****************/
1042     case OV_ECTL_RATEMANAGE_SET:
1043       {
1044         struct ovectl_ratemanage_arg *ai=
1045           (struct ovectl_ratemanage_arg *)arg;
1046         if(ai==NULL){
1047           hi->managed=0;
1048         }else{
1049           hi->managed=ai->management_active;
1050           vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_AVG,arg);
1051           vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_HARD,arg);
1052         }
1053       }
1054       return 0;
1055
1056     /* now deprecated *****************/
1057     case OV_ECTL_RATEMANAGE_AVG:
1058       {
1059         struct ovectl_ratemanage_arg *ai=
1060           (struct ovectl_ratemanage_arg *)arg;
1061         if(ai==NULL){
1062           hi->bitrate_av=0;
1063         }else{
1064           hi->bitrate_av=(ai->bitrate_av_lo+ai->bitrate_av_hi)*.5;
1065         }
1066       }
1067       return(0);
1068     /* now deprecated *****************/
1069     case OV_ECTL_RATEMANAGE_HARD:
1070       {
1071         struct ovectl_ratemanage_arg *ai=
1072           (struct ovectl_ratemanage_arg *)arg;
1073         if(ai==NULL){
1074           hi->bitrate_min=0;
1075           hi->bitrate_max=0;
1076         }else{
1077           hi->bitrate_min=ai->bitrate_hard_min;
1078           hi->bitrate_max=ai->bitrate_hard_max;
1079           hi->bitrate_reservoir=ai->bitrate_hard_window*
1080             (hi->bitrate_max+hi->bitrate_min)*.5;
1081         }
1082         if(hi->bitrate_reservoir<128.)
1083           hi->bitrate_reservoir=128.;
1084       }
1085       return(0);
1086
1087       /* replacement ratemanage interface */
1088     case OV_ECTL_RATEMANAGE2_GET:
1089       {
1090         struct ovectl_ratemanage2_arg *ai=
1091           (struct ovectl_ratemanage2_arg *)arg;
1092         if(ai==NULL)return OV_EINVAL;
1093
1094         ai->management_active=hi->managed;
1095         ai->bitrate_limit_min_kbps=hi->bitrate_min/1000;
1096         ai->bitrate_limit_max_kbps=hi->bitrate_max/1000;
1097         ai->bitrate_average_kbps=hi->bitrate_av/1000;
1098         ai->bitrate_average_damping=hi->bitrate_av_damp;
1099         ai->bitrate_limit_reservoir_bits=hi->bitrate_reservoir;
1100         ai->bitrate_limit_reservoir_bias=hi->bitrate_reservoir_bias;
1101       }
1102       return (0);
1103     case OV_ECTL_RATEMANAGE2_SET:
1104       {
1105         struct ovectl_ratemanage2_arg *ai=
1106           (struct ovectl_ratemanage2_arg *)arg;
1107         if(ai==NULL){
1108           hi->managed=0;
1109         }else{
1110           /* sanity check; only catch invariant violations */
1111           if(ai->bitrate_limit_min_kbps>0 &&
1112              ai->bitrate_average_kbps>0 &&
1113              ai->bitrate_limit_min_kbps>ai->bitrate_average_kbps)
1114             return OV_EINVAL;
1115
1116           if(ai->bitrate_limit_max_kbps>0 &&
1117              ai->bitrate_average_kbps>0 &&
1118              ai->bitrate_limit_max_kbps<ai->bitrate_average_kbps)
1119             return OV_EINVAL;
1120
1121           if(ai->bitrate_limit_min_kbps>0 &&
1122              ai->bitrate_limit_max_kbps>0 &&
1123              ai->bitrate_limit_min_kbps>ai->bitrate_limit_max_kbps)
1124             return OV_EINVAL;
1125
1126           if(ai->bitrate_average_damping <= 0.)
1127             return OV_EINVAL;
1128
1129           if(ai->bitrate_limit_reservoir_bits < 0)
1130             return OV_EINVAL;
1131
1132           if(ai->bitrate_limit_reservoir_bias < 0.)
1133             return OV_EINVAL;
1134
1135           if(ai->bitrate_limit_reservoir_bias > 1.)
1136             return OV_EINVAL;
1137
1138           hi->managed=ai->management_active;
1139           hi->bitrate_min=ai->bitrate_limit_min_kbps * 1000;
1140           hi->bitrate_max=ai->bitrate_limit_max_kbps * 1000;
1141           hi->bitrate_av=ai->bitrate_average_kbps * 1000;
1142           hi->bitrate_av_damp=ai->bitrate_average_damping;
1143           hi->bitrate_reservoir=ai->bitrate_limit_reservoir_bits;
1144           hi->bitrate_reservoir_bias=ai->bitrate_limit_reservoir_bias;
1145         }
1146       }
1147       return 0;
1148
1149     case OV_ECTL_LOWPASS_GET:
1150       {
1151         double *farg=(double *)arg;
1152         *farg=hi->lowpass_kHz;
1153       }
1154       return(0);
1155     case OV_ECTL_LOWPASS_SET:
1156       {
1157         double *farg=(double *)arg;
1158         hi->lowpass_kHz=*farg;
1159
1160         if(hi->lowpass_kHz<2.)hi->lowpass_kHz=2.;
1161         if(hi->lowpass_kHz>99.)hi->lowpass_kHz=99.;
1162       }
1163       return(0);
1164     case OV_ECTL_IBLOCK_GET:
1165       {
1166         double *farg=(double *)arg;
1167         *farg=hi->impulse_noisetune;
1168       }
1169       return(0);
1170     case OV_ECTL_IBLOCK_SET:
1171       {
1172         double *farg=(double *)arg;
1173         hi->impulse_noisetune=*farg;
1174
1175         if(hi->impulse_noisetune>0.)hi->impulse_noisetune=0.;
1176         if(hi->impulse_noisetune<-15.)hi->impulse_noisetune=-15.;
1177       }
1178       return(0);
1179     }
1180
1181
1182     return(OV_EIMPL);
1183   }
1184   return(OV_EINVAL);
1185 }