lib/vorbisenc.c

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