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 https://xiph.org/ * 10 * * 11 ******************************************************************** 12 13 function: bitrate tracking and management 14 15 ********************************************************************/ 16 17 #include "ogg.h" 18 #include "vorbis_codec.h" 19 #include "vorbis_codec_internal.h" 20 #include "vorbis_os.h" 21 #include "vorbis_misc.h" 22 #include "vorbis_bitrate.h" 23 24 /* compute bitrate tracking setup */ 25 void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){ 26 codec_setup_info *ci = (codec_setup_info *) vi->codec_setup; 27 bitrate_manager_info *bi=&ci->bi; 28 29 memset(bm,0,sizeof(*bm)); 30 31 if(bi && (bi->reservoir_bits>0)){ 32 long ratesamples=vi->rate; 33 int halfsamples=ci->blocksizes[0]>>1; 34 35 bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0]; 36 bm->managed=1; 37 38 bm->avg_bitsper= rint(1.*bi->avg_rate*halfsamples/ratesamples); 39 bm->min_bitsper= rint(1.*bi->min_rate*halfsamples/ratesamples); 40 bm->max_bitsper= rint(1.*bi->max_rate*halfsamples/ratesamples); 41 42 bm->avgfloat=PACKETBLOBS/2; 43 44 /* not a necessary fix, but one that leads to a more balanced 45 typical initialization */ 46 { 47 long desired_fill=bi->reservoir_bits*bi->reservoir_bias; 48 bm->minmax_reservoir=desired_fill; 49 bm->avg_reservoir=desired_fill; 50 } 51 52 } 53 } 54 55 void vorbis_bitrate_clear(bitrate_manager_state *bm){ 56 memset(bm,0,sizeof(*bm)); 57 return; 58 } 59 60 int vorbis_bitrate_managed(vorbis_block *vb){ 61 vorbis_dsp_state *vd=vb->vd; 62 private_state *b = (private_state *) vd->backend_state; 63 bitrate_manager_state *bm=&b->bms; 64 65 if(bm && bm->managed)return(1); 66 return(0); 67 } 68 69 /* finish taking in the block we just processed */ 70 int vorbis_bitrate_addblock(vorbis_block *vb){ 71 vorbis_block_internal *vbi = (vorbis_block_internal *) vb->internal; 72 vorbis_dsp_state *vd=vb->vd; 73 private_state *b = (private_state *) vd->backend_state; 74 bitrate_manager_state *bm=&b->bms; 75 vorbis_info *vi=vd->vi; 76 codec_setup_info *ci = ( codec_setup_info *) vi->codec_setup; 77 bitrate_manager_info *bi=&ci->bi; 78 79 int choice=rint(bm->avgfloat); 80 long this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 81 long min_target_bits=(vb->W?bm->min_bitsper*bm->short_per_long:bm->min_bitsper); 82 long max_target_bits=(vb->W?bm->max_bitsper*bm->short_per_long:bm->max_bitsper); 83 int samples=ci->blocksizes[vb->W]>>1; 84 long desired_fill=bi->reservoir_bits*bi->reservoir_bias; 85 if(!bm->managed){ 86 /* not a bitrate managed stream, but for API simplicity, we'll 87 buffer the packet to keep the code path clean */ 88 89 if(bm->vb)return(-1); /* one has been submitted without 90 being claimed */ 91 bm->vb=vb; 92 return(0); 93 } 94 95 bm->vb=vb; 96 97 /* look ahead for avg floater */ 98 if(bm->avg_bitsper>0){ 99 double slew=0.; 100 long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper); 101 double slewlimit= 15./bi->slew_damp; 102 103 /* choosing a new floater: 104 if we're over target, we slew down 105 if we're under target, we slew up 106 107 choose slew as follows: look through packetblobs of this frame 108 and set slew as the first in the appropriate direction that 109 gives us the slew we want. This may mean no slew if delta is 110 already favorable. 111 112 Then limit slew to slew max */ 113 114 if(bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){ 115 while(choice>0 && this_bits>avg_target_bits && 116 bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){ 117 choice--; 118 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 119 } 120 }else if(bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){ 121 while(choice+1<PACKETBLOBS && this_bits<avg_target_bits && 122 bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){ 123 choice++; 124 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 125 } 126 } 127 128 slew=rint(choice-bm->avgfloat)/samples*vi->rate; 129 if(slew<-slewlimit)slew=-slewlimit; 130 if(slew>slewlimit)slew=slewlimit; 131 choice=rint(bm->avgfloat+= slew/vi->rate*samples); 132 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 133 } 134 135 136 137 /* enforce min(if used) on the current floater (if used) */ 138 if(bm->min_bitsper>0){ 139 /* do we need to force the bitrate up? */ 140 if(this_bits<min_target_bits){ 141 while(bm->minmax_reservoir-(min_target_bits-this_bits)<0){ 142 choice++; 143 if(choice>=PACKETBLOBS)break; 144 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 145 } 146 } 147 } 148 149 /* enforce max (if used) on the current floater (if used) */ 150 if(bm->max_bitsper>0){ 151 /* do we need to force the bitrate down? */ 152 if(this_bits>max_target_bits){ 153 while(bm->minmax_reservoir+(this_bits-max_target_bits)>bi->reservoir_bits){ 154 choice--; 155 if(choice<0)break; 156 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 157 } 158 } 159 } 160 161 /* Choice of packetblobs now made based on floater, and min/max 162 requirements. Now boundary check extreme choices */ 163 164 if(choice<0){ 165 /* choosing a smaller packetblob is insufficient to trim bitrate. 166 frame will need to be truncated */ 167 long maxsize=(max_target_bits+(bi->reservoir_bits-bm->minmax_reservoir))/8; 168 bm->choice=choice=0; 169 170 if(oggpack_bytes(vbi->packetblob[choice])>maxsize){ 171 172 oggpack_writetrunc(vbi->packetblob[choice],maxsize*8); 173 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 174 } 175 }else{ 176 long minsize=(min_target_bits-bm->minmax_reservoir+7)/8; 177 if(choice>=PACKETBLOBS) 178 choice=PACKETBLOBS-1; 179 180 bm->choice=choice; 181 182 /* prop up bitrate according to demand. pad this frame out with zeroes */ 183 minsize-=oggpack_bytes(vbi->packetblob[choice]); 184 while(minsize-->0)oggpack_write(vbi->packetblob[choice],0,8); 185 this_bits=oggpack_bytes(vbi->packetblob[choice])*8; 186 187 } 188 189 /* now we have the final packet and the final packet size. Update statistics */ 190 /* min and max reservoir */ 191 if(bm->min_bitsper>0 || bm->max_bitsper>0){ 192 193 if(max_target_bits>0 && this_bits>max_target_bits){ 194 bm->minmax_reservoir+=(this_bits-max_target_bits); 195 }else if(min_target_bits>0 && this_bits<min_target_bits){ 196 bm->minmax_reservoir+=(this_bits-min_target_bits); 197 }else{ 198 /* inbetween; we want to take reservoir toward but not past desired_fill */ 199 if(bm->minmax_reservoir>desired_fill){ 200 if(max_target_bits>0){ /* logical bulletproofing against initialization state */ 201 bm->minmax_reservoir+=(this_bits-max_target_bits); 202 if(bm->minmax_reservoir<desired_fill)bm->minmax_reservoir=desired_fill; 203 }else{ 204 bm->minmax_reservoir=desired_fill; 205 } 206 }else{ 207 if(min_target_bits>0){ /* logical bulletproofing against initialization state */ 208 bm->minmax_reservoir+=(this_bits-min_target_bits); 209 if(bm->minmax_reservoir>desired_fill)bm->minmax_reservoir=desired_fill; 210 }else{ 211 bm->minmax_reservoir=desired_fill; 212 } 213 } 214 } 215 } 216 217 /* avg reservoir */ 218 if(bm->avg_bitsper>0){ 219 long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper); 220 bm->avg_reservoir+=this_bits-avg_target_bits; 221 } 222 223 return(0); 224 } 225 226 int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){ 227 private_state *b = (private_state *) vd->backend_state; 228 bitrate_manager_state *bm=&b->bms; 229 vorbis_block *vb=bm->vb; 230 int choice=PACKETBLOBS/2; 231 if(!vb)return 0; 232 233 if(op){ 234 vorbis_block_internal *vbi = (vorbis_block_internal *) vb->internal; 235 236 if(vorbis_bitrate_managed(vb)) 237 choice=bm->choice; 238 239 op->packet=oggpack_get_buffer(vbi->packetblob[choice]); 240 op->bytes=oggpack_bytes(vbi->packetblob[choice]); 241 op->b_o_s=0; 242 op->e_o_s=vb->eofflag; 243 op->granulepos=vb->granulepos; 244 op->packetno=vb->sequence; /* for sake of completeness */ 245 } 246 247 bm->vb=0; 248 return(1); 249 } 250