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