mpeg3dec.c

mp3解码源代码

/****************************************************************************/

/*
 *	mpeg3dec.c -- MPEG layer III decoding functions
 *
 *	Author  :   St閜hane TAVENARD
 *
 *	(C) Copyright 1997-1999 St閜hane TAVENARD
 *	    All Rights Reserved
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *	
 *	This program 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 General Public License for more details.
 *	
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/****************************************************************************/

#include <stdio.h>
#include "defs.h"
#include "bitstr.h"
#include "mpegaud.h"
#include "mpegtab.h"
#include "mpegsub.h"
#include "mpegimdc.h"
#include "mpegdec.h"
#include "mpeg3dec.h"
#include <math.h>

#ifdef USE_RC4
#include "rc4.h"
#endif

/****************************************************************************/

/*
 *	Return the main data slots of current MPEG III frame
 */

static int MPEG3_main_data_slots(MPA_STREAM *mps)
{
	INT32 slots;
	MPA_HEADER *h = &mps->header;


	slots = (144000 * mps->bitrate) / mps->sfreq;

	if (h->ID == MPA_ID_1) {
		// MPEG1
		if (mps->stereo)
			slots -= 36;
		else
			slots -= 21;
	} else {
		// MPEG2
		slots >>= 1;
		if (mps->stereo)
			slots -= 21;
		else
			slots -= 13;
	}

	if (h->padding_bit)
		slots++;
	if (h->protection_bit)
		slots -= 2;
	return(slots);
}

/****************************************************************************/

/*
 *	Decode the sideo info of MPEG III stream
 *	Return 0 if Ok
 */

static int MPEG3_decode_side_info(MPA_STREAM *mps)
{
	BITSTREAM *bs = mps->bitstream;
	MPA_SIDE_INFO *si = &mps->side_info;
	UINT16 ch, i, gr;
	UINT16 gr_max, scf;

	if (mps->header.ID == MPA_ID_1) {
		// MPEG1
		gr_max = MPA_MAX_GRANULES;
		scf = 4;
		si->main_data_begin = BSTR_read_bits(bs, 9);
		if (mps->stereo)
			si->private_bits = BSTR_read_bits(bs, 3);
		else
			si->private_bits = BSTR_read_bits(bs, 5);
		for (ch = 0; ch < mps->channels; ch++) {
			for (i = 0; i < 4; i++)
				si->ch[ch].scfsi[i] = BSTR_read_bit(bs);
		}
	} else {
		// MPEG2 - LSF
		gr_max = 1;
		scf = 9;
		si->main_data_begin = BSTR_read_bits(bs, 8);
		if (mps->stereo)
			si->private_bits = BSTR_read_bits(bs, 2);
		else
			si->private_bits = BSTR_read_bits(bs, 1);
	}

	for (gr = 0; gr < gr_max; gr++) {
		for (ch = 0; ch < mps->channels; ch++) {
			MPA_GRANULE_INFO *gi = &si->ch[ch].gr[gr];
			gi->part2_3_length = BSTR_read_bits(bs, 12);
			gi->big_values = BSTR_read_bits(bs, 9);
			gi->global_gain = BSTR_read_bits(bs, 8);
			gi->scalefac_compress = BSTR_read_bits(bs, scf);
			gi->window_switching_flag = BSTR_read_bit(bs);

			if (gi->window_switching_flag) {
				gi->block_type = BSTR_read_bits(bs, 2);
				gi->mixed_block_flag = BSTR_read_bit(bs);
				for (i = 0; i < 2; i++)
					gi->table_select[i] =
						BSTR_read_bits(bs, 5);
				for (i = 0; i < 3; i++)
					gi->subblock_gain[i] =
						BSTR_read_bits(bs, 3);
				// Implicit regionX_count parameters setting
				if ((gi->block_type == 2) &&
				    (!gi->mixed_block_flag))
					gi->region0_count = 8;
				else
					gi->region0_count = 7;
				gi->region1_count = 20 - gi->region0_count;
			} else {
				for (i = 0; i < 3; i++)
					gi->table_select[i] =
						BSTR_read_bits(bs, 5);
				gi->region0_count = BSTR_read_bits(bs, 4);
				gi->region1_count = BSTR_read_bits(bs, 3);
				gi->block_type = 0;
			}
			if (mps->header.ID == MPA_ID_1)
				gi->preflag = BSTR_read_bit(bs);
			gi->scalefac_scale = BSTR_read_bit(bs);
			gi->count1table_select = BSTR_read_bit(bs);
		}
	}

	return(MPEGDEC_ERR_NONE);
}

/****************************************************************************/

static const INT16 slen[2][16] = {
	{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
	{0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
};

/****************************************************************************/

/*
 *	Decode the scales of MPEG1-III stream
 *	Return 0 if Ok
 */

static int MPEG3_decode_scale1(MPA_STREAM *mps, INT16 gr, INT16 ch)
{
	INT16 sfb, win;
	MPA_GRANULE_INFO *gi = &mps->side_info.ch[ch].gr[gr];
	MPA_SCALE_FAC3 *sf = &mps->scale_fac3[ch];
	HUFFMAN *h = mps->huffman;
	INT16 slen1 = slen[0][gi->scalefac_compress];
	INT16 slen2 = slen[1][gi->scalefac_compress];

	if ((gi->window_switching_flag) && (gi->block_type == 2)) {
		if (gi->mixed_block_flag) {
			// Mixed block
			for (sfb = 0; sfb < 8; sfb++)
				sf->l[sfb] = HUFF_read_bits(h, slen1);
			for (sfb = 3; sfb < 6; sfb++)
				for (win = 0; win < 3; win++)
					sf->s[win][sfb] =
						HUFF_read_bits(h, slen1);
			for (sfb = 6; sfb < 12; sfb++)
				for (win = 0; win < 3; win++)
					sf->s[win][sfb] =
						HUFF_read_bits(h, slen2);
			sf->s[0][12] = sf->s[1][12] = sf->s[2][12] = 0;
		} else {
			// Short blocks
			for (sfb = 0; sfb < 6; sfb++)
				for (win = 0; win < 3; win++)
					sf->s[win][sfb] =
						HUFF_read_bits(h, slen1);
			for (sfb = 6; sfb < 12; sfb++)
				for (win = 0; win < 3; win++)
					sf->s[win][sfb] =
						HUFF_read_bits(h, slen2);
			sf->s[0][12] = sf->s[1][12] = sf->s[2][12] = 0;
		}
	} else {
		// Long blocks 0, 1 or 3
		if ((mps->side_info.ch[ch].scfsi[0] == 0) || (gr == 0)) {
			for (sfb = 0; sfb < 6; sfb++)
				sf->l[sfb] = HUFF_read_bits(h, slen1);
		}
		if ((mps->side_info.ch[ch].scfsi[1] == 0) || (gr == 0)) {
			for (sfb = 6; sfb < 11; sfb++)
				sf->l[sfb] = HUFF_read_bits(h, slen1);
		}
		if ((mps->side_info.ch[ch].scfsi[2] == 0) || (gr == 0)) {
			for (sfb = 11; sfb < 16; sfb++)
				sf->l[sfb] = HUFF_read_bits(h, slen2);
		}
		if ((mps->side_info.ch[ch].scfsi[3] == 0) || (gr == 0)) {
			for (sfb = 16; sfb < 21; sfb++)
				sf->l[sfb] = HUFF_read_bits(h, slen2);
		}
		sf->l[21] = sf->l[22] = 0;
	}

	return(MPEGDEC_ERR_NONE);
}

/****************************************************************************/

static const INT16 sfb_bt[6][3][4] = {
	{ {6, 5, 5, 5}, {9, 9, 9, 9}, {6, 9, 9, 9} },
	{ {6, 5, 7, 3}, {9, 9, 12, 6}, {6, 9, 12, 6} },
	{ {11, 10, 0, 0}, {18, 18, 0, 0}, {15, 18, 0, 0} },
	{ {7, 7, 7, 0}, {12, 12, 12, 0}, {6, 15, 12, 0} },
	{ {6, 6, 6, 3}, {12, 9, 9, 6}, {6, 12, 9, 6} },
	{ {8, 8, 5, 0}, {15, 12, 9, 0}, {6, 18, 9, 0} }
};

/****************************************************************************/

/*
 *	Decode the scales of MPEG2-III stream
 *	Return 0 if Ok
 */

static int MPEG3_decode_scale2(MPA_STREAM *mps, INT16 gr, INT16 ch)
{
	INT16 i, j, k, sfb, win;
	MPA_GRANULE_INFO *gi = &mps->side_info.ch[ch].gr[gr];
	MPA_SCALE_FAC3 *sf = &mps->scale_fac3[ch];
	HUFFMAN *h = mps->huffman;
	INT16 block_type_number, block_number;
	INT16 slen[4];
	INT16 sfb_nb, len;
	INT16 scalefac[36];	/* #11 suppressed static */
	INT16 is_max[36];	/* #11 suppressed static */

	block_type_number = 0;
	if (gi->block_type == 2)
		block_type_number = (gi->mixed_block_flag) ? 2 : 1;

	if (((mps->header.mode_extension == 1)
	     || (mps->header.mode_extension == 3)) && (ch == 1)) {
		INT16 int_scalefac_comp = gi->scalefac_compress >> 1;

		if (int_scalefac_comp < 180) {
			slen[0] = int_scalefac_comp / 36;
			slen[1] = (INT16) (int_scalefac_comp % 36) / 6;
			slen[2] = (INT16) (int_scalefac_comp % 36) % 6;
			slen[3] = 0;
			gi->preflag = 0;
			block_number = 3;
		} else if (int_scalefac_comp < 244) {
			slen[0] = ((INT16) (int_scalefac_comp - 180) % 64) >> 4;
			slen[1] = ((INT16) (int_scalefac_comp - 180) % 16) >> 2;
			slen[2] = (INT16) (int_scalefac_comp - 180) % 4;
			slen[3] = 0;
			gi->preflag = 0;
			block_number = 4;
		} else {
			slen[0] = (INT16) (int_scalefac_comp - 244) / 3;
			slen[1] = (INT16) (int_scalefac_comp - 244) % 3;
			slen[2] = 0;
			slen[3] = 0;
			gi->preflag = 0;
			block_number = 5;
		}
	} else {
		INT16 scalefac_comp = gi->scalefac_compress;

		if (scalefac_comp < 400) {
			slen[0] = (INT16) (scalefac_comp >> 4) / 5;
			slen[1] = (INT16) (scalefac_comp >> 4) % 5;
			slen[2] = (INT16) (scalefac_comp % 16) >> 2;
			slen[3] = (INT16) (scalefac_comp % 4);
			gi->preflag = 0;
			block_number = 0;
		} else if (scalefac_comp < 500) {
			slen[0] = ((INT16) (scalefac_comp - 400) >> 2) / 5;
			slen[1] = ((INT16) (scalefac_comp - 400) >> 2) % 5;
			slen[2] = (INT16) (scalefac_comp - 400) % 4;
			slen[3] = 0;
			gi->preflag = 0;
			block_number = 1;
		} else {
			slen[0] = (INT16) (scalefac_comp - 500) / 3;
			slen[1] = (INT16) (scalefac_comp - 500) % 3;
			slen[2] = 0;
			slen[3] = 0;
			gi->preflag = 1;
			block_number = 2;
		}
	}

	k = 0;
	for (i = 0; i < 4; i++) {
		sfb_nb = sfb_bt[block_number][block_type_number][i];
		len = slen[i];
		if (len) {
			for (j = 0; j < sfb_nb; j++) {
				scalefac[k] = HUFF_read_bits(h, len);
				is_max[k++] = (1 << len) - 1;
			}
		} else {
			for (j = 0; j < sfb_nb; j++) {
				scalefac[k] = 0;
				is_max[k++] = 0;
			}
		}
	}
	while (k < 36)
		scalefac[k++] = 0;

	k = 0;

	if ((gi->window_switching_flag) && (gi->block_type == 2)) {
		if (gi->mixed_block_flag) {
			// Mixed block
			for (sfb = 0; sfb < 6; sfb++) {
				sf->l[sfb] = scalefac[k];
				mps->is_max_l[sfb] = is_max[k++];
			}
			for (sfb = 3; sfb < 12; sfb++) {
				for (win = 0; win < 3; win++) {
					sf->s[win][sfb] = scalefac[k];
					mps->is_max_s[win][sfb] = is_max[k++];
				}
			}
			sf->s[0][12] = sf->s[1][12] = sf->s[2][12] = 0;
		} else {
			// Short blocks
			for (sfb = 0; sfb < 12; sfb++) {
				for (win = 0; win < 3; win++) {
					sf->s[win][sfb] = scalefac[k];
					mps->is_max_s[win][sfb] = is_max[k++];
				}
			}
			sf->s[0][12] = sf->s[1][12] = sf->s[2][12] = 0;
		}
	} else {
		// Long blocks 0, 1 or 3
		for (sfb = 0; sfb < 21; sfb++) {
			sf->l[sfb] = scalefac[k];
			mps->is_max_l[sfb] = is_max[k++];
		}
		sf->l[21] = sf->l[22] = 0;
	}

	return(MPEGDEC_ERR_NONE);
}

/****************************************************************************/

static const INT16 sfBandIndex_l[2][3][23] = {
	{{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
	  238, 284, 336, 396, 464, 522, 576},
	 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194,
	  232, 278, 330, 394, 464, 540, 576},
	 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
	  238, 284, 336, 396, 464, 522, 576}},
	{{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134,
	  162, 196, 238, 288, 342, 418, 576},
	 {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128,
	  156, 190, 230, 276, 330, 384, 576},
	 {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156,
	  194, 240, 296, 364, 448, 550, 576}}
};

static const INT16 sfBandIndex_s[2][3][14] = {
	{{0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192},
	 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192},
	 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}},
	{{0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192},
	 {0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192},
	 {0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192}}
};

/****************************************************************************/

/*
 *	Decode the huffman data of MPEG III stream
 *	Return 0 if Ok
 */

static int MPEG3_huffman_decode(MPA_STREAM *mps, INT16 *is, INT16 gr,
	INT16 ch, int part2_start)
{
	INT16 i;
	INT16 region1Start;
	INT16 region2Start;
	INT16 region_stop;
	INT16 *isp;
	INT16 htable;
	INT16 huff_count;
	INT16 max_val;
	int pos, count;
	MPA_GRANULE_INFO *gi = &mps->side_info.ch[ch].gr[gr];
	HUFFMAN *h = mps->huffman;

	if ((gi->window_switching_flag) && (gi->block_type == 2)) {
		region1Start = 36;	// sfb[9/3]*3=36
		region2Start = 576;	// No Region2 for short block case
	} else {
		const INT16 *band = sfBandIndex_l[mps->header.ID][mps->header. sampling_frequency];

		region1Start = band[gi->region0_count + 1];
		region2Start = band[gi->region0_count + gi->region1_count + 2];
	}

	/* Read bigvalues area. */
	i = 0;
	isp = is;
	region_stop = (gi->big_values) << 1;

	max_val = mps->sb_max * MPA_SSLIMIT;
	if (max_val > 574)
		max_val = 574;
	if (region_stop > max_val)
		region_stop = max_val;

	if (region1Start > region_stop)
		region1Start = region_stop;
	if (region2Start > region_stop)
		region2Start = region_stop;

	if (region_stop > 0) {
		huff_count = region1Start - i;
		if (huff_count > 0) {
			HUFF_decode_pair(h, gi->table_select[0],
				 (INT16) (huff_count >> 1), isp);
			isp += huff_count;
			i += huff_count;
		}
		huff_count = region2Start - i;
		if (huff_count > 0) {
			HUFF_decode_pair(h, gi->table_select[1],
				 (INT16) (huff_count >> 1), isp);
			isp += huff_count;
			i += huff_count;
		}
		huff_count = region_stop - i;
		if (huff_count > 0) {
			HUFF_decode_pair(h, gi->table_select[2],
				 (INT16) (huff_count >> 1), isp);
			isp += huff_count;
			i += huff_count;
		}
	}
	/* Read count1 area. */
	htable = gi->count1table_select;
	pos = HUFF_pos(h);
	count = HUFF_diff(part2_start, pos);	// bits already used
	region_stop = gi->part2_3_length - count;	// max bits to use
	HUFF_decode_quad(h, htable, region_stop, i, max_val, isp);

	return(MPEGDEC_ERR_NONE);
}

/****************************************************************************/

/*
 *	Get nul pos of the current samples of MPEG III stream
 *	Return 0 if Ok
 */

static INT16 MPEG3_get_nul_pos(MPA_STREAM *mps, INT16 *is, INT16 gr, INT16 ch)
{
	MPA_GRANULE_INFO *gi = &mps->side_info.ch[ch].gr[gr];
	const INT16 *band_l = sfBandIndex_l[mps->header.ID][mps->header.sampling_frequency];
	const INT16 *band_s = sfBandIndex_s[mps->header.ID][mps->header.sampling_frequency];
	INT16 nul_begin = mps->huffman->nul_begin;
	INT16 sfb;

	if ((gi->window_switching_flag) && (gi->block_type == 2)) {
		// Short blocks
		INT16 nul_s;

		nul_s = (INT16) (nul_begin + 2) / 3;
		if (gi->mixed_block_flag) {
			// First 2 subbands are long blocks
			if (nul_begin > 36) {
				// can be in short blocks
				sfb = 12;
				while ((band_s[sfb] >= nul_s) && (sfb >= 3))
					sfb--;
				mps->sfb_nul_s_top[ch] =
					mps->sfb_nul_s[0][ch] =
					mps->sfb_nul_s[1][ch] =
					mps->sfb_nul_s[2][ch] = sfb + 1;
				mps->sfb_nul_l[ch] = 8;
			} else {
				sfb = 7;
				while ((band_l[sfb] >= nul_begin) && (sfb >= 0))
					sfb--;
				mps->sfb_nul_l[ch] = sfb + 1;
				mps->sfb_nul_s_top[ch] =
					mps->sfb_nul_s[0][ch] =
					mps->sfb_nul_s[1][ch] =
					mps->sfb_nul_s[2][ch] = 3;
			}
		} else {
			sfb = 12;
			while ((band_s[sfb] >= nul_s) && (sfb >= 0))
				sfb--;
			mps->sfb_nul_s_top[ch] = mps->sfb_nul_s[0][ch] =
				mps->sfb_nul_s[1][ch] =
				mps->sfb_nul_s[2][ch] = sfb + 1;
			mps->sfb_nul_l[ch] = 0;
		}
		if (mps->header.ID == MPA_ID_2) {
			// Each null band should be evaluated for each window
			INT16 w;
			INT16 sfb_top = mps->sfb_nul_s[0][ch];
			INT16 sfb_min = (gi->mixed_block_flag) ? 3 : 0;

			mps->sfb_nul_s_top[ch] = 0;
			for (w = 0; w < 3; w++) {
				register INT16 index;
				register INT16 cnt;
				register INT16 *isp;

				sfb = sfb_top;
				index = (band_s[sfb - 1] * 3) + ((INT16)
					(band_s[sfb] - band_s[sfb - 1]) *
					(INT16) (w + 1)) - 1;
				if (nul_begin < index)
					index = nul_begin;
				while (sfb > sfb_min) {
					isp = &is[index];
					cnt = 1 + index -
						((band_s[sfb - 1] * 3) +
						((INT16) (band_s[sfb] -
						band_s[sfb - 1]) * w));
					while (cnt--)
						if (*isp--)
							break;
					if (cnt >= 0)
						break;
					sfb--;
					index = (band_s[sfb - 1] * 3) +
						((INT16) (band_s[sfb] -
						band_s[sfb - 1]) *
						(INT16) (w + 1)) - 1;
				}
				mps->sfb_nul_s[w][ch] = sfb;
				if (sfb > mps->sfb_nul_s_top[ch])
					mps->sfb_nul_s_top[ch] = sfb;
				if ((sfb == sfb_min) && (sfb_min > 0)) {
					// Find into long blocks now
					sfb = 6;
					index = band_l[sfb] - 1;
					if (nul_begin < index)
						index = nul_begin;
					while (sfb > 0) {
						isp = &is[index];
						cnt = 1 + index -
							band_l[sfb - 1];
						while (cnt--)
							if (*isp--)
								break;
						if (cnt >= 0)
							break;