X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=lib%2Fbitrate.c;h=e261bb1737ac57187485def1823a9ade858729d9;hb=e5b1378996dba3ea82fb35403cb1f0bbff19495c;hp=0404b82532a9ce01d6f7fda1e31dfb6a6bcba1cd;hpb=a2a3bd3e6ddb745d9b0bea2dcae9759ed293bc8a;p=platform%2Fupstream%2Flibvorbis.git diff --git a/lib/bitrate.c b/lib/bitrate.c index 0404b82..e261bb1 100644 --- a/lib/bitrate.c +++ b/lib/bitrate.c @@ -5,17 +5,16 @@ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * - * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 * - * by the XIPHOPHORUS Company http://www.xiph.org/ * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 * + * by the Xiph.Org Foundation http://www.xiph.org/ * * * ******************************************************************** function: bitrate tracking and management - last mod: $Id: bitrate.c,v 1.21 2002/10/11 11:14:41 xiphmont Exp $ + last mod: $Id$ ********************************************************************/ -#include #include #include #include @@ -26,506 +25,229 @@ #include "misc.h" #include "bitrate.h" +/* compute bitrate tracking setup */ +void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){ + codec_setup_info *ci=vi->codec_setup; + bitrate_manager_info *bi=&ci->bi; -static long BINBYTES(bitrate_manager_state *bm,long pos,long bin){ - int bins=bm->queue_bins; - return(bm->queue_binned[pos*bins+bin]); -} - -#define LIMITBYTES(pos,bin) (bm->minmax_binstack[(pos)*bins*2+((bin)+bins)]) - -static long LACING_ADJUST(long bytes){ - int addto=bytes/255+1; - return(bytes+addto); -} - -static int floater_interpolate(bitrate_manager_state *bm,vorbis_info *vi, - double desired_rate){ - int bin=rint(bm->avgfloat); - double lobitrate,hibitrate; - + memset(bm,0,sizeof(*bm)); - lobitrate=(double)(bm->avg_binacc[bin]*8)/bm->avg_sampleacc*vi->rate; - while(lobitrate>desired_rate && bin>0){ - bin--; - lobitrate=(double)(bm->avg_binacc[bin]*8)/bm->avg_sampleacc*vi->rate; - } + if(bi && (bi->reservoir_bits>0)){ + long ratesamples=vi->rate; + int halfsamples=ci->blocksizes[0]>>1; - if(bin+1queue_bins){ - hibitrate=(double)(bm->avg_binacc[bin+1]*8)/bm->avg_sampleacc*vi->rate; - if(fabs(hibitrate-desired_rate) < fabs(lobitrate-desired_rate))bin++; - } - return(bin); -} + bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0]; + bm->managed=1; -/* try out a new limit */ -static long limit_sum(bitrate_manager_state *bm,int limit){ - int i=bm->minmax_stackptr; - long acc=bm->minmax_acctotal; - long bins=bm->queue_bins; - - acc-=LIMITBYTES(i,0); - acc+=LIMITBYTES(i,limit); - - while(i-->0){ - if(bm->minmax_limitstack[i]<=limit)break; - acc-=LIMITBYTES(i,bm->minmax_limitstack[i]); - acc+=LIMITBYTES(i,limit); - } - return(acc); -} + bm->avg_bitsper= rint(1.*bi->avg_rate*halfsamples/ratesamples); + bm->min_bitsper= rint(1.*bi->min_rate*halfsamples/ratesamples); + bm->max_bitsper= rint(1.*bi->max_rate*halfsamples/ratesamples); -/* compute bitrate tracking setup, allocate circular packet size queue */ -void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){ - int i; - codec_setup_info *ci=vi->codec_setup; - bitrate_manager_info *bi=&ci->bi; - long maxlatency; + bm->avgfloat=PACKETBLOBS/2; - memset(bm,0,sizeof(*bm)); - - if(bi){ - - bm->avg_sampledesired=bi->queue_avg_time*vi->rate; - bm->avg_centerdesired=bi->queue_avg_time*vi->rate*bi->queue_avg_center; - bm->minmax_sampledesired=bi->queue_minmax_time*vi->rate; - - /* first find the max possible needed queue size */ - maxlatency=max(bm->avg_sampledesired-bm->avg_centerdesired, - bm->minmax_sampledesired)+bm->avg_centerdesired; - - if(maxlatency>0 && - (bi->queue_avgmin>0 || bi->queue_avgmax>0 || bi->queue_hardmax>0 || - bi->queue_hardmin>0)){ - long maxpackets=maxlatency/(ci->blocksizes[0]>>1)+3; - long bins=PACKETBLOBS; - - bm->queue_size=maxpackets; - bm->queue_bins=bins; - bm->queue_binned=_ogg_calloc(maxpackets,bins*sizeof(*bm->queue_binned)); - bm->queue_actual=_ogg_calloc(maxpackets,sizeof(*bm->queue_actual)); - - if((bi->queue_avgmin>0 || bi->queue_avgmax>0) && - bi->queue_avg_time>0){ - - bm->avg_binacc=_ogg_calloc(bins,sizeof(*bm->avg_binacc)); - bm->avgfloat=PACKETBLOBS/2; - - }else{ - bm->avg_tail= -1; - } - - if((bi->queue_hardmin>0 || bi->queue_hardmax>0) && - bi->queue_minmax_time>0){ - - bm->minmax_binstack=_ogg_calloc((bins*2+1)*bins*2, - sizeof(*bm->minmax_binstack)); - bm->minmax_posstack=_ogg_calloc((bins*2+1), - sizeof(*bm->minmax_posstack)); - bm->minmax_limitstack=_ogg_calloc((bins*2+1), - sizeof(*bm->minmax_limitstack)); - }else{ - bm->minmax_tail= -1; - } - - /* space for the packet queueing */ - bm->packetbuffers=_ogg_calloc(maxpackets,sizeof(*bm->packetbuffers)); - bm->packets=_ogg_calloc(maxpackets,sizeof(*bm->packets)); - for(i=0;ipacketbuffers+i); - - }else{ - bm->packetbuffers=_ogg_calloc(1,sizeof(*bm->packetbuffers)); - bm->packets=_ogg_calloc(1,sizeof(*bm->packets)); - oggpack_writeinit(bm->packetbuffers); + /* not a necessary fix, but one that leads to a more balanced + typical initialization */ + { + long desired_fill=bi->reservoir_bits*bi->reservoir_bias; + bm->minmax_reservoir=desired_fill; + bm->avg_reservoir=desired_fill; + } - } } } void vorbis_bitrate_clear(bitrate_manager_state *bm){ - int i; - if(bm){ - if(bm->queue_binned)_ogg_free(bm->queue_binned); - if(bm->queue_actual)_ogg_free(bm->queue_actual); - if(bm->avg_binacc)_ogg_free(bm->avg_binacc); - if(bm->minmax_binstack)_ogg_free(bm->minmax_binstack); - if(bm->minmax_posstack)_ogg_free(bm->minmax_posstack); - if(bm->minmax_limitstack)_ogg_free(bm->minmax_limitstack); - - if(bm->packetbuffers){ - if(bm->queue_size==0){ - oggpack_writeclear(bm->packetbuffers); - }else{ - for(i=0;iqueue_size;i++) - oggpack_writeclear(bm->packetbuffers+i); - } - _ogg_free(bm->packetbuffers); - } - if(bm->packets)_ogg_free(bm->packets); - - memset(bm,0,sizeof(*bm)); - } + memset(bm,0,sizeof(*bm)); + return; } int vorbis_bitrate_managed(vorbis_block *vb){ vorbis_dsp_state *vd=vb->vd; - private_state *b=vd->backend_state; + private_state *b=vd->backend_state; bitrate_manager_state *bm=&b->bms; - if(bm->queue_binned)return(1); + if(bm && bm->managed)return(1); return(0); } /* finish taking in the block we just processed */ int vorbis_bitrate_addblock(vorbis_block *vb){ - int i; vorbis_block_internal *vbi=vb->internal; vorbis_dsp_state *vd=vb->vd; - private_state *b=vd->backend_state; + private_state *b=vd->backend_state; bitrate_manager_state *bm=&b->bms; vorbis_info *vi=vd->vi; codec_setup_info *ci=vi->codec_setup; bitrate_manager_info *bi=&ci->bi; - int eofflag=vb->eofflag; - int head=bm->queue_head; - int next_head=head+1; - int bins=bm->queue_bins; - int minmax_head,new_minmax_head; - - ogg_uint32_t *head_ptr; - oggpack_buffer temp; - - if(!bm->queue_binned){ - oggpack_buffer temp; + + int choice=rint(bm->avgfloat); + long this_bits=oggpack_bytes(vbi->packetblob[choice])*8; + long min_target_bits=(vb->W?bm->min_bitsper*bm->short_per_long:bm->min_bitsper); + long max_target_bits=(vb->W?bm->max_bitsper*bm->short_per_long:bm->max_bitsper); + int samples=ci->blocksizes[vb->W]>>1; + long desired_fill=bi->reservoir_bits*bi->reservoir_bias; + if(!bm->managed){ /* not a bitrate managed stream, but for API simplicity, we'll - buffer one packet to keep the code path clean */ - - if(bm->queue_head)return(-1); /* one has been submitted without - being claimed */ - bm->queue_head++; - - bm->packets[0].packet=oggpack_get_buffer(&vb->opb); - bm->packets[0].bytes=oggpack_bytes(&vb->opb); - bm->packets[0].b_o_s=0; - bm->packets[0].e_o_s=vb->eofflag; - bm->packets[0].granulepos=vb->granulepos; - bm->packets[0].packetno=vb->sequence; /* for sake of completeness */ - - memcpy(&temp,bm->packetbuffers,sizeof(vb->opb)); - memcpy(bm->packetbuffers,&vb->opb,sizeof(vb->opb)); - memcpy(&vb->opb,&temp,sizeof(vb->opb)); + buffer the packet to keep the code path clean */ + if(bm->vb)return(-1); /* one has been submitted without + being claimed */ + bm->vb=vb; return(0); } - /* add encoded packet to head */ - if(next_head>=bm->queue_size)next_head=0; - head_ptr=bm->queue_binned+bins*head; - - /* is there room to add a block? In proper use of the API, this will - never come up... but guard it anyway */ - if(next_head==bm->avg_tail || next_head==bm->minmax_tail)return(-1); - - /* add the block to the toplevel queue */ - bm->queue_head=next_head; - bm->queue_actual[head]=(vb->W?0x80000000UL:0); - - /* buffer packet fields */ - bm->packets[head].packet=oggpack_get_buffer(&vb->opb); - bm->packets[head].bytes=oggpack_bytes(&vb->opb); - bm->packets[head].b_o_s=0; - bm->packets[head].e_o_s=vb->eofflag; - bm->packets[head].granulepos=vb->granulepos; - bm->packets[head].packetno=vb->sequence; /* for sake of completeness */ - - /* swap packet buffers */ - memcpy(&temp,bm->packetbuffers+head,sizeof(vb->opb)); - memcpy(bm->packetbuffers+head,&vb->opb,sizeof(vb->opb)); - memcpy(&vb->opb,&temp,sizeof(vb->opb)); - - /* save markers */ - head_ptr[0]=vbi->packetblob_markers[0]; - for(i=1;ipacketblob_markers[i]-vbi->packetblob_markers[i-1]; - } + bm->vb=vb; + + /* look ahead for avg floater */ + if(bm->avg_bitsper>0){ + double slew=0.; + long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper); + double slewlimit= 15./bi->slew_damp; - if(bm->avg_binacc) - new_minmax_head=minmax_head=bm->avg_center; - else - new_minmax_head=minmax_head=head; - - /* the average tracking queue is updated first; its results (if it's - in use) are taken into account by the min/max limiter (if min/max - is in use) */ - if(bm->avg_binacc){ - unsigned long desired_center=bm->avg_centerdesired; - if(eofflag)desired_center=0; - - /* update the avg head */ - for(i=0;iavg_binacc[i]+=LACING_ADJUST(head_ptr[i]); - bm->avg_sampleacc+=ci->blocksizes[vb->W]>>1; - bm->avg_centeracc+=ci->blocksizes[vb->W]>>1; - - if(bm->avg_sampleacc>bm->avg_sampledesired || eofflag){ - - /* update the avg center */ - if(bm->avg_centeracc>desired_center){ - /* choose the new average floater */ - int samples=ci->blocksizes[vb->W]>>1; - double upper=floater_interpolate(bm,vi,bi->queue_avgmax); - double lower=floater_interpolate(bm,vi,bi->queue_avgmin); - double new=PACKETBLOBS/2.,slew; - int bin; - - if(uppernew)new=lower; - - slew=(new-bm->avgfloat)/samples*vi->rate; - - if(slewavgfloat_downslew_max) - new=bm->avgfloat+bi->avgfloat_downslew_max/vi->rate*samples; - if(slew>bi->avgfloat_upslew_max) - new=bm->avgfloat+bi->avgfloat_upslew_max/vi->rate*samples; - - bm->avgfloat=new; - /* apply the average floater to new blocks */ - bin=rint(bm->avgfloat); - - /*fprintf(stderr,"%d ",bin);*/ - - while(bm->avg_centeracc>desired_center){ - samples=ci->blocksizes[bm->queue_actual[bm->avg_center]& - 0x80000000UL?1:0]>>1; - - bm->queue_actual[bm->avg_center]|=bin; - - bm->avg_centeracc-=samples; - bm->avg_center++; - if(bm->avg_center>=bm->queue_size)bm->avg_center=0; - } - new_minmax_head=bm->avg_center; - + /* choosing a new floater: + if we're over target, we slew down + if we're under target, we slew up + + choose slew as follows: look through packetblobs of this frame + and set slew as the first in the appropriate direction that + gives us the slew we want. This may mean no slew if delta is + already favorable. + + Then limit slew to slew max */ + + if(bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){ + while(choice>0 && this_bits>avg_target_bits && + bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){ + choice--; + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; } - - /* update the avg tail if needed */ - while(bm->avg_sampleacc>bm->avg_sampledesired){ - int samples= - ci->blocksizes[bm->queue_actual[bm->avg_tail]&0x80000000UL?1:0]>>1; - for(i=0;iqueue_bins;i++) - bm->avg_binacc[i]-=LACING_ADJUST(bm->queue_binned[bins*bm->avg_tail+i]); - bm->avg_sampleacc-=samples; - bm->avg_tail++; - if(bm->avg_tail>=bm->queue_size)bm->avg_tail=0; + }else if(bm->avg_reservoir+(this_bits-avg_target_bits)avg_reservoir+(this_bits-avg_target_bits)packetblob[choice])*8; } - - } - }else{ - /* if we're not using an average tracker, the 'float' is nailed to - the avgfloat_initial value. It needs to be set for the min/max - to deal properly */ - long bin=PACKETBLOBS/2; - bm->queue_actual[head]|=bin; - new_minmax_head=next_head; - } - - /* update the min/max queues and enforce limits */ - if(bm->minmax_binstack){ - unsigned long sampledesired=eofflag?0:bm->minmax_sampledesired; - - /* add to stack recent */ - while(minmax_head!=new_minmax_head){ - unsigned int i; - int samples=ci->blocksizes[bm->queue_actual[minmax_head]& - 0x80000000UL?1:0]>>1; - int actual=bm->queue_actual[minmax_head]&0x7fffffffUL; - - for(i=0;i<(unsigned int)bins;i++){ - bm->minmax_binstack[bm->minmax_stackptr*bins*2+bins+i]+= - LACING_ADJUST(BINBYTES(bm,minmax_head, - actual>i?actual:i)); - - bm->minmax_binstack[bm->minmax_stackptr*bins*2+i]+= - LACING_ADJUST(BINBYTES(bm,minmax_head, - actualminmax_posstack[bm->minmax_stackptr]=minmax_head; /* not one - past - like - typical */ - bm->minmax_limitstack[bm->minmax_stackptr]=0; - bm->minmax_sampleacc+=samples; - bm->minmax_acctotal+= - LACING_ADJUST(BINBYTES(bm,minmax_head,actual)); - - minmax_head++; - if(minmax_head>=bm->queue_size)minmax_head=0; + slew=rint(choice-bm->avgfloat)/samples*vi->rate; + if(slew<-slewlimit)slew=-slewlimit; + if(slew>slewlimit)slew=slewlimit; + choice=rint(bm->avgfloat+= slew/vi->rate*samples); + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; + } - } - - /* check limits, enforce changes */ - if(bm->minmax_sampleacc>sampledesired){ - double bitrate=(double)(bm->minmax_acctotal*8)/ - bm->minmax_sampleacc*vi->rate; - int limit=0; - - if((bi->queue_hardmax>0 && bitrate>bi->queue_hardmax) || - (bi->queue_hardmin>0 && bitratequeue_hardmin)){ - int newstack; - int stackctr; - long bitsum=bm->minmax_acctotal*8; - - bitrate=(double)bitsum/bm->minmax_sampleacc*vi->rate; - - /* we're off rate. Iteratively try out new hard floater - limits until we find one that brings us inside. Here's - where we see the whole point of the limit stacks. */ - if(bi->queue_hardmax>0 && bitrate>bi->queue_hardmax){ - for(limit=-1;limit>-bins+1;limit--){ - long bitsum=limit_sum(bm,limit)*8; - bitrate=(double)bitsum/bm->minmax_sampleacc*vi->rate; - if(bitrate<=bi->queue_hardmax)break; - } - }else if(bitratequeue_hardmin){ - for(limit=1;limitminmax_sampleacc*vi->rate; - if(bitrate>=bi->queue_hardmin)break; - } - if(bitrate>bi->queue_hardmax)limit--; - } - - /* trace the limit backward, stop when we see a lower limit */ - newstack=bm->minmax_stackptr-1; - while(newstack>=0){ - if(bm->minmax_limitstack[newstack]minmax_stackptr; - while(stackctr>newstack){ - bm->minmax_acctotal-= - LIMITBYTES(stackctr,bm->minmax_limitstack[stackctr]); - bm->minmax_acctotal+=LIMITBYTES(stackctr,limit); - - if(stackctrminmax_stackptr) - for(i=0;iminmax_binstack[stackctr*bins*2+i]+= - bm->minmax_binstack[(stackctr+1)*bins*2+i]; - - stackctr--; - } - stackctr++; - bm->minmax_posstack[stackctr]=bm->minmax_posstack[bm->minmax_stackptr]; - bm->minmax_limitstack[stackctr]=limit; - - /* set up new blank stack entry */ - stackctr++; - bm->minmax_stackptr=stackctr; - memset(&bm->minmax_binstack[stackctr*bins*2], - 0, - sizeof(*bm->minmax_binstack)*bins*2); - bm->minmax_limitstack[stackctr]=0; - bm->minmax_posstack[stackctr]=-1; - + + + /* enforce min(if used) on the current floater (if used) */ + if(bm->min_bitsper>0){ + /* do we need to force the bitrate up? */ + if(this_bitsminmax_reservoir-(min_target_bits-this_bits)<0){ + choice++; + if(choice>=PACKETBLOBS)break; + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; } } - - /* remove from tail */ - while(bm->minmax_sampleacc>sampledesired){ - int samples= - ci->blocksizes[bm->queue_actual[bm->minmax_tail]&0x80000000UL?1:0]>>1; - int actual=bm->queue_actual[bm->minmax_tail]&0x7fffffffUL; - - for(i=0;iminmax_binstack[bins+i]-= /* always comes off the stack bottom */ - LACING_ADJUST(BINBYTES(bm,bm->minmax_tail, - actual>i? - actual:i)); - bm->minmax_binstack[i]-= - LACING_ADJUST(BINBYTES(bm,bm->minmax_tail, - actualminmax_limitstack[0]>actual) - actual=bm->minmax_limitstack[0]; - if(bins+bm->minmax_limitstack[0]minmax_limitstack[0]; - - bm->minmax_acctotal-=LACING_ADJUST(BINBYTES(bm,bm->minmax_tail,actual)); - bm->minmax_sampleacc-=samples; - - /* revise queue_actual to reflect the limit */ - bm->queue_actual[bm->minmax_tail]&=0x80000000UL; - bm->queue_actual[bm->minmax_tail]|=actual; - - if(bm->minmax_tail==bm->minmax_posstack[0]){ - /* the stack becomes a FIFO; the first data has fallen off */ - memmove(bm->minmax_binstack,bm->minmax_binstack+bins*2, - sizeof(*bm->minmax_binstack)*bins*2*bm->minmax_stackptr); - memmove(bm->minmax_posstack,bm->minmax_posstack+1, - sizeof(*bm->minmax_posstack)*bm->minmax_stackptr); - memmove(bm->minmax_limitstack,bm->minmax_limitstack+1, - sizeof(*bm->minmax_limitstack)*bm->minmax_stackptr); - bm->minmax_stackptr--; + /* enforce max (if used) on the current floater (if used) */ + if(bm->max_bitsper>0){ + /* do we need to force the bitrate down? */ + if(this_bits>max_target_bits){ + while(bm->minmax_reservoir+(this_bits-max_target_bits)>bi->reservoir_bits){ + choice--; + if(choice<0)break; + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; } - - bm->minmax_tail++; - if(bm->minmax_tail>=bm->queue_size)bm->minmax_tail=0; - } - - - bm->last_to_flush=bm->minmax_tail; - }else{ - bm->last_to_flush=bm->avg_center; } - if(eofflag) - bm->last_to_flush=bm->queue_head; - return(0); -} -int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){ - private_state *b=vd->backend_state; - bitrate_manager_state *bm=&b->bms; + /* Choice of packetblobs now made based on floater, and min/max + requirements. Now boundary check extreme choices */ - if(bm->queue_size==0){ - if(bm->queue_head==0)return(0); + if(choice<0){ + /* choosing a smaller packetblob is insufficient to trim bitrate. + frame will need to be truncated */ + long maxsize=(max_target_bits+(bi->reservoir_bits-bm->minmax_reservoir))/8; + bm->choice=choice=0; - memcpy(op,bm->packets,sizeof(*op)); - bm->queue_head=0; + if(oggpack_bytes(vbi->packetblob[choice])>maxsize){ + oggpack_writetrunc(vbi->packetblob[choice],maxsize*8); + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; + } }else{ + long minsize=(min_target_bits-bm->minmax_reservoir+7)/8; + if(choice>=PACKETBLOBS) + choice=PACKETBLOBS-1; - if(bm->next_to_flush==bm->last_to_flush)return(0); + bm->choice=choice; - { - long bin=bm->queue_actual[bm->next_to_flush]&0x7fffffff,i; - long bins=bm->queue_bins; - ogg_uint32_t *markers=bm->queue_binned+bins*bm->next_to_flush; - long bytes=markers[bin]; - - memcpy(op,bm->packets+bm->next_to_flush,sizeof(*op)); - - /* we have [PACKETBLOBS] possible packets all squished together in - the buffer, in sequence. count in to number [bin] */ - for(i=0;ipacket+=markers[i]; - op->bytes=bytes; - + /* prop up bitrate according to demand. pad this frame out with zeroes */ + minsize-=oggpack_bytes(vbi->packetblob[choice]); + while(minsize-->0)oggpack_write(vbi->packetblob[choice],0,8); + this_bits=oggpack_bytes(vbi->packetblob[choice])*8; + + } + + /* now we have the final packet and the final packet size. Update statistics */ + /* min and max reservoir */ + if(bm->min_bitsper>0 || bm->max_bitsper>0){ + + if(max_target_bits>0 && this_bits>max_target_bits){ + bm->minmax_reservoir+=(this_bits-max_target_bits); + }else if(min_target_bits>0 && this_bitsminmax_reservoir+=(this_bits-min_target_bits); + }else{ + /* inbetween; we want to take reservoir toward but not past desired_fill */ + if(bm->minmax_reservoir>desired_fill){ + if(max_target_bits>0){ /* logical bulletproofing against initialization state */ + bm->minmax_reservoir+=(this_bits-max_target_bits); + if(bm->minmax_reservoirminmax_reservoir=desired_fill; + }else{ + bm->minmax_reservoir=desired_fill; + } + }else{ + if(min_target_bits>0){ /* logical bulletproofing against initialization state */ + bm->minmax_reservoir+=(this_bits-min_target_bits); + if(bm->minmax_reservoir>desired_fill)bm->minmax_reservoir=desired_fill; + }else{ + bm->minmax_reservoir=desired_fill; + } + } } + } + + /* avg reservoir */ + if(bm->avg_bitsper>0){ + long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper); + bm->avg_reservoir+=this_bits-avg_target_bits; + } - bm->next_to_flush++; - if(bm->next_to_flush>=bm->queue_size)bm->next_to_flush=0; + return(0); +} +int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){ + private_state *b=vd->backend_state; + bitrate_manager_state *bm=&b->bms; + vorbis_block *vb=bm->vb; + int choice=PACKETBLOBS/2; + if(!vb)return 0; + + if(op){ + vorbis_block_internal *vbi=vb->internal; + + if(vorbis_bitrate_managed(vb)) + choice=bm->choice; + + op->packet=oggpack_get_buffer(vbi->packetblob[choice]); + op->bytes=oggpack_bytes(vbi->packetblob[choice]); + op->b_o_s=0; + op->e_o_s=vb->eofflag; + op->granulepos=vb->granulepos; + op->packetno=vb->sequence; /* for sake of completeness */ } + bm->vb=0; return(1); }