Subversion Repositories planix.SVN

/*

 *	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 <config.h>

#endif

#include <assert.h>

#include "util.h"

#include "reservoir.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#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;

}