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