/* * bit reservoir source file * * Copyright (c) 1999 Mark Taylor * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* $Id: reservoir.c,v 1.14 2001/01/05 15:20:33 aleidinger Exp $ */ #ifdef HAVE_CONFIG_H # include #endif #include #include "util.h" #include "reservoir.h" #ifdef WITH_DMALLOC #include #endif /* ResvFrameBegin: Called (repeatedly) at the beginning of a frame. Updates the maximum size of the reservoir, and checks to make sure main_data_begin was set properly by the formatter */ /* * Background information: * * This is the original text from the ISO standard. Because of * sooo many bugs and irritations correcting comments are added * in brackets []. A '^W' means you should remove the last word. * * 1) The following rule can be used to calculate the maximum * number of bits used for one granule [^W frame]: * At the highest possible bitrate of Layer III (320 kbps * per stereo signal [^W^W^W], 48 kHz) the frames must be of * [^W^W^W are designed to have] constant length, i.e. * one buffer [^W^W the frame] length is: * * 320 kbps * 1152/48 kHz = 7680 bit = 960 byte * * This value is used as the maximum buffer per channel [^W^W] at * lower bitrates [than 320 kbps]. At 64 kbps mono or 128 kbps * stereo the main granule length is 64 kbps * 576/48 kHz = 768 bit * [per granule and channel] at 48 kHz sampling frequency. * This means that there is a maximum deviation (short time buffer * [= reservoir]) of 7680 - 2*2*768 = 4608 bits is allowed at 64 kbps. * The actual deviation is equal to the number of bytes [with the * meaning of octets] denoted by the main_data_end offset pointer. * The actual maximum deviation is (2^9-1)*8 bit = 4088 bits * [for MPEG-1 and (2^8-1)*8 bit for MPEG-2, both are hard limits]. * ... The xchange of buffer bits between the left and right channel * is allowed without restrictions [exception: dual channel]. * Because of the [constructed] constraint on the buffer size * main_data_end is always set to 0 in the case of bit_rate_index==14, * i.e. data rate 320 kbps per stereo signal [^W^W^W]. In this case * all data are allocated between adjacent header [^W sync] words * [, i.e. there is no buffering at all]. */ int ResvFrameBegin(lame_global_flags *gfp,III_side_info_t *l3_side, int mean_bits, int frameLength ) { lame_internal_flags *gfc=gfp->internal_flags; int fullFrameBits; int resvLimit; int maxmp3buf; /* * Meaning of the variables: * resvLimit: (0, 8, ..., 8*255 (MPEG-2), 8*511 (MPEG-1)) * Number of bits can be stored in previous frame(s) due to * counter size constaints * maxmp3buf: ( ??? ... 8*1951 (MPEG-1 and 2), 8*2047 (MPEG-2.5)) * Number of bits allowed to encode one frame (you can take 8*511 bit * from the bit reservoir and at most 8*1440 bit from the current * frame (320 kbps, 32 kHz), so 8*1951 bit is the largest possible * value for MPEG-1 and -2) * fullFrameBits: * * mean_bits: * * frameLength: * * gfc->ResvMax: * * gfc->ResvSize: * * l3_side->resvDrain_pre: * */ /* main_data_begin has 9 bits in MPEG-1, 8 bits MPEG-2 */ resvLimit = (gfp->version==1) ? 8*511 : 8*255 ; /* maximum allowed frame size */ maxmp3buf = (gfp->strict_ISO) ? 8*960 : 8*2047; if ( frameLength > maxmp3buf || gfp->disable_reservoir ) { gfc->ResvMax = 0; } else { gfc->ResvMax = maxmp3buf - frameLength; if ( gfc->ResvMax > resvLimit ) gfc->ResvMax = resvLimit; } fullFrameBits = mean_bits * gfc->mode_gr + Min ( gfc->ResvSize, gfc->ResvMax ); if ( gfp->strict_ISO && fullFrameBits > maxmp3buf ) fullFrameBits = maxmp3buf; assert ( 0 == gfc->ResvMax % 8 ); assert ( gfc->ResvMax >= 0 ); l3_side->resvDrain_pre = 0; if ( gfc->pinfo != NULL ) { gfc->pinfo->mean_bits = mean_bits / 2; /* expected bits per channel per granule [is this also right for mono/stereo, MPEG-1/2 ?] */ gfc->pinfo->resvsize = gfc->ResvSize; } return fullFrameBits; } /* ResvMaxBits returns targ_bits: target number of bits to use for 1 granule extra_bits: amount extra available from reservoir Mark Taylor 4/99 */ void ResvMaxBits(lame_global_flags *gfp, int mean_bits, int *targ_bits, int *extra_bits) { lame_internal_flags *gfc=gfp->internal_flags; int add_bits; int full_fac; *targ_bits = mean_bits ; /* extra bits if the reservoir is almost full */ full_fac=9; if (gfc->ResvSize > ((gfc->ResvMax * full_fac) / 10)) { add_bits= gfc->ResvSize-((gfc->ResvMax * full_fac) / 10); *targ_bits += add_bits; }else { add_bits =0 ; /* build up reservoir. this builds the reservoir a little slower * than FhG. It could simple be mean_bits/15, but this was rigged * to always produce 100 (the old value) at 128kbs */ /* *targ_bits -= (int) (mean_bits/15.2);*/ if (!gfp->disable_reservoir) *targ_bits -= .1*mean_bits; } /* amount from the reservoir we are allowed to use. ISO says 6/10 */ *extra_bits = (gfc->ResvSize < (gfc->ResvMax*6)/10 ? gfc->ResvSize : (gfc->ResvMax*6)/10); *extra_bits -= add_bits; if (*extra_bits < 0) *extra_bits=0; } /* ResvAdjust: Called after a granule's bit allocation. Readjusts the size of the reservoir to reflect the granule's usage. */ void ResvAdjust(lame_internal_flags *gfc,gr_info *gi, III_side_info_t *l3_side, int mean_bits ) { gfc->ResvSize += (mean_bits / gfc->channels_out) - gi->part2_3_length; #if 0 printf("part2_3_length: %i avg=%i incres: %i resvsize=%i\n",gi->part2_3_length, mean_bits/gfc->channels_out, mean_bits/gfc->channels_out-gi->part2_3_length,gfc->ResvSize); #endif } /* ResvFrameEnd: Called after all granules in a frame have been allocated. Makes sure that the reservoir size is within limits, possibly by adding stuffing bits. */ void ResvFrameEnd(lame_internal_flags *gfc, III_side_info_t *l3_side, int mean_bits) { int stuffingBits; int over_bits; /* just in case mean_bits is odd, this is necessary... */ if ( gfc->channels_out == 2 && (mean_bits & 1) ) gfc->ResvSize += 1; stuffingBits=0; l3_side->resvDrain_post = 0; l3_side->resvDrain_pre = 0; /* we must be byte aligned */ if ( (over_bits = gfc->ResvSize % 8) != 0 ) stuffingBits += over_bits; over_bits = (gfc->ResvSize - stuffingBits) - gfc->ResvMax; if (over_bits > 0) { assert ( 0 == over_bits % 8 ); assert ( over_bits >= 0 ); stuffingBits += over_bits; } #define NEW_DRAINXX #ifdef NEW_DRAIN /* drain as many bits as possible into previous frame ancillary data * In particular, in VBR mode ResvMax may have changed, and we have * to make sure main_data_begin does not create a reservoir bigger * than ResvMax mt 4/00*/ { int mdb_bytes = Min(l3_side->main_data_begin*8,stuffingBits)/8; l3_side->resvDrain_pre += 8*mdb_bytes; stuffingBits -= 8*mdb_bytes; gfc->ResvSize -= 8*mdb_bytes; l3_side->main_data_begin -= mdb_bytes; /* drain just enough to be byte aligned. The remaining bits will * be added to the reservoir, and we will deal with them next frame. * If the next frame is at a lower bitrate, it may have a larger ResvMax, * and we will not have to waste these bits! mt 4/00 */ assert ( stuffingBits >= 0 ); l3_side->resvDrain_post += (stuffingBits % 8); gfc->ResvSize -= stuffingBits % 8; } #else /* drain the rest into this frames ancillary data*/ l3_side->resvDrain_post += stuffingBits; gfc->ResvSize -= stuffingBits; #endif return; }