/*
(c) Copyright 1998-2001 - Tord Jansson
======================================
This file is part of the BladeEnc MP3 Encoder, based on
ISO's reference code for MPEG Layer 3 compression, and might
contain smaller or larger sections that are directly taken
from ISO's reference code.
All changes to the ISO reference code herein are either
copyrighted by Tord Jansson ([email protected])
or sublicensed to Tord Jansson by a third party.
BladeEnc is free software; you can redistribute this file
and/or modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
------------ Changes ------------
2000-11-10 Andre Piotrowski
- reformatted, used 'static' functions, global variables, less parameters
2000-11-11 ap
- a lot of functions redesigned to let the bladetable become superfluous:
genNoisePowTab(), iteration_loop(), calc_noise(), preemphasis(), amp_scalefac_bands()
- bladTabValue() replaced by cutting_crew()
2000-11-22 ap
- bug fix: module - reset fInit_huffman_read_flag
2000-11-28 ap
- speed up : implemented partial quantizing
2000-11-30 ap
- speed up : implemented faster Huffman coding
- integration : improved (optional) Huffman coding
[choosing better tables]
- integration : improved (optional) binary search
[in fact, this is a BUG FIX (original dist10 bug)]
2000-12-02 ap
- bug fix : original dist10's outer_loop could cause an endless loop (huff_bits <= 0).
- speed up : faster part2_length/scale_bitcount calculation
- integration : improved (optional) scalefactor compression
[smart preflag switching and choosing best compression]
2000-12-03 ap
- integration : improved (optional) quantanf algorithm
[calculating exact quantizer step boundaries]
- integration : improved (optional) preemphasing/amplifying algorithm
[preemphase only if iteration==1, according to ISO]
- integration : improved (optional) outer_loop algorithm
[amplify the bands, marked as "should be amplified"]
2000-12-10 ap
- definitely killed SCFSI
2001-01-12 ap
- use some explicit type casting to avoid compiler warnings
- clear some backward compatability flags for 0.93.10
2001-04-07 ap
- implemented flag CHECK_TJ_OVERFLOW to check for huffman table overflow
2001-05-02 ap
- bug fix: outer_loop() - correct handling of flag tjBitOverflow2
*/
/* ======================================================================================== */
/* keeping backward compatability */
/* ======================================================================================== */
#define ORG_HUFFMAN_CODING 0 /* 0 = use better Huffman tables for shorter code */
#define ORG_BINARY_SEARCH 0 /* 0 = use a correct implemented binary search */
#define ORG_QUANTANF_INIT 0 /* 0 = use better quantization start value */
#define ORG_PREEMPHASING 0 /* 0 = use a more ISO-like preemphasing algorithm */
#define ORG_SCF_COMPRESS 0 /* 0 = choose better scalefactor compression tables and smart preemphasing */
#define ORG_OUTER_LOOP 0 /* 0 = differ between marked as "been amplified" and "should be amplified" */
#define ORG_HIGHEST_SFB 1 /* 0 = cut off highest frequencies (in last scale factor band) */
#define CHECK_TJ_OVERFLOW 1 /* 1 = check for huffman table overflow */
#define infinity 99999999
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include "system.h"
#include "common.h"
#include "l3side.h"
#include "l3psy.h"
#include "huffman.h"
#include "l3bitstream.h"
#include "reservoir.h"
#include "loop.h"
#include "loop-pvt.h"
#if ORG_HUFFMAN_CODING
static void tiny_single_Huffman_2 /* Escape tables */
(
unsigned start,
unsigned end,
unsigned table0, /* 15... */
unsigned *choice,
unsigned *sum
);
#endif
static int amplify_short (void);
static int amplify_long
(
int iteration
);
int my_nint (double in)
{
if (in < 0)
return (int)(in - 0.5);
else
return (int)(in + 0.5);
}
/*
Here are MPEG1 Table B.8 and MPEG2 Table B.1
-- Layer III scalefactor bands.
Index into this using a method such as:
idx = fr_ps->header->sampling_frequency
+ (fr_ps->header->version * 3)
*/
struct scalefac_struct sfBandIndex[3] =
{
{ /* Table B.8.b: 44.1 kHz */
{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,22,30,40,52,66,84,106,136,192}
},
{ /* Table B.8.c: 48 kHz */
{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,22,28,38,50,64,80,100,126,192}
},
{ /* Table B.8.a: 32 kHz */
{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
{0,4,8,12,16,22,30,42,58,78,104,138,180,192}
}
};
/*
The following table is used to implement the scalefactor
partitioning for MPEG2 as described in section
2.4.3.2 of the IS. The indexing corresponds to the
way the tables are presented in the IS:
[table_number][row_in_table][column of nr_of_sfb]
*/
static unsigned nr_of_sfb_block[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}
}
};
/* Table B.6: layer3 preemphasis */
int pretab[21] =
{
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1,
1, 2, 2, 3, 3, 3, 2
};
/* This is the scfsi_band table from 2.4.2.7 of the IS */
int scfsi_band_long[5] = { 0, 6, 11, 16, 21 };
int *scalefac_band_long;
int *scalefac_band_short;
int fInit_iteration_loop;
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
int tjBitOverflow2;
#endif
/* We need this initialization here since some compilers chokes on the
the declaration if it constains an initialization that point directly
into a struct.
*/
void fixStatic_loop( void )
{
scalefac_band_long = &sfBandIndex[0].l[0];
scalefac_band_short = &sfBandIndex[0].s[0];
}
/* ======================================================================== */
/* generating the power tables */
/* ======================================================================== */
#define BOT 200
#define POW216_MAX (BOT/2 * 16)
#define POW216_MIN (-25 * 16)
static double pow216_space[POW216_MAX-POW216_MIN+1];
static double *pow216 = pow216_space - POW216_MIN;
static double noisePowTab[8191+15];
void genNoisePowTab (void)
{
int i;
for (i = POW216_MIN; i <= POW216_MAX; i++)
pow216[i] = pow (2.0, (double)i/16.0);
for (i = 0; i < 8191+15; i++)
noisePowTab[i] = pow (i, 4.0/3.0);
}
/* ======================================================================== */
/* static variables */
/* ======================================================================== */
static int gr; /* the current granule */
static int ch; /* the current channel */
static III_side_info_t *side_info; /* the current side information */
static gr_info *cod_info; /* the current coding information */
static double *xr_org_l; /* the initial magnitudes of the spectral values */
static double xr34_l[576]; /* the magnitudes powered by 3/4 */
static int *ix_l; /* quantized values */
static double energy_l[SFB_LMAX];
static double xmin_l[SFB_LMAX]; /* the allowed distortion of the scalefactor band */
static double xfsf_l[SFB_LMAX]; /* the current distortion of the scalefactor band */
static int expo16_l[SFB_LMAX]; /* sixteen times the scale factor band exponent */
static int *scalefac_l; /* the current scale factors */
static int *scalefac_0_l; /* scale factors for first granule */
static double (*xr_org_s)[3]; /* some short block versions */
static double (*xr34_s)[3] = (double (*)[3]) xr34_l;
static int (*ix_s)[3];
static double energy_s[SFB_SMAX][3];
static double xmin_s[SFB_SMAX][3];
static double xfsf_s[SFB_SMAX][3];
static int expo16_s[SFB_SMAX][3];
static int (*scalefac_s)[3];
static int max_used_sfb_l;
static int min_used_sfb_s;
static int end_sfb_l;
static int end_sfb_s;
static double xmax_l[SFB_LMAX]; /* The initial (absolute) maximum magnitude */
static int xmax_line_l[SFB_LMAX]; /* of the long bands and their line indices */
static double xmax_s[SFB_SMAX][3]; /* Guess ... */
static int xmax_line_s[SFB_SMAX][3];
static int mark_idx_l; /* speed up - partial quantizing */
static int mark_tab_l[SFB_LMAX]; /* changed sfb-s */
static int mark_idx_s;
static int mark_tab_s[SFB_SMAX*3*2]; /* changed (sfb,b)-s */
#if !ORG_QUANTANF_INIT
static int lo_quant_l [SFB_LMAX];
static int hi_quant_l [SBMAX_l];
static int lo_quant_s [SFB_SMAX][3];
static int hi_quant_s [SFB_SMAX][3];
static int the_lo_quant;
static int the_hi_quant;
static double log_2, cc, dd;
#endif
/* ======================================================================== */
/* iteration_loop */
/* ======================================================================== */
void iteration_loop
(
double pe[][2],
double xr_org[2][2][576],
III_psy_ratio *ratio,
III_side_info_t *l3_side,
int l3_enc[2][2][576],
int mean_bits,
int stereo,
double xr_dec[2][2][576],
III_scalefac_t *scalefac,
frame_params *fr_ps,
int ancillary_pad,
int bitsPerFrame
)
{
int max_bits;
int i, sfb, b, scfsi_band;
int mode_gr;
int *main_data_begin;
layer *info;
int start, end;
#if ORG_QUANTANF_INIT
double log_sum;
#endif
double total_energy, temp, x;
side_info = l3_side;
main_data_begin = &side_info->main_data_begin;
info = fr_ps->header;
side_info->resvDrain = 0;
if (!fInit_iteration_loop)
{
*main_data_begin = 0;
fInit_iteration_loop = 1;
#if !ORG_QUANTANF_INIT
log_2 = log(2.0);
cc = 4.0/3.0 * log(8205.0 - 0.5 + 0.0946) / log_2;
dd = 4.0/3.0 * log( 1.0 - 0.5 + 0.0946) / log_2;
#endif
}
mode_gr = 2;
scalefac_band_long = &sfBandIndex[info->sampling_frequency].l[0];
scalefac_band_short = &sfBandIndex[info->sampling_frequency].s[0];
ResvFrameBegin (fr_ps, side_info, mean_bits, bitsPerFrame);
for (gr = 0; gr < mode_gr; gr++)
{
for (ch = 0; ch < stereo; ch++)
{
xr_org_l = xr_org[gr][ch];
xr_org_s = (double (*)[3]) xr_org_l;
ix_l = l3_enc[gr][ch];
ix_s = (int (*)[3]) ix_l;
cod_info = &side_info->gr[gr].ch[ch].tt;
scalefac_l = scalefac->l[gr][ch]; scalefac_0_l = scalefac->l[0][ch];
scalefac_s = scalefac->s[gr][ch];
/* reset of iteration variables */
for (scfsi_band = 0; scfsi_band < 4; scfsi_band++)
cod_info->slen[scfsi_band] = 0;
cod_info->sfb_partition_table = &nr_of_sfb_block[0][0][0];
cod_info->part2_3_length = 0;
cod_info->big_values = 0;
cod_info->count1 = 0;
cod_info->scalefac_compress = 0;
cod_info->table_select[0] = 0;
cod_info->table_select[1] = 0;
cod_info->table_select[2] = 0;
cod_info->subblock_gain[0] = 0;
cod_info->subblock_gain[1] = 0;
cod_info->subblock_gain[2] = 0;
cod_info->region0_count = 0;
cod_info->region1_count = 0;
cod_info->part2_length = 0;
cod_info->preflag = 0;
cod_info->scalefac_scale = 0;
cod_info->quantizerStepSize = 0.0;
cod_info->count1table_select = 0;
/* ======== gr_deco ======== */
if (cod_info->window_switching_flag && (cod_info->block_type == SHORT_TYPE))
{
if (cod_info->mixed_block_flag)
{
/*
In mixed blocks there come first 8 long scale factor band areas covering
the place normally used by the first 3 short scale factor band areas.
*/
max_used_sfb_l = cod_info->sfb_lmax = 8;
min_used_sfb_s = cod_info->sfb_smax = 3;
/* The following values don� need to be set again and again ... */
cod_info->region0_count = 7; /* scalefac_band_long[7+1 ] = 36 */
cod_info->region1_count = 13; /* scalefac_band_long[7+13+2] = 576 (no region2) */
}
else
{
max_used_sfb_l = cod_info->sfb_lmax = 0; /* No long blocks */
min_used_sfb_s = cod_info->sfb_smax = 0;
/* The following values don� need to be set again and again ... */
cod_info->region0_count = 8; /* scalefac_band_short[(8+1 )/3] = 12 ( 12*3 = 36) */
cod_info->region1_count = 36; /* 36? should be 29: scalefac_band_short[(8+29+2)/3] = 192 (192*3 = 576) */
/* probably meant : scalefac_band_short[36/3 + 1 ] = 192 (192*3 = 576) */
/* 2000-02-27 AP no effect on output because block_type != NORM_TYPE */
}
/* to access the entire array we need the last scalefac_band_short area */
end_sfb_l = max_used_sfb_l; /*cod_info->sfb_lmax;*/
end_sfb_s = SFB_SMAX;
/* The following values don� need to be set again and again ... */
cod_info->count1 = 0; /* (zero_region-bigv_region) / 4; */
cod_info->big_values = 288; /* bigv_region / 2; */
cod_info->count1table_select = 1; /* sum0 == sum1 == 0 */
cod_info->address1 = 36; /* choose one of the region0_count formulas above */
cod_info->address2 = 576; /* bigv_region; */
cod_info->address3 = 0;
}
else
{
max_used_sfb_l = cod_info->sfb_lmax = SBMAX_l;
min_used_sfb_s = cod_info->sfb_smax = SBMAX_s; /* No short blocks */
/* to access the entire array we need the last scalefac_band_long area */
end_sfb_l = SFB_LMAX;
end_sfb_s = min_used_sfb_s; /*cod_info->sfb_smax;*/
}
/* reset of iteration variables */
for (sfb = 0; sfb < max_used_sfb_l/*SFB_LMAX-1*/; sfb++)
scalefac_l[sfb] = 0;
for (sfb = min_used_sfb_s/*0*/; sfb < SFB_SMAX-1; sfb++)
for (b = 0; b < 3; b++)
scalefac_s[sfb][b] = 0;
/* ======== calc_xmin and start of quantanf_init ======== */
/*
Calculate the allowed distortion for each scalefactor band,
as determined by the psychoacoustic model.
xmin(sb) = ratio(sb) * energy(sb) / bandwidth(sb)
*/
#if ORG_QUANTANF_INIT
log_sum = 0.0;
#endif
total_energy = 0.0;
for (sfb = 0; sfb < end_sfb_l; sfb++)
{
start = scalefac_band_long[sfb];
end = scalefac_band_long[sfb+1];
expo16_l[sfb] = 0;
xmax_l[sfb] = 0.0;
xmax_line_l[sfb] = start;
temp = 0.0;
#if !ORG_HIGHEST_SFB
if (sfb < max_used_sfb_l)
{
#endif
for (i = start; i < end; i++)
{
if ((x = fabs(xr_org_l[i])) != 0.0)
{
xr34_l[i] = sqrt(x * sqrt(x));
temp += x*x;
# if ORG_QUANTANF_INIT
log_sum += log(x);
# endif
if (x > xmax_l[sfb])
{
xmax_l[sfb] = x;
xmax_line_l[sfb] = i;
}
}
else
xr34_l[i] = 0.0;
}
#if !ORG_HIGHEST_SFB
}
else /* cut off the (highest frequency) entries in the unused scale factor band */
{
for (i = start; i < end; i++)
xr34_l[i] = 0.0;
}
#endif
total_energy += energy_l[sfb] = temp;
if (sfb < max_used_sfb_l)
xmin_l[sfb] = ratio->l[gr][ch][sfb] * temp;
}
for (sfb = min_used_sfb_s; sfb < end_sfb_s; sfb++)
{
start = scalefac_band_short[sfb];
end = scalefac_band_short[sfb+1];
for (b = 0; b < 3; b++)
{
expo16_s[sfb][b] = 0;
xmax_s[sfb][b] = 0.0;
xmax_line_s[sfb][b] = start;
temp = 0.0;
#if !ORG_HIGHEST_SFB
if (sfb < SBMAX_s)
{
#endif
for (i = start; i < end; i++)
{
if ((x = fabs(xr_org_s[i][b])) != 0.0)
{
xr34_s[i][b] = sqrt(x * sqrt(x));
temp += x*x;
#if ORG_QUANTANF_INIT
log_sum += log(x);
#endif
if (x > xmax_s[sfb][b])
{
xmax_s[sfb][b] = x;
xmax_line_s[sfb][b] = i;
}
}
else
xr34_s[i][b] = 0.0;
}
#if !ORG_HIGHEST_SFB
}
else /* cut off the (highest frequency) entries in the unused scale factor band */
{
for (i = start; i < end; i++)
xr34_s[i][b] = 0.0;
}
#endif
total_energy += energy_s[sfb][b] = temp;
if (sfb < SFB_SMAX-1)
xmin_s[sfb][b] = ratio->s[gr][ch][sfb][b] * temp;
}
}
/* ======== calc_scfsi ======== */
/* None of the granules contains short blocks */
if (!cod_info->window_switching_flag || (cod_info->block_type != SHORT_TYPE))
{
if (gr == 1)
{
for (scfsi_band = 0; scfsi_band < 4; scfsi_band++)
side_info->scfsi[ch][scfsi_band] = 0;
}
}
/* calculation of number of available bit( per granule ) */
max_bits = ResvMaxBits (fr_ps, side_info, &pe[gr][ch], mean_bits);
/* all spectral values zero ? */
if (total_energy != 0.0)
{
#if ORG_QUANTANF_INIT
/* ======== quantanf_init (remaining) ======== */
#define system_const 8.0
#define minlimit -100.0
temp = my_nint (system_const * (log_sum/288.0 - log(total_energy/576.0)));
if (temp < minlimit)
temp = minlimit;
/*
SS 19-12-96. Starting value of
global_gain or quantizerStepSize
has to be reduced for iteration_loop
*/
temp -= 70.0;
cod_info->quantizerStepSize = temp;
#else /* ORG_QUANTANF_INIT */
double xmax, the_xmax;
the_lo_quant = -infinity; /* "-infinity" */
the_hi_quant = -infinity; /* the real maximum for high_quant is about +4 ! */
the_xmax = -1.0;
for (sfb = 0; sfb < end_sfb_l; sfb++)
{
xmax = xmax_l[sfb];
if (xmax == 0.0)
{
lo_quant_l[sfb] = -infinity;
hi_quant_l[sfb] = -infinity;
}
else
{
lo_quant_l[sfb] = floor (4.0 * (log(xmax)/log_2 - cc)) + 1;
hi_quant_l[sfb] = floor (4.0 * (log(xmax)/log_2 - dd)) + 1;
if (xmax > the_xmax)
{
the_xmax = xmax;
the_lo_quant = lo_quant_l[sfb];
the_hi_quant = hi_quant_l[sfb];
}
}
}
for (sfb = min_used_sfb_s; sfb < end_sfb_s; sfb++)
{
for (b = 0; b < 3; b++)
{
xmax = xmax_s[sfb][b];
if (xmax == 0.0)
{
lo_quant_s[sfb][b] = -infinity;
hi_quant_s[sfb][b] = -infinity;
}
else
{
lo_quant_s[sfb][b] = floor (4.0 * (log(xmax)/log_2 - cc) /* - 8 * cod_info->subblock_gain[b] */) + 1;
hi_quant_s[sfb][b] = floor (4.0 * (log(xmax)/log_2 - dd) /* - 8 * cod_info->subblock_gain[b] */) + 1;
if (xmax > the_xmax)
{
the_xmax = xmax;
the_lo_quant = lo_quant_s[sfb][b];
the_hi_quant = hi_quant_s[sfb][b];
}
}
}
}
/*
Try the power table at its least boundary
I�e never reached this deep before!
*/
assert (the_lo_quant > -POW216_MAX);
cod_info->quantizerStepSize = the_lo_quant;
#endif /* ORG_QUANTANF_INIT */
cod_info->part2_3_length = outer_loop (max_bits, fr_ps);
}
ResvAdjust (fr_ps, cod_info, side_info, mean_bits);
cod_info->global_gain = my_nint (cod_info->quantizerStepSize + 210.0);
/* assert (cod_info->global_gain < 256); */
} /* for ch */
} /* for gr */
ResvFrameEnd (fr_ps, side_info, mean_bits);
}
/* ======================================================================== */
/* outer_loop */
/* ======================================================================== */
/*
The outer iteration loop controls the masking conditions
of all scalefactorbands. It computes the best scalefac and
global gain. This module calls the inner iteration loop
*/
static int outer_loop
(
int max_bits,
frame_params *fr_ps
)
{
int scalesave_l[SFB_LMAX-1];
int scalesave_s[SFB_SMAX-1][3];
int bits, huff_bits, save_preflag, save_compress, save_part2_length;
int sfb, b, over, iteration;
/* reset the pointers of our changed sfb [(sfb,b)] indices list */
mark_idx_l = mark_idx_s = 0;
#if 0
cod_info->preflag = 0; /* assignments are all done in iteration_loop() */
cod_info->scalefac_compress = 0; /* just to show what� going on ... */
cod_info->part2_length = 0; /* == part2_length(fr_ps) because of slen1_tab[0] = slen2_tab[0] = 0 */
#endif
huff_bits = max_bits /* - cod_info->part2_length */; /* try first without scaling */
iteration = 1;
bits = bin_search_StepSize (max_bits, cod_info->quantizerStepSize); /* speeds things up a bit */
while (1)
{
for (sfb = 0; sfb < SFB_LMAX-1; sfb++) /* save scaling factors */
scalesave_l[sfb] = scalefac_l[sfb];
for (sfb = 0; sfb < SFB_SMAX-1; sfb++)
for (b = 0; b < 3; b++)
scalesave_s[sfb][b] = scalefac_s[sfb][b];
save_preflag = cod_info->preflag;
save_compress = cod_info->scalefac_compress;
save_part2_length = cod_info->part2_length;
calc_noise (); /* distortion calculation */
over = amplify (iteration);
#if ORG_OUTER_LOOP
/*
misplaced break condition in original dist10:
- There is one flag only for both, marking a scalefactor band as
"should be amplified" or marking it as "is amplified", namely
a corresponding scalefactor greater than zero!
- The desired amplification of the scalefactors bands marked as
"should be amplified" is actually not done before the next call
to quantize(), respectively partial_quantize().
- Thus, it can happen that all scalefactor bands are marked, but
not all of the marked bands are amplified.
- Since loop_break() doesn't know that, the outer loop frequently
gets terminated to early.
*/
if (loop_break ())
break;
#endif
huff_bits = max_bits - needed_bits_for_storing_scalefactors (fr_ps);
if (huff_bits < 0)
break; /* not enough space to store the scale factors */
/* We have to wait checking this break condition */
/* until needed_bits_for_storing_scalefactors() */
/* set the scalefac compress index!!! */
if (over == 0)
break; /* no more bands to amplify */
iteration++;
/*
Most of the times, only a few bands will be changed,
so why quantize the whole area?
*/
partial_quantize ();
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
if (tjBitOverflow2)
bits = infinity;
else
bits = count_bits ();
#else
bits = count_bits ();
#endif
while (bits > huff_bits)
{
cod_info->quantizerStepSize += 1.0;
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
tjBitOverflow2 = FALSE;
quantize ();
if (tjBitOverflow2)
bits = infinity;
else
bits = count_bits ();
#else
quantize ();
bits = count_bits ();
#endif
}
#if !ORG_OUTER_LOOP
/*
A break would mean to restore the parameters of the last iteration,
but we like to accept the current state. If you want to avoid the
'goto', you have to to take the long way home and place the loop
break condition in front of the call to calc_noise().
*/
if (loop_break())
goto take_that_and_party;
#endif
}
cod_info->preflag = save_preflag;
cod_info->scalefac_compress = save_compress;
cod_info->part2_length = save_part2_length;
for (sfb = 0; sfb < SFB_LMAX-1; sfb++)
scalefac_l[sfb] = scalesave_l[sfb];
for (sfb = 0; sfb < SFB_SMAX-1; sfb++)
for (b = 0; b < 3; b++)
scalefac_s[sfb][b] = scalesave_s[sfb][b];
take_that_and_party:
cod_info->part2_3_length = cod_info->part2_length + bits;
return cod_info->part2_3_length;
}
/* ======================================================================================== */
/* needed_bits_for_storing_scalefactors */
/* ======================================================================================== */
/*
counts the bits needed to code the scale factors (cod_info->part2_length)
and the compression index (cod_info->scalefac_compress).
If there is no suitable index, it returns "infinity".
*/
static int needed_bits_for_storing_scalefactors
(
frame_params *fr_ps
)
{
#if 0
static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
#endif
/* 2^^slen1[k] */
static int pow2_slen1[16] = { 1, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16};
/* 2^^slen2[k] */
static int pow2_slen2[16] = { 1, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8};
/* (8+9) * slen1[k] + (9+9) * slen2[k] */
static int part2_len_m[16] = { 0, 18, 36, 54, 51, 35, 53, 71, 52, 70, 88, 69, 87,105,104,122};
/* (9+9) * slen1[k] + (9+9) * slen2[k] */
static int part2_len_s[16] = { 0, 18, 36, 54, 54, 36, 54, 72, 54, 72, 90, 72, 90,108,108,126};
/* (6+5) * slen1[k] + (5+5) * slen2[k] */
static int part2_len_l[16] = { 0, 10, 20, 30, 33, 21, 31, 41, 32, 42, 52, 43, 53, 63, 64, 74};
int sfb, b, k;
int max_slen1, max_slen2, *table;
max_slen1 = max_slen2 = 0;
if (cod_info->window_switching_flag && (cod_info->block_type == SHORT_TYPE))
{
if (cod_info->mixed_block_flag)
{
table = part2_len_m;
for (sfb = 0; sfb < 8; sfb++)
if (scalefac_l[sfb] > max_slen1)
max_slen1 = scalefac_l[sfb];
for (sfb = 3; sfb < 6; sfb++)
for (b = 0; b < 3; b++)
if (scalefac_s[sfb][b] > max_slen1)
max_slen1 = scalefac_s[sfb][b];
}
else
{
table = part2_len_s;
for (sfb = 0; sfb < 6; sfb++)
for (b = 0; b < 3; b++)
if (scalefac_s[sfb][b] > max_slen1)
max_slen1 = scalefac_s[sfb][b];
}
for (sfb = 6; sfb < 12/*SBMAX_s*/; sfb++)
for (b = 0; b < 3; b++)
if (scalefac_s[sfb][b] > max_slen2)
max_slen2 = scalefac_s[sfb][b];
}
else
{
table = part2_len_l;
for (sfb = 0; sfb < 11; sfb++)
if (scalefac_l[sfb] > max_slen1)
max_slen1 = scalefac_l[sfb];
#if ORG_SCF_COMPRESS && !ORG_PREEMPHASING
/* This was seen in LAME */
if (!cod_info->preflag)
{
for (sfb = 11; sfb < SBMAX_l; sfb++)
if (scalefac_l[sfb] < (1 + cod_info->scalefac_scale) * pretab[sfb])
break;
if (sfb == SBMAX_l)
{
for (sfb = 11; sfb < SBMAX_l; sfb++)
scalefac_l[sfb] -= (1 + cod_info->scalefac_scale) * pretab[sfb];
cod_info->preflag = 1;
}
}
#endif
for (sfb = 11; sfb < 21/*SBMAX_l*/; sfb++)
if (scalefac_l[sfb] > max_slen2)
max_slen2 = scalefac_l[sfb];
}
cod_info->part2_length = infinity;
for (k = 0; k < 16; k++)
{
if (max_slen1 < pow2_slen1[k] && max_slen2 < pow2_slen2[k])
{
#if ORG_SCF_COMPRESS
cod_info->scalefac_compress = k;
cod_info->part2_length = table[k];
break;
#else
if (cod_info->part2_length > table[k])
{
cod_info->scalefac_compress = k;
cod_info->part2_length = table[k];
}
#endif
}
}
return cod_info->part2_length;
}
/* ======================================================================================== */
/* calc_noise */
/* ======================================================================================== */
/*
calculates the distortion introduced by the qunatization
in each scale factor band.
*/
static void calc_noise (void)
{
int i, b, sfb, start, end, off;
double f, sum, temp;
off = -4 * (int)cod_info->quantizerStepSize;
for (sfb = 0; sfb < max_used_sfb_l; sfb++)
{
if (ix_l[xmax_line_l[sfb]] == 0) /* quantized values all zero? */
{
xfsf_l[sfb] = energy_l[sfb]; /* see calculation of xmin_l */
}
else
{
start = scalefac_band_long[sfb];
end = scalefac_band_long[sfb+1];
sum = 0.0;
f = pow216[expo16_l[sfb] + off];
for (i = start; i < end; i++)
{
temp = fabs(xr_org_l[i]) - noisePowTab[ix_l[i]] / f;
sum += temp * temp;
}
xfsf_l[sfb] = sum;
}
}
for (b = 0; b < 3; b++)
{
off = -4 * ((int)cod_info->quantizerStepSize + 8 * cod_info->subblock_gain[b]);
for (sfb = min_used_sfb_s; sfb < SFB_SMAX-1; sfb++)
{
if (ix_s[xmax_line_s[sfb][b]] == 0) /* quantized values all zero? */
{
xfsf_s[sfb][b] = energy_s[sfb][b]; /* see calculation of xmin_s */
}
else
{
start = scalefac_band_short[sfb];
end = scalefac_band_short[sfb+1];
sum = 0.0;
f = pow216[expo16_s[sfb][b] + off];
for (i = start; i < end; i++)
{
temp = fabs(xr_org_s[i][b]) - noisePowTab[ix_s[i][b]] / f;
sum += temp * temp;
}
xfsf_s[sfb][b] = sum;
}
}
}
}
/* ======================================================================================== */
/* loop_break */
/* ======================================================================================== */
/*
returns zero if there is a scalefac which has not been amplified.
Otherwise it returns one.
*/
static int loop_break (void)
{
int sfb, b;
for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++)
if (scalefac_l[sfb] == 0)
return 0;
for (sfb = min_used_sfb_s; sfb < 12; sfb++)
for (b = 0; b < 3; b++)
if (scalefac_s[sfb][b] == 0)
return 0;
return 1;
}
/* ======================================================================================== */
/* preemphasing and amplifying */
/* ======================================================================================== */
/*
Preemphasing: see ISO 11172-3 section C.1.5.4.3.4
Amplifying : see ISO 11172-3 section C.1.5.4.3.5
amplifying the scalefactor bands that violate the masking threshold.
*/
static int amplify
(
int iteration
)
{
if (cod_info->window_switching_flag && cod_info->block_type == SHORT_TYPE)
return amplify_short ();
else
return amplify_long (iteration);
}
static int amplify_short (void)
{
int sfb, b, over, expo16_off;
expo16_off = 16 * (1 + cod_info->scalefac_scale) / 2;
over = 0;
#ifdef MIXED_BLOCKS
for (sfb = 0; sfb < max_used_sfb_l; sfb++)
{
if (xfsf_l[sfb] > xmin_l[sfb])
{
scalefac_l[sfb]++;
expo16_l[sfb] += expo16_off;
over++;
mark_tab_l[mark_idx_l++] = sfb;
}
}
#endif
for (sfb = min_used_sfb_s; sfb < SBMAX_s; sfb++)
{
for (b = 0; b < 3; b++)
{
if (xfsf_s[sfb][b] > xmin_s[sfb][b])
{
scalefac_s[sfb][b]++;
expo16_s[sfb][b] += expo16_off;
over++;
mark_tab_s[mark_idx_s++] = sfb;
mark_tab_s[mark_idx_s++] = b;
}
}
}
return over;
}
static int amplify_long
(
int iteration
)
{
int pre_expo_off[SFB_LMAX];
int sfb, stop_at, over = 0;
int expo16_off;
stop_at = max_used_sfb_l;
expo16_off = 16 * (1 + cod_info->scalefac_scale) / 2;
/*
Preemphasis is switched on if in all the upper four scalefactor
bands the actual distortion exceeds the threshold after the
first call of the inner loop.
Original bug of dist10 - preemphasis() didn't know 'iteration'!!!
*/
#if !ORG_PREEMPHASING
if (iteration == 1)
#endif
if (!cod_info->preflag)
{
for (sfb = max_used_sfb_l-4; sfb < max_used_sfb_l; sfb++)
if (xfsf_l[sfb] <= xmin_l[sfb])
goto no_preemphasing;
cod_info->preflag = 1;
stop_at = 11; /* pretab[sfb] = 0 for sfb = 0..10 */
for (sfb = stop_at; sfb < max_used_sfb_l; sfb++)
{
expo16_l[sfb] += pre_expo_off[sfb] = expo16_off * pretab[sfb];
mark_tab_l[mark_idx_l++] = sfb;
}
}
no_preemphasing:
for (sfb = 0; sfb < stop_at; sfb++)
{
if (xfsf_l[sfb] > xmin_l[sfb])
{
over++;
expo16_l[sfb] += expo16_off;
scalefac_l[sfb]++;
mark_tab_l[mark_idx_l++] = sfb;
}
}
for (sfb = stop_at; sfb < max_used_sfb_l; sfb++) /* The just preemphased bands have to be treated differently */
{
if (xfsf_l[sfb] > xmin_l[sfb] * pow216[2*pre_expo_off[sfb]])
{
over++;
expo16_l[sfb] += expo16_off;
scalefac_l[sfb]++;
}
}
return over;
}
/* ======================================================================== */
/* quantize */
/* ======================================================================== */
/*
Quantization of the vector xr ( -> ix)
*/
static int INLINE cutting_crew (FLOAT in)
{
int retVal;
retVal = (int) (in + 0.4054);
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
if (retVal > 8191+14)
tjBitOverflow2 = TRUE;
#endif
return retVal;
}
static void quantize (void)
{
int sfb, i, b, start, end;
double f, z, y;
for (sfb = 0; sfb < end_sfb_l; sfb++)
{
start = scalefac_band_long[sfb];
end = scalefac_band_long[sfb+1];
/* (expo16_l[sfb] - 16/4 * quant_step) * 3/4 */
f = pow216[(expo16_l[sfb]/4 - (int)cod_info->quantizerStepSize) * 3];
for (i = start; i < end; i += 2)
{
z = xr34_l[i ] * f;
y = xr34_l[i+1] * f;
ix_l[i ] = cutting_crew (z);
ix_l[i+1] = cutting_crew (y);
}
}
for (sfb = min_used_sfb_s; sfb < end_sfb_s; sfb++)
{
start = scalefac_band_short[sfb];
end = scalefac_band_short[sfb+1];
for (b = 0; b < 3; b++)
{
/* (expo_s[sfb][b] - 16/4 * (quant_step + 8 * cod_info->subblock_gain[b])) * 3/4 */
f = pow216[(expo16_s[sfb][b] / 4 - (int)cod_info->quantizerStepSize - 8 * cod_info->subblock_gain[b]) * 3];
for (i = start; i < end; i += 2)
{
z = xr34_s[i ][b] * f;
y = xr34_s[i+1][b] * f;
ix_s[i ][b] = cutting_crew (z);
ix_s[i+1][b] = cutting_crew (y);
}
}
}
}
static void partial_quantize (void)
{
int sfb, i, b, start, end;
double f, z, y;
while (mark_idx_l)
{
sfb = mark_tab_l[--mark_idx_l];
start = scalefac_band_long[sfb];
end = scalefac_band_long[sfb+1];
/* (expo16_l[sfb] - 16/4 * quant_step) * 3/4 */
f = pow216[(expo16_l[sfb]/4 - (int)cod_info->quantizerStepSize) * 3];
for (i = start; i < end; i += 2)
{
z = xr34_l[i ] * f;
y = xr34_l[i+1] * f;
ix_l[i ] = cutting_crew (z);
ix_l[i+1] = cutting_crew (y);
}
}
while (mark_idx_s)
{
b = mark_tab_s[--mark_idx_s];
sfb = mark_tab_s[--mark_idx_s];
start = scalefac_band_short[sfb];
end = scalefac_band_short[sfb+1];
/* (expo_16s[sfb][b] - 16/4 * (quant_step + 8 * cod_info->subblock_gain[b])) * 3/4 */
f = pow216[(expo16_s[sfb][b] / 4 - (int)cod_info->quantizerStepSize - 8 * cod_info->subblock_gain[b]) * 3];
for (i = start; i < end; i += 2)
{
z = xr34_s[i ][b] * f;
y = xr34_s[i+1][b] * f;
ix_s[i ][b] = cutting_crew (z);
ix_s[i+1][b] = cutting_crew (y);
}
}
}
/* ======================================================================== */
/* count_bits */
/* ======================================================================== */
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 */
};
/*
Calculation of rzero, count1, big_values
(Partitions ix into big values, quadruples and zeros).
Determines the number of bits to encode the quadruples.
Presumable subdivides the bigvalue region which will
use separate Huffman tables.
Select huffman code tables for bigvalues regions
Count the number of bits necessary to code the bigvalues region.
*/
static int count_bits (void)
{
cod_info->table_select[0] = 0;
cod_info->table_select[1] = 0;
cod_info->table_select[2] = 0;
if (cod_info->window_switching_flag && (cod_info->block_type == SHORT_TYPE))
return count_bits_short ();
else
return count_bits_long ();
}
static int count_bits_short (void)
{
unsigned int bits = 0;
/*
Within each scalefactor band, data is given for successive
time windows, beginning with window 0 and ending with window 2.
Within each window, the quantized values are then arranged in
order of increasing frequency...
*/
int sfb, b;
unsigned int max, temp;
/*
the first part --- 8 long blocks or 3 short blocks
*/
max = 0;
#ifdef MIXED_BLOCKS
if (cod_info->mixed_block_flag)
{
for (sfb = 0; sfb < 8; sfb++)
if ((temp = ix_l[xmax_line_l[sfb]]) > max)
max = temp;
choose_table_long (0, 36, max, &cod_info->table_select[0], &bits);
}
else
#endif
{
for (sfb = 0; sfb < 3; sfb++)
for (b = 0; b < 3; b++)
if ((temp = ix_s[xmax_line_s[sfb][b]][b]) > max)
max = temp;
choose_table_short (0, 3, max, &cod_info->table_select[0], &bits);
}
/*
the second part --- short blocks only
*/
max = 0;
for (sfb = 3; sfb < SFB_SMAX; sfb++)
for (b = 0; b < 3; b++)
if ((temp = ix_s[xmax_line_s[sfb][b]][b]) > max)
max = temp;
choose_table_short (3, SFB_SMAX, max, &cod_info->table_select[1], &bits);
return bits;
}
static int count_bits_long (void)
{
int zero_region;
int bigv_region;
unsigned bits = 0;
int sum0 = 0;
int sum1 = 0;
int sfb_anz, index0, index1, sfb, i;
unsigned max, temp;
int p;
for (zero_region = 576; zero_region > 1; zero_region -= 2)
if (ix_l[zero_region-1]) break;
else if (ix_l[zero_region-2]) break;
for (bigv_region = zero_region; bigv_region > 3; bigv_region -= 4)
{
if (ix_l[bigv_region-1] > 1) break;
else if (ix_l[bigv_region-2] > 1) break;
else if (ix_l[bigv_region-3] > 1) break;
else if (ix_l[bigv_region-4] > 1) break;
p = 0;
if (ix_l[bigv_region-1]) bits++, p |= 8;
if (ix_l[bigv_region-2]) bits++, p |= 4;
if (ix_l[bigv_region-3]) bits++, p |= 2;
if (ix_l[bigv_region-4]) bits++, p |= 1;
sum0 += ht[32].hlen[p];
sum1 += ht[33].hlen[p];
}
cod_info->count1 = (zero_region-bigv_region) / 4;
cod_info->big_values = bigv_region / 2;
if (sum0 < sum1)
{
bits += sum0;
cod_info->count1table_select = 0;
}
else
{
bits += sum1;
cod_info->count1table_select = 1;
}
if (bigv_region)
{
sfb_anz = 1;
while (scalefac_band_long[sfb_anz] < bigv_region)
sfb_anz++;
if (cod_info->window_switching_flag) /* START_TYPE, STOP_TYPE */
{
index0 = (cod_info->region0_count = 7) + 1;
cod_info->region1_count = 13;
index1 = sfb_anz - index0; if (index0 + index1 < 22) index1++;
cod_info->address1 = 36;
cod_info->address2 = bigv_region;
cod_info->address3 = 0;
}
else /* NORM_TYPE */
{
index0 = (cod_info->region0_count = subdv_table[sfb_anz].region0_count) + 1;
index1 = (cod_info->region1_count = subdv_table[sfb_anz].region1_count) + 1;
cod_info->address1 = scalefac_band_long[index0];
cod_info->address2 = scalefac_band_long[index0 + index1];
cod_info->address3 = bigv_region;
}
if (cod_info->address1 > 0)
{
max = 0;
for (sfb = 0; sfb < index0; sfb++)
if ((temp = ix_l[xmax_line_l[sfb]]) > max)
max = temp;
choose_table_long (0, cod_info->address1, max, &cod_info->table_select[0], &bits);
}
if (cod_info->address2 > cod_info->address1)
{
max = 0;
for (sfb = index0; sfb < index0+index1; sfb++)
if ((temp = ix_l[xmax_line_l[sfb]]) > max)
max = temp;
choose_table_long (cod_info->address1, cod_info->address2, max, &cod_info->table_select[1], &bits);
}
if (bigv_region > cod_info->address2)
{
max = 0;
for (sfb = index0+index1; sfb < sfb_anz-1; sfb++)
if ((temp = ix_l[xmax_line_l[sfb]]) > max)
max = temp;
for (i = scalefac_band_long[sfb_anz-1]; i < bigv_region; i++)
if ((temp = ix_l[i]) > max)
max = temp;
choose_table_long (cod_info->address2, bigv_region, max, &cod_info->table_select[2], &bits);
}
}
else
{ /* no big_values region */
cod_info->region0_count = 0;
cod_info->region1_count = 0;
cod_info->address1 = 0;
cod_info->address2 = 0;
cod_info->address3 = 0;
}
return bits;
}
/* ======================================================================== */
/* bin_search_step_size */
/* ======================================================================== */
/*
The following optional code written by Seymour Shlien
will speed up the outer_loop code which is called
by iteration_loop. When BIN_SEARCH is defined, the
outer_loop function precedes the call to the function inner_loop
with a call to bin_search gain defined below, which
returns a good starting quantizerStepSize.
The function count_bits() [a sequence of statements, originally part of inner_loop()]
was completely rewritten.
changed the behaviour:
now, it returns the found number of bits <= desired_rate
*/
static int bin_search_StepSize
(
int desired_rate,
double start
)
{
int bits;
int top = start;
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT
int bot = 200;
#else
int bot = the_hi_quant;
#endif
int next = start;
#if ORG_BINARY_SEARCH
int last;
do
{
last = next;
next = (top + bot) / 2;
cod_info->quantizerStepSize = next;
tjBitOverflow2 = FALSE;
quantize ();
if (tjBitOverflow2)
bits = infinity;
else
bits = count_bits ();
if (bits > desired_rate)
top = next;
else
bot = next;
}
while ((bits != desired_rate) && (abs(last-next) > 1));
#else /* ORG_BINARY_SEARCH */
do
{
next = top + (bot - top) / 2;
cod_info->quantizerStepSize = next;
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
tjBitOverflow2 = FALSE;
quantize ();
if (tjBitOverflow2)
bits = infinity;
else
bits = count_bits ();
#else
quantize ();
bits = count_bits ();
#endif
if (bits > desired_rate)
top = next + 1;
else
bot = next;
}
while (top < bot);
#endif /* ORG_BINARY_SEARCH */
if (bits > desired_rate)
{
cod_info->quantizerStepSize = next+1;
#if ORG_BINARY_SEARCH || ORG_QUANTANF_INIT || CHECK_TJ_OVERFLOW
tjBitOverflow2 = FALSE;
quantize ();
assert(! tjBitOverflow2);
#else
quantize ();
#endif
bits = count_bits ();
assert(bits <= desired_rate);
}
return bits;
}
/* ======================================================================================== */
/* choose_table_long */
/* ======================================================================================== */
/*
Choose the Huffman table that will encode ix[start..end] with the fewest
bits and increases the bit_sum by the amount of these 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 void choose_table_long
(
unsigned start,
unsigned end,
unsigned max,
unsigned *table,
unsigned *bit_sum
)
{
unsigned choice0, choice1;
if (max == 0)
{
*table = 0;
return;
}
if (max < 15)
{
choice0 = 1; /* we can start with 1 because ht[0].xlen == 0 <= max */
while (ht[choice0].xlen <= max)
choice0++;
switch (choice0)
{
case 1: single_Huffman (start, end,/* 1 */ table, bit_sum); break;
case 2: double_Huffman (start, end, 2, 3, table, bit_sum); break;
case 5: double_Huffman (start, end, 5, 6, table, bit_sum); break;
case 7: triple_Huffman (start, end, 7, 8, 9, table, bit_sum); break;
case 10: triple_Huffman (start, end, 10, 11, 12, table, bit_sum); break;
case 13: double_Huffman (start, end, 13, 15, table, bit_sum); break;
}
}
#if !ORG_HUFFMAN_CODING /* no part of original BladeEnc */
else if (max == 15)
{
triple_Huffman_2 (start, end,/* 13, 15, 24, */ table, bit_sum);
}
#endif
else
{
max -= 15;
#if ORG_HUFFMAN_CODING
choice0 = 15; while (ht[choice0].linmax < max) choice0++;
#else
choice0 = 16; while (ht[choice0].linmax < max) choice0++;
#endif
assert(choice0 < 24);
choice1 = 24; while (ht[choice1].linmax < max) choice1++;
assert(choice1 < 32);
#if ORG_HUFFMAN_CODING
double_Huffman_2 (start, end, choice1, choice0, table, bit_sum);
#else
double_Huffman_2 (start, end, choice0, choice1, table, bit_sum);
#endif
}
}
/* ======================================================================================== */
/* choose_table_short */
/* ======================================================================================== */
/*
Choose the Huffman table that will encode ix[start_sfb..end_sfb][0..2]
with the fewest bits and increases the bit_sum by the amount of these 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 void choose_table_short
(
unsigned start_sfb,
unsigned end_sfb,
unsigned max,
unsigned *table,
unsigned *bit_sum
)
{
unsigned choice0;
#if !ORG_HUFFMAN_CODING
unsigned choice1;
#endif
int start, end;
start = 3 * scalefac_band_short[start_sfb];
end = 3 * scalefac_band_short[ end_sfb];
if (max == 0)
{
*table = 0;
return;
}
if (max < 15)
{
choice0 = 1; /* we can start with 1 because ht[0].xlen == 0 <= max */
while (ht[choice0].xlen <= max)
choice0++;
#if ORG_HUFFMAN_CODING
tiny_single_Huffman (start, end, choice0, table, bit_sum);
#else
switch (choice0)
{
case 1: tiny_single_Huffman (start, end,/* 1 */ table, bit_sum); break;
case 2: tiny_double_Huffman (start, end, 2, 3, table, bit_sum); break;
case 5: tiny_double_Huffman (start, end, 5, 6, table, bit_sum); break;
case 7: tiny_triple_Huffman (start, end, 7, 8, 9, table, bit_sum); break;
case 10: tiny_triple_Huffman (start, end, 10, 11, 12, table, bit_sum); break;
case 13: tiny_double_Huffman (start, end, 13, 15, table, bit_sum); break;
}
#endif
}
#if !ORG_HUFFMAN_CODING /* no part of original BladeEnc */
else if (max == 15)
{
tiny_triple_Huffman_2 (start, end,/* 13, 15, 24, */ table, bit_sum);
}
#endif
else
{
max -= 15;
#if ORG_HUFFMAN_CODING
choice0 = 15; while (ht[choice0].linmax < max) choice0++;
assert(choice0 < 24);
tiny_single_Huffman_2 (start, end, choice0, table, bit_sum);
#else
choice0 = 16; while (ht[choice0].linmax < max) choice0++;
assert(choice0 < 24);
choice1 = 24; while (ht[choice1].linmax < max) choice1++;
assert(choice1 < 32);
tiny_double_Huffman_2 (start, end, choice0, choice1, table, bit_sum);
#endif
}
}
/* ======================================================================================== */
/* Huffmania */
/* ======================================================================================== */
/*
That case, we don� need to decide which is the best table.
*/
static void single_Huffman
(
unsigned start,
unsigned end,
/* unsigned table0, == 1 */
unsigned *choice,
unsigned *sum
)
{
/*
int v;
*/
unsigned bits0, signs, idx;
static struct huffcodetab *h0 = ht + /* table0 */ 1; /* static because of the constant!!! */
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == 2 */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = signs = 0;
while (pos < fin)
{
idx = 0;
#if 0
v = *pos++; if (v) {signs++; idx = v /* * ylen */ + v;}
v = *pos++; if (v) {signs++; idx += v;}
#else
if (*pos++) {signs++; idx = 2;}
if (*pos++) {signs++; idx++;}
#endif
bits0 += h0->hlen[idx];
}
*choice = /* table0 */ 1;
*sum += bits0 + signs;
}
#if ORG_HUFFMAN_CODING
static void tiny_single_Huffman
(
unsigned start,
unsigned end,
unsigned table0,
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, signs, idx0, idx1, idx2;
struct huffcodetab *h0 = ht + table0;
unsigned ylen = h0->ylen;
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = signs = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {signs++; idx0 = v0 * ylen;}
v1 = *pos++; if (v1) {signs++; idx1 = v1 * ylen;}
v2 = *pos++; if (v2) {signs++; idx2 = v2 * ylen;}
v0 = *pos++; if (v0) {signs++; idx0 += v0;}
v1 = *pos++; if (v1) {signs++; idx1 += v1;}
v2 = *pos++; if (v2) {signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
}
*choice = table0;
*sum += bits0 + signs;
}
#else
static void tiny_single_Huffman
(
unsigned start,
unsigned end,
/* unsigned table0 == 1 */
unsigned *choice,
unsigned *sum
)
{
/*
int v0, v1, v2;
*/
unsigned bits0, signs, idx0, idx1, idx2;
static struct huffcodetab *h0 = ht + /* table0 */ 1; /* static because of the constant!!! */
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == 2 --- static because of the constant!!! */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = signs = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
if (*pos++) {signs++; idx0 = 2;}
if (*pos++) {signs++; idx1 = 2;}
if (*pos++) {signs++; idx2 = 2;}
if (*pos++) {signs++; idx0++;}
if (*pos++) {signs++; idx1++;}
if (*pos++) {signs++; idx2++;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
}
*choice = /* table0 */ 1;
*sum += bits0 + signs;
}
#endif
#if ORG_HUFFMAN_CODING
static void tiny_single_Huffman_2 /* Escape tables */
(
unsigned start,
unsigned end,
unsigned table0, /* 15... */
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, signs, xbits, idx0, idx1, idx2;
struct huffcodetab *h0 = ht + table0;
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == h1->ylen == 16 --- static because of the constant!!! */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = signs = xbits = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {if (v0 > 14) {v0 = 15; xbits++;} signs++; idx0 = v0 /* * ylen */ << 4;}
v1 = *pos++; if (v1) {if (v1 > 14) {v1 = 15; xbits++;} signs++; idx1 = v1 /* * ylen */ << 4;}
v2 = *pos++; if (v2) {if (v2 > 14) {v2 = 15; xbits++;} signs++; idx2 = v2 /* * ylen */ << 4;}
v0 = *pos++; if (v0) {if (v0 > 14) {v0 = 15; xbits++;} signs++; idx0 += v0;}
v1 = *pos++; if (v1) {if (v1 > 14) {v1 = 15; xbits++;} signs++; idx1 += v1;}
v2 = *pos++; if (v2) {if (v2 > 14) {v2 = 15; xbits++;} signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
}
bits0 += xbits * h0->linbits;
*choice = table0;
*sum += bits0 + signs;
}
#endif
/*
The following function is called for the most maximum values below 16 (respectively 15)
*/
static void double_Huffman
(
unsigned start,
unsigned end,
unsigned table0, /* 2, 5, 13 */
unsigned table1, /* 3, 6, 15 */
unsigned *choice,
unsigned *sum
)
{
int v;
unsigned bits0, bits1, signs, idx;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
unsigned ylen = h0->ylen; /* == h1->ylen */
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = signs = 0;
while (pos < fin)
{
idx = 0;
v = *pos++; if (v) {signs++; idx = v * ylen;}
v = *pos++; if (v) {signs++; idx += v;}
bits0 += h0->hlen[idx];
bits1 += h1->hlen[idx];
}
if (bits0 < bits1)
{
*choice = table0;
*sum += bits0 + signs;
}
else
{
*choice = table1;
*sum += bits1 + signs;
}
}
static void tiny_double_Huffman
(
unsigned start,
unsigned end,
unsigned table0, /* 2, 5, 13 */
unsigned table1, /* 3, 6, 15 */
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, bits1, signs, idx0, idx1, idx2;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
unsigned ylen = h0->ylen; /* == h1->ylen */
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = signs = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {signs++; idx0 = v0 * ylen;}
v1 = *pos++; if (v1) {signs++; idx1 = v1 * ylen;}
v2 = *pos++; if (v2) {signs++; idx2 = v2 * ylen;}
v0 = *pos++; if (v0) {signs++; idx0 += v0;}
v1 = *pos++; if (v1) {signs++; idx1 += v1;}
v2 = *pos++; if (v2) {signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
bits1 += h1->hlen[idx0] + h1->hlen[idx1] + h1->hlen[idx2];
}
if (bits0 < bits1)
{
*choice = table0;
*sum += bits0 + signs;
}
else
{
*choice = table1;
*sum += bits1 + signs;
}
}
/*
poor men� brave tailor --- only three at a blow...
*/
static void triple_Huffman
(
unsigned start,
unsigned end,
unsigned table0, /* 7, 10 */
unsigned table1, /* 8, 11 */
unsigned table2, /* 9, 12 */
unsigned *choice,
unsigned *sum
)
{
int v;
unsigned bits0, bits1, bits2, signs, idx;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
struct huffcodetab *h2 = ht + table2;
unsigned ylen = h0->ylen; /* == h1->ylen == h2->ylen */
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = bits2 = signs = 0;
while (pos < fin)
{
idx = 0;
v = *pos++; if (v) {signs++; idx = v * ylen;}
v = *pos++; if (v) {signs++; idx += v;}
bits0 += h0->hlen[idx];
bits1 += h1->hlen[idx];
bits2 += h2->hlen[idx];
}
if (bits0 < bits1 && bits0 < bits2)
{
*choice = table0;
*sum += bits0 + signs;
}
else if (bits1 < bits2)
{
*choice = table1;
*sum += bits1 + signs;
}
else
{
*choice = table2;
*sum += bits2 + signs;
}
}
static void tiny_triple_Huffman
(
unsigned start,
unsigned end,
unsigned table0, /* 7, 10 */
unsigned table1, /* 8, 11 */
unsigned table2, /* 9, 12 */
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, bits1, bits2, signs, idx0, idx1, idx2;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
struct huffcodetab *h2 = ht + table2;
unsigned ylen = h0->ylen; /* == h1->ylen == h2->ylen */
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = bits2 = signs = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {signs++; idx0 = v0 * ylen;}
v1 = *pos++; if (v1) {signs++; idx1 = v1 * ylen;}
v2 = *pos++; if (v2) {signs++; idx2 = v2 * ylen;}
v0 = *pos++; if (v0) {signs++; idx0 += v0;}
v1 = *pos++; if (v1) {signs++; idx1 += v1;}
v2 = *pos++; if (v2) {signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
bits1 += h1->hlen[idx0] + h1->hlen[idx1] + h1->hlen[idx2];
bits2 += h2->hlen[idx0] + h2->hlen[idx1] + h2->hlen[idx2];
}
if (bits0 < bits1 && bits0 < bits2)
{
*choice = table0;
*sum += bits0 + signs;
}
else if (bits1 < bits2)
{
*choice = table1;
*sum += bits1 + signs;
}
else
{
*choice = table2;
*sum += bits2 + signs;
}
}
/*
The escape table 24 deals with linbits=4 instead of linbits=0 in case of table 13 and 15.
Nevertheless, sometimes it produces the better result...
Furthermore we take advantage because of the constant table numbers.
*/
static void triple_Huffman_2
(
unsigned start,
unsigned end,
/* unsigned table0, == 13 */
/* unsigned table1, == 15 */
/* unsigned table2, == 24 */
unsigned *choice,
unsigned *sum
)
{
int v;
unsigned bits0, bits1, bits2, signs, idx;
static struct huffcodetab *h0 = ht + /* table0 */ 13; /* all static declarations because of the constant values!!! */
static struct huffcodetab *h1 = ht + /* table1 */ 15;
static struct huffcodetab *h2 = ht + /* table2 */ 24;
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == h1->ylen == h2->ylen */ /* == 16 */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = bits2 = signs = 0;
while (pos < fin)
{
idx = 0;
v = *pos++; if (v) {if (v == 15) bits2 += /* h2->linbits */ 4; signs++; idx = v /* * ylen */ << 4;}
v = *pos++; if (v) {if (v == 15) bits2 += /* h2->linbits */ 4; signs++; idx += v;}
bits0 += h0->hlen[idx];
bits1 += h1->hlen[idx];
bits2 += h2->hlen[idx];
}
if (bits0 < bits1 && bits0 < bits2)
{
*choice = /* table0 */ 13;
*sum += bits0 + signs;
}
else if (bits1 < bits2)
{
*choice = /* table1 */ 15;
*sum += bits1 + signs;
}
else
{
*choice = /* table2 */ 24;
*sum += bits2 + signs;
}
}
static void tiny_triple_Huffman_2
(
unsigned start,
unsigned end,
/* unsigned table0, == 13 */
/* unsigned table1, == 15 */
/* unsigned table2, == 24 */
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, bits1, bits2, signs, idx0, idx1, idx2;
static struct huffcodetab *h0 = ht + /* table0 */ 13; /* all static declarations because of the constant values!!! */
static struct huffcodetab *h1 = ht + /* table1 */ 15;
static struct huffcodetab *h2 = ht + /* table2 */ 24;
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == h1->ylen == h2->ylen */ /* == 16 */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = bits2 = signs = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {if (v0 == 15) bits2 += /* h2->linbits */ 4; signs++; idx0 = v0 /* * ylen */ << 4;}
v1 = *pos++; if (v1) {if (v1 == 15) bits2 += /* h2->linbits */ 4; signs++; idx1 = v1 /* * ylen */ << 4;}
v2 = *pos++; if (v2) {if (v2 == 15) bits2 += /* h2->linbits */ 4; signs++; idx2 = v2 /* * ylen */ << 4;}
v0 = *pos++; if (v0) {if (v0 == 15) bits2 += /* h2->linbits */ 4; signs++; idx0 += v0;}
v1 = *pos++; if (v1) {if (v1 == 15) bits2 += /* h2->linbits */ 4; signs++; idx1 += v1;}
v2 = *pos++; if (v2) {if (v2 == 15) bits2 += /* h2->linbits */ 4; signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
bits1 += h1->hlen[idx0] + h1->hlen[idx1] + h1->hlen[idx2];
bits2 += h2->hlen[idx0] + h2->hlen[idx1] + h2->hlen[idx2];
}
if (bits0 < bits1 && bits0 < bits2)
{
*choice = /* table0 */ 13;
*sum += bits0 + signs;
}
else if (bits1 < bits2)
{
*choice = /* table1 */ 15;
*sum += bits1 + signs;
}
else
{
*choice = /* table2 */ 24;
*sum += bits2 + signs;
}
}
/*
In case of two escape tables, we esepecially have to take care for
the possibly different linbits values...
*/
static void double_Huffman_2 /* Escape tables */
(
unsigned start,
unsigned end,
unsigned table0, /* 16... */
unsigned table1, /* 24... */
unsigned *choice,
unsigned *sum
)
{
int v;
unsigned bits0, bits1, signs, xbits, idx;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == h1->ylen */ /* == 16 */
#endif
unsigned linbits0 = h0->linbits;
unsigned linbits1 = h1->linbits;
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = signs = xbits = 0;
while (pos < fin)
{
idx = 0;
v = *pos++; if (v) {if (v > 14) {v = 15; xbits++;/*bits0 += linbits0; bits1 += linbits1;*/} signs++; idx = v /* * ylen */ << 4;}
v = *pos++; if (v) {if (v > 14) {v = 15; xbits++;/*bits0 += linbits0; bits1 += linbits1;*/} signs++; idx += v;}
bits0 += h0->hlen[idx];
bits1 += h1->hlen[idx];
}
bits0 += xbits * linbits0;
bits1 += xbits * linbits1;
if (bits0 < bits1)
{
*choice = table0;
*sum += bits0 + signs;
}
else
{
*choice = table1;
*sum += bits1 + signs;
}
}
static void tiny_double_Huffman_2 /* Escape tables */
(
unsigned start,
unsigned end,
unsigned table0, /* 16... */
unsigned table1, /* 24... */
unsigned *choice,
unsigned *sum
)
{
int v0, v1, v2;
unsigned bits0, bits1, signs, xbits, idx0, idx1, idx2;
struct huffcodetab *h0 = ht + table0;
struct huffcodetab *h1 = ht + table1;
#if 0 /* not needed */
static unsigned ylen = h0->ylen; /* == h1->ylen == 16 --- static because of the constant!!! */
#endif
int *pos = ix_l + start;
int *fin = ix_l + end;
bits0 = bits1 = signs = xbits = 0;
while (pos < fin)
{
idx0 = idx1 = idx2 = 0;
v0 = *pos++; if (v0) {if (v0 > 14) {v0 = 15; xbits++;} signs++; idx0 = v0 /* * ylen */ << 4;}
v1 = *pos++; if (v1) {if (v1 > 14) {v1 = 15; xbits++;} signs++; idx1 = v1 /* * ylen */ << 4;}
v2 = *pos++; if (v2) {if (v2 > 14) {v2 = 15; xbits++;} signs++; idx2 = v2 /* * ylen */ << 4;}
v0 = *pos++; if (v0) {if (v0 > 14) {v0 = 15; xbits++;} signs++; idx0 += v0;}
v1 = *pos++; if (v1) {if (v1 > 14) {v1 = 15; xbits++;} signs++; idx1 += v1;}
v2 = *pos++; if (v2) {if (v2 > 14) {v2 = 15; xbits++;} signs++; idx2 += v2;}
bits0 += h0->hlen[idx0] + h0->hlen[idx1] + h0->hlen[idx2];
bits1 += h1->hlen[idx0] + h1->hlen[idx1] + h1->hlen[idx2];
}
bits0 += xbits * h0->linbits;
bits1 += xbits * h1->linbits;
if (bits0 < bits1)
{
*choice = table0;
*sum += bits0 + signs;
}
else
{
*choice = table1;
*sum += bits1 + signs;
}
}
|
