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