/* *	MP3 huffman table selecting and bit counting * *	Copyright (c) 1999 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. */#include <assert.h>#include "util.h"#include "l3side.h"#include "tables.h"#include "quantize-pvt.h"struct{    unsigned region0_count;    unsigned region1_count;} subdv_table[ 23 ] ={{0, 0}, /* 0 bands */{0, 0}, /* 1 bands */{0, 0}, /* 2 bands */{0, 0}, /* 3 bands */{0, 0}, /* 4 bands */{0, 1}, /* 5 bands */{1, 1}, /* 6 bands */{1, 1}, /* 7 bands */{1, 2}, /* 8 bands */{2, 2}, /* 9 bands */{2, 3}, /* 10 bands */{2, 3}, /* 11 bands */{3, 4}, /* 12 bands */{3, 4}, /* 13 bands */{3, 4}, /* 14 bands */{4, 5}, /* 15 bands */{4, 5}, /* 16 bands */{4, 6}, /* 17 bands */{5, 6}, /* 18 bands */{5, 6}, /* 19 bands */{5, 7}, /* 20 bands */{6, 7}, /* 21 bands */{6, 7}, /* 22 bands */};unsigned int largetbl[16*16];unsigned int table23[3*3];unsigned int table56[4*4];#ifdef MMX_choose_tableunsigned long long tableABC[16*8];unsigned long long tableDEF[16*16];#define table789 (tableABC+9)unsigned long long linbits32[13];unsigned short choose_table_H[13];extern int choose_table_MMX(int *ix, int *end, int *s);#define choose_table(a,b,c) (assert(a<b),choose_table_MMX(a,b,c))#else/*************************************************************************//*	      ix_max							 *//*************************************************************************/int ix_max(int *ix, int *end){    int max1 = 0, max2 = 0;    do {	int x1 = *ix++;	int x2 = *ix++;	if (max1 < x1) 	    max1 = x1;	if (max2 < x2) 	    max2 = x2;    } while (ix < end);    if (max1 < max2) 	max1 = max2;    return max1;}intcount_bit_ESC(int *ix, int *end, int t1, int t2, int *s){    /* ESC-table is used */    int linbits = ht[t1].xlen * 65536 + ht[t2].xlen;    unsigned int sum = 0, sum2;    do {	int x = *ix++;	int y = *ix++;	if (x != 0) {	    if (x > 14) {		x = 15;		sum += linbits;	    }	    x *= 16;	}	if (y != 0) {	    if (y > 14) {		y = 15;		sum += linbits;	    }	    x += y;	}	sum += largetbl[x];    } while (ix < end);    sum2 = sum & 0xffff;    sum >>= 16;    if (sum > sum2) {	sum = sum2;	t1 = t2;    }    *s += sum;    return t1;}INLINE static intcount_bit_noESC(int *ix, int *end, int *s){    /* No ESC-words */    int	sum1 = 0;    const unsigned char *hlen1 = ht[1].hlen;    do {	int x = ix[0] * 2 + ix[1];	ix += 2;	sum1 += hlen1[x];    } while (ix < end);    *s += sum1;    return 1;}INLINE static intcount_bit_noESC_from2(int *ix, int *end, int t1, int *s){    /* No ESC-words */    unsigned int sum = 0, sum2;    const unsigned int xlen = ht[t1].xlen;    unsigned int *hlen;    if (t1 == 2)	hlen = table23;    else	hlen = table56;    do {	int x = ix[0] * xlen + ix[1];	ix += 2;	sum += hlen[x];    } while (ix < end);    sum2 = sum & 0xffff;    sum >>= 16;    if (sum > sum2) {	sum = sum2;	t1++;    }    *s += sum;    return t1;}INLINE static intcount_bit_noESC_from3(int *ix, int *end, int t1, int *s){    /* No ESC-words */    int	sum1 = 0;    int	sum2 = 0;    int	sum3 = 0;    const unsigned int xlen = ht[t1].xlen;    const unsigned char *hlen1 = ht[t1].hlen;    const unsigned char *hlen2 = ht[t1+1].hlen;    const unsigned char *hlen3 = ht[t1+2].hlen;    int t;    do {	int x = ix[0] * xlen + ix[1];	ix += 2;	sum1 += hlen1[x];	sum2 += hlen2[x];	sum3 += hlen3[x];    } while (ix < end);    t = t1;    if (sum1 > sum2) {	sum1 = sum2;	t++;    }    if (sum1 > sum3) {	sum1 = sum3;	t = t1+2;    }    *s += sum1;    return t;}/*************************************************************************//*	      choose table						 *//*************************************************************************//*  Choose the Huffman table that will encode ix[begin..end] with  the fewest bits.  Note: This code contains knowledge about the sizes and characteristics  of the Huffman tables as defined in the IS (Table B.7), and will not work  with any arbitrary tables.*/static int choose_table(int *ix, int *end, int *s){    unsigned int max;    int choice, choice2;    static const int huf_tbl_noESC[] = {	1, 2, 5, 7, 7,10,10,13,13,13,13,13,13,13,13    };    max = ix_max(ix, end);    switch (max) {    case 0:	return (int)max;    case 1:	return count_bit_noESC(ix, end, s);    case 2:    case 3:	return count_bit_noESC_from2(ix, end, huf_tbl_noESC[max - 1], s);    case 4: case 5: case 6:    case 7: case 8: case 9:    case 10: case 11: case 12:    case 13: case 14: case 15:	return count_bit_noESC_from3(ix, end, huf_tbl_noESC[max - 1], s);    default:	/* try tables with linbits */	if (max > IXMAX_VAL) {	    *s = LARGE_BITS;	    return -1;	}	max -= 15;	for (choice2 = 24; choice2 < 32; choice2++) {	    if (ht[choice2].linmax >= max) {		break;	    }	}	for (choice = choice2 - 8; choice < 24; choice++) {	    if (ht[choice].linmax >= max) {		break;	    }	}	return count_bit_ESC(ix, end, choice, choice2, s);    }}#endif/*************************************************************************//*	      count_bit							 *//*************************************************************************//* Function: Count the number of bits necessary to code the subregion. */int count_bits_long(lame_internal_flags *gfc, int ix[576], gr_info *gi){    int i, a1, a2;    int bits = 0;    i=576;    /* Determine count1 region */    for (; i > 1; i -= 2) 	if (ix[i - 1] | ix[i - 2])	    break;    gi->count1 = i;    /* Determines the number of bits to encode the quadruples. */    a1 = a2 = 0;    for (; i > 3; i -= 4) {	int p;	if ((unsigned int)(ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) > 1)	    break;	p = ((ix[i-4] * 2 + ix[i-3]) * 2 + ix[i-2]) * 2 + ix[i-1];	a1 += t32l[p];	a2 += t33l[p];    }    bits = a1;    gi->count1table_select = 0;    if (a1 > a2) {	bits = a2;	gi->count1table_select = 1;    }    gi->count1bits = bits;    gi->big_values = i;    if (i == 0 )	return bits;    if (gi->block_type == SHORT_TYPE) {      a1=3*gfc->scalefac_band.s[3];      if (a1 > gi->big_values) a1 = gi->big_values;      a2 = gi->big_values;    }else if (gi->block_type == NORM_TYPE) {	int index;	int scfb_anz = 0;	while (gfc->scalefac_band.l[++scfb_anz] < i) 	    ;	index = subdv_table[scfb_anz].region0_count;	while (gfc->scalefac_band.l[index + 1] > i)	    index--;	gi->region0_count = index;	index = subdv_table[scfb_anz].region1_count;	while (gfc->scalefac_band.l[index + gi->region0_count + 2] > i)	    index--;	gi->region1_count = index;	a1 = gfc->scalefac_band.l[gi->region0_count + 1];	a2 = gfc->scalefac_band.l[index + gi->region0_count + 2];	if (a2 < i)	  gi->table_select[2] = choose_table(ix + a2, ix + i, &bits);    } else {	gi->region0_count = 7;	/*gi->region1_count = SBPSY_l - 7 - 1;*/	gi->region1_count = SBMAX_l -1 - 7 - 1;	a1 = gfc->scalefac_band.l[7 + 1];	a2 = i;	if (a1 > a2) {	    a1 = a2;	}    }    /* Count the number of bits necessary to code the bigvalues region. */    if (0 < a1)      gi->table_select[0] = choose_table(ix, ix + a1, &bits);    if (a1 < a2)      gi->table_select[1] = choose_table(ix + a1, ix + a2, &bits);    return bits;}