mirror of
https://github.com/cookiengineer/audacity
synced 2025-10-31 22:23:54 +01:00
254 lines
8.3 KiB
C
254 lines
8.3 KiB
C
/********************************************************************
|
|
* *
|
|
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
|
|
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
|
|
* 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-2009 *
|
|
* by the Xiph.Org Foundation http://www.xiph.org/ *
|
|
* *
|
|
********************************************************************
|
|
|
|
function: bitrate tracking and management
|
|
last mod: $Id: bitrate.c 16227 2009-07-08 06:58:46Z xiphmont $
|
|
|
|
********************************************************************/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <ogg/ogg.h>
|
|
#include "vorbis/codec.h"
|
|
#include "codec_internal.h"
|
|
#include "os.h"
|
|
#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;
|
|
|
|
memset(bm,0,sizeof(*bm));
|
|
|
|
if(bi && (bi->reservoir_bits>0)){
|
|
long ratesamples=vi->rate;
|
|
int halfsamples=ci->blocksizes[0]>>1;
|
|
|
|
bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0];
|
|
bm->managed=1;
|
|
|
|
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);
|
|
|
|
bm->avgfloat=PACKETBLOBS/2;
|
|
|
|
/* 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){
|
|
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;
|
|
bitrate_manager_state *bm=&b->bms;
|
|
|
|
if(bm && bm->managed)return(1);
|
|
return(0);
|
|
}
|
|
|
|
/* finish taking in the block we just processed */
|
|
int vorbis_bitrate_addblock(vorbis_block *vb){
|
|
vorbis_block_internal *vbi=vb->internal;
|
|
vorbis_dsp_state *vd=vb->vd;
|
|
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 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 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);
|
|
}
|
|
|
|
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;
|
|
|
|
/* 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;
|
|
}
|
|
}else if(bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
|
|
while(choice+1<PACKETBLOBS && this_bits<avg_target_bits &&
|
|
bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
|
|
choice++;
|
|
this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
/* 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_bits<min_target_bits){
|
|
while(bm->minmax_reservoir-(min_target_bits-this_bits)<0){
|
|
choice++;
|
|
if(choice>=PACKETBLOBS)break;
|
|
this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Choice of packetblobs now made based on floater, and min/max
|
|
requirements. Now boundary check extreme choices */
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
bm->choice=choice;
|
|
|
|
/* 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_bits<min_target_bits){
|
|
bm->minmax_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_reservoir<desired_fill)bm->minmax_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;
|
|
}
|
|
|
|
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);
|
|
}
|