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