int compute_region_powers(int number_of_regions, float *coefs, int *drp_num_bits, int *drp_code_bits, int *absolute_region_power_index, int esf_adjustment) {
	float region_power = 0;
	int num_bits;
	int idx;
	int max_idx, min_idx;
	int region, i;

	for (region = 0; region < number_of_regions; region++) {
		region_power = 0.0f;
		for (i = 0 ; i < region_size; i++) {
			region_power += coefs[(region*region_size)+i] * coefs[(region*region_size)+i];
		}
		region_power *= region_size_inverse;

		min_idx = 0;
		max_idx = 64;
		for (i = 0; i < 6; i++) {
			idx = (min_idx + max_idx) / 2;
			if (region_power_table_boundary[idx-1] <= region_power) {
				min_idx = idx;
			} else {
				max_idx = idx;
			}
		}
		absolute_region_power_index[region] = min_idx - 24;

	}

	for (region = number_of_regions-2; region >= 0; region--) {
		if (absolute_region_power_index[region] < absolute_region_power_index[region+1] - 11)
			absolute_region_power_index[region] = absolute_region_power_index[region+1] - 11;
	}

	if (absolute_region_power_index[0] < (1-esf_adjustment))
		absolute_region_power_index[0] = (1-esf_adjustment);

	if (absolute_region_power_index[0] > (31-esf_adjustment))
		absolute_region_power_index[0] = (31-esf_adjustment);

	drp_num_bits[0] = 5;
	drp_code_bits[0] = absolute_region_power_index[0] + esf_adjustment;


	for(region = 1; region < number_of_regions; region++) {
		if (absolute_region_power_index[region] < (-8 - esf_adjustment))
			absolute_region_power_index[region] = (-8 - esf_adjustment);
		if (absolute_region_power_index[region] > (31-esf_adjustment))
			absolute_region_power_index[region] = (31-esf_adjustment);
	}

	num_bits = 5;
	
	for(region = 0; region < number_of_regions-1; region++) {
		idx = absolute_region_power_index[region+1] - absolute_region_power_index[region] + 12;
		if (idx < 0) 
			idx = 0;

		absolute_region_power_index[region+1] = absolute_region_power_index[region] + idx - 12;
		drp_num_bits[region+1] = differential_region_power_bits[region][idx];
		drp_code_bits[region+1] = differential_region_power_codes[region][idx];
		num_bits += drp_num_bits[region+1];
	}

	return num_bits;
}





/***************************************************************************
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<number_of_regions; region++) {
		ftemp0 = 0.0;
		for (j=0; j<region_size; j++) {
			ftemp1 = *input_ptr++;
			ftemp0 += ftemp1*ftemp1;
		}
		ftemp0 *= region_size_inverse;


		index_min = 0;
		index_max = REGION_POWER_TABLE_SIZE;
		for (iterations = 0; iterations < 6; iterations++) {
			index = (index_min + index_max) >> 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<number_of_regions; region++) {
		if (absolute_region_power_index[region] < -8 -ESF_ADJUSTMENT_TO_RMS_INDEX)
			absolute_region_power_index[region] = -8-ESF_ADJUSTMENT_TO_RMS_INDEX;
		if (absolute_region_power_index[region] > 31-ESF_ADJUSTMENT_TO_RMS_INDEX)
			absolute_region_power_index[region] = 31-ESF_ADJUSTMENT_TO_RMS_INDEX;
	}

	for (region=1; region<number_of_regions; region++) {
		j = absolute_region_power_index[region] - absolute_region_power_index[region-1];
		if (j < DRP_DIFF_MIN) {
			j = DRP_DIFF_MIN;
		}
		j -= DRP_DIFF_MIN;
		differential_region_power_index[region] = j;
		absolute_region_power_index[region] = absolute_region_power_index[region-1] +
			differential_region_power_index[region] + DRP_DIFF_MIN;

		number_of_bits += differential_region_power_bits[region][j];
		drp_num_bits[region] = differential_region_power_bits[region][j];
		drp_code_bits[region] = differential_region_power_codes[region][j];
	}

	return(number_of_bits);
}