bitstream.c

音频编码

/*
 *	MP3 bitstream Output interface for LAME
 *
 *	Copyright (c) 1999-2000 Mark Taylor
 *	Copyright (c) 1999-2002 Takehiro Tominaga
 *
 * 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: bitstream.c,v 1.69.2.1 2005/11/20 14:08:24 bouvigne Exp $
 */


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include "tables.h"
#include "bitstream.h"
#include "quantize.h"
#include "quantize_pvt.h"
#include "version.h"
#include "VbrTag.h"
#include "machine.h"
#include "gain_analysis.h"

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif

/* unsigned int is at least this large:  */
/* we work with ints, so when doing bit manipulation, we limit
 * ourselves to MAX_LENGTH-2 just to be on the safe side */
#define MAX_LENGTH      32  



#ifdef DEBUG
static int hoge, hogege;
#endif





/***********************************************************************
 * compute bitsperframe and mean_bits for a layer III frame 
 **********************************************************************/
int getframebits(const lame_global_flags * gfp)
{
    lame_internal_flags *gfc=gfp->internal_flags;
    int  bit_rate;

    /* get bitrate in kbps [?] */
    if (gfc->bitrate_index) 
	bit_rate = bitrate_table[gfp->version][gfc->bitrate_index];
    else
	bit_rate = gfp->brate;
    assert ( bit_rate <= 550 );

    /* main encoding routine toggles padding on and off */
    /* one Layer3 Slot consists of 8 bits */
    return 8 * ((gfp->version+1)*72000*bit_rate / gfp->out_samplerate
		+ gfc->padding);
}




void putheader_bits(lame_internal_flags *gfc)
{
    Bit_stream_struc *bs;
    bs = &gfc->bs;
#ifdef DEBUG
    hoge += gfc->sideinfo_len * 8;
    hogege += gfc->sideinfo_len * 8;
#endif
    memcpy(&bs->buf[bs->buf_byte_idx], gfc->header[gfc->w_ptr].buf,
	   gfc->sideinfo_len);
    bs->buf_byte_idx += gfc->sideinfo_len;
    bs->totbit += gfc->sideinfo_len * 8;
    gfc->w_ptr = (gfc->w_ptr + 1) & (MAX_HEADER_BUF - 1);
}




/*write j bits into the bit stream */
inline static void
putbits2(lame_internal_flags *gfc, int val, int j)
{
    Bit_stream_struc *bs;
    bs = &gfc->bs;

    assert(j < MAX_LENGTH-2);

    while (j > 0) {
	int k;
	if (bs->buf_bit_idx == 0) {
	    bs->buf_bit_idx = 8;
	    bs->buf_byte_idx++;
	    assert(bs->buf_byte_idx < BUFFER_SIZE);
	    assert(gfc->header[gfc->w_ptr].write_timing >= bs->totbit);
	    if (gfc->header[gfc->w_ptr].write_timing == bs->totbit) {
	      putheader_bits(gfc);
	    }
	    bs->buf[bs->buf_byte_idx] = 0;
	}

	k = Min(j, bs->buf_bit_idx);
	j -= k;
        
	bs->buf_bit_idx -= k;
        
	assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */
        assert (bs->buf_bit_idx < MAX_LENGTH); 
	
        bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
	bs->totbit += k;
    }
}

/*write j bits into the bit stream, ignoring frame headers */
inline static void
putbits_noheaders(lame_internal_flags *gfc, int val, int j)
{
    Bit_stream_struc *bs;
    bs = &gfc->bs;

    assert(j < MAX_LENGTH-2);

    while (j > 0) {
	int k;
	if (bs->buf_bit_idx == 0) {
	    bs->buf_bit_idx = 8;
	    bs->buf_byte_idx++;
	    assert(bs->buf_byte_idx < BUFFER_SIZE);
	    bs->buf[bs->buf_byte_idx] = 0;
	}

	k = Min(j, bs->buf_bit_idx);
	j -= k;
        
	bs->buf_bit_idx -= k;
        
	assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */
        assert (bs->buf_bit_idx < MAX_LENGTH); 
	
        bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
	bs->totbit += k;
    }
}


/*
  Some combinations of bitrate, Fs, and stereo make it impossible to stuff
  out a frame using just main_data, due to the limited number of bits to
  indicate main_data_length. In these situations, we put stuffing bits into
  the ancillary data...
*/

inline static void
drain_into_ancillary(lame_global_flags *gfp, int remainingBits)
{
    lame_internal_flags *gfc=gfp->internal_flags;
    int i;
    assert(remainingBits >= 0);

    if (remainingBits >= 8) {
      putbits2(gfc,0x4c,8);
      remainingBits -= 8;
    }
    if (remainingBits >= 8) {
      putbits2(gfc,0x41,8);
      remainingBits -= 8;
    }
    if (remainingBits >= 8) {
      putbits2(gfc,0x4d,8);
      remainingBits -= 8;
    }
    if (remainingBits >= 8) {
      putbits2(gfc,0x45,8);
      remainingBits -= 8;
    }
      
    if (remainingBits >= 32) {
      const char *version = get_lame_short_version ();
      if (remainingBits >= 32) 
	for (i=0; i<(int)strlen(version) && remainingBits >=8 ; ++i) {
	  remainingBits -= 8;
	  putbits2(gfc,version[i],8);
	}
    }

    for (; remainingBits >= 1; remainingBits -= 1 ) {
        putbits2(gfc, gfc->ancillary_flag, 1 );
	gfc->ancillary_flag ^= !gfp->disable_reservoir;
    }

    assert (remainingBits == 0);

}

/*write N bits into the header */
inline static void
writeheader(lame_internal_flags *gfc,int val, int j)
{
    int ptr = gfc->header[gfc->h_ptr].ptr;

    while (j > 0) {
	int k = Min(j, 8 - (ptr & 7));
	j -= k;
        assert (j < MAX_LENGTH); /* >> 32  too large for 32 bit machines */
	gfc->header[gfc->h_ptr].buf[ptr >> 3]
	    |= ((val >> j)) << (8 - (ptr & 7) - k);
	ptr += k;
    }
    gfc->header[gfc->h_ptr].ptr = ptr;
}


static int
CRC_update(int value, int crc)
{
    int i;
    value <<= 8;
    for (i = 0; i < 8; i++) {
	value <<= 1;
	crc <<= 1;

	if (((crc ^ value) & 0x10000))
	    crc ^= CRC16_POLYNOMIAL;
    }
    return crc;
}


void
CRC_writeheader(lame_internal_flags *gfc, char *header)
{
    int crc = 0xffff; /* (jo) init crc16 for error_protection */
    int i;

    crc = CRC_update(((unsigned char*)header)[2], crc);
    crc = CRC_update(((unsigned char*)header)[3], crc);
    for (i = 6; i < gfc->sideinfo_len; i++) {
	crc = CRC_update(((unsigned char*)header)[i], crc);
    }

    header[4] = crc >> 8;
    header[5] = crc & 255;
}

inline static void
encodeSideInfo2(lame_global_flags *gfp,int bitsPerFrame)
{
    lame_internal_flags *gfc=gfp->internal_flags;
    III_side_info_t *l3_side;
    int gr, ch;
    
    l3_side = &gfc->l3_side;
    gfc->header[gfc->h_ptr].ptr = 0;
    memset(gfc->header[gfc->h_ptr].buf, 0, gfc->sideinfo_len);
    if (gfp->out_samplerate < 16000) 
      writeheader(gfc,0xffe,                12);
    else
      writeheader(gfc,0xfff,                12);
    writeheader(gfc,(gfp->version),            1);
    writeheader(gfc,4 - 3,                 2);
    writeheader(gfc,(!gfp->error_protection),  1);
    writeheader(gfc,(gfc->bitrate_index),      4);
    writeheader(gfc,(gfc->samplerate_index),   2);
    writeheader(gfc,(gfc->padding),            1);
    writeheader(gfc,(gfp->extension),          1);
    writeheader(gfc,(gfp->mode),               2);
    writeheader(gfc,(gfc->mode_ext),           2);
    writeheader(gfc,(gfp->copyright),          1);
    writeheader(gfc,(gfp->original),           1);
    writeheader(gfc,(gfp->emphasis),           2);
    if (gfp->error_protection) {
	writeheader(gfc,0, 16); /* dummy */
    }

    if (gfp->version == 1) {
	/* MPEG1 */
	assert(l3_side->main_data_begin >= 0);
	writeheader(gfc,(l3_side->main_data_begin), 9);

	if (gfc->channels_out == 2)
	    writeheader(gfc,l3_side->private_bits, 3);
	else
	    writeheader(gfc,l3_side->private_bits, 5);

	for (ch = 0; ch < gfc->channels_out; ch++) {
	    int band;
	    for (band = 0; band < 4; band++) {
		writeheader(gfc,l3_side->scfsi[ch][band], 1);
	    }
	}

	for (gr = 0; gr < 2; gr++) {
	    for (ch = 0; ch < gfc->channels_out; ch++) {
		gr_info *gi = &l3_side->tt[gr][ch];
		writeheader(gfc,gi->part2_3_length+gi->part2_length, 12);
		writeheader(gfc,gi->big_values / 2,        9);
		writeheader(gfc,gi->global_gain,           8);
		writeheader(gfc,gi->scalefac_compress,     4);

		if (gi->block_type != NORM_TYPE) {
		    writeheader(gfc, 1, 1); /* window_switching_flag */
		    writeheader(gfc,gi->block_type,       2);
		    writeheader(gfc,gi->mixed_block_flag, 1);

		    if (gi->table_select[0] == 14)
			gi->table_select[0] = 16;
		    writeheader(gfc,gi->table_select[0],  5);
		    if (gi->table_select[1] == 14)
			gi->table_select[1] = 16;
		    writeheader(gfc,gi->table_select[1],  5);

		    writeheader(gfc,gi->subblock_gain[0], 3);
		    writeheader(gfc,gi->subblock_gain[1], 3);
		    writeheader(gfc,gi->subblock_gain[2], 3);
		} else {
		    writeheader(gfc, 0, 1); /* window_switching_flag */
		    if (gi->table_select[0] == 14)
			gi->table_select[0] = 16;
		    writeheader(gfc,gi->table_select[0], 5);
		    if (gi->table_select[1] == 14)
			gi->table_select[1] = 16;
		    writeheader(gfc,gi->table_select[1], 5);
		    if (gi->table_select[2] == 14)
			gi->table_select[2] = 16;
		    writeheader(gfc,gi->table_select[2], 5);

		    assert(gi->region0_count < 16U);
		    assert(gi->region1_count < 8U);
		    writeheader(gfc,gi->region0_count, 4);
		    writeheader(gfc,gi->region1_count, 3);
		}
		writeheader(gfc,gi->preflag,            1);
		writeheader(gfc,gi->scalefac_scale,     1);
		writeheader(gfc,gi->count1table_select, 1);
	    }
	}
    } else {
	/* MPEG2 */
	assert(l3_side->main_data_begin >= 0);
	writeheader(gfc,(l3_side->main_data_begin), 8);
	writeheader(gfc,l3_side->private_bits, gfc->channels_out);

	gr = 0;
	for (ch = 0; ch < gfc->channels_out; ch++) {
	    gr_info *gi = &l3_side->tt[gr][ch];
	    writeheader(gfc,gi->part2_3_length+gi->part2_length, 12);
	    writeheader(gfc,gi->big_values / 2,        9);
	    writeheader(gfc,gi->global_gain,           8);
	    writeheader(gfc,gi->scalefac_compress,     9);

	    if (gi->block_type != NORM_TYPE) {
		writeheader(gfc, 1, 1); /* window_switching_flag */
		writeheader(gfc,gi->block_type,       2);
		writeheader(gfc,gi->mixed_block_flag, 1);

		if (gi->table_select[0] == 14)
		    gi->table_select[0] = 16;
		writeheader(gfc,gi->table_select[0],  5);
		if (gi->table_select[1] == 14)
		    gi->table_select[1] = 16;
		writeheader(gfc,gi->table_select[1],  5);

		writeheader(gfc,gi->subblock_gain[0], 3);
		writeheader(gfc,gi->subblock_gain[1], 3);
		writeheader(gfc,gi->subblock_gain[2], 3);
	    } else {
		writeheader(gfc, 0, 1); /* window_switching_flag */
		if (gi->table_select[0] == 14)
		    gi->table_select[0] = 16;
		writeheader(gfc,gi->table_select[0], 5);
		if (gi->table_select[1] == 14)
		    gi->table_select[1] = 16;
		writeheader(gfc,gi->table_select[1], 5);
		if (gi->table_select[2] == 14)
		    gi->table_select[2] = 16;
		writeheader(gfc,gi->table_select[2], 5);

		assert(gi->region0_count < 16U);
		assert(gi->region1_count < 8U);
		writeheader(gfc,gi->region0_count, 4);
		writeheader(gfc,gi->region1_count, 3);
	    }

	    writeheader(gfc,gi->scalefac_scale,     1);
	    writeheader(gfc,gi->count1table_select, 1);
	}
    }

    if (gfp->error_protection) {
	/* (jo) error_protection: add crc16 information to header */
	CRC_writeheader(gfc, gfc->header[gfc->h_ptr].buf);
    }

    {
	int old = gfc->h_ptr;
	assert(gfc->header[old].ptr == gfc->sideinfo_len * 8);

	gfc->h_ptr = (old + 1) & (MAX_HEADER_BUF - 1);
	gfc->header[gfc->h_ptr].write_timing =
	    gfc->header[old].write_timing + bitsPerFrame;

	if (gfc->h_ptr == gfc->w_ptr) {
	  /* yikes! we are out of header buffer space */
	  ERRORF(gfc,"Error: MAX_HEADER_BUF too small in bitstream.c \n");
	}

    }
}


inline static int
huffman_coder_count1(lame_internal_flags *gfc, gr_info *gi)
{
    /* Write count1 area */
    const struct huffcodetab *h = &ht[gi->count1table_select + 32];
    int i,bits=0;
#ifdef DEBUG
    int gegebo = gfc->bs.totbit;
#endif

    int *ix = &gi->l3_enc[gi->big_values];
    FLOAT *xr = &gi->xr[gi->big_values];
    assert(gi->count1table_select < 2);

    for (i = (gi->count1 - gi->big_values) / 4; i > 0; --i) {
	int huffbits = 0;
	int p = 0, v;

	v = ix[0];
	if (v) {
	    p += 8;
	    if (xr[0] < 0)
		huffbits++;
	    assert(v <= 1u);
	}

	v = ix[1];
	if (v) {
	    p += 4;
	    huffbits *= 2;
	    if (xr[1] < 0)
		huffbits++;
	    assert(v <= 1u);
	}

	v = ix[2];
	if (v) {
	    p += 2;
	    huffbits *= 2;
	    if (xr[2] < 0)
		huffbits++;
	    assert(v <= 1u);
	}

	v = ix[3];
	if (v) {
	    p++;
	    huffbits *= 2;
	    if (xr[3] < 0)
		huffbits++;
	    assert(v <= 1u);
	}

	ix += 4;
	xr += 4;
	putbits2(gfc, huffbits + h->table[p], h->hlen[p]);
	bits += h->hlen[p];
    }
#ifdef DEBUG
    DEBUGF(gfc,"count1: real: %ld counted:%d (bigv %d count1len %d)\n",
	   gfc->bs.totbit -gegebo, gi->count1bits, gi->big_values, gi->count1);
#endif
    return bits;
}



/*
  Implements the pseudocode of page 98 of the IS
  */
inline static int
Huffmancode( lame_internal_flags* const gfc, const int tableindex,
	     int start, int end, gr_info *gi)
{
    const struct huffcodetab* h = &ht[tableindex];
    int index, bits = 0;

    assert(tableindex < 32u);
    if (!tableindex)
	return bits;

    for (index = start; index < end; index += 2) {
	int cbits   = 0;
	int xbits   = 0;
	int linbits = h->xlen;
	int xlen    = h->xlen;
	int ext = 0;
	int x1 = gi->l3_enc[index];
	int x2 = gi->l3_enc[index+1];