www.pudn.com > T-REC-G.722.1-200505-I!!SOFT-ZST-E.zip > encoder.c
/*****************************************************************
******************************************************************
**
** ITU-T Wideband Coder Candidate (G.WB) Source Code
**
** File Name : encoder.c
**
** © 2000 PictureTel Coporation
** Andover, MA, USA
**
** All rights reserved.
**
**************************************************************************/
/***************************************************************************
Filename: encoder.c
Original Author:
Creation Date:
Purpose: Contains files used to implement
the G.722.1 encoder
***************************************************************************/
/***************************************************************************
Include files
***************************************************************************/
#include
#include
#include "defs.h"
#include "huff_defs.h"
/* local function declarations */
int compute_region_powers(int, float [], int [], int [], int[]);
void vector_quantize_mlts(int, int, float [], int[], int [], int [], int *,
int [], int []);
int vector_huffman(int , int, float *, int *);
extern float region_standard_deviation_table[REGION_POWER_TABLE_SIZE];
extern float standard_deviation_inverse_table[REGION_POWER_TABLE_SIZE];
extern float step_size_inverse_table[NUM_CATEGORIES];
extern float dead_zone[NUM_CATEGORIES];
extern int region_size;
extern float region_size_inverse;
extern float region_power_table[REGION_POWER_TABLE_SIZE];
extern float region_power_table_boundary[REGION_POWER_TABLE_SIZE-1];
extern int differential_region_power_bits[MAX_NUM_REGIONS][DIFF_REGION_POWER_LEVELS];
extern int differential_region_power_codes[MAX_NUM_REGIONS][DIFF_REGION_POWER_LEVELS];
extern int table_of_bitcount_tables[NUM_CATEGORIES-1];
extern int table_of_code_tables[NUM_CATEGORIES-1];
extern int vector_dimension[NUM_CATEGORIES];
extern int number_of_vectors[NUM_CATEGORIES];
extern float step_size[NUM_CATEGORIES];
extern int max_bin[NUM_CATEGORIES];
static int num_rate_control_bits;
static int num_rate_control_possibilities;
/***************************************************************************
Procedure/Function: encoder
Syntax: void encoder( number_of_regions,
number_of_available_bits,
mlt_coefs,
out_words)
int number_of_regions;
int number_of_available_bits;
float mlt_coefs[MAX_DCT_SIZE];
short int out_words[MAX_BITS_PER_FRAME/16];
inputs: number_of_regions
number_of_available_bits
mlt_coefs[MAX_DCT_SIZE]
outputs: out_words[MAX_BITS_PER_FRAME/16]
Description: Encodes the mlt coefs into out_words using the G.722.1 algorithm
***************************************************************************/
void encoder(number_of_regions,
number_of_available_bits,
mlt_coefs,
out_words)
int number_of_regions;
int number_of_available_bits;
float mlt_coefs[MAX_DCT_SIZE];
short int out_words[MAX_BITS_PER_FRAME/16];
{
extern void categorize(int, int, int[], int[], int[]);
int number_of_bits_per_frame;
int number_of_envelope_bits;
int rate_control;
int region;
int absolute_region_power_index[MAX_NUM_REGIONS];
int power_categories[MAX_NUM_REGIONS];
int category_balances[MAX_NUM_RATE_CONTROL_POSSIBILITIES-1];
int drp_num_bits[MAX_NUM_REGIONS+1];
int drp_code_bits[MAX_NUM_REGIONS+1];
int region_mlt_bit_counts[MAX_NUM_REGIONS];
int region_mlt_bits[4*MAX_NUM_REGIONS];
if (number_of_regions <= 14) {
num_rate_control_bits = 4;
num_rate_control_possibilities = 16;
}
number_of_bits_per_frame = number_of_available_bits;
/* Estimate power envelope. */
number_of_envelope_bits = compute_region_powers(number_of_regions,
mlt_coefs,
drp_num_bits,
drp_code_bits,
absolute_region_power_index);
number_of_available_bits -= number_of_envelope_bits;
number_of_available_bits -= num_rate_control_bits;
categorize(number_of_regions,
number_of_available_bits,
absolute_region_power_index,
power_categories,
category_balances);
/* Adjust absolute_region_category_index[] for mag_shift.
This assumes that REGION_POWER_STEPSIZE_DB is defined
to be exactly 3.010299957 or 20.0 times log base 10
of square root of 2. */
for (region=0; region= 0) {
out_word += current_word >> j;
out_words[out_word_index++] = out_word;
out_word_bits_free = 16;
out_word = current_word << (16 - j);
out_word_bits_free -= j;
}
else {
out_word += current_word << (-j);
out_word_bits_free -= current_word_bits_left;
}
}
/* These code bits are left justified. */
for (region=0; (region 0) && ((16*out_word_index)= out_word_bits_free) {
slice = current_word >> (32 - out_word_bits_free);
out_word += slice;
current_word <<= out_word_bits_free;
current_word_bits_left -= out_word_bits_free;
out_words[out_word_index++] = out_word;
out_word = 0;
out_word_bits_free = 16;
}
else {
slice = current_word >> (32 - current_word_bits_left);
out_word += slice << (out_word_bits_free - current_word_bits_left);
out_word_bits_free -= current_word_bits_left;
current_word_bits_left = 0;
}
if (current_word_bits_left == 0){
current_word = *in_word_ptr++;
region_bit_count -= 32;
current_word_bits_left = MIN(32, region_bit_count);
}
}
}
/* Fill out with 1's. */
while ((16*out_word_index)> (16 - out_word_bits_free);
out_word += slice;
out_words[out_word_index++] = out_word;
out_word = 0;
out_word_bits_free = 16;
}
}
}
/***************************************************************************
Procedure/Function: compute_region_powers
Syntax: int compute_region_powers( number_of_regions,
mlt_coefs,
drp_num_bits,
drp_code_bits,
absolute_region_power_index)
int number_of_regions;
float mlt_coefs[MAX_DCT_SIZE];
int drp_num_bits[MAX_NUM_REGIONS];
int drp_code_bits[MAX_NUM_REGIONS];
int absolute_region_power_index[MAX_NUM_REGIONS];
Description: Computes the power for each of the regions
***************************************************************************/
int compute_region_powers(number_of_regions,
mlt_coefs,
drp_num_bits,
drp_code_bits,
absolute_region_power_index)
int number_of_regions;
float mlt_coefs[MAX_DCT_SIZE];
int drp_num_bits[MAX_NUM_REGIONS];
int drp_code_bits[MAX_NUM_REGIONS];
int absolute_region_power_index[MAX_NUM_REGIONS];
{
float *input_ptr;
int iterations;
float ftemp0, ftemp1;
int index, index_min, index_max;
int region;
int j;
int differential_region_power_index[MAX_NUM_REGIONS];
int number_of_bits;
input_ptr = mlt_coefs;
for (region=0; region> 1;
if (ftemp0 < region_power_table_boundary[index-1])
index_max = index;
else
index_min = index;
}
absolute_region_power_index[region] = index_min-REGION_POWER_TABLE_NUM_NEGATIVES;
}
/* Before we differentially encode the quantized region powers, adjust upward the
valleys to make sure all the peaks can be accurately represented. */
for (region = number_of_regions-2; region >= 0; region--) {
if (absolute_region_power_index[region] < absolute_region_power_index[region+1] - DRP_DIFF_MAX)
absolute_region_power_index[region] = absolute_region_power_index[region+1] - DRP_DIFF_MAX;
}
/* The MLT is currently scaled too low by the factor
ENCODER_SCALE_FACTOR(=18318)/32768 * (1./sqrt(160).
This is the ninth power of 1 over the square root of 2.
So later we will add ESF_ADJUSTMENT_TO_RMS_INDEX (now 9)
to drp_code_bits[0]. */
/* drp_code_bits[0] can range from 1 to 31. 0 will be used only as an escape sequence. */
if (absolute_region_power_index[0] < 1-ESF_ADJUSTMENT_TO_RMS_INDEX)
absolute_region_power_index[0] = 1-ESF_ADJUSTMENT_TO_RMS_INDEX;
if (absolute_region_power_index[0] > 31-ESF_ADJUSTMENT_TO_RMS_INDEX)
absolute_region_power_index[0] = 31-ESF_ADJUSTMENT_TO_RMS_INDEX;
differential_region_power_index[0] = absolute_region_power_index[0];
number_of_bits = 5;
drp_num_bits[0] = 5;
drp_code_bits[0] = absolute_region_power_index[0] + ESF_ADJUSTMENT_TO_RMS_INDEX;
/* Lower limit the absolute region power indices to -8 and upper limit them to 31. Such extremes
may be mathematically impossible anyway.*/
for (region=1; region 31-ESF_ADJUSTMENT_TO_RMS_INDEX)
absolute_region_power_index[region] = 31-ESF_ADJUSTMENT_TO_RMS_INDEX;
}
for (region=1; region> 1) - 1);
(*p_rate_control)++) {
region = category_balances[*p_rate_control];
power_categories[region]++;
}
for (region=0; region 0)) {
(*p_rate_control)--;
region = category_balances[*p_rate_control];
power_categories[region]--;
total_mlt_bits -= region_mlt_bit_counts[region];
category = power_categories[region];
raw_mlt_ptr = &mlt_coefs[region*region_size];
if (category < NUM_CATEGORIES-1)
{
region_mlt_bit_counts[region] =
vector_huffman(category, absolute_region_power_index[region],raw_mlt_ptr,
®ion_mlt_bits[4*region]);
}
else
{
region_mlt_bit_counts[region] = 0;
}
total_mlt_bits += region_mlt_bit_counts[region];
}
/* If too many bits... */
while ((total_mlt_bits > number_of_available_bits) && (*p_rate_control < num_rate_control_possibilities-1)) {
region = category_balances[*p_rate_control];
power_categories[region]++;
total_mlt_bits -= region_mlt_bit_counts[region];
category = power_categories[region];
raw_mlt_ptr = &mlt_coefs[region*region_size];
if (category < NUM_CATEGORIES-1)
{
region_mlt_bit_counts[region] =
vector_huffman(category, absolute_region_power_index[region],raw_mlt_ptr,
®ion_mlt_bits[4*region]);
}
else
{
region_mlt_bit_counts[region] = 0;
}
total_mlt_bits += region_mlt_bit_counts[region];
(*p_rate_control)++;
}
}
/***************************************************************************
Procedure/Function: vector_huffman
Syntax: int vector_huffman(category,
power_index,
raw_mlt_ptr,
word_ptr)
int category;
int power_index;
float *raw_mlt_ptr;
int *word_ptr;
inputs: int category
int power_index
float *raw_mlt_ptr
outputs: int *word_ptr
Description: Huffman encoding for each region based on category and power_index
***************************************************************************/
int vector_huffman(category,
power_index,
raw_mlt_ptr,
word_ptr)
int category;
int power_index;
float *raw_mlt_ptr;
int *word_ptr;
{
float inv_of_step_size_times_std_dev;
int j,n;
int k;
int number_of_region_bits;
int number_of_non_zero;
int vec_dim;
int num_vecs;
int kmax, kmax_plus_one;
int index,signs_index;
int *bitcount_table_ptr;
int *code_table_ptr;
int code_bits;
int number_of_code_bits;
int current_word;
int current_word_bits_free;
vec_dim = vector_dimension[category];
num_vecs = number_of_vectors[category];
kmax = max_bin[category];
kmax_plus_one = kmax + 1;
current_word = 0;
current_word_bits_free = 32;
number_of_region_bits = 0;
bitcount_table_ptr = (int *) table_of_bitcount_tables[category];
code_table_ptr = (int *) table_of_code_tables[category];
inv_of_step_size_times_std_dev =
step_size_inverse_table[category]*standard_deviation_inverse_table[power_index];
for (n=0; n 0)
signs_index++;
if (k > kmax)
k = kmax;
}
index = index*(kmax_plus_one) + k;
raw_mlt_ptr++;
}
code_bits = *(code_table_ptr+index);
number_of_code_bits = *(bitcount_table_ptr+index) + number_of_non_zero;
number_of_region_bits += number_of_code_bits;
code_bits = (code_bits << number_of_non_zero) + signs_index;
/* msb of codebits is transmitted first. */
j = current_word_bits_free - number_of_code_bits;
if (j >= 0) {
current_word += code_bits << j;
current_word_bits_free = j;
}
else {
j = -j;
current_word += code_bits >> j;
*word_ptr++ = current_word;
current_word_bits_free = 32-j;
current_word = code_bits << current_word_bits_free;
}
}
*word_ptr++ = current_word;
return(number_of_region_bits);
}